diff --git a/cmd/clairclt/LICENSE b/cmd/clairclt/LICENSE new file mode 100644 index 00000000..e181acdd --- /dev/null +++ b/cmd/clairclt/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2016 wemanity-belgium + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/cmd/clair-clt/README.md b/cmd/clairclt/README.md similarity index 100% rename from cmd/clair-clt/README.md rename to cmd/clairclt/README.md diff --git a/cmd/clairclt/VERSION b/cmd/clairclt/VERSION new file mode 100644 index 00000000..1d0ba9ea --- /dev/null +++ b/cmd/clairclt/VERSION @@ -0,0 +1 @@ +0.4.0 diff --git a/cmd/clairclt/clair/analyse.go b/cmd/clairclt/clair/analyse.go new file mode 100644 index 00000000..058d9cc5 --- /dev/null +++ b/cmd/clairclt/clair/analyse.go @@ -0,0 +1,39 @@ +package clair + +import ( + "encoding/json" + "fmt" + "io/ioutil" + "net/http" + + "github.com/coreos/clair/api/v1" +) + +//Analyse get Analysis os specified layer +func Analyse(id string) (v1.LayerEnvelope, error) { + + lURI := fmt.Sprintf("%v/layers/%v?vulnerabilities", uri, id) + // lURI := fmt.Sprintf("%v/layers/%v/vulnerabilities?minimumPriority=%v", uri, id, priority) + response, err := http.Get(lURI) + if err != nil { + return v1.LayerEnvelope{}, fmt.Errorf("analysing layer %v: %v", id, err) + } + defer response.Body.Close() + + body, err := ioutil.ReadAll(response.Body) + + if err != nil { + return v1.LayerEnvelope{}, fmt.Errorf("reading layer analysis: %v", err) + } + if response.StatusCode != 200 { + return v1.LayerEnvelope{}, fmt.Errorf("%d - %s", response.StatusCode, string(body)) + } + + var analysis v1.LayerEnvelope + + err = json.Unmarshal(body, &analysis) + if err != nil { + return v1.LayerEnvelope{}, fmt.Errorf("unmarshalling layer analysis: %v", err) + } + return analysis, nil +} diff --git a/cmd/clairclt/clair/clair.go b/cmd/clairclt/clair/clair.go new file mode 100644 index 00000000..6bb6ffae --- /dev/null +++ b/cmd/clairclt/clair/clair.go @@ -0,0 +1,103 @@ +package clair + +import ( + "strconv" + "strings" + + "github.com/coreos/clair/api/v1" + "github.com/coreos/clair/cmd/clairclt/xstrings" + "github.com/spf13/viper" +) + +var uri string +var priority string +var healthPort int + +//Report Reporting Config value +var Report ReportConfig + +//ImageAnalysis Full image analysis +type ImageAnalysis struct { + Registry string + ImageName string + Tag string + Layers []v1.LayerEnvelope +} + +func (imageAnalysis ImageAnalysis) String() string { + return imageAnalysis.Registry + "/" + imageAnalysis.ImageName + ":" + imageAnalysis.Tag +} + +func (imageAnalysis ImageAnalysis) ShortName(l v1.Layer) string { + return xstrings.Substr(l.Name, 0, 12) +} + +func (imageAnalysis ImageAnalysis) CountVulnerabilities(l v1.Layer) int { + count := 0 + for _, f := range l.Features { + count += len(f.Vulnerabilities) + } + return count +} + +type Vulnerability struct { + Name, Severity, IntroduceBy, Description, Layer string +} + +func (imageAnalysis ImageAnalysis) SortVulnerabilities() []Vulnerability { + low := []Vulnerability{} + medium := []Vulnerability{} + high := []Vulnerability{} + critical := []Vulnerability{} + defcon1 := []Vulnerability{} + + for _, l := range imageAnalysis.Layers { + for _, f := range l.Layer.Features { + for _, v := range f.Vulnerabilities { + nv := Vulnerability{ + Name: v.Name, + Severity: v.Severity, + IntroduceBy: f.Name + ":" + f.Version, + Description: v.Description, + Layer: l.Layer.Name, + } + switch strings.ToLower(v.Severity) { + case "low": + low = append(low, nv) + case "medium": + medium = append(medium, nv) + case "high": + high = append(high, nv) + case "critical": + critical = append(critical, nv) + case "defcon1": + defcon1 = append(defcon1, nv) + } + } + } + } + + return append(defcon1, append(critical, append(high, append(medium, low...)...)...)...) +} + +func fmtURI(u string, port int) { + uri = u + if port != 0 { + uri += ":" + strconv.Itoa(port) + } + if !strings.HasSuffix(uri, "/v1") { + uri += "/v1" + } + if !strings.HasPrefix(uri, "http://") && !strings.HasPrefix(uri, "https://") { + uri = "http://" + uri + } +} + +//Config configure Clair from configFile +func Config() { + fmtURI(viper.GetString("clair.uri"), viper.GetInt("clair.port")) + priority = viper.GetString("clair.priority") + healthPort = viper.GetInt("clair.healthPort") + Report.Path = viper.GetString("clair.report.path") + Report.Format = viper.GetString("clair.report.format") +} diff --git a/cmd/clairclt/clair/clair_test.go b/cmd/clairclt/clair/clair_test.go new file mode 100644 index 00000000..83b73e26 --- /dev/null +++ b/cmd/clairclt/clair/clair_test.go @@ -0,0 +1,31 @@ +package clair + +import ( + "net/http" + "net/http/httptest" + "testing" +) + +func newServer(httpStatus int) *httptest.Server { + return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(httpStatus) + })) +} + +func TestIsHealthy(t *testing.T) { + server := newServer(http.StatusOK) + defer server.Close() + uri = server.URL + if h := IsHealthy(); !h { + t.Errorf("IsHealthy() => %v, want %v", h, true) + } +} + +func TestIsNotHealthy(t *testing.T) { + server := newServer(http.StatusInternalServerError) + defer server.Close() + uri = server.URL + if h := IsHealthy(); h { + t.Errorf("IsHealthy() => %v, want %v", h, true) + } +} diff --git a/cmd/clairclt/clair/health.go b/cmd/clairclt/clair/health.go new file mode 100644 index 00000000..33315bcd --- /dev/null +++ b/cmd/clairclt/clair/health.go @@ -0,0 +1,26 @@ +package clair + +import ( + "fmt" + "net/http" + "os" + "strconv" + "strings" +) + +func IsHealthy() bool { + healthURI := strings.Replace(uri, "6060/v1", strconv.Itoa(healthPort), 1) + "/health" + response, err := http.Get(healthURI) + if err != nil { + + fmt.Fprintf(os.Stderr, "requesting Clair health: %v", err) + return false + } + defer response.Body.Close() + + if response.StatusCode != http.StatusOK { + return false + } + + return true +} diff --git a/cmd/clairclt/clair/push.go b/cmd/clairclt/clair/push.go new file mode 100644 index 00000000..576636b2 --- /dev/null +++ b/cmd/clairclt/clair/push.go @@ -0,0 +1,59 @@ +package clair + +import ( + "bytes" + "encoding/json" + "errors" + "fmt" + "io/ioutil" + "net/http" + + "github.com/coreos/clair/api/v1" +) + +//ErrOSNotSupported is returned when Clair received a layer which on os not supported +var ErrOSNotSupported = errors.New("worker: OS and/or package manager are not supported") + +//Push send a layer to Clair for analysis +func Push(layer v1.LayerEnvelope) error { + lJSON, err := json.Marshal(layer) + if err != nil { + return fmt.Errorf("marshalling layer: %v", err) + } + + lURI := fmt.Sprintf("%v/layers", uri) + request, err := http.NewRequest("POST", lURI, bytes.NewBuffer(lJSON)) + if err != nil { + return fmt.Errorf("creating 'add layer' request: %v", err) + } + request.Header.Set("Content-Type", "application/json") + + response, err := (&http.Client{}).Do(request) + if err != nil { + return fmt.Errorf("pushing layer to clair: %v", err) + } + defer response.Body.Close() + + if response.StatusCode != 201 { + if response.StatusCode == 422 { + return ErrOSNotSupported + } + + body, err := ioutil.ReadAll(response.Body) + if err != nil { + return fmt.Errorf("reading 'add layer' response : %v", err) + } + type layerError struct { + Message string + } + var lErr layerError + err = json.Unmarshal(body, &lErr) + + if err != nil { + return fmt.Errorf("unmarshalling 'add layer' error message: %v", err) + } + return fmt.Errorf("%d - %s", response.StatusCode, string(body)) + } + + return nil +} diff --git a/cmd/clairclt/clair/report.go b/cmd/clairclt/clair/report.go new file mode 100644 index 00000000..87b35e6d --- /dev/null +++ b/cmd/clairclt/clair/report.go @@ -0,0 +1,32 @@ +package clair + +import ( + "bytes" + "fmt" + "text/template" +) + +//go:generate go-bindata -pkg clair -o templates.go templates/... + +//ReportConfig Reporting configuration +type ReportConfig struct { + Path string + Format string +} + +//ReportAsHTML report analysis as HTML +func ReportAsHTML(analyses ImageAnalysis) (string, error) { + asset, err := Asset("templates/analysis-template.html") + if err != nil { + return "", fmt.Errorf("accessing template: %v", err) + } + + templte := template.Must(template.New("analysis-template").Parse(string(asset))) + + var doc bytes.Buffer + err = templte.Execute(&doc, analyses) + if err != nil { + return "", fmt.Errorf("rendering HTML report: %v", err) + } + return doc.String(), nil +} diff --git a/cmd/clairclt/clair/report_test.go b/cmd/clairclt/clair/report_test.go new file mode 100644 index 00000000..a1d43b49 --- /dev/null +++ b/cmd/clairclt/clair/report_test.go @@ -0,0 +1,1611 @@ +package clair + +import ( + "encoding/json" + "io/ioutil" + "log" + "os" + "testing" +) + +func TestReportAsHtml(t *testing.T) { + var analysis ImageAnalysis + err := json.Unmarshal([]byte(sampleJSON), &analysis) + + if err != nil { + t.Errorf("Failing with error: %v", err) + } + + html, err := ReportAsHTML(analysis) + if err != nil { + log.Fatal(err) + } + + err = ioutil.WriteFile(os.TempDir()+"/hyperclair-html-report.html", []byte(html), 0700) + if err != nil { + log.Fatal(err) + } +} + +const sampleJSON = ` +{ + "Registry": "registry:5000", + "ImageName": "jgsqware/ubuntu-git", + "Tag": "latest", + "Layers": [ + { + "Layer": { + "Name": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845", + "Namespace": "ubuntu:14.04", + "ParentName": "sha256:9e0bc8a71bde464f710bc2b593a1fc21521517671e918687892303151331fa56", + "IndexedByVersion": 2, + "Features": [ + { + "Name": "sudo", + "Namespace": "ubuntu:14.04", + "Version": "1.8.9p5-1ubuntu1.2", + "Vulnerabilities": [ + { + "Name": "CVE-2015-8239", + "Namespace": "ubuntu:14.04", + "Description": "race condition checking digests/checksums in sudoers", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8239", + "Severity": "Medium" + }, + { + "Name": "CVE-2015-5602", + "Namespace": "ubuntu:14.04", + "Description": "sudoedit in Sudo before 1.8.15 allows local users to gain privileges via a symlink attack on a file whose full path is defined using multiple wildcards in /etc/sudoers, as demonstrated by \"/home/*/*/file.txt.\"", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-5602", + "Severity": "Medium" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libtext-soundex-perl", + "Namespace": "ubuntu:14.04", + "Version": "3.4-1build1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "dash", + "Namespace": "ubuntu:14.04", + "Version": "0.5.7-4ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "eject", + "Namespace": "ubuntu:14.04", + "Version": "2.1.5+deb1+cvs20081104-13.1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "gcc-4.8", + "Namespace": "ubuntu:14.04", + "Version": "4.8.4-2ubuntu1~14.04", + "Vulnerabilities": [ + { + "Name": "CVE-2014-5044", + "Namespace": "ubuntu:14.04", + "Description": "Array memory allocations could cause an integer overflow and thus memory overflow issues at runtime.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2014-5044", + "Severity": "Low" + }, + { + "Name": "CVE-2015-5276", + "Namespace": "ubuntu:14.04", + "Description": "The std::random_device class in libstdc++ in the GNU Compiler Collection (aka GCC) before 4.9.4 does not properly handle short reads from blocking sources, which makes it easier for context-dependent attackers to predict the random values via unspecified vectors.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-5276", + "Severity": "Low" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "lvm2", + "Namespace": "ubuntu:14.04", + "Version": "2.02.98-6ubuntu2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "net-tools", + "Namespace": "ubuntu:14.04", + "Version": "1.60-25ubuntu2.1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libsepol", + "Namespace": "ubuntu:14.04", + "Version": "2.2-1ubuntu0.1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libtext-charwidth-perl", + "Namespace": "ubuntu:14.04", + "Version": "0.04-7build3", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "cdebconf", + "Namespace": "ubuntu:14.04", + "Version": "0.187ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "vim", + "Namespace": "ubuntu:14.04", + "Version": "2:7.4.052-1ubuntu3", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "attr", + "Namespace": "ubuntu:14.04", + "Version": "1:2.4.47-1ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "gnutls26", + "Namespace": "ubuntu:14.04", + "Version": "2.12.23-12ubuntu2.3", + "Vulnerabilities": [ + { + "Name": "CVE-2015-7575", + "Namespace": "ubuntu:14.04", + "Description": "Mozilla Network Security Services (NSS) before 3.20.2, as used in Mozilla Firefox before 43.0.2 and Firefox ESR 38.x before 38.5.2, does not reject MD5 signatures in Server Key Exchange messages in TLS 1.2 Handshake Protocol traffic, which makes it easier for man-in-the-middle attackers to spoof servers by triggering a collision.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-7575", + "Severity": "Medium", + "FixedBy": "2.12.23-12ubuntu2.4" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "python3.4", + "Namespace": "ubuntu:14.04", + "Version": "3.4.3-1ubuntu1~14.04.3", + "Vulnerabilities": [ + { + "Name": "CVE-2014-2667", + "Namespace": "ubuntu:14.04", + "Description": "Race condition in the _get_masked_mode function in Lib/os.py in Python 3.2 through 3.5, when exist_ok is set to true and multiple threads are used, might allow local users to bypass intended file permissions by leveraging a separate application vulnerability before the umask has been set to the expected value.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2014-2667", + "Severity": "Low" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "logrotate", + "Namespace": "ubuntu:14.04", + "Version": "3.8.7-1ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "adduser", + "Namespace": "ubuntu:14.04", + "Version": "3.113+nmu3ubuntu3", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "base-passwd", + "Namespace": "ubuntu:14.04", + "Version": "3.5.33", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "grep", + "Namespace": "ubuntu:14.04", + "Version": "2.16-1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "dpkg", + "Namespace": "ubuntu:14.04", + "Version": "1.17.5ubuntu5.5", + "Vulnerabilities": [ + { + "Name": "CVE-2014-8625", + "Namespace": "ubuntu:14.04", + "Description": "Multiple format string vulnerabilities in the parse_error_msg function in parsehelp.c in dpkg before 1.17.22 allow remote attackers to cause a denial of service (crash) and possibly execute arbitrary code via format string specifiers in the (1) package or (2) architecture name.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2014-8625", + "Severity": "Low" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "ustr", + "Namespace": "ubuntu:14.04", + "Version": "1.0.4-3ubuntu2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "db5.3", + "Namespace": "ubuntu:14.04", + "Version": "5.3.28-3ubuntu3", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libtext-iconv-perl", + "Namespace": "ubuntu:14.04", + "Version": "1.7-5build2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "gccgo-4.9", + "Namespace": "ubuntu:14.04", + "Version": "4.9.1-0ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "xz-utils", + "Namespace": "ubuntu:14.04", + "Version": "5.1.1alpha+20120614-2ubuntu2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "netcat-openbsd", + "Namespace": "ubuntu:14.04", + "Version": "1.105-7ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "coreutils", + "Namespace": "ubuntu:14.04", + "Version": "8.21-1ubuntu5.3", + "Vulnerabilities": [ + { + "Name": "CVE-2015-1865", + "Namespace": "ubuntu:14.04", + "Description": "\"time of check to time of use\" race condition fts.c", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-1865", + "Severity": "Low" + }, + { + "Name": "CVE-2016-2781", + "Namespace": "ubuntu:14.04", + "Description": "nonpriv session can escape to the parent session by using the TIOCSTI ioctl", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-2781", + "Severity": "Medium" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "cpio", + "Namespace": "ubuntu:14.04", + "Version": "2.11+dfsg-1ubuntu1.1", + "Vulnerabilities": [ + { + "Name": "CVE-2016-2037", + "Namespace": "ubuntu:14.04", + "Description": "The cpio_safer_name_suffix function in util.c in cpio 2.11 allows remote attackers to cause a denial of service (out-of-bounds write) via a crafted cpio file.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-2037", + "Severity": "Medium", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 4.3, + "Vectors": "AV:N/AC:M/Au:N/C:N/I:N" + } + } + }, + "FixedBy": "2.11+dfsg-1ubuntu1.2" + }, + { + "Name": "CVE-2015-1197", + "Namespace": "ubuntu:14.04", + "Description": "cpio 2.11, when using the --no-absolute-filenames option, allows local users to write to arbitrary files via a symlink attack on a file in an archive.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-1197", + "Severity": "Low", + "FixedBy": "2.11+dfsg-1ubuntu1.2" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "tar", + "Namespace": "ubuntu:14.04", + "Version": "1.27.1-1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libffi", + "Namespace": "ubuntu:14.04", + "Version": "3.1~rc1+r3.0.13-12ubuntu0.1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libgcrypt11", + "Namespace": "ubuntu:14.04", + "Version": "1.5.3-2ubuntu4.2", + "Vulnerabilities": [ + { + "Name": "CVE-2015-7511", + "Namespace": "ubuntu:14.04", + "Description": "ECDH Key-Extraction via Low-Bandwidth Electromagnetic Attacks on PCs", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-7511", + "Severity": "Medium", + "FixedBy": "1.5.3-2ubuntu4.3" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "findutils", + "Namespace": "ubuntu:14.04", + "Version": "4.4.2-7", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "gzip", + "Namespace": "ubuntu:14.04", + "Version": "1.6-3ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "klibc", + "Namespace": "ubuntu:14.04", + "Version": "2.0.3-0ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "gnupg", + "Namespace": "ubuntu:14.04", + "Version": "1.4.16-1ubuntu2.3", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "readline6", + "Namespace": "ubuntu:14.04", + "Version": "6.3-4ubuntu2", + "Vulnerabilities": [ + { + "Name": "CVE-2014-2524", + "Namespace": "ubuntu:14.04", + "Description": "The _rl_tropen function in util.c in GNU readline before 6.3 patch 3 allows local users to create or overwrite arbitrary files via a symlink attack on a /var/tmp/rltrace.[PID] file.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2014-2524", + "Severity": "Low" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "lockfile-progs", + "Namespace": "ubuntu:14.04", + "Version": "0.1.17", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "fribidi", + "Namespace": "ubuntu:14.04", + "Version": "0.19.6-1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "json-c", + "Namespace": "ubuntu:14.04", + "Version": "0.11-3ubuntu1.2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "sysvinit", + "Namespace": "ubuntu:14.04", + "Version": "2.88dsf-41ubuntu6.2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "base-files", + "Namespace": "ubuntu:14.04", + "Version": "7.2ubuntu5.3", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "ifupdown", + "Namespace": "ubuntu:14.04", + "Version": "0.7.47.2ubuntu4.1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "resolvconf", + "Namespace": "ubuntu:14.04", + "Version": "1.69ubuntu1.1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "bash", + "Namespace": "ubuntu:14.04", + "Version": "4.3-7ubuntu1.5", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "console-setup", + "Namespace": "ubuntu:14.04", + "Version": "1.70ubuntu8", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "pcre3", + "Namespace": "ubuntu:14.04", + "Version": "1:8.31-2ubuntu2.1", + "Vulnerabilities": [ + { + "Name": "CVE-2015-2328", + "Namespace": "ubuntu:14.04", + "Description": "PCRE before 8.36 mishandles the /((?(R)a|(?1)))+/ pattern and related patterns with certain recursion, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-2328", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 7.5, + "Vectors": "AV:N/AC:L/Au:N/C:P/I:P" + } + } + } + }, + { + "Name": "CVE-2016-3191", + "Namespace": "ubuntu:14.04", + "Description": "The compile_branch function in pcre_compile.c in PCRE 8.x before 8.39 and pcre2_compile.c in PCRE2 before 10.22 mishandles patterns containing an (*ACCEPT) substring in conjunction with nested parentheses, which allows remote attackers to execute arbitrary code or cause a denial of service (stack-based buffer overflow) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-3542.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-3191", + "Severity": "Medium", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 7.5, + "Vectors": "AV:N/AC:L/Au:N/C:P/I:P" + } + } + } + }, + { + "Name": "CVE-2015-8394", + "Namespace": "ubuntu:14.04", + "Description": "PCRE before 8.38 mishandles the (?(\u003cdigits\u003e) and (?(R\u003cdigits\u003e) conditions, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8394", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 7.5, + "Vectors": "AV:N/AC:L/Au:N/C:P/I:P" + } + } + } + }, + { + "Name": "CVE-2015-8391", + "Namespace": "ubuntu:14.04", + "Description": "The pcre_compile function in pcre_compile.c in PCRE before 8.38 mishandles certain [: nesting, which allows remote attackers to cause a denial of service (CPU consumption) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8391", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 9, + "Vectors": "AV:N/AC:L/Au:N/C:P/I:P" + } + } + } + }, + { + "Name": "CVE-2015-8390", + "Namespace": "ubuntu:14.04", + "Description": "PCRE before 8.38 mishandles the [: and \\\\ substrings in character classes, which allows remote attackers to cause a denial of service (uninitialized memory read) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8390", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 7.5, + "Vectors": "AV:N/AC:L/Au:N/C:P/I:P" + } + } + } + }, + { + "Name": "CVE-2015-8382", + "Namespace": "ubuntu:14.04", + "Description": "The match function in pcre_exec.c in PCRE before 8.37 mishandles the /(?:((abcd))|(((?:(?:(?:(?:abc|(?:abcdef))))b)abcdefghi)abc)|((*ACCEPT)))/ pattern and related patterns involving (*ACCEPT), which allows remote attackers to obtain sensitive information from process memory or cause a denial of service (partially initialized memory and application crash) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-2547.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8382", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 6.4, + "Vectors": "AV:N/AC:L/Au:N/C:P/I:N" + } + } + } + }, + { + "Name": "CVE-2015-8387", + "Namespace": "ubuntu:14.04", + "Description": "PCRE before 8.38 mishandles (?123) subroutine calls and related subroutine calls, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8387", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 7.5, + "Vectors": "AV:N/AC:L/Au:N/C:P/I:P" + } + } + } + }, + { + "Name": "CVE-2015-8393", + "Namespace": "ubuntu:14.04", + "Description": "pcregrep in PCRE before 8.38 mishandles the -q option for binary files, which might allow remote attackers to obtain sensitive information via a crafted file, as demonstrated by a CGI script that sends stdout data to a client.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8393", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 5, + "Vectors": "AV:N/AC:L/Au:N/C:P/I:N" + } + } + } + }, + { + "Name": "CVE-2015-8386", + "Namespace": "ubuntu:14.04", + "Description": "PCRE before 8.38 mishandles the interaction of lookbehind assertions and mutually recursive subpatterns, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8386", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 7.5, + "Vectors": "AV:N/AC:L/Au:N/C:P/I:P" + } + } + } + }, + { + "Name": "CVE-2015-8380", + "Namespace": "ubuntu:14.04", + "Description": "The pcre_exec function in pcre_exec.c in PCRE before 8.38 mishandles a // pattern with a \\01 string, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8380", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 7.5, + "Vectors": "AV:N/AC:L/Au:N/C:P/I:P" + } + } + } + }, + { + "Name": "CVE-2015-8385", + "Namespace": "ubuntu:14.04", + "Description": "PCRE before 8.38 mishandles the /(?|(\\k'Pm')|(?'Pm'))/ pattern and related patterns with certain forward references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8385", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 7.5, + "Vectors": "AV:N/AC:L/Au:N/C:P/I:P" + } + } + } + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libsemanage", + "Namespace": "ubuntu:14.04", + "Version": "2.2-1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "gdbm", + "Namespace": "ubuntu:14.04", + "Version": "1.8.3-12build1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "xkeyboard-config", + "Namespace": "ubuntu:14.04", + "Version": "2.10.1-1ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "ncurses", + "Namespace": "ubuntu:14.04", + "Version": "5.9+20140118-1ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "python3-defaults", + "Namespace": "ubuntu:14.04", + "Version": "3.4.0-0ubuntu2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libarchive-extract-perl", + "Namespace": "ubuntu:14.04", + "Version": "0.70-1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "iproute2", + "Namespace": "ubuntu:14.04", + "Version": "3.12.0-2ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "liblocale-gettext-perl", + "Namespace": "ubuntu:14.04", + "Version": "1.05-7build3", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "mawk", + "Namespace": "ubuntu:14.04", + "Version": "1.3.3-17ubuntu2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "expat", + "Namespace": "ubuntu:14.04", + "Version": "2.1.0-4ubuntu1.1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libcap2", + "Namespace": "ubuntu:14.04", + "Version": "1:2.24-0ubuntu2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "initramfs-tools", + "Namespace": "ubuntu:14.04", + "Version": "0.103ubuntu4.2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libestr", + "Namespace": "ubuntu:14.04", + "Version": "0.1.9-0ubuntu2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libtext-wrapi18n-perl", + "Namespace": "ubuntu:14.04", + "Version": "0.06-7", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "debianutils", + "Namespace": "ubuntu:14.04", + "Version": "4.4", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "insserv", + "Namespace": "ubuntu:14.04", + "Version": "1.14.0-5ubuntu2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "slang2", + "Namespace": "ubuntu:14.04", + "Version": "2.2.4-15ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "systemd", + "Namespace": "ubuntu:14.04", + "Version": "204-5ubuntu20.15", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "upstart", + "Namespace": "ubuntu:14.04", + "Version": "1.12.1-0ubuntu4.2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "kbd", + "Namespace": "ubuntu:14.04", + "Version": "1.15.5-1ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "busybox", + "Namespace": "ubuntu:14.04", + "Version": "1:1.21.0-1ubuntu1", + "Vulnerabilities": [ + { + "Name": "CVE-2014-9645", + "Namespace": "ubuntu:14.04", + "Description": "modprobe wrongly accepts paths as module names", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2014-9645", + "Severity": "Low" + }, + { + "Name": "CVE-2011-5325", + "Namespace": "ubuntu:14.04", + "Description": "path traversal vulnerability in busybox tar", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2011-5325", + "Severity": "Medium" + }, + { + "Name": "CVE-2016-2147", + "Namespace": "ubuntu:14.04", + "Description": "OOB heap write due to integer underflow", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-2147", + "Severity": "Low" + }, + { + "Name": "CVE-2016-2148", + "Namespace": "ubuntu:14.04", + "Description": "heap overflow in OPTION_6RD parsing", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-2148", + "Severity": "Low" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "eglibc", + "Namespace": "ubuntu:14.04", + "Version": "2.19-0ubuntu6.6", + "Vulnerabilities": [ + { + "Name": "CVE-2015-8778", + "Namespace": "ubuntu:14.04", + "Description": "hcreate((size_t)-1) should fail with ENOMEM", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8778", + "Severity": "Low" + }, + { + "Name": "CVE-2014-9761", + "Namespace": "ubuntu:14.04", + "Description": "nan function unbounded stack allocation", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2014-9761", + "Severity": "Low" + }, + { + "Name": "CVE-2015-5180", + "Namespace": "ubuntu:14.04", + "Description": "DNS resolver NULL pointer dereference with crafted record type", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-5180", + "Severity": "Low" + }, + { + "Name": "CVE-2013-2207", + "Namespace": "ubuntu:14.04", + "Description": "pt_chown in GNU C Library (aka glibc or libc6) before 2.18 does not properly check permissions for tty files, which allows local users to change the permission on the files and obtain access to arbitrary pseudo-terminals by leveraging a FUSE file system.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2013-2207", + "Severity": "Low" + }, + { + "Name": "CVE-2015-8776", + "Namespace": "ubuntu:14.04", + "Description": "Passing out of range data to strftime() causes a segfault", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8776", + "Severity": "Low" + }, + { + "Name": "CVE-2015-8779", + "Namespace": "ubuntu:14.04", + "Description": "catopen() Multiple unbounded stack allocations", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8779", + "Severity": "Low" + }, + { + "Name": "CVE-2015-5277", + "Namespace": "ubuntu:14.04", + "Description": "The get_contents function in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) before 2.20 might allow local users to cause a denial of service (heap corruption) or gain privileges via a long line in the NSS files database.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-5277", + "Severity": "Medium" + }, + { + "Name": "CVE-2015-7547", + "Namespace": "ubuntu:14.04", + "Description": "Multiple stack-based buffer overflows in the (1) send_dg and (2) send_vc functions in the libresolv library in the GNU C Library (aka glibc or libc6) before 2.23 allow remote attackers to cause a denial of service (crash) or possibly execute arbitrary code via a crafted DNS response that triggers a call to the getaddrinfo function with the AF_UNSPEC or AF_INET6 address family, related to performing \"dual A/AAAA DNS queries\" and the libnss_dns.so.2 NSS module.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-7547", + "Severity": "High", + "FixedBy": "2.19-0ubuntu6.7" + }, + { + "Name": "CVE-2014-8121", + "Namespace": "ubuntu:14.04", + "Description": "DB_LOOKUP in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) 2.21 and earlier does not properly check if a file is open, which allows remote attackers to cause a denial of service (infinite loop) by performing a look-up while the database is iterated over the database, which triggers the file pointer to be reset.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2014-8121", + "Severity": "Low" + }, + { + "Name": "CVE-2015-1781", + "Namespace": "ubuntu:14.04", + "Description": "Buffer overflow in the gethostbyname_r and other unspecified NSS functions in the GNU C Library (aka glibc or libc6) before 2.22 allows context-dependent attackers to cause a denial of service (crash) or execute arbitrary code via a crafted DNS response, which triggers a call with a misaligned buffer.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-1781", + "Severity": "Low" + }, + { + "Name": "CVE-2016-1234", + "Namespace": "ubuntu:14.04", + "Description": "glob: buffer overflow with GLOB_ALTDIRFUNC due to incorrect NAME_MAX limit assumption", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-1234", + "Severity": "Medium" + }, + { + "Name": "CVE-2015-8777", + "Namespace": "ubuntu:14.04", + "Description": "The process_envvars function in elf/rtld.c in the GNU C Library (aka glibc or libc6) before 2.23 allows local users to bypass a pointer-guarding protection mechanism via a zero value of the LD_POINTER_GUARD environment variable.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8777", + "Severity": "Low" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "hostname", + "Namespace": "ubuntu:14.04", + "Version": "3.15ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "bzip2", + "Namespace": "ubuntu:14.04", + "Version": "1.0.6-5", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libnih", + "Namespace": "ubuntu:14.04", + "Version": "1.0.3-4ubuntu25", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "mpdecimal", + "Namespace": "ubuntu:14.04", + "Version": "2.4.0-6", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "openssl", + "Namespace": "ubuntu:14.04", + "Version": "1.0.1f-1ubuntu2.16", + "Vulnerabilities": [ + { + "Name": "CVE-2016-0797", + "Namespace": "ubuntu:14.04", + "Description": "Multiple integer overflows in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allow remote attackers to cause a denial of service (heap memory corruption or NULL pointer dereference) or possibly have unspecified other impact via a long digit string that is mishandled by the (1) BN_dec2bn or (2) BN_hex2bn function, related to crypto/bn/bn.h and crypto/bn/bn_print.c.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-0797", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 5, + "Vectors": "AV:N/AC:L/Au:N/C:N/I:N" + } + } + }, + "FixedBy": "1.0.1f-1ubuntu2.18" + }, + { + "Name": "CVE-2016-2842", + "Namespace": "ubuntu:14.04", + "Description": "The doapr_outch function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not verify that a certain memory allocation succeeds, which allows remote attackers to cause a denial of service (out-of-bounds write or memory consumption) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-0799.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-2842", + "Severity": "Medium", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 10, + "Vectors": "AV:N/AC:L/Au:N/C:C/I:C" + } + } + }, + "FixedBy": "1.0.1f-1ubuntu2.18" + }, + { + "Name": "CVE-2016-0702", + "Namespace": "ubuntu:14.04", + "Description": "The MOD_EXP_CTIME_COPY_FROM_PREBUF function in crypto/bn/bn_exp.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not properly consider cache-bank access times during modular exponentiation, which makes it easier for local users to discover RSA keys by running a crafted application on the same Intel Sandy Bridge CPU core as a victim and leveraging cache-bank conflicts, aka a \"CacheBleed\" attack.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-0702", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 1.9, + "Vectors": "AV:L/AC:M/Au:N/C:P/I:N" + } + } + }, + "FixedBy": "1.0.1f-1ubuntu2.18" + }, + { + "Name": "CVE-2016-0705", + "Namespace": "ubuntu:14.04", + "Description": "Double free vulnerability in the dsa_priv_decode function in crypto/dsa/dsa_ameth.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory corruption) or possibly have unspecified other impact via a malformed DSA private key.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-0705", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 10, + "Vectors": "AV:N/AC:L/Au:N/C:C/I:C" + } + } + }, + "FixedBy": "1.0.1f-1ubuntu2.18" + }, + { + "Name": "CVE-2016-0798", + "Namespace": "ubuntu:14.04", + "Description": "Memory leak in the SRP_VBASE_get_by_user implementation in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory consumption) by providing an invalid username in a connection attempt, related to apps/s_server.c and crypto/srp/srp_vfy.c.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-0798", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 7.8, + "Vectors": "AV:N/AC:L/Au:N/C:N/I:N" + } + } + }, + "FixedBy": "1.0.1f-1ubuntu2.18" + }, + { + "Name": "CVE-2016-0799", + "Namespace": "ubuntu:14.04", + "Description": "The fmtstr function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g improperly calculates string lengths, which allows remote attackers to cause a denial of service (overflow and out-of-bounds read) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-2842.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-0799", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 10, + "Vectors": "AV:N/AC:L/Au:N/C:C/I:C" + } + } + }, + "FixedBy": "1.0.1f-1ubuntu2.18" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "diffutils", + "Namespace": "ubuntu:14.04", + "Version": "1:3.3-1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "apt", + "Namespace": "ubuntu:14.04", + "Version": "1.0.1ubuntu2.10", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "debconf", + "Namespace": "ubuntu:14.04", + "Version": "1.5.51ubuntu2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "ubuntu-meta", + "Namespace": "ubuntu:14.04", + "Version": "1.325", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "rsyslog", + "Namespace": "ubuntu:14.04", + "Version": "7.4.4-1ubuntu2.6", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "dh-python", + "Namespace": "ubuntu:14.04", + "Version": "1.20140128-1ubuntu8.2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libpng", + "Namespace": "ubuntu:14.04", + "Version": "1.2.50-1ubuntu2.14.04.1", + "Vulnerabilities": [ + { + "Name": "CVE-2015-8540", + "Namespace": "ubuntu:14.04", + "Description": "underflow read in png_check_keyword in pngwutil.c", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8540", + "Severity": "Medium", + "FixedBy": "1.2.50-1ubuntu2.14.04.2" + }, + { + "Name": "CVE-2015-8472", + "Namespace": "ubuntu:14.04", + "Description": "Buffer overflow in the png_set_PLTE function in libpng before 1.0.65, 1.1.x and 1.2.x before 1.2.55, 1.3.x, 1.4.x before 1.4.18, 1.5.x before 1.5.25, and 1.6.x before 1.6.20 allows remote attackers to cause a denial of service (application crash) or possibly have unspecified other impact via a small bit-depth value in an IHDR (aka image header) chunk in a PNG image. NOTE: this vulnerability exists because of an incomplete fix for CVE-2015-8126.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8472", + "Severity": "Medium", + "FixedBy": "1.2.50-1ubuntu2.14.04.2" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libmodule-pluggable-perl", + "Namespace": "ubuntu:14.04", + "Version": "5.1-1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "mountall", + "Namespace": "ubuntu:14.04", + "Version": "2.53", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "cron", + "Namespace": "ubuntu:14.04", + "Version": "3.0pl1-124ubuntu2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "acl", + "Namespace": "ubuntu:14.04", + "Version": "2.2.52-1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libdrm", + "Namespace": "ubuntu:14.04", + "Version": "2.4.60-2~ubuntu14.04.1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "util-linux", + "Namespace": "ubuntu:14.04", + "Version": "2.20.1-5.1ubuntu20.7", + "Vulnerabilities": [ + { + "Name": "CVE-2014-9114", + "Namespace": "ubuntu:14.04", + "Description": "blkid command injection", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2014-9114", + "Severity": "Low" + }, + { + "Name": "CVE-2013-0157", + "Namespace": "ubuntu:14.04", + "Description": "(a) mount and (b) umount in util-linux 2.14.1, 2.17.2, and probably other versions allow local users to determine the existence of restricted directories by (1) using the --guess-fstype command-line option or (2) attempting to mount a non-existent device, which generates different error messages depending on whether the directory exists.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2013-0157", + "Severity": "Low" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "tzdata", + "Namespace": "ubuntu:14.04", + "Version": "2015g-0ubuntu0.14.04", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "less", + "Namespace": "ubuntu:14.04", + "Version": "458-2", + "Vulnerabilities": [ + { + "Name": "CVE-2014-9488", + "Namespace": "ubuntu:14.04", + "Description": "The is_utf8_well_formed function in GNU less before 475 allows remote attackers to have unspecified impact via malformed UTF-8 characters, which triggers an out-of-bounds read.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2014-9488", + "Severity": "Low" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "popt", + "Namespace": "ubuntu:14.04", + "Version": "1.16-8ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "init-system-helpers", + "Namespace": "ubuntu:14.04", + "Version": "1.14", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "mime-support", + "Namespace": "ubuntu:14.04", + "Version": "3.54ubuntu1.1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "p11-kit", + "Namespace": "ubuntu:14.04", + "Version": "0.20.2-2ubuntu2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "cgmanager", + "Namespace": "ubuntu:14.04", + "Version": "0.24-0ubuntu7.5", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libselinux", + "Namespace": "ubuntu:14.04", + "Version": "2.2.2-1ubuntu0.1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "langpack-locales", + "Namespace": "ubuntu:14.04", + "Version": "2.13+git20120306-12.1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "procps", + "Namespace": "ubuntu:14.04", + "Version": "1:3.3.9-1ubuntu2.2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "ureadahead", + "Namespace": "ubuntu:14.04", + "Version": "0.100.0-16", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "file", + "Namespace": "ubuntu:14.04", + "Version": "1:5.14-2ubuntu3.3", + "Vulnerabilities": [ + { + "Name": "CVE-2014-9621", + "Namespace": "ubuntu:14.04", + "Description": "The ELF parser in file 5.16 through 5.21 allows remote attackers to cause a denial of service via a long string.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2014-9621", + "Severity": "Low" + }, + { + "Name": "CVE-2014-9620", + "Namespace": "ubuntu:14.04", + "Description": "The ELF parser in file 5.08 through 5.21 allows remote attackers to cause a denial of service via a large number of notes.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2014-9620", + "Severity": "Low" + }, + { + "Name": "CVE-2014-9653", + "Namespace": "ubuntu:14.04", + "Description": "readelf.c in file before 5.22, as used in the Fileinfo component in PHP before 5.4.37, 5.5.x before 5.5.21, and 5.6.x before 5.6.5, does not consider that pread calls sometimes read only a subset of the available data, which allows remote attackers to cause a denial of service (uninitialized memory access) or possibly have unspecified other impact via a crafted ELF file.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2014-9653", + "Severity": "Low" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "dbus", + "Namespace": "ubuntu:14.04", + "Version": "1.6.18-0ubuntu4.3", + "Vulnerabilities": [ + { + "Name": "CVE-2015-0245", + "Namespace": "ubuntu:14.04", + "Description": "D-Bus 1.4.x through 1.6.x before 1.6.30, 1.8.x before 1.8.16, and 1.9.x before 1.9.10 does not validate the source of ActivationFailure signals, which allows local users to cause a denial of service (activation failure error returned) by leveraging a race condition involving sending an ActivationFailure signal before systemd responds.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-0245", + "Severity": "Low" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "zlib", + "Namespace": "ubuntu:14.04", + "Version": "1:1.2.8.dfsg-1ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "netbase", + "Namespace": "ubuntu:14.04", + "Version": "5.2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libtasn1-6", + "Namespace": "ubuntu:14.04", + "Version": "3.4-3ubuntu0.3", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "sed", + "Namespace": "ubuntu:14.04", + "Version": "4.2.2-4ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "e2fsprogs", + "Namespace": "ubuntu:14.04", + "Version": "1.42.9-3ubuntu1.3", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "sensible-utils", + "Namespace": "ubuntu:14.04", + "Version": "0.0.9", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libusb", + "Namespace": "ubuntu:14.04", + "Version": "2:0.1.12-23.3ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "shadow", + "Namespace": "ubuntu:14.04", + "Version": "1:4.1.5.1-1ubuntu9.1", + "Vulnerabilities": [ + { + "Name": "CVE-2013-4235", + "Namespace": "ubuntu:14.04", + "Description": "TOCTOU race conditions by copying and removing directory trees", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2013-4235", + "Severity": "Low" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "kmod", + "Namespace": "ubuntu:14.04", + "Version": "15-0ubuntu6", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "ucf", + "Namespace": "ubuntu:14.04", + "Version": "3.0027+nmu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libpod-latex-perl", + "Namespace": "ubuntu:14.04", + "Version": "0.61-1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "ubuntu-keyring", + "Namespace": "ubuntu:14.04", + "Version": "2012.05.19", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "perl", + "Namespace": "ubuntu:14.04", + "Version": "5.18.2-2ubuntu1", + "Vulnerabilities": [ + { + "Name": "CVE-2016-2381", + "Namespace": "ubuntu:14.04", + "Description": "environment variable confusion", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-2381", + "Severity": "Medium", + "FixedBy": "5.18.2-2ubuntu1.1" + }, + { + "Name": "CVE-2013-7422", + "Namespace": "ubuntu:14.04", + "Description": "Integer underflow in regcomp.c in Perl before 5.20, as used in Apple OS X before 10.10.5 and other products, allows context-dependent attackers to execute arbitrary code or cause a denial of service (application crash) via a long digit string associated with an invalid backreference within a regular expression.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2013-7422", + "Severity": "Low", + "FixedBy": "5.18.2-2ubuntu1.1" + }, + { + "Name": "CVE-2014-4330", + "Namespace": "ubuntu:14.04", + "Description": "The Dumper method in Data::Dumper before 2.154, as used in Perl 5.20.1 and earlier, allows context-dependent attackers to cause a denial of service (stack consumption and crash) via an Array-Reference with many nested Array-References, which triggers a large number of recursive calls to the DD_dump function.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2014-4330", + "Severity": "Low", + "FixedBy": "5.18.2-2ubuntu1.1" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "lsb", + "Namespace": "ubuntu:14.04", + "Version": "4.1+Debian11ubuntu6", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "makedev", + "Namespace": "ubuntu:14.04", + "Version": "2.3.1-93ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libterm-ui-perl", + "Namespace": "ubuntu:14.04", + "Version": "0.42-1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "isc-dhcp", + "Namespace": "ubuntu:14.04", + "Version": "4.2.4-7ubuntu12.3", + "Vulnerabilities": [ + { + "Name": "CVE-2015-8605", + "Namespace": "ubuntu:14.04", + "Description": "ISC DHCP 4.x before 4.1-ESV-R12-P1 and 4.2.x and 4.3.x before 4.3.3-P1 allows remote attackers to cause a denial of service (application crash) via an invalid length field in a UDP IPv4 packet.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8605", + "Severity": "Medium", + "FixedBy": "4.2.4-7ubuntu12.4" + }, + { + "Name": "CVE-2016-2774", + "Namespace": "ubuntu:14.04", + "Description": "ISC DHCP 4.1.x before 4.1-ESV-R13 and 4.2.x and 4.3.x before 4.3.4 does not restrict the number of concurrent TCP sessions, which allows remote attackers to cause a denial of service (INSIST assertion failure or request-processing outage) by establishing many sessions.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-2774", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 7.1, + "Vectors": "AV:N/AC:M/Au:N/C:N/I:N" + } + } + } + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "liblog-message-simple-perl", + "Namespace": "ubuntu:14.04", + "Version": "0.10-1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "plymouth", + "Namespace": "ubuntu:14.04", + "Version": "0.8.8-0ubuntu17.1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "audit", + "Namespace": "ubuntu:14.04", + "Version": "1:2.3.2-2ubuntu1", + "Vulnerabilities": [ + { + "Name": "CVE-2015-5186", + "Namespace": "ubuntu:14.04", + "Description": "log terminal emulator escape sequences handling", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-5186", + "Severity": "Negligible" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libbsd", + "Namespace": "ubuntu:14.04", + "Version": "0.6.0-2ubuntu1", + "Vulnerabilities": [ + { + "Name": "CVE-2016-2090", + "Namespace": "ubuntu:14.04", + "Description": "Heap buffer overflow in fgetwln function of libbsd", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-2090", + "Severity": "Low" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "iputils", + "Namespace": "ubuntu:14.04", + "Version": "3:20121221-4ubuntu1.1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libgpg-error", + "Namespace": "ubuntu:14.04", + "Version": "1.12-0.2ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "pam", + "Namespace": "ubuntu:14.04", + "Version": "1.1.8-1ubuntu2", + "Vulnerabilities": [ + { + "Name": "CVE-2015-3238", + "Namespace": "ubuntu:14.04", + "Description": "The _unix_run_helper_binary function in the pam_unix module in Linux-PAM (aka pam) before 1.2.1, when unable to directly access passwords, allows local users to enumerate usernames or cause a denial of service (hang) via a large password.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-3238", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 5.8, + "Vectors": "AV:N/AC:M/Au:N/C:P/I:N" + } + } + }, + "FixedBy": "1.1.8-1ubuntu2.1" + }, + { + "Name": "CVE-2013-7041", + "Namespace": "ubuntu:14.04", + "Description": "The pam_userdb module for Pam uses a case-insensitive method to compare hashed passwords, which makes it easier for attackers to guess the password via a brute force attack.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2013-7041", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 4.3, + "Vectors": "AV:N/AC:M/Au:N/C:P/I:N" + } + } + }, + "FixedBy": "1.1.8-1ubuntu2.1" + }, + { + "Name": "CVE-2014-2583", + "Namespace": "ubuntu:14.04", + "Description": "Multiple directory traversal vulnerabilities in pam_timestamp.c in the pam_timestamp module for Linux-PAM (aka pam) 1.1.8 allow local users to create aribitrary files or possibly bypass authentication via a .. (dot dot) in the (1) PAM_RUSER value to the get_ruser function or (2) PAM_TTY value to the check_tty funtion, which is used by the format_timestamp_name function.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2014-2583", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 5.8, + "Vectors": "AV:N/AC:M/Au:N/C:P/I:P" + } + } + }, + "FixedBy": "1.1.8-1ubuntu2.1" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "liblockfile", + "Namespace": "ubuntu:14.04", + "Version": "1.09-6ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "ntp", + "Namespace": "ubuntu:14.04", + "Version": "1:4.2.6.p5+dfsg-3ubuntu2.14.04.6", + "Vulnerabilities": [ + { + "Name": "CVE-2016-0727", + "Namespace": "ubuntu:14.04", + "Description": "NTP statsdir cleanup cronjob insecure", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-0727", + "Severity": "Low" + }, + { + "Name": "CVE-2015-8158", + "Namespace": "ubuntu:14.04", + "Description": "Potential Infinite Loop in ntpq", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8158", + "Severity": "Low" + }, + { + "Name": "CVE-2015-7973", + "Namespace": "ubuntu:14.04", + "Description": "Deja Vu: Replay attack on authenticated broadcast mode", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-7973", + "Severity": "Low" + }, + { + "Name": "CVE-2015-8140", + "Namespace": "ubuntu:14.04", + "Description": "ntpq vulnerable to replay attacks", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8140", + "Severity": "Low" + }, + { + "Name": "CVE-2015-8139", + "Namespace": "ubuntu:14.04", + "Description": "Origin Leak: ntpq and ntpdc, disclose origin", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8139", + "Severity": "Low" + }, + { + "Name": "CVE-2015-7976", + "Namespace": "ubuntu:14.04", + "Description": "ntpq saveconfig command allows dangerous characters in filenames", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-7976", + "Severity": "Low" + }, + { + "Name": "CVE-2015-7979", + "Namespace": "ubuntu:14.04", + "Description": "Off-path Denial of Service (DoS) attack on authenticated broadcast mode", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-7979", + "Severity": "Low" + }, + { + "Name": "CVE-2015-8138", + "Namespace": "ubuntu:14.04", + "Description": "ntp: missing check for zero originate timestamp", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8138", + "Severity": "Medium" + }, + { + "Name": "CVE-2015-7977", + "Namespace": "ubuntu:14.04", + "Description": "reslist NULL pointer dereference", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-7977", + "Severity": "Medium" + }, + { + "Name": "CVE-2015-7978", + "Namespace": "ubuntu:14.04", + "Description": "Stack exhaustion in recursive traversal of restriction list", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-7978", + "Severity": "Medium" + }, + { + "Name": "CVE-2015-7974", + "Namespace": "ubuntu:14.04", + "Description": "NTP 4.x before 4.2.8p6 and 4.3.x before 4.3.90 do not verify peer associations of symmetric keys when authenticating packets, which might allow remote attackers to conduct impersonation attacks via an arbitrary trusted key, aka a \"skeleton key.\"", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-7974", + "Severity": "Low" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "newt", + "Namespace": "ubuntu:14.04", + "Version": "0.52.15-2ubuntu5", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "sqlite3", + "Namespace": "ubuntu:14.04", + "Version": "3.8.2-1ubuntu2.1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + } + ] + } + }, + { + "Layer": { + "Name": "sha256:9e0bc8a71bde464f710bc2b593a1fc21521517671e918687892303151331fa56", + "Namespace": "ubuntu:14.04", + "ParentName": "sha256:27aa681c95e5165caf287dcfe896532df4ae8b10e099500f2f8f71acf4002a89", + "IndexedByVersion": 2 + } + }, + { + "Layer": { + "Name": "sha256:27aa681c95e5165caf287dcfe896532df4ae8b10e099500f2f8f71acf4002a89", + "Namespace": "ubuntu:14.04", + "ParentName": "sha256:a3ed95caeb02ffe68cdd9fd84406680ae93d633cb16422d00e8a7c22955b46d4", + "IndexedByVersion": 2 + } + }, + { + "Layer": { + "Name": "sha256:a3ed95caeb02ffe68cdd9fd84406680ae93d633cb16422d00e8a7c22955b46d4", + "IndexedByVersion": 2 + } + } + ] +} +` diff --git a/cmd/clairclt/clair/templates.go b/cmd/clairclt/clair/templates.go new file mode 100644 index 00000000..1e6f1a97 --- /dev/null +++ b/cmd/clairclt/clair/templates.go @@ -0,0 +1,237 @@ +// Code generated by go-bindata. +// sources: +// templates/analysis-template.html +// DO NOT EDIT! + +package clair + +import ( + "bytes" + "compress/gzip" + "fmt" + "io" + "io/ioutil" + "os" + "path/filepath" + "strings" + "time" +) + +func bindataRead(data []byte, name string) ([]byte, error) { + gz, err := gzip.NewReader(bytes.NewBuffer(data)) + if err != nil { + return nil, fmt.Errorf("Read %q: %v", name, err) + } + + var buf bytes.Buffer + _, err = io.Copy(&buf, gz) + clErr := gz.Close() + + if err != nil { + return nil, fmt.Errorf("Read %q: %v", name, err) + } + if clErr != nil { + return nil, err + } + + return buf.Bytes(), nil +} + +type asset struct { + bytes []byte + info os.FileInfo +} + +type bindataFileInfo struct { + name string + size int64 + mode os.FileMode + modTime time.Time +} + +func (fi bindataFileInfo) Name() string { + return fi.name +} +func (fi bindataFileInfo) Size() int64 { + return fi.size +} +func (fi bindataFileInfo) Mode() os.FileMode { + return fi.mode +} +func (fi bindataFileInfo) ModTime() time.Time { + return fi.modTime +} +func (fi bindataFileInfo) IsDir() bool { + return false +} +func (fi bindataFileInfo) Sys() interface{} { + return nil +} + +var _templatesAnalysisTemplateHtml = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xec\xbd\x7b\x7f\xe3\xc6\xb1\x20\xfa\x7f\x3e\x05\x45\xdb\x32\x39\x02\x39\x7c\x4b\x22\x4d\xe9\x38\xb6\x73\xec\x5d\x3b\xc9\xc6\x3e\x67\xb3\x57\x23\xef\x0f\x04\x40\x12\x33\x20\xc1\x01\x40\x69\x64\x8a\xf9\xec\xb7\xfa\x05\xf4\xa3\x1a\x00\x35\xe3\x9c\x73\x7f\x37\x99\x78\x06\xec\xae\xae\xae\xae\xae\xae\xaa\xae\x7e\x7d\x75\xf6\xed\x5f\xbe\xf9\xe5\xff\xfc\xf5\xbb\xc6\x3a\xdb\x44\x37\x7f\xf8\x8a\xfc\xd3\x88\xdc\xed\x6a\xde\x0c\xb6\xcd\x9b\x3f\x40\x4a\xe0\xfa\x37\x7f\x68\x34\xbe\xda\x04\x99\xdb\xf0\xd6\x6e\x92\x06\xd9\xbc\xb9\xcf\x96\x9d\xab\x66\x91\xb1\xce\xb2\x5d\x27\x78\xbf\x0f\x1f\xe6\xcd\xbf\x77\xfe\xe3\xeb\xce\x37\xf1\x66\xe7\x66\xe1\x22\x0a\x9a\x0d\x2f\xde\x66\xc1\x16\x4a\xfd\xf0\xdd\x3c\xf0\x57\x81\x54\x6e\xeb\x6e\x82\x79\xf3\x21\x0c\x1e\x77\x71\x92\x49\xa0\x8f\xa1\x9f\xad\xe7\x7e\xf0\x10\x7a\x41\x87\xfe\x70\x1a\xe1\x36\xcc\x42\x37\xea\xa4\x9e\x1b\x05\xf3\x3e\xa1\x0f\xf0\x64\x61\x16\x05\x37\xdf\x3f\xed\x82\xc4\x8b\xdc\x30\x69\xfc\x2d\x20\xb8\xd2\xaf\x5e\xb3\x1c\x02\x93\x66\x4f\xec\xeb\xd5\x01\xfe\x6a\x34\x96\x50\x4d\x67\xe9\x6e\xc2\xe8\x69\xda\x68\xfe\xb8\xf7\x42\xdf\x6d\x7c\x13\x6f\xd3\x18\xe8\x75\x1a\x3f\xc5\x5b\xd7\x8b\x9d\xc6\x26\xde\xc6\xe9\xce\xf5\x82\x19\x94\x3a\xc2\x7f\xdd\x6f\x83\x25\x90\xd8\x67\x58\x16\xae\xf7\x6e\x95\xc4\xfb\xad\xdf\xf1\xe2\x28\x4e\xa6\x8d\x45\x04\x49\x33\x9a\xc9\x53\x1e\xd7\x61\x56\x14\xff\x26\x81\x16\x00\xf5\xb6\xf2\xc9\x6a\xd1\xea\x8f\xaf\x9c\xc6\x04\xfe\xdf\x56\x10\xe5\xa8\x29\xa2\xef\xc3\xd5\xba\x14\xc9\xd5\xa5\xd3\x18\xd2\xff\xca\xd0\xfc\x14\xf8\xe1\x7e\x53\x86\x68\xd0\x1f\x3a\x8d\xfe\x25\x60\x1a\x8c\xca\x30\xfd\x18\x3f\x96\xa1\x19\x8d\x01\xcb\x78\xe4\x34\x46\x43\x2b\x16\x82\x26\x73\x41\x62\x1a\x07\xda\xe1\xd3\x86\xbb\xcf\xe2\x19\x45\xff\xb0\x8f\xbe\x89\xa3\x43\x83\x67\xf4\x07\xbd\xdd\x87\xc6\x59\xb8\x21\x3d\xed\x6e\xb3\x19\x23\x22\x5c\x28\x40\x57\x26\x10\x40\xbd\x7e\x75\x46\x08\x78\xd5\xf8\x63\x1c\x67\x69\x96\xb8\xbb\xc6\xc3\xb0\x3b\xec\x8e\x1b\x2d\x22\xc5\xd3\xd7\xaf\x57\x41\xb6\x10\x79\x5d\x2f\xde\xb4\x19\xfc\x37\xf1\xee\x29\x01\xbe\x67\x8d\x41\xaf\xdf\xef\xc0\x5f\xe3\xc6\x2f\x8f\x61\x96\x05\x89\xd3\xf8\x61\xeb\x75\x19\xd8\x8f\x20\xb1\xdb\x34\xf0\x1b\xc0\x82\x20\x69\xfc\xf4\xc3\x2f\x0c\x71\x4a\x30\x87\xd9\x7a\xbf\x20\x38\x5f\x67\x8f\x8b\xf4\x75\x5e\xcd\xeb\x45\x14\x2f\x5e\x6f\xdc\x14\x90\xbd\xfe\xf1\x87\x6f\xbe\xfb\xf3\xcf\xdf\xb1\x6a\x5f\x03\xbd\x8d\x6d\x9c\x6c\xdc\x28\xfc\x2d\xe8\x7a\x69\x4a\xc8\xed\x75\x87\x8d\x67\x8a\x9b\x57\x07\xbf\x24\xe4\xdb\x00\xd8\xeb\xa6\xaf\xd5\x72\xaf\x5e\x93\xf1\x7d\x90\x85\x3f\x75\xb7\x69\x27\x0d\x92\x70\x39\xeb\x3c\x06\x8b\x77\x61\xd6\xc9\x82\x0f\x59\x27\x85\x32\x1d\xd7\x7f\xbb\x4f\xb3\x69\xbf\xd7\xfb\x62\xd6\xd9\xa4\x78\xce\x71\x11\xfb\x4f\x87\x8d\x9b\xac\xc2\xed\xb4\x77\x74\x13\x10\xf0\x28\x70\xdc\x34\xf4\x03\xc7\x87\x31\x1e\x46\xa9\xb3\x0c\x57\x9e\xbb\xcb\xc2\x78\x4b\x3e\xf7\x49\xe0\x2c\xa1\xe5\xc0\x37\xa2\x5e\xc8\x3f\x44\x62\x76\xce\xc6\x0d\xb7\xce\x26\xd8\xee\x9d\xad\xfb\xe0\xa4\x81\x47\x4b\xa4\xfb\x0d\xa0\x7f\x3a\xf8\x61\xba\x8b\xdc\xa7\x29\xb0\xca\x7b\x77\x74\xf7\x7e\x18\x3b\x9e\xbb\x7d\x70\x53\x67\x97\xc4\xab\x24\x48\x53\xe7\x01\x6a\x8d\x73\xc8\x70\x1b\x85\xdb\xa0\x43\x0b\xcc\x1e\x82\x84\x8e\xbd\x0e\x30\x64\xb5\x9d\x2e\xdc\x34\x20\xb9\x0c\xd1\x74\x1b\x67\xad\x3b\xa2\x7d\x92\x38\x4a\xef\xdb\x39\x8a\x6d\xbc\x0d\x66\xeb\x80\x74\x3b\xb4\xee\x6e\x1d\xfa\x7e\xb0\xbd\x77\xb2\x60\x03\xd9\x59\xa0\xc0\x1d\xdd\x83\x21\xfd\xd0\xb9\x5b\x50\x21\x09\x28\xb5\xa3\x3b\x75\xa1\x45\x0f\xc0\x9c\xe9\x3a\x06\x72\x0e\xf1\x3e\x23\x24\x10\xb6\x2d\x16\xc9\x1d\xd5\x57\xf7\x87\x45\x9c\x00\x4f\x3a\x8b\x38\xcb\xe2\xcd\xb4\x0f\x32\xec\xc3\x67\xe0\x1f\x17\x0e\xc8\x4a\xbc\x5d\xb1\x1e\x7c\x64\x44\x5d\xf6\x7a\x47\x7f\xb9\x65\x69\x54\xcf\x4d\xc3\x0c\x9a\xe8\x1d\xd7\x7d\xd1\x2d\xdd\xc9\x65\xb0\x69\xf4\x66\x0c\x06\x3a\x70\x3a\x08\x36\x47\xc8\x7c\x77\x60\x54\x7e\xd6\xeb\xf5\x66\x05\xed\xd3\xcf\x96\xcb\xde\x31\x05\xd1\xe1\xd2\x42\xcb\x5c\x41\x67\xa7\x7b\x20\x62\xbf\x3b\xec\xe2\x34\x24\x9d\x33\x4d\x02\x60\x03\xb4\x49\xc2\x7d\x39\xfe\x62\x46\xf9\x2e\xd8\x66\x65\x3d\xc1\x94\xc5\xbb\x69\xa7\x3b\x06\x7a\x00\xf7\x81\x37\xba\xd3\x1d\x90\x94\x70\xb3\xe2\xdc\x00\x16\xa5\x0f\x2b\xda\x4b\xd3\x04\x44\xa7\x7d\x20\x0c\x5c\x46\xf1\xe3\x94\x75\xc9\x91\xc9\x95\x68\x71\x1f\xda\x3b\x82\xe1\x7f\x5c\x27\x87\x9c\x0c\x21\xe1\x8b\xf8\x03\xa1\x34\xdc\xae\xa6\xdc\xde\x90\x24\x10\xf1\xf8\x37\x5b\x1e\x9e\x7c\xdc\x41\x8d\x39\x21\x44\x5b\x1d\xbd\x18\xc4\xfe\xdd\xc2\x07\x91\x0c\x9c\xd4\xdd\xec\x94\xe1\x96\x1b\x14\xa7\x30\x2d\x05\xe3\x80\xe8\xe3\x62\x0f\x0c\xd8\x3a\xe1\x76\xb7\xcf\x9c\x78\x97\xb1\x81\x01\xfc\x82\xc1\xe0\x90\x01\x08\xa2\xe4\xe6\xc3\x8d\x16\x06\x31\x5f\xc3\x08\xce\x66\xac\x2f\xf9\x2f\x8e\xa9\x20\xef\x21\x4c\x89\x39\x16\x35\x30\x94\x07\x3a\xa6\xa9\x90\x2e\x41\x57\x30\x31\xe6\x10\xd4\x19\xa0\x84\xdc\x65\x60\x5d\xe7\x2c\xf9\xde\x91\x92\x60\xcc\x05\x99\x92\x02\x9d\xb8\x09\xb3\xfb\x83\xe0\xb5\xbb\xdb\x05\x2e\xa0\xf7\x82\x29\x2b\x3f\xf3\xf6\x49\x0a\x64\xee\xe2\x10\xf8\x98\xf0\xca\xee\x60\x1c\x11\xd5\xef\xdf\xcb\xd5\xe6\x89\x07\x5e\xc8\x0f\x96\xee\x3e\x12\x6d\x9b\x4e\x69\x97\x2d\x63\x6f\x9f\x76\xc2\xed\x16\x14\x09\x2d\x67\xa6\x1f\x76\xae\xef\x93\xce\x03\x29\x17\xf2\x44\x41\x0f\xb2\xa0\x32\x6d\x79\x94\x5a\xe3\xad\x03\xef\x1d\x74\xb4\xda\x68\x17\x14\x46\xd1\x42\x49\x34\xf2\x91\x6b\x0a\x93\x94\x85\xa7\xe6\x14\xca\xf5\x6f\xf7\x9b\x45\x90\xdc\x43\x83\x78\x65\xb4\x35\x9d\x74\x17\x6e\x3b\xb2\xa4\x58\xa0\x41\xbf\xa8\xd0\x62\x2c\x50\x51\x95\x7b\x0d\xfa\xc8\x5b\xa3\x6d\xfa\xb8\x11\x32\x43\xe4\x80\x88\xdc\x32\x0c\x22\x1f\xa1\xa0\xa0\x9d\x25\x74\x3c\x52\x24\x42\x1a\x6b\x2b\xe0\x83\xe9\x4b\x5c\xa2\x9b\x30\x19\xa4\xf2\x4d\x2b\x07\xc1\xcd\xa5\xa2\x3b\x04\x6d\xd3\xe8\x4e\x06\xf4\x9f\x4b\xf8\x7b\x26\x46\x58\x63\xb0\xfb\x20\x64\x86\xa8\x62\xf0\x10\x43\xbf\x91\x86\x11\x0c\xab\x63\x14\xac\x82\xad\x8f\x09\x57\x3e\x52\x55\xed\x20\x06\xb4\xa1\xc1\xa9\xdf\x23\x34\x3f\xd1\x0b\x32\x3e\x62\x4a\x22\x77\x97\x06\x53\xf1\x71\xcc\x7c\x27\x5b\x17\x15\x1f\x89\x93\xf0\x73\xbc\x4f\xa0\x89\x0d\xc4\xd9\x58\x8f\x17\x3b\x6a\xfc\xc7\xd0\x29\x61\x14\x24\xd4\x78\x29\x4e\x47\x9a\x78\xaf\xc1\x49\x78\x4d\x6c\x30\xf7\x16\xfe\x6d\x03\xee\xa1\xdb\xd8\x25\x30\x52\x0f\xaf\x9c\xa9\xbb\x24\x26\x7b\xba\x08\x40\x55\x04\x92\xe5\x90\x5c\x2c\xe6\x22\xac\x5d\x1f\x5a\x4c\x78\x2d\x65\x49\xe6\xa5\xd7\x90\xcb\x28\x42\x87\x17\xb5\xe5\x1c\x5d\xb0\xa5\x44\xb1\x81\x79\x64\xaa\xac\xe8\xfe\x29\xf5\xbf\x98\x89\xbf\x5b\x27\xc1\xf2\x9e\x35\xe0\xc0\xc5\x73\xda\x6c\xb4\x9a\x0d\x37\xcb\x92\x16\xc9\x6d\x37\x9a\xed\xa6\x6c\x87\xad\xd0\x34\x9b\x83\x53\xc4\xbf\xce\x9b\x6f\x5d\x70\x43\xbc\x24\xdc\x01\x20\x2f\xe9\xe4\x99\x9f\x35\x0d\x64\xcd\x23\x75\x4a\xde\xef\xc1\x0b\x22\xa6\xe2\x60\x88\xd8\x67\xd7\xd7\xd7\xa0\x14\x56\xe0\xbe\x80\x1c\xbd\x83\x91\x4f\x3c\xaa\xa9\xfb\x10\x87\xfe\x31\x23\x7e\x53\xee\x7b\x50\xe1\xe9\x30\x57\xaa\x43\xe5\x8b\x58\x4e\x27\x23\x6a\x0f\x2f\x4f\x0c\xeb\xc6\xfd\xc0\x26\x56\xd4\x8d\x93\x78\xba\x1e\x38\xeb\xa1\xb3\x3b\xc4\xc9\x6e\x0d\x76\x61\x3a\x9c\x01\x58\xfc\x08\x1f\x2c\x4b\xc6\x4a\x9b\xc5\x91\x76\xc1\x69\x5b\xb8\x89\xea\x12\x75\x17\xd9\xf6\xa6\xeb\xc1\x58\xc8\x9c\xae\x9f\xc4\xbb\xfd\xee\x46\x4a\x13\x22\x0f\x5e\x40\x07\x13\xa8\x63\x37\x72\x17\x41\x84\xb0\x07\xc0\x8e\x5d\x65\xd8\x18\xa3\x44\x46\xc3\x26\x16\x30\x6c\xc4\xd7\xda\xf4\xd5\xc0\xeb\x59\x1a\x65\x3a\x0c\x3b\xf8\xf3\x79\x61\x29\x69\x8d\x50\xe6\xfb\xbe\x84\xe5\xf8\x6f\xdc\x01\xf0\x02\xc5\x15\xf8\xf2\xdf\xa3\xa7\xdd\x3a\x04\x89\x48\x1b\xdf\xbb\xd1\x12\x04\x75\x95\x7e\x39\x83\x61\x38\xdd\x27\x51\xab\xdb\x7d\x4d\xa0\xd3\xd7\xab\x1c\xac\xb3\x16\x60\x9d\x24\x58\xed\x23\x37\xe9\x06\xe0\x09\x9d\x5e\xe4\xf6\xb3\x30\x58\x86\x1f\xda\x0d\x62\xf2\xdd\xac\xf5\x65\x00\x76\x03\x9c\x28\xbf\x13\xef\x40\x3a\x41\xbb\x7e\xd9\x76\xea\x63\x7c\x8c\x97\xcb\x41\x81\x8c\xfe\x3c\x19\x81\x5a\xfe\xa4\xe2\x59\x26\x95\xce\x92\x7d\x70\x72\x0b\xc0\xb5\xfc\xac\x00\xf8\xbf\x39\x00\xcf\x2f\xb0\x03\xe0\x97\xed\x63\x37\x87\x45\xfc\x60\xe2\xcf\x82\x30\xcc\xd0\x39\x48\x0d\x01\x90\xfc\x78\xe6\x8f\xcc\x64\x5b\x31\x02\x3f\x5d\x76\x59\xfa\xb9\xf6\x64\xe5\x36\xe0\x1b\xaf\x89\x49\x00\xd1\x0b\xc1\xdb\x06\x4f\xdb\x67\x66\x3b\x4e\x3f\xe8\x30\xab\xc4\x7d\xa2\xb1\x14\xa9\x45\x1d\x6a\x0d\xc2\xf4\x5d\xa1\xe6\xb9\xca\x7a\x33\x70\x9b\x32\xe0\x2e\xda\xa7\x08\xd0\x42\x01\x0a\xf6\x09\x87\x71\xd4\xd4\x18\x29\xda\x73\x3d\xa5\xf0\x26\xdc\xa2\x55\x0c\xfa\x03\x05\xce\x8b\xe2\xbd\x8f\xc0\x4d\x7a\x7d\x95\x98\xed\x43\x10\x81\x88\x23\xa0\x97\xbd\x6b\xb5\x71\xc1\xd6\x0b\x23\x14\x70\xa9\x00\xae\x60\x9a\x8d\xd0\x18\xf4\xb4\xba\x37\xfb\x34\xf4\x50\x38\xb5\x2d\xcc\x8b\x41\x01\x87\x0a\x20\xa8\xfb\x24\x43\xe1\xc6\x2a\x42\xf0\x43\x50\xb0\x89\x01\xd6\x81\x49\x6d\xf6\x84\x02\x5f\x2a\xc0\xfb\x34\xc0\x71\x5e\x29\x60\xcb\x30\xda\xa0\x60\x2a\xaf\xb3\x75\x07\x06\xd9\x0a\xe9\x96\xa0\xd7\xef\x69\xa0\x28\x50\xdf\xc0\x17\xa6\x28\x6f\x34\xc1\x89\x11\x29\x07\x20\x95\xd1\x49\xb0\x01\x27\x0e\x05\x1c\x29\x80\xbf\xc5\xf1\x06\xcc\x2c\x0a\x39\x36\x21\xc1\x39\x47\x41\xd5\x7e\x01\x65\x88\x42\xa9\x1d\x92\xc2\xb4\xda\x45\xc4\x15\x00\xd5\x2e\xf1\xe2\x15\x0a\xa5\xf5\x48\xe2\xa6\x28\xa7\x07\x6a\x77\xac\xe3\x0d\xca\x98\x41\x5f\x97\x03\x1c\x4c\xed\x8d\x2c\xb4\x60\xd3\xfa\x23\x76\x91\xc1\x0e\x60\x6a\x6f\x80\xc7\xb2\x8d\x00\xb4\xe3\x46\x28\x9f\x07\x63\x14\x1c\x05\x55\xbb\x64\xbf\xb3\x02\xaa\xbd\x12\x6e\xc1\x71\x45\xe1\xae\x34\x4d\xea\x3e\x75\xbc\x30\xf1\x2c\x6c\xba\xd6\xe4\x11\x66\x33\x68\x93\x86\x3d\x0d\x70\x09\xf3\x73\xb4\x1f\x87\x6a\x07\x91\xe1\x62\xe3\xd3\x50\xed\x24\x62\xc6\x50\x30\xb5\x93\x96\x91\x8b\x0a\xda\x70\xa4\x2b\x31\x7f\xb7\x06\x3f\x11\x55\xa1\x43\xb5\x8b\x1e\xe2\x68\xbf\x09\x6c\x23\x62\x38\xc1\x80\x49\xb7\xa2\xd0\x97\x18\xf4\x7e\x87\xc2\xaa\xbd\xf5\x3e\x21\x31\x1e\x14\x50\xed\x28\xf0\x85\x6d\x90\x23\x4d\xad\xe1\xcc\x1a\xf5\x75\x28\x94\x4d\x23\xb5\x87\x16\x31\xae\xd6\x46\x43\x03\x8c\x44\x00\x51\x50\xb5\x97\xe8\x04\x10\x85\x53\x3b\xc8\x73\x37\x41\xe2\xa2\x80\x6a\xe7\xd0\xa8\x15\x06\x76\xa9\x91\x18\xa1\xc3\x6c\xa4\x76\x08\x0b\x77\xa2\x80\x9a\x5a\x23\x13\x44\xee\x38\x21\xd0\xe3\x9e\x09\xcd\x26\x48\x18\xb0\xda\x37\x34\xb0\xd9\x89\x82\x25\x8e\x79\x80\x00\x7b\x01\x89\x7f\xa1\xe0\x43\x04\x3c\xb1\x92\x3d\x42\xa0\x49\x78\x3e\x5c\xa2\xb6\x7c\x3c\x36\xc6\x3e\x0a\x36\xd1\x74\x99\x4f\x42\x3a\xd6\x16\xea\x9a\x8f\x42\xdb\x69\xd6\x1c\x05\x98\x1c\x11\xed\xdf\xa1\xe1\x7b\xb4\x80\xe6\x9e\x85\x5e\xb6\x4f\xd0\xa1\x35\x51\x7b\x71\xe3\xee\x3a\x44\xcc\x71\x4e\x4f\xb4\x8e\x61\xcb\x1a\x18\xe0\x50\x33\x55\xb8\x00\x4f\xd4\xbe\x08\xfc\x10\x07\xd3\x5c\xb4\xb5\x6b\x69\x8b\xda\x07\x34\x1a\x89\xc2\xa9\xdc\xb7\xf9\x2b\x93\x2b\xcd\xe5\x0b\x76\x1d\x32\x09\x7e\x74\x13\x74\x9c\x4d\xae\xb5\x5e\x02\x2b\x51\x06\x7f\xd9\xd3\xf4\x5f\x09\x68\xdf\xb0\x80\x28\x98\xda\x3f\x3b\x17\x3c\x4f\x14\x6e\xa8\xb5\x2c\x46\x35\xf9\xe5\x48\x53\x43\x89\x95\xbe\xb1\xd9\xf4\x32\x70\xdd\x99\x06\xce\x96\x81\xab\xfd\x15\xbc\x0d\x3c\x54\x4e\x2e\xaf\xf4\xfe\x7f\x48\x62\xbb\x9a\xb9\xbc\x46\xc1\xad\xa3\xf0\xaa\x67\x4c\xe8\xa8\x27\x89\xc2\xf6\xcd\xa9\x99\x1d\x78\x80\x78\xd0\x76\xe8\xa1\xe6\x94\xdb\x21\xd5\xfe\x7b\xbf\x0f\x52\x32\xf9\xb6\xc3\x8f\x35\xad\xb4\x8c\xed\xb0\x5a\x17\x7a\x49\x10\x6c\xd3\x75\x8c\x73\xee\x12\x6b\xa0\xdd\x85\xbb\xba\xd2\x9b\x58\x02\xab\x7b\x11\xdb\x12\xe0\x6b\xb5\x0b\xdd\x24\x89\x1f\xad\xf2\x71\xdd\x47\x80\xad\xd2\x71\x3d\x40\xa0\x71\x0f\xe9\x7a\x88\x80\xda\x5c\xaf\xeb\x91\xa9\xfc\x6c\xce\xe7\xf5\x58\xe3\x33\x5d\x7d\x5e\xee\x23\x74\xae\x73\x3d\xc1\xa0\xe9\x32\x26\x0a\xae\x8d\xc2\x0f\x5e\xe4\x6e\xdc\x32\x81\xea\x6b\x93\xfa\x55\x88\x32\xba\xaf\xcd\xe9\xa3\xc0\xc5\x5c\xd6\xbe\x36\xa3\x5f\x86\xa8\x15\xe8\xf7\x34\xa3\xf2\x14\xd0\x38\x1d\x0a\x3a\x36\x40\xbd\x28\x46\x75\x66\x5f\x0b\x00\x80\xae\xda\x86\xdb\x95\xbd\xe9\x97\xba\xc6\xde\xe2\x68\x35\x9d\xe5\x46\xc1\xd6\x47\x43\x10\x7d\x2d\x0e\x90\xb8\x5b\x3f\xc6\x02\x06\x7d\x2d\x0a\xe0\xc5\x9b\x4d\x80\x1a\xe0\xbe\x16\x0a\xd8\xb8\xab\x6d\x80\x03\x0e\x50\x5d\x89\xca\x77\x5f\x8b\x08\x08\x60\x8b\x84\xf7\xb5\xb8\x40\x12\x64\x8f\x81\x85\x0a\xdd\x11\x88\x77\x3b\xd2\x09\x1e\x1e\xdb\xe9\xf7\x75\x3f\x3a\xa2\x81\x6f\x5b\x17\x6b\x51\x02\x0e\x6e\x13\x1e\x2d\x54\xc0\x87\x8f\x58\xbb\x47\x4b\xe8\x33\x53\x5a\x62\x1d\x27\xe1\x6f\x00\x85\x97\xd1\x43\x08\x3e\x66\x21\xfb\x5a\x04\x61\x01\x23\x1e\xd0\xa2\x64\x6b\x51\x84\x45\x80\x8e\xf6\xbe\x16\x45\xf0\x48\xb3\x96\xd0\xb0\x0c\xe5\x9c\x16\x4c\xc8\xd6\xfb\xcd\x22\xb5\x48\x87\x16\x49\xe0\xb0\x36\xe1\xd0\x82\x09\x6b\x10\x7a\xab\x0e\xee\x6b\x01\x05\x0a\x6c\xd1\xee\x7d\x2d\xa8\x40\x61\x2d\x04\x5f\x9b\x90\x36\x72\xb5\x98\x02\xb3\x44\x15\xa6\xa3\xaf\x85\x17\x94\x42\x36\xf2\xb5\x38\x83\x52\x06\x6f\x86\x16\x72\x50\x4a\x58\x9b\xa3\xf6\xeb\x2a\x8a\x17\x68\xff\x6b\xa1\x87\xc7\x24\xd8\xa2\x51\xd9\xbe\x16\x76\xc8\xdc\xf4\x1d\x36\x49\xef\x6b\x01\x87\x65\x18\xe1\x93\xbf\xbe\x16\x6d\x58\x24\x61\xb0\xf4\x5c\x7c\x7c\x6b\x01\x07\x62\x17\x99\xdf\x82\x01\x6b\x31\x07\xdf\x4d\xd7\x8b\x18\x77\x50\xfb\x5a\xe4\x61\xe7\xd2\xcd\x95\x21\xda\x0d\x5a\xf8\x81\xc6\xa5\xad\x91\xe4\xbe\x16\x85\x88\xc2\x2d\x36\xa3\xe9\xeb\x11\x08\x12\x23\x42\xe1\xd4\x7e\xda\xed\xd3\xf5\x0e\x0d\xc1\xf6\xb5\x10\xc4\x3e\xc5\x1b\xae\x72\x7f\xb5\xc0\x9b\xac\xf2\x3d\x8d\x71\x6d\xad\x05\x14\x08\x58\x67\xf1\x04\xbe\xce\x6e\xed\x2e\x70\x83\xa0\x85\x15\xf4\x22\x16\x3f\xa9\xaf\x05\x18\x44\x31\xb6\x34\x89\xc1\x0f\xed\xf0\xd6\x3a\x46\x38\x69\x59\x96\x84\x8b\x7d\x86\x86\xf0\xfa\x5a\xb0\xc1\x2c\x64\xad\x4d\xeb\xae\x2d\x9d\xfc\x06\x68\xa7\x8d\x75\x47\x6e\x07\x1a\x0d\x05\xd4\x83\xe1\x6c\x9d\xd8\xaa\x2d\xb4\xa8\x43\x0e\x8f\xeb\x23\x2d\xf2\x10\xc5\x2b\x7c\x35\xa0\x3f\xe9\xeb\xb1\x52\x34\x4a\xdb\x9f\xe8\xa1\xd7\x95\x65\xd1\xa0\xaf\x85\x27\xb6\xc1\x63\xe7\x31\xdc\x92\xfd\x12\x18\xb0\xee\x9e\x78\x31\xae\x05\xf4\x30\x85\x8b\x86\x15\xfa\x5a\x94\xc2\xe6\x5e\x68\x41\x0a\x82\x0d\xaf\x55\x8b\xee\xd1\x95\x74\x14\xf0\x5a\xef\x76\x0b\xa0\x16\x97\x48\x03\x5c\x3a\x2e\xf5\x6e\x01\x67\xec\xa9\xe3\xa3\x6b\xa1\x00\x3d\xc0\xa0\xad\xad\xba\xd4\xe3\xe3\x14\xdc\xba\xb6\xd4\xd7\x43\x15\x05\x7a\x14\x7a\x8c\x41\xdb\x7a\x42\x8b\x56\x80\xc5\xf0\xc3\x8c\xf8\x9c\x38\xe5\x6a\xbf\xb1\xbd\x82\xb8\x5a\xd1\xe3\x15\xfb\x2c\x0a\x12\xd4\x0c\x68\xa1\x0a\xb6\x77\x05\x03\xbc\x32\x5c\xff\x1d\xd9\xe8\x8b\x33\x59\x0b\x52\x80\x25\xb2\x1a\x0e\x2d\x44\x41\xe1\x6c\xba\x48\x0b\x50\x64\xf1\xa3\x85\x56\x4d\x43\x66\x6e\x86\x2a\x45\x2d\x2c\x91\xfa\xd6\xb8\x67\x5f\x8b\x4a\xac\xcb\x40\xb5\xf1\xb5\x5f\xd0\x8d\x4a\x38\x05\x5a\x24\x90\x6e\x82\x21\x0b\xff\x16\xd4\xba\xbd\xdb\x53\x8f\x31\x5a\xa0\x7d\x7b\xad\x9b\x3d\x02\x3d\xee\xf4\x51\x58\xdd\xde\x11\xd8\x89\x05\x56\x37\x72\x04\xf6\xd2\x02\xab\xf9\x86\x62\xeb\x7e\xc7\xb2\xe4\xd1\xbf\xd6\x95\xe2\x2a\x24\x1b\xf3\x69\x34\xc0\x5a\x46\x5b\xfe\x20\xdb\x10\xca\x16\x12\xfb\x5a\xc4\x81\x15\xb0\x2e\x27\xf6\xaf\xaf\xb4\x91\x17\xc0\x74\x3e\xde\x86\x96\xd1\x77\xad\x2f\xe2\x02\xb8\x1f\x78\xa1\xbf\x8f\xb1\x6d\x14\xc1\xa0\xa7\x8d\x2d\x8c\x88\x81\x16\xf2\x20\x1a\xc8\xb6\xa0\x3b\xd0\xe2\x1e\x44\xff\xd8\x61\x35\x47\x30\x78\x08\x22\xdc\xb0\x0e\xb4\x00\x08\xe9\x4c\x14\x4c\xf3\x05\xc9\x4e\x16\x14\x4e\x1d\x53\x2e\xe8\x28\x6c\xd8\x0f\xb4\xf0\x44\xf0\x7e\x4f\x8f\x52\x60\xbc\x1f\x68\x11\x8a\x77\x74\x73\x2f\x02\xd6\xd7\x03\x98\xa8\x86\xd6\x37\xb8\xec\x5c\xd4\x3f\x19\x68\x71\x89\x45\x48\x02\x08\x28\xa0\xca\xc1\x77\x5b\xcb\xcc\x6d\xa0\x05\x24\x16\x2e\x38\x6b\x00\xb4\xd9\x47\xd8\xba\xde\x40\x8b\x47\x64\x68\x54\x66\x30\x59\xaa\x3b\x87\xe8\x99\x1f\xdb\xdc\x63\xa0\x85\x21\x16\xa8\xaa\x1f\x68\xa1\x07\x77\xb7\xc3\xc4\x6c\x79\xb5\x54\xb7\xeb\x04\x09\x3e\x95\x1a\x68\x01\x87\x75\xbc\x4f\x2c\x5b\x7b\x06\xc3\xbe\xba\xc7\x29\x72\x37\x28\xd3\xb5\x88\x83\x0f\x03\xdd\x16\x6f\x18\x68\xf1\x86\x5d\xb8\x5a\x3d\x91\xd0\x2f\xa6\x77\x06\x5a\xc0\x21\xf5\xc2\x14\x1c\x6b\x74\x88\x6b\xd1\x86\x45\x98\x79\x31\xea\x94\x0e\xb4\x50\xc3\x22\xc3\x56\x54\x75\xa8\x0f\x0b\x54\x8a\x34\xa8\x27\x4c\xc8\x7b\x3d\x57\x6d\xc6\x5b\x6c\x54\x1b\x50\xc9\x7e\x81\x75\xf4\xa0\xb7\xf0\x75\xb8\x1a\x50\x74\xf7\x1b\xd6\x02\x2d\xec\x41\x0e\x21\x46\xe0\xfd\xa3\x7a\x47\x8b\x76\xe4\xb0\x24\x18\x90\xe1\xd2\xab\x05\x3b\x02\x7f\xef\xb1\x3d\xcb\x18\xac\xb6\x3c\x42\x8f\x51\x95\x07\xd9\x06\x5a\x98\x83\x97\x29\x09\xe5\x0d\xb4\x80\x07\x39\x84\xd5\x59\xbb\x9b\x05\x0c\x03\x5c\xe3\x69\x81\x8f\x4d\xec\xbb\x91\x7d\xd2\x31\xd0\xe2\x1f\x31\xb6\xb9\x0e\xa0\xb4\xe9\x77\xe2\xe2\xc2\xaa\x05\x3e\xd2\xfd\x96\x0e\x56\xd4\xd9\x19\xe8\x9b\x2d\xc4\x29\x36\x14\xb6\x6f\xc2\xb2\xcd\xc1\x18\xf0\xc0\x04\x96\x76\xb9\x63\x25\xb4\xbe\x5c\x90\x95\x3f\xbe\x64\x8f\xaf\x59\x0e\xb4\x48\x88\x52\x84\x9f\x96\xc2\x4a\x8d\xed\xa5\xca\x45\x47\x8b\x93\x28\x25\x2d\xb1\xbb\x81\xb6\x6f\x43\x29\x53\x26\x74\x5a\xb4\x45\x29\x67\x0b\x2e\x0e\xf4\x4d\x1d\x49\xe8\x42\xef\x07\xf6\x02\xfa\xbe\x0e\x51\xc0\xd6\x1a\x2d\x06\x93\xc3\xdb\xb9\xad\x85\x5f\xf2\x12\x96\x2e\x1d\xeb\xce\x29\x3d\x77\x8c\x42\x6a\x33\x8a\xfd\x2e\x48\xf8\x31\x03\x0c\x7a\xac\xcf\x00\x4a\x60\x27\xe6\x78\xb7\x32\xe4\xd2\x84\xb5\x73\xfb\xca\x04\xb6\xc4\x57\x06\x5a\x7c\x85\xc2\xe2\x2e\x20\x89\xad\xbc\xfa\xc4\x47\xae\x8e\xda\x81\x96\x4f\x8c\xbd\x38\x6b\xcb\x0e\xf7\xf5\x76\xc5\x69\xa8\xcc\xdd\x75\xd6\xc0\xc1\x88\xce\x49\x98\x82\x49\x56\x0b\xb7\xd5\x73\xe8\x9f\x36\x3b\x55\x2b\x6f\x17\x6f\x7e\x1f\x44\x0f\x01\x19\x4a\x8d\x3f\x07\xfb\xa0\xe9\xe4\xbf\x9d\xaf\x41\xde\x22\x47\x3a\xca\x2b\xd5\x3a\x82\x5a\x95\x0d\xe3\xdd\xd1\xe0\x6a\x7c\xd9\x1f\x0d\x67\xfc\xd0\xc3\x70\x38\x9c\xa1\x47\x21\xd4\xb3\x88\xfa\x11\x44\x99\x36\x71\x00\xb1\xa8\x57\xa4\xc8\x55\x8b\x83\x89\xee\x21\xaf\xf9\xd2\x5d\x5c\xce\xf4\x73\x3b\xec\x28\xed\x94\x1e\xdf\xcb\x8f\xca\xf2\x22\x60\xa7\x06\x97\x9e\x51\x44\x3a\xea\xc3\xca\xe5\x47\x6b\xc9\x4e\x77\x7e\x7e\x76\x26\xd2\xc6\xbb\x0f\xf4\x68\x79\xa3\xd8\x3b\x4f\x4e\x0a\x26\x74\xe5\x8d\xd4\x23\x20\xc9\x5e\xc3\x34\xc8\xa6\x9d\xc1\xee\x83\x76\xc0\xb4\x47\xcf\xd0\x68\x07\x5b\x37\xa1\xef\x93\xdd\xf4\x9e\x0b\xbc\x04\x86\xb1\xe3\x7a\x37\xdd\x30\x0b\x36\x37\xee\x0d\x39\x94\x83\xe7\xd1\x1c\xf8\x8b\x2c\xa1\xed\x40\x1d\x90\x43\xc2\x5d\xba\x90\xb4\x75\xc3\xa8\xc1\x8b\xe6\x09\xe4\xa7\x7a\x1c\x7a\xa6\x9e\xe6\x99\xc9\xe7\xfc\x18\x62\xd2\xb9\x81\x2f\xce\xca\x90\x33\x8c\x30\x29\x9c\x40\xbb\x68\x76\x8e\x1a\x3f\x3b\x6d\xc7\x9e\x9f\x5b\x2c\x11\x34\x54\xba\xcc\x43\x75\xe4\xe0\xcc\x4c\xa5\x6f\x24\x8f\x19\x12\x78\x62\x87\x2d\xdc\x28\x6a\x74\x07\x69\x23\x00\x67\x1e\xf8\x48\xa2\xa2\xb3\x4e\x5c\x05\x51\x9e\xcd\xf8\xc0\x16\x91\x34\x2e\x8d\x7b\x5f\x90\x73\xc4\xac\xe7\xa9\x52\x27\xd7\x0f\xf0\x23\x82\xc2\x2c\xd0\x24\x71\xfe\x6f\x56\x1c\x6b\x92\x1b\x18\x04\x20\x1c\x69\xd2\x89\xb7\xd1\x53\x71\x74\xc4\x5d\x40\xf6\x3e\x0b\x66\x9c\xc3\x80\x47\xf0\x70\x27\x9d\x0b\x15\x47\x12\x3b\x24\x55\x3b\xfd\x3c\xa3\x8b\x33\x09\x0c\xd0\x5c\x83\x14\x67\x11\x45\x8d\x4c\xcc\xc9\x01\x26\x71\x0e\x1d\xc9\x61\xa3\x27\xa7\x8d\xc4\xb0\x42\x8f\x53\x46\xfb\x5b\xee\xfb\xfc\x18\xb2\x7e\xc8\x98\xd1\x43\xa5\xef\x2e\x01\xdb\x26\xce\x0e\x1f\xb4\xc3\xbf\xdd\x75\xdf\xe9\xae\x07\xf0\xdf\x10\xfe\x1b\xc1\x7f\x63\xf8\x6f\xe2\x40\x32\x3b\x85\x06\x69\x90\xb4\x9e\xd8\xd5\x0d\x3f\x18\x33\xd6\x0f\xc6\x74\xfb\x33\xf5\x3c\x34\xd4\xd5\xe8\xd2\xcd\x20\x0e\xf9\x14\x5f\x83\x22\x71\x90\x27\x0e\x8b\xc4\x61\x9e\x38\x2a\x12\x47\x79\xe2\xb8\x48\x1c\xe7\x89\x93\x22\x71\xc2\x13\x8b\xca\xf3\xba\x8b\xaa\xf3\x9a\x8b\x8a\xf3\x7a\x8b\x6a\xf3\x5a\x8b\x4a\xf3\x3a\x8b\x2a\x45\x8d\x87\xf2\x63\x43\x7c\x20\x5e\x5e\x5e\x2a\x9d\x20\x18\x5f\x21\xec\xc4\x98\x7d\x2c\x43\x5f\xca\x11\xc9\xa6\x4e\xc6\x5f\x1c\x15\xb1\x11\xd2\x22\x51\xdf\xb7\x52\xff\x71\xfd\xf9\x51\xdd\x22\xee\x49\xa0\xbc\x5f\xf7\xa5\xc4\x21\x55\xc9\xa4\x0f\x06\x72\x2a\xa3\x78\x48\x7a\x46\xba\xc4\x61\xc4\xda\x01\x24\xc8\x8e\xc6\x15\x4d\x05\x3e\x8c\x0f\xaa\x23\x70\xa4\x3c\x9a\xc8\xa9\xc4\xb0\xed\x72\x9b\xd6\xe8\x35\x18\x6f\x22\x72\xbc\x14\xd1\x6f\x52\xc9\x89\xf8\xc9\x45\x6c\x68\x0c\xc0\xd1\x91\x1f\x20\x6e\x6d\x00\x0d\x53\x21\x97\x13\xa0\xae\x7d\x60\x15\x48\x2d\x01\x9d\x76\x3c\x72\x56\x19\xf7\x4e\x10\x3e\x91\x18\xac\x43\x6f\xac\xc8\x0f\x6d\x0f\x82\x0d\x66\x5a\xbc\xe5\x55\x30\x3c\x76\xa9\x8b\x40\x3c\x5a\x76\x2e\x98\x19\x68\xf2\x9b\x67\x51\x07\x56\xce\xa3\x09\x3c\x93\xed\xcd\x96\x73\x59\x0a\xcf\xe6\xbb\xab\xe5\x7c\x9e\xc4\x01\xb6\xf1\x63\xe2\xee\x0e\xf4\xf2\x1f\x7a\x9c\x9b\x1c\xe6\x23\x49\x82\x2e\xb2\x84\x40\x56\xf5\xf5\xfb\x17\xf2\x0c\x0e\xb8\xdf\xed\x70\xc0\x3c\x43\x50\xec\xee\xe8\x3e\xf8\xdf\x0c\xc8\x22\x87\x83\x6e\xf6\xe4\xb4\xb4\xac\x00\x68\xf2\x2e\x09\xe9\x35\x2b\x8a\x73\x76\x74\x95\x4c\xe1\x94\xa9\x89\xaa\x87\x76\x35\xe9\x5d\xf7\x38\xce\x74\xef\x79\x41\x9a\xe6\x38\xbd\xcb\xc9\xd0\x17\x38\x79\xa6\x8a\x53\x24\xaa\x38\x17\xe3\xd1\xc0\xe3\x38\xc9\x2e\xce\x1c\x61\xff\xb2\x77\xb5\x14\x08\x49\x8e\x8a\x8d\xa6\xa8\xa8\x46\xe3\xc1\xe4\x9a\xa3\xe2\x7b\xde\x44\xde\x95\x3b\xf1\x87\x0b\x81\x8d\x67\xaa\x08\x45\xa2\x82\x73\x32\x19\xf7\x73\xf2\x7c\x98\xfa\x15\x59\xee\xf5\x68\x34\x1a\x08\x94\x2c\x4f\xc5\xc8\xd3\x14\x84\x57\xa3\xe1\x78\x38\x3a\x76\x17\x2b\xbd\x57\xa8\xe3\x64\xc8\x7c\xde\x57\x45\x81\xbc\x12\x29\x89\xd5\x61\x16\x17\x5d\x06\xa0\xa2\xc3\x4c\x20\x7f\xb9\xec\xf9\x57\xac\x0e\xbd\xe7\xa4\x24\x5b\x1d\x5e\x3f\x18\x2c\x86\xb4\x0e\xda\x81\x48\x05\xd7\x81\xbf\xe4\x8d\x50\x7a\x52\xfc\xb6\xa1\x76\x97\x50\x34\xa0\xa8\x45\x87\x5a\xd5\x82\x2b\x41\xc9\x15\xa8\xfd\x8a\x14\xbf\x0c\xbc\xc5\x98\xd6\xc1\x3b\x18\x81\x19\x80\x83\x1d\xb0\x2a\xb4\x9e\x2e\x52\x6c\x15\x04\xa3\xc5\xf5\x02\xe4\x92\x9e\xad\x67\xcb\xa1\x42\xd3\x09\x0d\x7c\x9d\x1b\xb2\x29\xb9\xda\x06\x94\xb5\xe4\x73\xca\xd7\x05\x49\xde\x66\x1c\x39\xfb\x48\x36\x87\x3d\xcc\x16\xc6\x51\x03\x00\xe1\xef\x3d\x01\x6f\xd0\x42\x8d\xa2\x1c\x07\x05\x09\xa1\x07\xc5\xf6\x5b\x7a\x3c\x39\xbf\xf7\x82\xc5\x0d\x88\xf6\x4f\x8b\x93\xcb\xe4\xe8\x3f\x4d\x60\xf3\x08\x1d\x96\x63\xa6\xbf\x3a\x63\x3a\x75\xb0\x17\xbe\x89\x42\x7c\x5a\x22\x90\xb2\x60\xc4\xb8\xf0\x96\x19\x62\x48\x38\xfa\xa5\xad\x27\x0c\x3c\xfa\xbe\xe3\xab\x17\xc1\x14\x73\x97\x23\xe4\x18\xb7\x2d\xe5\xa6\x91\x35\xa6\xc4\xcc\xf9\x91\x14\x6d\x6b\x10\x5c\x51\xec\x66\xd4\x0c\x09\x6f\x7f\xd2\x43\xdd\xf9\xc0\x4d\x18\x98\x6e\xa1\x58\x42\x5e\x20\x88\xc0\xd3\x4e\xc3\x74\x86\xd9\x1a\xad\x7a\x95\x6e\x7a\x3d\xda\x91\xdd\x78\xe1\xbb\x99\xdb\x01\x48\xc8\x84\xc9\x2c\xbb\xff\xc2\x91\xef\xa4\xe2\x7e\xfb\x3a\x88\x76\x88\xc0\xb1\xf9\x75\x83\x19\x13\x7e\x4b\x5f\x98\x6e\x24\x1b\x7e\x0d\xb3\x46\xab\x05\x2b\xae\xc2\xc8\x8d\x3b\x11\xcb\x86\xe4\x78\x52\xdf\x44\x77\x41\x2e\xbb\xe3\x42\xfe\x45\x8f\xcb\xd2\x5f\x20\x06\x99\x9e\x46\xe4\x10\x87\xb7\x0e\x23\xdf\x91\x32\x76\x96\xf4\xbd\x5c\xc0\x18\x09\x12\x20\xf7\x5a\xa4\x14\x7e\xb7\x99\x94\xc2\x5c\x1a\x75\xc6\xae\x5c\xac\x55\x11\xa3\x21\x8c\x35\xaa\xe4\x71\x2b\xb3\x66\x24\x03\xdd\x04\xff\xe5\x9b\x41\xaf\x3f\x6a\xbc\xe9\xf5\xbe\xee\x7d\x09\xba\x2d\x07\xef\x24\x01\xc8\x57\x2a\x63\xe8\xee\xf6\x51\xc4\x9d\x26\x75\xd8\xf5\x8d\x71\xd7\x33\x85\x56\x4c\xa8\xc5\x40\x95\x7a\x49\xe9\xc0\x1e\x46\x86\xd6\x5e\x0c\x42\x6d\x38\x06\x61\x61\x99\xd4\x2e\x2b\x5b\x65\x18\x1b\x87\x65\x18\x9c\xd9\x28\x87\x45\x9d\x2c\x12\x59\xd2\x32\x3b\x80\x8c\xa0\xb4\x5d\x65\x20\x4a\x2d\x65\xad\x52\xef\xb1\xf9\x92\xca\x4e\x83\xca\xd1\x97\x47\x90\x01\xb2\x37\xc7\x3e\x71\x90\x6f\xb5\xb0\xe8\xdb\xf2\xfb\xd3\x7e\x0a\xb6\x51\xec\xf0\xeb\x39\xbf\xa1\x71\x73\x37\x75\x9a\xdf\xc4\xfb\x24\x0c\x92\xc6\x9f\x83\xc7\x66\x71\xb3\x1a\xc5\x95\x6b\x14\x98\xe9\x34\x46\x8a\xfe\x20\x3a\x49\x78\x27\x97\x83\xf1\x28\xc0\x66\x13\xd7\xcb\xc1\x72\x64\x46\xa5\x8e\x40\x62\x3d\xd4\x36\x8f\x6d\xa8\x21\x1d\x4a\xa1\x2e\xe9\xbe\xa3\x70\x9b\x06\x19\xe8\x3e\x12\xf5\x81\x7f\xa4\x20\x71\x77\x30\x6e\xcf\x6a\x43\x12\x82\x1b\x32\xd1\xf2\x6d\x80\x34\xa8\xa7\x99\x39\xdb\xb5\x4c\xfa\x65\x4c\xf4\x0e\x3c\x55\xb3\x89\x2a\xae\xa9\x7e\xd6\x26\x97\x72\xb5\xc3\x5a\xc1\xe9\x47\xe0\x13\xbb\x6e\x68\xca\x2f\x1d\x8a\x22\x96\x48\xac\x1c\x4f\x23\xbf\xb1\xfe\x1b\x93\x3f\x48\xac\xd1\xf3\x3c\xa4\x57\xa1\x2d\x0d\x45\x6a\x7a\x48\x4c\x5b\x09\x2b\x29\x76\x17\x8a\x53\x9a\x4c\x42\xa4\x6b\x20\xb5\x6a\x41\xe3\x91\x62\xa9\x97\x90\xdd\xa5\xe4\x3a\x23\x12\x6c\xe5\x0c\x19\x8e\x64\xef\xa0\xf3\x34\x65\x60\xc7\x2e\x19\x80\x6e\x28\xdd\x6c\x67\x55\xc6\xfd\xa2\x0f\x38\x8c\x14\xba\x63\x20\x34\x4e\x67\x77\x62\x8a\xba\x78\xfa\x98\x3a\x0e\x66\x81\xeb\xeb\x01\x5a\xe0\xfa\xd2\x52\xa0\x3f\xe8\xf5\xd0\x12\xfd\x3e\x2b\x52\x64\x74\x96\xd1\x3e\xf4\x3f\x59\x6b\xbb\x49\xfc\x78\x50\xe0\x3a\x72\x51\xe6\x97\x92\x14\x42\x42\xd4\x89\x56\x9d\xbe\x93\x7f\xf5\x8a\x4f\x29\x75\x90\x7f\x16\x5f\xc3\xfc\x6b\x94\x7f\x8d\xf3\xaf\x49\xfe\x75\x99\x7f\x5d\xe5\x5f\xd7\xec\x6b\xe3\x8b\xaa\xc9\x57\xaf\xf8\x94\x52\x07\xf9\x67\xf1\x35\xcc\xbf\x46\xf9\xd7\x38\xff\x9a\xe4\x5f\x97\xf9\xd7\x55\xfe\xc5\xab\x4e\x37\xa2\x6a\xf2\xd5\x2b\x3e\xa5\xd4\x41\xfe\x59\x7c\x0d\xf3\xaf\x51\xfe\x35\xce\xbf\x26\xf9\xd7\x65\xfe\x75\x95\x7f\xf1\xaa\x3f\xa4\xa2\x6a\xf2\xd5\x2b\x3e\xa5\xd4\x41\xfe\x59\x7c\x0d\xf3\xaf\x51\xfe\x35\xce\xbf\x26\xf9\xd7\x65\xfe\x75\x95\x7f\x5d\x23\xb7\x39\x11\x59\x35\x83\xf1\xa5\xe2\x77\xfc\x2f\x6c\x40\x31\xbd\x28\xa8\x18\x1c\x8a\x95\x9b\x22\xb5\x2f\xc6\x66\xbf\x3b\x61\xff\xbb\x94\x72\x7b\x3c\xf7\x6a\xd8\x1d\xf2\xff\x15\xb9\xd7\xb9\x1e\x28\xd2\xae\x78\xda\x64\x82\xa0\xbb\xe4\x99\xe3\x2b\x04\xdb\x44\x64\x4a\xd4\x8d\x79\xda\x08\x23\x6e\xc4\x33\x87\x18\x6d\x43\x9e\x39\x90\x68\xcb\x19\x80\xd1\x26\xf8\x80\x91\x46\x9d\x1f\xe0\x1f\xef\x6d\x99\x7f\x2c\xab\xcf\xb3\x50\x26\x32\x90\x1e\x07\x41\x39\x49\x41\xae\x39\x84\xcc\x4e\x9a\x71\xc5\x33\x50\x9e\x52\x88\x4b\x0e\x81\x32\x96\x42\x4c\x04\x84\x4e\xfb\x98\x67\xa0\x2c\xa6\x10\x23\x0e\x81\xf2\x99\x42\x0c\x39\xc4\x40\xa7\x3c\x67\x99\x95\x72\xc1\x39\x2b\xe1\x82\x6f\x4c\x5b\xe7\x39\xe9\x9a\x74\x08\x1b\x6b\x6a\x7f\x90\x9c\x3e\xcb\xb1\x74\x07\x81\xe8\x31\x08\x4b\x6f\x00\xc4\x35\x03\x50\x3b\x03\xd2\xaf\x58\xba\xa5\x2f\x00\xe0\x92\x01\x58\xba\x02\x00\x26\x1c\x40\xa7\x7a\xcc\xd2\x2d\x1d\x01\x00\x23\x06\x60\xe9\x07\x00\x18\x32\x80\x81\x4e\xb3\x60\x94\x95\x66\xce\x2f\x2b\xc9\x9c\x5b\x4a\x1f\xb0\x25\x71\xd2\x0b\x4a\x30\x41\xee\x0c\x01\xd2\x57\x40\xd0\x5e\x11\xa0\x3d\x05\x14\xed\x1e\x0e\x7a\xad\x40\xca\xfd\xc4\x01\xae\x14\x00\xb4\xc3\x38\xe4\xa5\x02\x89\xf6\x1c\x87\x9c\xa8\x90\x66\x5b\xc7\x0a\x00\xda\x97\x1c\x72\xa4\x40\xa2\x9d\xca\x21\x87\x0a\xe4\xc0\x6c\xa9\xd6\x05\x25\x2d\x55\x7b\xa2\xa4\xa1\xbd\xda\xa1\xad\xff\x32\x07\xc1\x30\x72\xb4\x16\xc3\xc8\x51\x32\xac\x46\x8e\xd2\x6b\x35\x72\xb4\x1a\xcd\xc8\x11\x22\xac\x46\x8e\xd0\x6a\x35\x72\xa4\x49\xba\x91\x23\x0d\xb6\x1a\x39\xc2\x17\xab\x91\x23\xec\xd3\x8d\x1c\x61\xae\xd5\xc8\x91\xa6\xda\x8c\x1c\xe4\xd9\x8c\x5c\x9e\x65\x37\x72\x39\x88\xdd\xc8\x09\x10\xc3\xc8\x89\x0c\xbb\x91\x13\x10\x76\x23\x27\x20\x0c\x23\x27\x32\xec\x46\x4e\x40\xd8\x8d\x9c\x80\x30\x8c\x9c\xc8\xb0\x1b\xb9\x9c\x2f\x36\x23\x27\x00\x4c\x23\x47\x73\x50\x23\x97\xe7\x58\x8d\x5c\x0e\x61\x35\x72\x02\x42\x37\x72\x22\xdd\x6a\xe4\x04\x80\xd5\xc8\x09\x00\xdd\xc8\x89\x74\xab\x91\x13\x00\x56\x23\x27\x00\x74\x23\x27\xd2\xad\x46\x2e\x67\x87\xc5\xc8\x89\x7c\xc3\xc8\x41\x46\x95\x91\x93\x40\xaa\x8c\x9c\x04\x5a\x65\xe4\x0a\x50\x8b\x91\x2b\x00\xaa\x8c\x5c\x01\x59\x65\xe4\x0a\x48\x8b\x91\x2b\x00\xaa\x8c\x5c\x01\x59\x65\xe4\x0a\x48\x8b\x91\x2b\x00\xaa\x8c\x9c\xc4\xdf\x72\x23\x57\x00\xea\x46\xae\x34\x94\xf1\x5f\x34\x03\x37\xac\x1c\xad\xc5\xb0\x72\x94\x0c\xab\x95\xa3\xf4\x5a\xad\x1c\xad\x46\xb3\x72\x84\x08\xab\x95\x23\xb4\x5a\xad\x1c\x69\x92\x6e\xe5\x48\x83\xad\x56\x8e\xf0\xc5\x6a\xe5\x08\xfb\x74\x2b\x47\x98\x6b\xb5\x72\xa4\xa9\x36\x2b\x07\x79\x36\x2b\x97\x67\xd9\xad\x5c\x0e\x62\xb7\x72\x02\xc4\xb0\x72\x22\xc3\x6e\xe5\x04\x84\xdd\xca\x09\x08\xc3\xca\x89\x0c\xbb\x95\x13\x10\x76\x2b\x27\x20\x0c\x2b\x27\x32\xec\x56\x2e\xe7\x8b\xcd\xca\x09\x00\xd3\xca\xd1\x1c\xd4\xca\xe5\x39\x56\x2b\x97\x43\x58\xad\x9c\x80\xd0\xad\x9c\x48\xb7\x5a\x39\x01\x60\xb5\x72\x02\x40\xb7\x72\x22\xdd\x6a\xe5\x04\x80\xd5\xca\x09\x00\xdd\xca\x89\x74\xab\x95\xcb\xd9\x61\xb1\x72\x22\xdf\xb0\x72\x90\x51\x65\xe5\x24\x90\x2a\x2b\x27\x81\x56\x59\xb9\x02\xd4\x62\xe5\x0a\x80\x2a\x2b\x57\x40\x56\x59\xb9\x02\xd2\x62\xe5\x0a\x80\x2a\x2b\x57\x40\x56\x59\xb9\x02\xd2\x62\xe5\x0a\x80\x2a\x2b\x27\xf1\xb7\xdc\xca\x15\x80\x35\xac\x9c\x14\x7f\xff\x2f\x8a\x71\x1b\x66\x8e\xd6\x62\x98\x39\x4a\x86\xd5\xcc\x51\x7a\xad\x66\x8e\x56\xa3\x99\x39\x42\x84\xd5\xcc\x11\x5a\xad\x66\x8e\x34\x49\x37\x73\xa4\xc1\x56\x33\x47\xf8\x62\x35\x73\x84\x7d\xba\x99\x23\xcc\xb5\x9a\x39\xd2\x54\x9b\x99\x83\x3c\x9b\x99\xcb\xb3\xec\x66\x2e\x07\xb1\x9b\x39\x01\x62\x98\x39\x91\x61\x37\x73\x02\xc2\x6e\xe6\x04\x84\x61\xe6\x44\x86\xdd\xcc\x09\x08\xbb\x99\x13\x10\x86\x99\x13\x19\x76\x33\x97\xf3\xc5\x66\xe6\x04\x80\x69\xe6\x68\x0e\x6a\xe6\xf2\x1c\xab\x99\xcb\x21\xac\x66\x4e\x40\xe8\x66\x4e\xa4\x5b\xcd\x9c\x00\xb0\x9a\x39\x01\xa0\x9b\x39\x91\x6e\x35\x73\x02\xc0\x6a\xe6\x04\x80\x6e\xe6\x44\xba\xd5\xcc\xe5\xec\xb0\x98\x39\x91\x6f\x98\x39\xc8\xa8\x32\x73\x12\x48\x95\x99\x93\x40\xab\xcc\x5c\x01\x6a\x31\x73\x05\x40\x95\x99\x2b\x20\xab\xcc\x5c\x01\x69\x31\x73\x05\x40\x95\x99\x2b\x20\xab\xcc\x5c\x01\x69\x31\x73\x05\x40\x95\x99\x93\xf8\x5b\x6e\xe6\x0a\x40\xc3\xcc\xf1\x37\x81\xca\x1e\x62\xe4\x6f\x51\xe6\xab\xc9\x64\x6b\xe0\x95\xb4\x96\xc7\x77\xae\x90\x24\x2f\xdf\x80\x35\xd3\xf7\x91\x67\x6b\x64\x6b\x39\xad\x5c\x3a\x2a\xa5\x9d\x9c\x42\xb6\x1f\xb2\x32\x37\x19\x39\xf1\x77\x93\x25\x37\xf9\x33\x43\x52\xd2\x3a\x4f\x22\x1b\x75\x34\xa8\x3c\xa9\x80\xa2\xaf\xf6\xaa\x50\x79\x52\xf1\x6c\xd8\x95\x7d\xfb\x85\x76\xb0\x0d\x18\x64\x39\xd2\xe4\xfb\xfe\x11\xa9\x42\x7f\xf1\x91\xb6\x57\xdb\x39\x38\x40\xb1\xf0\xbe\xb9\x10\xd8\xa6\xcb\x30\x11\xdb\xf0\xa4\xf6\x94\x83\xe5\x9c\x80\xee\xa3\x0f\x62\x55\xa2\x2b\x87\x53\x39\xab\xe6\xd9\x50\x56\x83\xae\xa5\xd7\xaf\xa6\x3d\x45\x10\x2e\xe8\xdf\x72\x3e\xca\xad\x46\xd7\x22\xed\xf4\xfc\x26\x7f\xad\xca\x8b\xc9\x6d\xec\x69\xe0\x23\x32\x86\x66\xae\x91\x4c\x43\xee\xd0\x4c\xac\xa4\x21\x8b\x68\x66\x21\x95\xe3\x7c\x4c\xe4\xef\x6c\xe1\x8f\x6c\xe9\x50\x58\xf3\x90\xbc\xb5\x99\x67\x36\x0e\xc9\x43\xca\x99\x4d\x43\xf2\x2c\x4f\x84\x99\xd4\x9f\x84\x8d\x0f\x22\xae\x5b\x06\x05\xcf\xd2\x2c\x09\x77\x52\x83\xa7\xdb\x6c\x0d\xba\xb2\x43\x1e\xc5\x6a\xc5\xbe\xdf\xc6\x84\xe5\x9a\xfc\x11\x18\xe8\x16\xf5\xa2\xbc\x75\x4b\x3c\xdd\x5a\xc5\xd4\x2d\x79\xcd\xf9\xce\x23\x57\x30\xbc\x9a\x13\xf5\x7c\x6f\x9c\x20\x54\xdf\xaa\xf3\xc8\x7b\x1b\xdb\x19\x73\xfe\xe9\x2e\x32\xf1\x3e\x9b\x82\xc5\x11\x6f\xb5\x9d\x84\x3b\x88\x22\x19\xb3\xa6\x4c\xbb\xec\xec\x23\xa2\x66\xf3\x9c\xb5\xa9\x80\xfd\xae\x38\x32\x69\xa8\x66\x3d\x87\x0b\x0c\x52\x8f\x9e\x83\x69\x75\x0b\x36\xa4\x1e\x2e\x12\x48\x3d\x7a\x0e\x66\x17\x2c\xd8\x8a\x7a\xec\x3d\x8e\x8a\x09\x2f\x35\xe5\xa9\xb9\x08\x97\x42\xad\x71\x28\x9e\xad\x92\xa8\xc1\x14\x4d\x60\xd0\x36\xa8\xb5\x02\x85\x1d\xbc\xb8\x22\x7f\x0c\x29\xe1\xe7\x59\x30\x31\xc9\xb3\x50\x39\xe1\xb9\x98\xa0\xe8\x59\x42\x1e\x90\xba\x8c\x2c\x54\x56\x2c\x08\xb1\xba\x84\x4c\x20\x75\x19\x59\xa8\xbc\x58\x10\x4a\x75\xd9\x0f\x0d\xe1\xb2\xa0\x1c\x19\xb2\x8b\x8c\x06\x56\x21\x33\x2a\x99\x88\xd0\x28\xe8\xec\x52\x53\x75\x9e\xc9\xef\x05\xd7\xde\xc4\x10\x1b\x72\x50\x09\x93\x19\x96\x8e\x0a\x0c\xc9\xc2\xa4\x45\x49\x17\xf2\xa0\xe3\x57\xd3\x51\x21\xc1\xf0\x18\xf8\x85\x0c\xe8\xf8\xd5\x74\x54\x30\x30\x3c\x02\xbf\xfd\x98\x17\xde\xd7\xc5\x39\x2f\xbb\x3c\xc8\x30\x15\xc2\x20\x91\x86\x48\x42\x81\xc8\x2e\x06\xa5\x07\xcf\xbc\x51\x30\x5c\x0e\x0d\x19\xe0\x67\xc9\x30\x31\xc8\xb3\x50\x49\xe0\xb9\x98\x30\xe8\x59\xa2\xdf\x91\xba\x8c\x2c\x54\x2a\x2c\x08\xb1\xba\x84\x0c\x20\x75\x19\x59\xa8\x84\x58\x10\x4a\x75\xd9\x0f\xec\xe1\x32\xa0\x1c\xd7\xb3\x8b\x8a\x06\x56\x21\x2d\x2a\x99\x88\xc0\x28\xe8\xec\x32\x53\x79\x96\xd0\x5d\x0e\x3c\xcf\x10\x1b\x76\x40\x10\x93\x1a\x91\x83\x0a\x0d\xcb\xc4\x64\x46\xcb\x11\x72\x61\xd6\xa3\xe7\xa0\x02\x83\x63\x43\xea\x11\x32\x61\xd6\xa3\xe7\xa0\xc2\x82\x63\x2b\xea\xb1\x1f\xbc\xc4\x65\x40\x3e\x77\x69\x97\x14\x15\xaa\x42\x50\x14\x12\x11\x39\x91\x91\xd9\xc5\xa4\xea\x40\xe8\xc2\xf3\x72\x29\x91\xee\x85\x39\x48\x5b\x92\xbb\xbd\xfe\x17\xc5\xe9\x80\x0f\xca\x46\x7e\x76\x11\x7c\xc3\xdd\xfa\x8d\x56\x11\x84\xb8\x9c\x5c\xd2\x80\xbf\x81\xd5\x1a\xa3\xa0\x9b\x9c\xa5\x13\x08\xfc\x84\x62\x67\x93\xe6\x87\x10\xf9\xc1\x1e\x92\x44\x28\x00\x08\xfa\x90\x08\x3d\xaa\xb0\x70\x13\xfc\xa6\x17\xb3\x65\x37\x7c\x32\x6b\x9c\x3a\xb5\x00\x62\xf3\xbd\x32\xa0\x75\x09\x90\x39\x03\x2c\x03\x2a\xc3\x64\xce\xe2\xca\x80\xd6\xf8\x1d\x01\x78\x39\x63\x3e\x6c\xe7\x0d\x3a\x29\x96\xa3\x0f\x56\xe2\xd0\x29\xf3\xa9\x25\x0b\x76\xbe\xb8\xe4\xc9\x75\x16\x8c\x7f\x71\x49\xa5\xce\x83\x76\x2e\xf1\x24\x4e\x4b\x67\x4a\x4f\x63\xf4\x69\x05\x25\x3e\xbf\xb0\xe0\xa9\x35\x4a\x5c\x7e\x61\x41\xb9\xc6\x83\x72\x2e\xf4\x14\x26\x4b\x48\xca\x86\x5a\x45\x41\xfb\x40\x36\x79\x75\x7a\x8d\x58\x41\x2d\x7e\x43\x02\xd6\xcb\x30\x88\xfc\x34\xc8\x0e\xc5\xc2\x6c\xcf\xbc\xf6\xa9\x57\x5c\xe8\x14\x05\xab\x60\xeb\x6b\x87\xee\x24\x05\xae\x97\xb5\x5c\xe1\x42\x2e\x5d\xc1\x2e\x68\x53\x2e\x86\xd3\x2e\xb4\x42\x6e\x19\x18\x93\x3f\x47\xf6\x4c\x7f\x9d\xcb\xc3\x54\x9a\xc6\xda\x35\x32\xe4\x80\x3d\xbd\x70\xee\x8e\x04\xac\xe6\xec\x39\xec\xfb\x4f\x7d\x37\x9f\x54\x03\x7d\x57\x02\xd2\xee\x1d\x29\x91\x9c\xcd\x8b\xef\xc5\xbd\x38\x23\x7a\xa0\x32\xe7\x26\x8f\x80\xbf\xb9\x56\x98\xc7\x8e\xb5\xca\x98\xc9\xcd\xd7\xf7\x6a\x2f\x1d\x95\x3a\xc0\xfe\xdf\x5b\x7b\xf1\xc8\x2e\xdc\xbb\xdb\xec\xa3\x2c\xdc\x91\xf3\xf8\x3c\x81\xf4\xdd\xfd\x41\xbe\xe0\x4d\xaf\x93\x5f\x3b\x81\x35\xd2\xcc\x62\x4d\xfd\xdd\x6e\xcd\x83\x34\xa8\x0a\x3f\x20\x4a\x39\x79\xa9\x1e\x09\xad\xbe\xaf\x70\x3c\x1e\x1f\xbb\xe4\x06\x01\x12\x47\xce\xc0\xc7\xb0\x0f\x84\xfc\x14\xa5\x74\x8f\xda\x04\x9a\x41\xae\x3d\x3a\xb9\x52\xdb\x35\x76\x45\x6a\xb8\x71\x57\x81\x38\x24\x5b\xeb\xc0\x69\xd9\x89\x5f\x52\x96\xfc\x27\x1f\xe4\xed\x5d\xe2\x67\x7e\xad\xb0\xc8\xe5\x79\x9c\x08\xda\x04\xf9\x02\xbc\x46\xb7\x3f\x4e\x1d\x93\x20\x03\x46\xbb\x6a\xaf\x1c\x5f\x19\x9e\x4f\x81\x44\x15\x05\x2e\xc6\x32\x36\x72\x3d\x8f\xbb\x0c\xae\x73\x39\x46\x4f\x36\x57\x31\xd2\x21\xc7\x97\xaf\x44\x46\xbf\x37\x70\xfa\x97\x63\x67\x30\x1c\x3a\xdd\xc9\x49\x3d\x52\x8a\x48\x6b\xcc\x94\xea\x35\x10\x6d\x2f\x58\xd3\xa7\xdb\xc4\x2d\x40\xd7\xd7\xd0\x1c\xf0\x18\xc3\xec\x69\xda\xd7\x0a\x11\x2f\x9c\x0e\x6f\x4b\x41\xa3\x0e\xce\x8c\xfa\x65\xee\x60\xbc\x11\x4b\xe7\xdf\x3b\x6a\x7a\x02\x26\x9e\x5c\x27\x78\xef\x08\x93\x56\x80\x36\xd4\x21\x8b\xcc\x77\x82\xc0\xd6\x26\xa9\xc2\x4a\xc4\xfc\xa2\x92\x6d\x4c\xd6\x65\xc9\x6d\x5a\xfe\x51\x5c\x59\xaa\x02\x5a\x14\xa8\x6e\x70\xdc\xdd\x0e\x52\xdc\xad\xc7\xef\xa5\x41\x66\x57\x02\x94\x98\x6f\x3f\x78\x20\xf7\x7f\xef\xc2\x0f\x41\xd4\xa1\x97\x93\x4e\x7b\xed\x83\x84\xdf\x77\xb3\xe0\x5e\xa1\x44\x56\xc6\xe4\x11\x64\x7b\x2e\x29\x4b\x9f\x49\x06\x3d\xe7\x46\x76\xb8\x0d\x24\xad\xd5\x6c\xe5\x7a\x9b\x21\xbd\x0b\x8e\x75\x38\x5d\xf5\xec\xa4\x9b\x86\x4e\xa3\x53\x02\x40\xc9\x2c\x03\xd0\x28\x2d\x03\x65\xc4\xea\xcd\xbc\xe7\x25\xd2\x8d\xc9\x1e\x2c\x47\x67\x0d\x06\xc3\xd9\x22\xb2\x54\x96\xf4\x74\x96\x44\xab\x0a\x96\xa8\x00\x08\x4b\x4c\x0c\x56\x96\xa8\xa0\xe5\x2c\x89\x56\x36\x96\xa8\x39\x38\x4b\x54\x18\x85\x25\xd1\x4a\x61\xc9\x68\x42\x4f\xe0\x53\x29\xa2\x54\x1e\xcc\xc0\xc0\xb1\x2b\x3c\x0b\xa7\x4b\x1d\x09\xe4\x08\xb5\x7e\x4f\x6d\xf5\xcd\x8c\x02\x67\x83\x3a\x95\x1c\x33\xfb\x21\x47\x3f\xa8\x3b\xab\x1c\xbf\x46\x6e\xaa\xec\xcd\xf4\x7b\x30\xf5\x2b\x48\xf3\xda\x50\xa7\x30\xcf\xe6\x77\x51\x59\xa0\x18\x89\x86\x5b\xc5\x33\x90\xb2\xdc\xc3\x34\x2f\x81\x95\x18\x34\xa2\x4e\xa6\x72\x25\xc1\x40\x61\xd0\x85\xce\xfe\x0b\xde\x0b\x12\x92\x8e\xd2\x4d\x9c\x12\x95\xae\x92\x4e\x43\xaf\xdb\xaa\xcf\x6b\xf4\x7e\x64\x6b\x0f\x70\x72\x2e\xca\xa9\xbd\x50\x69\xc7\x6e\xf7\xe2\x1b\xbc\xe8\xa5\xcd\x86\xbd\x40\x3b\xb0\x1c\x8e\x77\x26\x56\xb2\x2b\x0a\xa0\xb9\x92\xe5\x32\xd0\xa1\x25\x59\x56\x51\x0c\xb3\x67\x3a\x7b\x0a\x44\x0a\x67\x8a\x64\xcc\x68\xea\x2c\xc6\x60\x14\x3e\x97\x11\x92\x57\xa5\x8c\x58\x3d\xb5\x8c\x8c\x12\x10\x79\xf4\x63\x44\xc8\x66\xae\xc3\x76\x04\xc8\x5a\x42\x76\xfe\xf3\x09\x87\xb6\xd1\xeb\xd2\x14\x65\x14\x6f\xa1\x43\x4b\x72\xc1\xb2\xa8\xd7\x44\xf4\xb4\xdb\xb1\x8e\x05\xa0\x64\x7d\x66\xd2\xfe\x17\xe3\xa2\x9c\x81\x31\x41\x19\x9b\xd7\x07\xf1\x19\x23\x8e\xdd\x30\x76\xfa\xf4\xb2\x30\x99\xb9\xbf\xa4\x23\x62\xbb\x2a\x0b\x83\x40\x2c\x39\xea\x54\x7d\xa2\xf6\x68\x55\xf1\xe6\x59\x2b\x34\xed\x39\x56\x5e\x6a\xb1\xe2\x3f\x69\xc0\xd5\x4e\x63\x19\x23\x84\x1c\xca\xe4\xc9\x32\x39\xd0\x27\xa4\xd5\xfc\x39\x16\x56\x5a\x32\xd0\x33\xe5\xc2\xbc\xe2\x52\xde\xfc\x26\x60\x0d\x0d\xdf\x45\x39\x33\xaf\x81\x57\x84\x47\xab\xc4\x70\x0b\x2c\xc2\x03\x03\x43\x13\x9e\x02\x91\xc1\x33\xf0\x79\x50\xe6\x7e\xda\x66\x69\x35\x96\xc8\x10\xde\x52\xb4\x7c\x1d\x19\x02\xe0\xd3\x64\x48\xe7\x87\x26\x43\x94\x3c\x59\x86\xae\x64\x36\xf5\x4f\x61\xd3\xb1\xbb\x76\xd3\xce\x32\x08\x7c\x32\x0d\x33\xad\xbf\x9a\xaf\xf5\x92\xaa\xdb\x46\x83\xee\x38\xe7\x92\x20\xdc\xc4\x9c\x7b\x37\xcc\x4c\x0b\xbd\xf8\x1b\x18\x17\x3f\xf8\x30\x1d\xcc\xb0\x10\x0e\xd5\xdc\xb2\x16\xd7\xe7\x30\x33\xe3\x7e\xe6\x19\xf7\x29\x3a\xc1\x03\xfc\x4e\xf9\x06\xb0\x12\x26\x5f\xe0\x94\xeb\xde\x79\x05\x98\x15\x40\x9c\x0a\x99\x14\x2d\xa9\x16\x33\x5d\x99\xd4\xa2\x31\xdd\x54\x80\x59\x01\xc4\xe1\x94\x9e\xc4\x6d\x5c\x9d\x12\xa9\xe0\xfb\x62\x1a\x92\xe7\x89\x26\xe7\xae\x9b\x9a\xcb\xeb\xe6\x6e\x82\x92\x47\xee\x16\x65\x8e\xa6\x96\x41\x1d\x00\x2c\x0d\xab\xc3\x98\x3c\x60\x79\xc2\x1f\x47\x40\x24\x6f\x03\xc9\x50\x0a\x6a\xb7\x5a\xab\x04\xaa\xd1\x0e\x25\x1e\xc5\xe0\x7f\xef\xd0\x5f\x09\x3d\x68\x94\x8c\xdd\xb1\xfd\xe2\xd8\x18\xb1\x62\x9f\x4d\x2e\x17\xfd\xc9\xd5\xc9\xe1\x30\xa9\xac\x46\xb5\x2c\xe1\xa0\x77\xe2\xad\xca\x73\x24\x24\xcb\x76\x9c\xcd\x30\x8e\x97\x70\xa4\x18\x0c\x48\x09\xbe\x9f\x43\x17\x79\x23\x59\x11\xc7\x22\xd7\x14\xf9\x3c\x4f\x17\xf9\x3c\x43\x12\x79\x35\x0d\xab\x03\x15\x79\x3d\x0f\x11\x79\x01\x62\x88\xbc\x92\x81\x8a\x3c\xbf\x29\x5d\x25\xb0\x44\xe4\x19\xfc\x3f\x47\xe4\x51\x7a\x2c\x81\x61\x72\x6f\xfb\xc7\x89\xbc\xd7\x73\xfb\x93\xc5\xcb\x44\x9e\x95\xd5\xa8\xb6\x8a\x3c\xe7\xa1\x6d\xa7\xd4\x0c\xe3\x78\x09\x47\x0c\x91\x97\x4b\x04\x49\x12\x27\xba\xc0\x6b\x89\x8a\x28\x8a\x3c\x53\xd8\x79\x8e\x2e\xea\x3c\x59\x12\x74\x39\xc5\xc4\x8d\x0a\xb9\x9a\x83\x88\x38\x03\x30\x04\x5c\x4a\x46\xc5\x9b\xdf\xda\x2f\x93\x55\x22\xdc\x0c\xfa\x9f\x23\xdc\x08\x35\xa8\x68\xb3\x17\x04\x3e\x52\xb4\x83\xab\xd1\xd5\xf0\x85\xa2\x4d\xcb\x2a\x34\x5b\x05\x9b\xf3\xcf\xb6\xaf\x6b\x86\x71\xdb\xca\x0d\x43\xac\x65\xf8\xdc\xa5\xa5\xbd\xfd\x0f\x4b\x41\x7a\xda\x66\x2c\x1c\x1e\xb5\x8c\x78\x31\xa9\xac\x2c\x4c\xf0\x0b\x69\x37\x9e\xe9\xca\xa3\x55\x63\x34\xfa\x99\x1f\x38\x1b\x92\x3f\x25\xf7\x6f\xd1\xfa\xb9\xf0\xca\x41\x5a\xcb\x12\xbc\x1a\xa7\xb3\xbc\x5b\x66\xe2\xd4\x97\x58\x15\xac\xd2\xab\x50\xa7\x22\x14\x93\x1b\x0c\xaf\x56\x4c\x92\x1b\x1d\x9c\x6e\xb8\xa8\x55\xb7\x84\xa4\x81\xcd\xd9\x50\x38\x43\x62\xeb\x02\x2f\xb2\xed\xa1\x60\x8e\x9d\x94\x1b\x95\xc9\xf2\xa9\x77\xa5\x88\xa2\x56\xf5\xfd\x71\xb5\xda\x5f\x68\x72\x25\x99\x45\x8b\xcb\x44\x06\x7b\x35\xe1\xb4\x2a\x85\xe2\x35\x2b\xe6\x4a\x57\x8f\x8e\xe1\x58\xf0\xb8\x3b\x82\xb4\x24\xc8\x5e\x5c\xeb\xaa\x1c\x19\x55\xb1\xd8\xe7\xbe\xfa\x30\xe7\x05\xa5\x27\x16\x74\x3e\x63\x59\xb9\x6d\x33\x20\xb8\x31\xc4\xd3\xf5\x87\x34\x44\x28\xb3\xac\x9f\x4e\x23\x90\x2f\x1d\x48\x0b\x2c\x97\xf9\xcc\x54\x86\x33\x57\x84\xca\x6f\x50\xae\xd0\x61\x0a\x75\x8a\xa0\x5b\x9a\x9a\x4b\xa1\xf1\x78\x13\x42\x6c\x9d\xde\x2c\x6e\xf3\x3d\x85\x56\x2d\xaa\x60\x27\xbd\x3f\xea\x0e\x87\x46\x68\x06\xbb\x8f\xa3\x4e\x5d\x24\x3a\x60\xaf\x6b\x62\xc4\x11\x81\x29\x44\x1d\x95\x2d\xe8\x14\x7b\x62\xd0\xf5\x9c\x62\x8f\x4c\xe9\x93\x72\xc5\x9e\x19\x33\x2c\x63\x6e\x72\xb5\x2c\x0d\x91\xdd\x0b\x59\xbc\xf7\xd6\x1d\x72\x6c\x0b\x86\xec\xc6\xdd\x86\xbb\x7d\x44\x9f\xf9\x9c\xd9\x73\xd4\x25\xa5\xdc\xef\xd9\xa7\xe0\x38\xb0\x98\x1d\xdb\x97\x43\x77\x54\x20\xa9\xa9\x99\x68\x24\xd4\xdc\xe9\x63\xbf\xea\x9d\x2e\xbb\x43\x67\xf0\x23\x69\x5d\xb6\x17\x4b\x4a\x99\x4a\x29\xc5\xe7\xd4\x00\x9f\x1a\xe0\xbf\xdb\xfe\x2d\x9d\x16\xe9\x53\x79\xb2\x8a\x44\x5f\xd1\x87\x5c\xa5\xe6\xc9\xb4\x1f\x70\x6e\xd6\xda\xa4\x03\x83\xa9\x31\xd6\xdc\xcf\xbe\xe5\x35\x04\x1b\x2c\xa3\xab\x58\x39\x83\x5f\x15\xdb\x4c\xc8\x28\x32\xd7\x9f\x66\xcb\x30\xa2\x2f\x67\x44\xbb\xb5\xdb\xe2\x1b\x58\xe6\x13\x69\xeb\x55\xc5\xfb\x09\xf9\xa6\x97\xee\x64\x4c\xde\x8e\x92\xa9\x42\xc8\xa0\x10\x07\x34\xcc\x09\x19\xc0\xfd\xa5\xbb\x8f\x32\xb9\x57\xca\x5e\x5f\xcd\x4f\x32\x91\x93\x06\x52\x79\xa9\xc7\x45\x12\x97\xb0\x52\xc4\xc1\x84\xfc\xd1\x67\xa2\x1e\xf9\xa3\xa0\x37\x45\xa7\x26\x2e\xd7\x27\x7f\x54\x52\x25\xd9\xca\xf1\x8b\xb4\x78\x17\x6c\x6f\xba\x7e\x12\xef\xc8\x13\xd4\xa0\x59\x56\xab\x28\xa8\xcf\xa8\x13\x69\x40\xb8\x66\x0e\x6c\x3d\x87\x9f\x12\x31\xa9\xc7\xfa\xc0\x8a\x6d\xaa\x62\xab\x6c\xb7\x40\x5e\x09\x38\xad\x0d\x58\xa3\x4f\xfd\x11\xf9\x53\x2d\x1f\x1f\xd9\xa7\xa8\x6a\x51\x2b\x50\x06\xbe\x91\x8a\xd5\x5f\x64\x22\x7d\x29\xf2\xa6\x65\x05\x31\x21\xc8\xf3\x4c\x31\x90\xb7\xd9\xa1\xc9\x18\x95\x52\xae\x59\x5b\x91\x89\xd1\x29\xe5\x96\x16\x65\x94\x5a\x34\xa4\x80\xaf\xca\x17\xb4\x57\x81\x31\x4a\x2a\xa0\xa6\xf5\x90\x4d\xeb\x21\xb3\x1e\xdb\xab\xd4\x9a\x80\xc7\xf5\x57\x41\xd5\x5b\x8d\x43\x56\xe8\x84\x97\x1d\xb5\x7a\x07\xc1\xc4\x77\x47\x0a\x16\xb9\xb7\x95\x17\x20\xcb\xd1\xb3\x97\x1f\x35\xf4\xfd\xc1\x60\x31\xea\x29\xe8\xd5\xc1\x7d\x02\xae\x41\x6f\xe4\x5f\x6a\xa4\xca\xb2\x27\xf0\x57\x0f\xee\x5a\xec\x3a\x91\x06\x84\x6b\x88\xc2\xd6\x72\xa4\x91\xaa\x52\x8f\xf5\x81\x15\x5b\x6d\x85\xad\x75\x70\x25\x60\xb5\xc2\x3e\xa5\x4f\x29\xeb\xaa\xe5\xe3\x23\xfb\xb4\x44\x61\x8b\x0a\x54\x85\xad\xa7\x62\xf5\xa3\x0a\x5b\xcf\x9b\x96\x15\xc4\x84\x00\x53\xd8\x3c\x4f\x57\xd8\x46\x32\x46\x25\xae\xb0\x8d\x4c\x8c\x4e\x5c\x61\x9b\x99\xe5\x0a\x9b\xc3\x57\xe5\x57\x29\x6c\x55\x4c\x2b\xa0\xaa\x14\xb6\x2a\xca\x55\x50\x36\x85\x5d\x57\x77\x6a\x6a\x5b\x14\xc3\xaf\x54\x22\xe5\xb4\x57\x8d\xf1\xa1\x33\xf6\x16\x57\x63\x4f\xab\x7d\xe4\xb9\xc1\xc8\x53\xb0\xc8\xdd\xae\xbc\xab\x5b\x8e\x7e\x34\xba\xf6\x47\xfa\xc8\x1c\x8c\xc7\x93\xc1\x58\x41\x5f\x67\x94\xa3\xb8\x86\xd7\x57\xa3\xe1\xb5\x4a\xaa\x2c\x84\x02\x7f\xf5\x28\xaf\xc5\xae\x13\x69\x40\xb8\x86\x68\x6e\x2d\x47\x1a\xb2\x2a\xf5\x58\x1f\x58\xb1\xd5\xd6\xdc\x5a\x07\x57\x02\x56\x6b\xee\x13\xfa\x94\xb1\xae\x5a\x3e\x3e\xb2\x4f\x4b\x34\xb7\xa8\x40\xd5\xdc\x7a\x2a\x56\x3f\xaa\xb9\xf5\xbc\x69\x59\x41\x4c\x08\x30\xcd\xcd\xf3\x74\xcd\x6d\x24\x63\x54\xe2\x9a\xdb\xc8\xc4\xe8\xc4\x35\xb7\x99\x59\xae\xb9\xc5\x55\x37\x15\xf9\x55\x9a\x5b\x15\xd3\x0a\xa8\x2a\xcd\xad\x8a\x72\x15\x94\x4d\x73\xd7\xd5\x9d\x9a\xe6\x16\xc5\xec\x9a\x5b\x7e\x3b\xde\xa2\xb6\x17\x5e\xcf\x58\x73\x1c\x4d\x16\x57\xbe\x5b\xa0\x90\x3b\xbc\x78\xaa\xbc\x62\x40\xf6\x17\x3d\x7f\xac\xbb\x52\x8b\x89\x7f\x35\x2e\x10\xd7\x1a\xd9\x18\xa2\xc1\xe4\xda\x5d\x78\x12\x85\xb2\xd4\x51\xcc\xd5\x63\xba\x9a\x39\xa7\x54\xad\xf3\x08\x51\xcf\x72\xb2\x34\x28\x25\x72\x0d\x46\xe3\x48\x6a\xab\x64\xb9\xf3\xca\xa1\xaa\x95\x71\xdd\xfe\x62\xfc\xa9\xe8\xf8\x17\xf7\x57\x89\x02\xa6\x78\x55\xed\xab\x24\x19\x75\xa2\x7a\x57\xc9\x98\x5a\x8b\x18\xfd\x8a\xa9\x5b\x92\xa1\xeb\x5a\x35\xcd\xa0\x09\xd7\xb2\x6a\x8e\x41\x15\xae\x5f\xb5\x9c\x72\xe5\x4a\xaf\x8e\x2a\xcb\xac\x52\xab\x92\xa8\x95\x81\x54\x29\x54\x49\x16\x4b\x41\xac\xaa\xb4\x8e\x3e\xd3\xf5\x28\x2f\x63\xd7\xa3\xe2\xda\xa6\x52\xc1\x5f\xf6\x5c\x7f\xa4\x57\x1d\x04\xee\x60\x38\x51\xb0\xc8\x1d\x2b\xee\x4e\xaa\xa1\x50\x03\xef\xfa\xb2\xaf\x87\x64\xae\xaf\xc6\xcb\x9e\xaf\xa0\xaf\x33\x46\x51\x5c\xfe\xf8\x6a\xdc\x1f\xa8\xa4\xca\x92\x26\xf0\x57\x8f\xd4\x5a\xec\x3a\x91\x06\x84\x6b\x88\x8a\xd5\x72\xa4\xb1\xa8\x52\x8f\xf5\x81\x15\x5b\x6d\x75\xab\x75\x70\x25\x60\xb5\xd2\x3d\xa1\x4f\x19\xeb\xaa\xe5\xe3\x23\xfb\xb4\x44\x01\x8b\x0a\x54\x1d\xac\xa7\x62\xf5\xa3\x9a\x58\xcf\x9b\x96\x15\xc4\x84\x00\x53\xc9\x3c\x4f\xd7\xca\x46\x32\x46\x25\xae\x9b\x8d\x4c\x8c\x4e\x5c\x43\x9b\x99\xe5\x4a\x5a\xdc\xd8\x56\x91\x5f\xa5\xaa\x55\x31\xad\x80\xaa\x52\xd8\xaa\x28\x57\x41\x59\x83\xcd\x35\x75\xa7\x1e\x72\xe6\xc5\xec\x9a\x9b\x5f\xa2\x56\x3e\x72\xae\xc7\xc3\x91\xa1\x89\x46\xc3\xe5\xd0\x95\x91\x28\x2b\x0c\xec\x32\xb3\x1a\x6a\xdb\xbb\x1e\xf6\x06\xba\x3b\x74\x39\xe9\x7b\xfd\x6b\x19\x79\x9d\x11\x8e\xa2\x72\xbd\xc1\xb5\x98\xe3\x72\x3a\x95\xc5\x0e\x86\xbd\xc6\x62\x52\x0d\x46\x9d\x46\x80\xc9\x2f\x6c\x75\x50\xc9\x90\x57\x85\x64\xc2\x11\xd6\xdb\x50\xd5\x5f\x19\x54\x3a\xb5\x0a\xae\xc6\xba\x60\xed\x7e\x64\x1c\xab\x14\x89\x8f\xea\xc7\xb2\x35\x41\x86\x5d\x5b\x12\x54\x13\x91\xba\xf1\x05\x41\x35\x6b\x5a\x52\x0c\xe9\x75\x74\x35\x90\x66\x19\x8b\x81\x5a\x2a\x42\x9f\x65\x29\x50\xcb\x43\x28\xb4\x2c\x04\xea\x79\x15\xeb\x80\xec\x8e\xc4\xf2\xec\xca\x55\x40\x59\x24\xcb\x81\x2a\xd7\x00\x65\xa9\xad\x00\xb2\xde\xf9\x5b\x4f\x2f\x6a\x3a\x59\x94\xb2\xeb\xe4\x28\xdc\xbe\x3b\x18\xd7\x14\x60\x41\x6c\xbe\x91\xa8\x57\x94\x73\xf2\x2f\x45\x04\x48\xc2\x54\x4f\xa8\xde\xe0\xc2\x48\x29\x7b\x3b\xa3\xee\xb6\x16\x8c\x42\x83\x20\x59\xbe\xe8\x6f\xce\x79\x99\xc1\xf2\xbb\x1d\x55\x05\xc5\x8c\x7b\x38\x1e\x5c\x7a\xc6\x76\x24\x68\x4f\x90\x90\xdd\x45\x66\x5f\xa0\x95\xe0\xe3\x40\xcb\x29\x1f\x05\x12\xad\xa5\x20\x0a\xf9\xf9\x5b\x23\xd8\x56\xaa\x7c\xc7\xe1\x0d\xf9\xc5\x49\x5a\x1d\x3e\xdd\x79\xd9\xa2\x8e\x74\x23\xd5\x51\x9c\x6a\xff\x98\x03\xdd\x05\xf2\x0f\xa9\x84\xfc\x43\x5a\x34\x80\xed\xd7\x7a\x21\x6e\x6c\xcb\xbd\xbc\xab\x3a\x87\xb9\x90\xc0\xd5\x3d\xf9\xf2\x65\x40\x8b\x7d\x96\xc5\xdb\xfb\x02\x56\xb9\xaa\x21\x80\xde\xb4\xe4\xa5\xfb\xc5\x26\x94\x33\xd5\xbd\xdd\xae\x1f\x1c\xc4\xb6\xaf\x1e\x76\x47\x17\xcf\xa4\x37\x5c\x35\x48\xdb\xdd\x44\xbb\x75\x0b\x83\x28\xcf\x66\xf5\x76\xc3\xed\x41\xba\x66\x09\x44\x2e\x72\x77\x69\x90\xf3\x8c\x09\x9a\x48\x26\xd0\x0a\x37\x8f\x59\x82\x66\xf2\xcb\x10\xe3\xc7\x23\xbd\x67\xb1\x1c\x86\x89\x40\x5e\x0b\x99\x45\x99\x5b\xb4\x79\x67\xf7\xf2\xbb\x67\xf3\x9b\x67\x0d\x76\x75\xb2\x70\x43\x76\x31\x2e\xf7\x5b\xb6\x35\x94\x5c\x12\xa6\xf2\x0b\x07\xa9\x44\x61\x56\xe5\xef\xf9\x88\xec\x0e\xf5\x9b\xd0\xb4\x3c\x7b\x21\x13\xeb\x0e\x1c\x97\x20\x81\x2e\x61\xad\x76\x1e\xc2\x34\x5c\x84\x11\x74\x92\x56\x45\x09\x60\x2d\x28\x60\x3a\x68\xb9\xac\xec\x3c\x47\xaf\x60\xbd\xf2\x9a\x13\x8c\x42\x7c\xcf\xae\xf4\x48\x0d\xb9\x29\xd1\x77\xd3\x75\xe0\xeb\xa9\x74\x6f\xec\x9b\x7c\x41\x8a\x9f\x1e\x2f\xdb\x34\xcb\xde\xa5\xc2\x20\x8e\xb9\xa3\xe7\xd0\xaf\xfd\x0e\x3b\xc3\xae\x39\x83\xda\x0e\xd9\x9e\x04\xb0\x09\xb6\x7b\xcb\x59\x75\x7a\x8d\x20\x3b\x26\x90\x9f\x56\x87\xb4\xde\x4c\x1e\x2f\xb3\xe2\x11\xc3\x99\xf4\xb8\xe2\x44\xbf\x05\x23\xbf\xcb\x73\xc0\x2f\x94\xd4\xb6\x57\x6b\xaf\x49\x81\xd2\x4b\x33\x7e\xb7\xb2\xbe\x01\x59\xf2\xa7\x73\x83\x2c\xe5\x46\xe1\x6e\x5a\xdc\x71\xf2\x61\x56\x9a\x57\x72\x55\xa1\x94\xaa\x6c\xa0\xa5\x7b\x6d\x6b\xdc\x65\xc8\x4e\x83\x11\x0d\xae\x96\xd7\xce\xbe\x95\x80\x69\xdd\xd4\xa5\x4f\xed\x51\xe9\x39\x88\x5b\x04\xa4\x17\xdf\x14\xd8\x06\xf8\xd3\x0f\x21\xb9\xc9\x4e\x18\x8e\x7c\x87\xfb\xf4\x9a\x76\x87\xae\x5a\x90\xa0\x1c\xbb\xdd\x54\x45\x7c\x13\x85\x37\x2e\x7e\xa5\x25\x31\x45\x0d\x7a\x35\x92\x17\x81\xce\x25\x0f\x5f\xad\xeb\x6e\x9b\x97\xb6\x4e\x62\x97\x42\x9b\x24\x08\xb7\x04\xc9\x51\xfd\xa1\x09\xf9\x83\xfa\x14\x98\x4c\xf1\x57\x5e\x54\xac\xe2\x31\x19\x57\xaf\x2e\xcf\xc0\xa9\x29\xb2\x8d\x89\x60\x4d\x7a\xb8\x07\x6c\x1b\xb8\x37\xf9\xac\x09\xa1\xad\xc8\xb2\x50\x27\x01\xe8\x3e\x58\x49\x3d\x75\x91\xa1\x2d\x44\xf6\x90\x97\x3a\xdc\xf8\x46\x79\xbe\xed\x1c\x34\xfd\x2a\xf4\xa7\xdf\xfe\xfd\x07\x92\xf5\x0b\x29\x46\xce\x8a\x74\x7f\x0a\xbd\x24\x4e\xe3\x65\xd6\x5d\x91\x11\x0a\x78\x5a\xc1\x96\x12\x37\x5f\xba\x51\x1a\xc0\xb8\xd2\xa6\xcc\x54\x09\xaa\xb6\x9e\x81\xb8\x56\x9d\x59\x73\x1c\x52\x4d\x2e\x3d\x8e\x39\x13\xc7\xae\x72\x28\x72\x37\x34\xb0\xab\x62\x44\x95\xba\x84\xfa\x28\x22\x4e\x74\xe9\x28\x22\x6c\x25\x3f\x0a\xc5\xbf\x0c\x3f\x40\x5f\xa8\x37\x94\xe4\x27\x61\x34\x1b\x70\x7d\x0d\xf4\x17\xba\x48\xe7\xa3\x85\x25\xe4\x9c\x20\xb5\xbf\x4e\x77\xeb\x3e\x2c\xdc\xa4\x43\xeb\xe4\xe7\x6d\x1a\x39\x12\x0e\x75\x20\xe7\x7c\xa0\xeb\xa6\xcd\xa6\x6c\x4e\xf5\xcb\x98\x4d\xa3\x2b\x65\x70\xbb\x5b\xd4\xaf\x10\x5a\x49\x87\xda\x2c\x52\x3b\xed\xc1\xfc\xc0\xaa\xf9\xa4\x61\xe9\x21\x2a\x5e\x1b\x65\x8f\x8e\x1c\xe1\x59\x09\xb8\x4d\xa8\xa4\x39\x86\x23\x4d\x37\x84\xe7\x52\xf7\xaa\x3b\xcb\x01\x47\x13\xa1\x34\x8b\xe1\x47\x3a\x17\xf4\x7c\x86\x5e\x8b\xfc\xce\xb1\x05\x8b\x32\x81\x47\xf2\xa7\x55\xf9\xd2\x2c\x15\xcb\x96\x82\x4a\x05\xa9\x66\xa5\x96\xba\xf0\x2a\x24\xcc\x87\xfc\x36\x1f\xa9\x85\x74\x8e\x7b\xa1\xf1\xa8\x48\x34\x3a\xaa\x51\x7c\xa2\xa5\xa4\x2c\xf5\x08\x22\x3f\x6f\x28\x26\x82\x59\x1c\x93\xa7\x27\xd4\xdc\xb1\x96\xdb\x28\x6a\x90\x53\x64\xa2\xf2\x74\xf9\x14\xb2\xde\x97\x1c\xe8\xc6\x40\x77\x63\x41\x77\xa3\xa0\x53\x1e\x6a\x55\x66\xc9\x8c\xbb\x60\x29\x5a\xf2\xc3\x04\x6d\x96\x52\xdc\x2a\xcf\x12\x74\x87\xb7\x7d\x40\x83\x46\x72\x67\x4a\x8f\x1d\x68\x27\x62\xed\x90\x27\x56\x0e\x2a\x83\x8d\xdf\x9c\x0c\x55\x49\x69\x99\x46\xcd\x45\x45\x26\x1f\x14\x39\xd4\xdd\x7d\x03\x5a\xa6\x88\x34\xd3\x46\x90\x92\xa7\xd3\x63\x91\x00\x1d\xa0\x46\x9f\x31\x45\x51\xd1\x45\x1c\x5b\x19\xfb\x75\x36\xe9\x83\xb3\x16\x0a\x8d\x79\x9f\xa8\xf3\x78\xd5\x65\x5d\x68\x0a\xe2\x47\xf6\x52\xc3\x10\x04\x43\x93\x51\xb7\xc6\x80\x93\xbd\x1c\xb5\x19\x17\x06\xa8\x7a\x07\xda\x95\x7e\x0d\xed\x95\x39\x88\xe9\x15\x61\xe5\x68\xfa\x03\x1d\x4f\x7f\xa0\x20\xb2\xd0\xfd\xcf\x38\x28\x59\x46\x40\x11\x37\x3e\x25\x34\x2c\x5c\x1c\x44\xef\xd0\xd3\xd4\x34\x93\x77\x39\x7f\x6e\x9f\x13\xa8\x4b\x02\x8f\x5a\x14\x1e\x4e\x09\x8e\x5e\x83\x63\xa9\x63\xca\xd5\x0c\xbb\x4f\x71\xa3\x5b\x7f\xd5\x8f\x2d\x9e\x22\x9d\x59\xdf\x85\xb6\x92\x23\xa3\x95\xdf\x34\xb5\x80\xeb\x36\x13\xc9\xad\xd5\x8e\x72\x3c\x56\x23\x4c\xef\x1b\xee\x6b\x97\x00\xf4\xac\xd4\xd6\xd0\x92\x25\x0a\x52\x77\x7e\x4a\x14\x9c\x55\x9f\x91\xb0\x45\x99\x46\xab\xa9\x74\x34\x52\xca\x14\x5e\xa5\x7e\xab\xd4\xb9\x72\xa9\x51\x89\x24\x7f\x32\x4b\x84\xa2\x7d\xa1\x49\x7a\x01\x2e\x8b\x6d\xfa\x74\xfd\xf5\xbb\x98\x29\xb3\x1b\xe5\xfa\xdf\xee\xd3\x2c\x5c\x86\x81\xaf\x06\xc7\x65\x05\xc1\xa2\xe5\x90\x05\x76\x89\x4f\x4d\x8b\x75\x31\x1a\x5b\x9f\xa6\xc1\xce\x4d\xdc\x2c\x40\x31\x1b\xda\x4c\xcd\xd1\x2e\xd4\x61\xb5\x69\x4f\x27\x0b\x72\xbe\xb0\x57\x20\xb9\xe6\x07\x5c\x9d\xe1\xf0\xea\xd4\xaf\x98\xf2\xdd\xf9\x6e\xe6\xf2\x9e\xe6\xcb\x2f\xe9\x3d\x2d\x89\x5f\x00\x53\x0f\x9e\xdf\xdf\x6d\x07\x96\xd4\xec\xa9\xf5\x58\x8a\x5a\xef\x77\xa7\xf1\xd7\x24\xf0\x32\x6e\x64\x7b\x6d\xfc\xd2\x52\x79\x86\x60\x9f\xb4\x32\xb1\xb1\x0b\x86\x84\x45\x7d\x43\x5b\xea\xe5\x7a\xb7\x55\xf3\x8e\x53\xef\x82\x35\xe8\x2a\x6e\x74\x95\x62\xe2\xd6\xc7\x9f\x7a\xfa\x93\x0b\x37\xda\xdd\x4c\x7a\x2e\x72\x23\x53\x19\x08\xf4\x09\x53\x6e\xbf\xff\x8d\xc9\x96\x16\x58\x60\xcc\x76\xd4\x00\x44\x5b\x53\xf7\x6a\xe6\x52\xfa\x4a\xa0\x6d\x94\xd6\x2c\x22\x68\xd6\xef\x85\xb6\x90\x63\x85\x32\xc9\xa8\x05\xaa\xb3\x8c\x85\x95\xd4\x7b\x73\xcb\x64\x8e\xe4\x56\xc8\x9c\x0e\xa2\x57\xf9\x7b\xdc\xed\x6e\x21\xdd\x02\x53\x4b\xd8\x6a\x35\xa3\xee\x25\xf2\xa5\xf4\x95\x40\x9f\x28\x6c\x36\x9a\x71\xd9\x30\xc8\xb1\x42\xd5\x14\xb6\x2a\x96\x19\xc2\xa6\xdf\x3c\x57\x21\x59\xf2\x54\xa2\xb0\xcf\x25\x18\x6b\xf8\x7a\x48\xa5\x27\x97\x7a\xa9\xe7\x5e\xa3\xb9\xc2\xe1\xa8\x7d\x61\x14\x82\xf5\x50\xf5\xd2\x5b\xe9\x72\x9c\xfc\xe0\x9b\x79\x8f\x15\xfe\x6c\x55\xcd\xc7\xde\x10\x5a\xbb\xfa\x93\x11\x56\x0d\x81\x6c\x78\xb1\x61\xab\xb3\x1d\x08\xd9\xf8\x63\xa0\xb3\x5c\xb9\x57\x0a\xa7\x3c\x9c\xd8\xe1\xb7\x61\xda\x05\x56\x79\xa8\xd5\x94\x4c\x6b\xb6\xe6\x8d\x73\x5f\xb7\x0a\x42\x72\xd5\x2a\x80\xb5\x39\x87\x09\x2d\x3d\xe9\xa9\xcf\xb5\xf4\x89\x50\x65\xe1\xdf\x3b\xa2\x5a\xca\x57\xe3\x05\x56\x7b\x67\xc9\x13\x3a\x13\xa7\x2d\xd7\xde\x11\x96\x69\x56\x75\x71\x2c\x12\x5c\xc1\xe3\x9a\x3d\x58\x03\xb6\x24\x54\x7a\x42\xbc\xb2\x8c\x7f\x07\x79\x03\x8c\x06\xbb\xc0\x17\x97\xf2\xc1\xdd\x43\x17\x3d\x51\x2b\x85\x6c\x99\xc1\xe0\x68\x98\x07\x59\x65\xc1\x60\xf3\x58\x2b\x9a\xc9\xd7\x8e\xd0\x3c\x63\x05\xe9\x53\x8d\x76\xfd\x8a\x4a\x84\xf4\x17\xca\x4a\x41\xed\xcc\xe4\xce\xd6\x7d\xd0\xee\x35\x35\xee\x56\xd4\x76\xf7\xd0\x32\x37\x51\x58\xf5\x82\x9a\x80\xbb\x71\x2b\xdf\x5a\x53\xad\xc0\x98\xd3\xa5\x6c\x1d\xc9\x7f\x97\x6c\x58\x40\x8d\x9e\x40\x25\x6d\x7a\x50\xf6\x4e\x18\xb9\x6a\x8d\x65\x1b\x2f\xf0\x8d\x21\x27\x6e\x9b\xa0\x14\x34\xf8\x0e\x06\x47\xfe\x21\x11\x92\x27\x59\x1f\xe1\x0f\xf4\x33\x38\x6c\x37\x0a\xc7\x0e\x7f\x75\x3e\xdd\x1e\x23\xd1\x17\x37\xe1\x66\x75\x28\xe2\xc3\xb9\x70\x90\xeb\x8e\xd3\x83\xf5\x21\x66\xfa\xa6\xbe\x00\x23\x82\x24\xef\x4a\x53\x64\x2f\x17\x51\x01\x0a\x7d\xa7\x0c\x93\x92\xed\x15\xa7\x5d\x77\xd9\xe0\x4f\x27\x6b\xb5\x61\xfb\xbc\x09\xaf\x1b\xec\x2f\xbd\x25\xd2\xde\x23\x2c\x55\xea\x50\x33\x4f\x11\x2e\xe2\xd4\x71\x39\xe2\x57\x76\x95\xde\x8e\xa8\x71\x57\xd3\xe8\xb8\xc8\x51\x0a\xe8\x47\x11\xe3\x93\xe2\x1f\xfa\xe3\xdf\x96\x22\x45\xf7\xa9\xbd\x6f\x40\x15\x3d\x27\xbd\xa7\x6d\xf8\xad\x56\x04\xd5\x3b\x3d\x8a\xd0\x5c\xe9\xae\x0e\x4b\x1b\x90\xf0\x62\x11\x53\xac\xdf\x28\xb2\xad\xa3\x06\x74\xb1\x69\xc7\xf0\xbc\x6d\xed\x37\x25\xcb\x06\xa1\x4b\x99\x15\x4e\x96\x6d\x7d\x7c\xbe\x80\x87\xd0\xbc\xb2\x21\x5f\x67\xcc\xfd\x93\x1b\xad\x0e\x10\x7a\xcc\x85\xd1\xb2\x0b\xa3\x48\xd3\x4c\x6a\x46\xd1\x56\xbd\xef\x04\xc4\x05\x94\xd6\x76\x25\xab\x00\x5a\xe3\x8c\x64\xb9\x45\x66\x66\x9d\xeb\x37\x0a\x03\x40\x2e\xb1\xf7\xde\xe1\xa3\xb5\xc8\x92\x48\xa6\x2f\x0b\x98\xcb\x63\x36\x6d\x71\xac\x56\x0a\x2f\xd5\x05\xbf\x87\x0a\x38\x6d\xe4\xd7\x1e\xf0\x12\x6b\xac\xda\xf3\xe5\x0a\xa1\x7c\x5c\xd4\x19\x13\xbf\x83\x12\xf8\xd4\x0a\xe0\x9f\xd0\x48\x74\xd0\x43\xc9\x0e\xdf\xc3\x78\x43\x7f\xec\xdc\xad\x7e\xd4\x44\x81\x61\xa8\xf5\x6d\xa8\x82\x08\x5d\x42\xf5\x55\xe7\x97\xac\xc9\xb1\x2d\x86\xd8\x13\x01\xc5\x3d\xf8\x63\xf3\xa9\x5b\xba\x21\xb5\xcc\x17\xaa\xdc\x04\x89\x68\xba\xea\x8d\x93\x7c\xa3\xac\xa4\x3f\xf3\x4d\x92\xf9\x49\x1e\x6d\x57\xc9\xd8\xd8\x55\x42\x52\x84\x57\xda\xf9\x30\xa5\x87\x43\xa2\xe2\xb0\x4b\x9e\x95\x7a\x30\xeb\x8f\xc8\x04\x82\xde\xbb\x2e\x6f\x41\xc5\xdd\xbf\x8a\xd7\x66\x7a\x6c\x6f\xc9\x60\x3c\x76\xc4\x7f\xdd\xbe\xf5\x0d\x1c\x1c\xda\x68\x2e\x3d\xcf\x24\x28\x7e\xaa\xa1\xa6\x14\x5e\x49\x2f\x98\x28\x1b\x6c\x6b\xef\x64\xd1\xa9\x31\xce\x53\x51\x11\x3e\x0b\x37\xbb\x38\xc9\x5c\xe0\x91\x14\x1b\x96\x52\xb5\xf7\x68\xa5\x59\x03\xef\x9d\x02\xb6\x8a\x03\xbc\xc0\x11\xdf\xd9\xab\x95\xd5\xf6\xff\x42\xe3\xed\x20\xec\xc5\x16\x14\xa6\xea\xc1\xdb\x4f\x46\x0c\x9d\x16\xe5\x2f\x40\xf6\xe4\xbd\xc6\x90\xc1\x1f\xdf\xe7\x6f\x2e\x5e\x41\x76\x9b\xbd\xd0\x1f\x27\x64\x07\x3c\x9b\x4c\x46\x90\x92\x7a\xee\x2e\x28\xc4\xe1\x53\x52\x35\xe8\xf5\xe8\x9b\x0b\x44\xa5\xb9\x30\x85\x82\x72\xd1\x3e\x04\xad\x69\xa0\xb5\x41\xb0\x31\x2e\xe5\x97\x95\xd5\x4a\x7d\xec\x83\x1c\xff\x1d\xa8\xee\x69\xee\xd1\xd1\x14\xc0\x83\x72\x14\x4b\xdb\xe1\x45\xd5\x47\xb5\x0e\x90\xb0\xe9\x2b\x15\xa8\xb8\x9a\x72\xa0\x9f\x1c\x50\x36\xb0\xcb\xc7\xc5\x86\xbd\x6a\x72\x2a\xaa\xaa\x20\x91\x80\x28\x47\x03\x54\x66\x60\x95\x1c\x72\x5d\xa3\x07\xa6\x14\x14\x7d\xc9\x97\x20\x28\x16\xa0\xef\x7d\x39\xb4\x20\xdb\xc8\x3c\xe0\x34\xe6\x01\xa7\xb2\xa5\x75\xf6\x94\xbd\x8c\x56\x72\x3a\x8a\x34\x7b\x60\x4a\x2d\x4c\xa3\x26\xaa\xe3\x50\xc5\xf4\x9b\x42\x22\x1b\x0a\x2e\xc7\x04\x60\xe2\xae\x82\x1d\xcc\xa1\x95\xd3\x24\xb6\x78\x5a\x0e\x02\x50\x59\xc9\xf9\x75\x2d\x16\x7d\x24\x8f\xe6\xaa\xf8\x29\x59\x72\xb5\xaf\xe8\x4a\xce\xe9\x67\x87\x4e\x7d\xb2\x44\x69\x92\x79\x8e\x52\xc9\x6e\x74\x43\xe0\x59\x87\x38\x38\xd8\x31\xec\xc1\xa0\x78\x65\xd6\x5c\xd6\xea\x1b\xb5\x15\xe8\x2e\x0a\xc4\x12\x97\x46\x75\x86\x3a\xef\x0b\xc5\xef\xcc\xeb\x21\x91\x5a\x1e\xb0\xbb\x24\x6f\x19\x37\x3a\x79\xa4\x94\x67\xf3\x60\xab\xfc\xa2\x4f\xcf\x7c\x43\xbe\xaf\x2f\x90\x0f\x74\xf3\x24\x68\xbb\x94\x69\xcb\xa3\x90\xba\x73\x9b\x4b\x0e\x53\x54\xe6\xb6\x2c\xea\xb5\x28\xaf\x3f\x95\x8b\x02\xeb\xf4\xd3\x7d\x1b\x1b\x85\x0d\xfd\xfc\x96\x53\x55\x42\x61\xe4\x54\xe8\x08\xba\x25\x77\xa0\xf1\xbc\xa4\xbc\x55\x87\x94\x16\xd3\x74\x4b\x39\xac\x11\x0e\x96\xae\x8c\xa9\x16\x37\x22\x51\x46\xec\x55\x1a\x28\x4c\xa4\xf4\x20\x88\x5d\xd8\xc6\x88\xb0\x29\xba\x86\xac\xd2\x1d\x8c\x60\x7f\xa9\x32\xe9\x58\xb4\x89\xa1\xd1\xaa\xbd\x7e\xdb\xe4\xf4\xa3\x67\x06\xce\xa7\x9b\x36\x94\xa2\xaa\x61\x9c\x81\xc1\x9f\xec\x91\x45\x13\xe7\x47\x3e\xb2\x68\x45\x58\xfe\xc8\xa2\x52\xec\xa5\x8f\x2c\xda\x90\xe8\x5b\x5d\xec\x70\xc8\xae\x90\x7a\xc0\x0b\xed\x91\x45\x5b\xa9\x92\x47\x16\x95\x22\x2f\x7a\x64\x51\xc5\x90\xbf\xad\xa7\x24\x7f\xe2\x47\x16\xd1\x2a\xc5\x23\x8b\x66\xc5\x96\x47\x16\x71\x2c\xf8\x8e\x0f\x04\xe9\x0b\x1e\x59\x54\xb0\x9c\xf0\xc8\x62\xa5\x09\x35\x46\xa7\x11\x05\xc5\xc6\x88\xbe\xe9\xdb\x8c\x40\xd6\x52\x0b\x72\x08\x41\xd6\xda\x3d\x73\x4e\x5f\x36\xcb\x39\xdd\x3c\xeb\x46\xc3\x1e\x1b\xeb\x7d\x44\x60\x0c\x9f\x1b\x97\x56\xa9\xcf\x23\xf4\x5a\x47\x6a\xa4\xee\x13\x9e\xc7\x10\xbe\x79\xb1\x5f\x41\xb3\x7d\x85\xa1\x93\x81\xe9\x92\x7e\xba\x91\xcb\xf4\xcd\x88\x5f\xbf\x87\x94\xfa\x90\x2a\xa5\x46\x66\x29\xc5\x81\x86\x49\x8c\x02\x8f\x3c\x01\x5c\x3e\x3f\x97\x11\x99\xcb\xbb\xe6\x3c\x21\x0f\xf8\xd5\x90\x66\x7a\xa0\xba\x40\x8a\x44\x9c\xd8\x71\x7f\x69\x02\x23\x45\xb0\x4c\xef\x42\x2d\xf6\x0f\x15\x89\x3a\x16\x0a\x61\x46\x9e\xf0\x12\x11\xe5\x2b\xf2\x47\xbf\x11\xf3\x92\xfc\xd1\x4b\x6b\xb3\x34\x6d\x5b\x82\x15\x50\x73\x11\x71\x18\x75\x3d\x99\x2e\xdd\x57\xef\x43\xc0\xd0\xd1\x3e\xac\x41\x5a\xee\x13\x9e\x00\x5b\xd1\x92\xad\xba\xe9\x43\xba\x77\xe4\x45\x2d\x21\xe8\xd4\x65\x85\x4a\xa8\x1a\x04\x96\x2c\xe1\x23\x5b\x28\xca\xe5\x80\xe2\x93\xaf\x09\xa9\x07\x57\x87\x4a\xdb\x3e\x16\xba\x03\xf4\x45\x72\xa1\x6c\x2b\x13\x77\x08\xf2\x1d\x11\xf6\x02\x15\xb4\x72\x20\xeb\xcd\x86\x95\xf8\xa5\x79\xbd\x59\xfc\xea\xea\xca\x5a\xdc\x88\xa3\xea\x00\xd4\x8a\x9e\x34\xac\x29\xe3\xa5\x9d\x3d\x15\x30\x75\xba\x51\xd9\x07\x54\x47\xd4\x2a\xbd\x12\xa4\x9a\x92\x49\x6d\xbd\xc1\x5d\x7b\x7a\x7b\x5a\xd9\x4f\xa6\x06\xf0\x3a\x6a\xe9\x86\x8a\xa2\x2f\x6d\xdf\x27\xd6\x22\x96\x4a\xea\xa9\x96\xca\xc2\x2f\x6e\xe4\x8b\x95\x90\xb5\xad\xf4\x3c\x77\x0d\xa1\x34\x6f\xaf\xa4\xef\x1b\xea\xd0\xf9\x11\xf1\x32\x94\x0b\xed\x72\x4f\x6b\x7e\xfd\xfa\xcc\x2b\x3c\x6b\x40\xda\xaf\xf4\xac\xa0\xf8\xa4\x22\x7a\x47\xe5\x8d\x08\xb7\x90\x91\x06\x88\x9a\x1d\x0c\xf4\xeb\xec\x7b\x57\xe4\x8f\x5e\x14\xf7\x7f\xae\x7d\xf2\xa7\x1c\x56\xe3\x12\x0e\x53\xbd\x49\x06\x53\x17\x3a\x2e\xd9\xff\xa9\x20\x4d\x77\x81\x6a\x82\x57\x34\x06\xf7\x82\x5e\xdc\x1e\xdc\x0b\x2a\x85\xaa\x41\xe0\x49\x5b\x93\x2a\xa4\xc1\xe6\x05\x55\xc0\xd5\xa1\xd2\xa6\x80\x46\xe4\x49\xb7\x17\x49\x07\xe6\x05\xc9\x43\x1d\x2f\x50\x41\x6b\x85\x17\x54\x8d\xbf\xd4\x0b\xa2\xf7\x39\x5b\x8a\x1b\x5e\x90\x0e\x80\x78\x41\xfd\x1e\xf9\x53\xde\x9d\x9a\x17\x54\x02\x53\xa7\x1b\x31\x2f\xa8\x54\xd4\x2a\xbd\x20\xa4\x1a\x9b\x0d\xd3\x2e\x83\x3b\x49\xd1\xd9\xd0\x16\x57\x40\xbe\x64\xb4\x54\xfb\x6b\xd5\x9a\xa8\xb6\xcb\x76\x5a\xd9\x4f\xa6\xb3\xea\xba\x6c\xa7\x17\x7d\x69\xfb\x3e\xb1\xca\xab\xef\xb2\xbd\xa4\xf0\x8b\x1b\xf9\x62\x8d\x69\x6d\xab\xec\x5f\x55\xc8\xa5\xe9\x80\xa0\xba\x4b\xf7\xda\x6c\x58\x2d\x8e\x9b\x99\x5f\xbf\x4a\xab\xe3\x56\x06\x59\xe9\xb8\xd9\x28\x3e\xa9\x88\xde\x5d\xc7\xee\x22\x01\x95\xe5\x25\xfb\xcd\x22\x5f\x85\xbb\xd2\x16\xe1\xe4\x6d\x83\x35\xae\xf5\xa5\x57\xb0\x62\x4b\xf1\x45\x55\xf2\x26\x5b\x75\x61\x47\x81\xb9\x88\xc2\xe9\x22\x00\xeb\x92\x6f\xd2\x62\x97\x20\xcd\xa4\x29\x42\x7e\xcd\xe4\xeb\x37\xbd\x9e\xdb\x6b\x2a\x28\xc4\x9e\x4c\xd9\x73\xdf\xb9\xd0\x26\xba\x11\x03\x5f\xd6\x40\x4f\x3e\xd1\xc6\x37\xd0\xcd\xb8\x05\x3e\xb3\x55\x5a\x2e\x19\xaf\x6a\x02\x0c\x8c\xf2\x0b\x17\x67\xc6\x81\x60\xfd\xbc\x56\xe5\x8d\xbc\xf4\x06\xda\xba\xf7\xe7\xda\xce\x8f\x68\x2d\x51\x0e\xac\xe9\xad\x52\x32\x69\x0b\xb1\xe5\x82\xb2\xd8\xba\xed\xb6\x20\xb5\x1a\xe9\x64\x9b\x41\x82\x94\x47\x29\x78\x61\xd0\xde\xac\xb5\x50\x9b\x7a\x32\xbf\xa2\xd2\xec\x60\xbc\x00\xcd\x51\x8f\x0e\xe6\x9d\xc6\x1f\x81\xa8\x73\xa6\x4b\xef\x1b\xc9\xfa\x61\xa9\x08\x2d\x9a\xcd\x42\xf3\x08\xb1\xd6\x8c\x12\x9c\x48\x23\x07\x33\x49\xd6\x2a\x0f\x34\xa1\xef\x60\x8b\x63\x0c\x72\x85\xb2\x4d\xc4\xd3\x31\x32\x75\x4b\x66\xc9\x35\x9b\xaf\x64\x95\x62\x96\x58\x20\x1d\x13\xac\x73\x22\x50\x1a\x8d\x96\xde\x26\x77\x86\xe8\x6a\x85\xa7\x31\xcd\xf2\xa2\xeb\x62\xcc\x1a\xec\xc3\x1d\xc9\xd7\xc7\x9b\x3c\x8a\x27\xa5\x63\x7c\xa2\x8e\x36\x8e\xdb\x36\xcc\xcd\xec\xd2\x91\x6e\x56\xad\x67\x2b\x75\xa7\x1b\x93\xb3\x2c\x4d\xe1\x6c\xcd\x4b\x51\x4c\xd4\x25\x2c\x35\xf3\xcb\x58\x3a\x2c\x65\xe9\x10\x6b\x96\x9d\xa5\x46\x76\x29\x4b\xcd\xaa\xf5\x6c\x5a\x37\x48\x7e\xa9\x51\x35\xaf\xaa\x30\x8e\x17\x53\x2c\x0d\xdc\xbe\xd2\x0c\xde\x0e\xf6\x4d\x89\x2e\x33\xee\xac\xdb\x46\xd8\x0e\xc4\xea\x23\x94\x62\xbf\xdf\x38\x6f\x5e\x43\x33\x0b\x22\xe5\xf4\x73\xc9\xac\x70\x77\x0b\x45\x8a\x16\xb1\x9f\xb4\x51\xd2\xfa\x65\x0e\xbc\x4b\x82\x87\x30\xde\xa7\x52\x81\x3c\x49\x2a\xc4\x36\x6b\x71\x00\x4d\x5b\xaa\x49\x6a\x4b\x70\x1d\xa9\x64\xd0\x5a\x5e\xa0\xdc\x8e\x5d\xb6\xbf\x43\xed\xaa\xbc\x93\xba\x83\x60\xd3\xe8\x4e\xc8\x5f\xc3\x60\x23\x8d\xb0\xcb\xf1\x17\xca\x45\x28\x97\xb6\x8b\x50\xf2\x9b\xfa\x15\xe9\xaa\xbe\x9f\x65\xe1\xa6\x01\x7b\x6c\x49\xe9\xf2\xee\x60\x1c\x6c\x8e\x2e\xa3\x9a\x73\x49\xfc\xaa\xf7\x42\x00\xe7\x0c\xbf\x34\x8d\xb7\x7f\x1a\x6c\x76\xd9\x93\x76\xb4\x88\x5c\xc9\xc6\xd9\x63\xfa\x87\xe2\xd4\x10\x47\x50\xb2\xf2\x4c\x5d\x5e\x05\xe8\x6e\x9d\x04\xcb\x7c\x66\x82\x65\x59\x9f\xe3\xa5\x2b\xc6\x02\xdd\x2e\x09\x61\x18\x3f\xa1\xa1\x28\x66\x9e\x15\x38\xac\x5a\x35\xcb\x56\xed\xe0\x6a\xd2\x23\x37\xd6\xb3\x32\xc8\xe3\xfd\x82\x3c\xfa\x82\xba\x06\x87\x55\xab\x66\xd9\xaa\x1d\x8d\xae\x7d\x32\x41\x62\x65\xf4\xf7\xaa\x45\x9d\xf4\xb5\x61\x19\x08\xab\x50\x4a\xb7\x86\xef\xe8\xeb\xe4\x02\x11\xf2\x3e\xab\x90\x2c\xfa\x48\xa6\x06\x87\xd5\xa9\x66\x59\xef\x08\xa0\xef\xf6\xe6\x12\x62\x3c\x37\x28\xdc\x0e\xfa\x0c\x9c\x0a\x86\xca\x91\x9c\x63\xab\x93\x3d\x3c\x79\xe4\x0f\xcd\xe1\x5b\xcb\x8a\x87\x68\xe4\xad\xf9\xe4\x9a\xdf\x4b\xd3\xd6\xfe\xae\xaa\x40\xbc\x13\x84\x8d\x2c\xdd\x22\xd0\x5d\x36\xb4\x59\xf6\x21\xcd\x5a\x5d\x36\xa4\x17\xfa\x3b\x63\xbc\x90\x78\x6e\x4c\xe0\x50\x76\x6a\x89\xb7\xc7\x40\x3b\x31\x02\x84\x76\x62\xbf\x5e\xa8\x9d\x88\x19\x66\xa4\x00\x9b\x36\xc2\xa9\x17\xe4\x6c\xf3\x63\xc8\xf9\x14\xe2\x46\x7d\x3e\x50\x78\xef\x16\xe5\xaf\xa2\x17\x65\x15\x1b\x87\xc3\x5c\x70\x50\x65\x27\xce\x58\x3f\x4e\x5d\x90\x23\xcf\x3f\xa9\x57\xf2\x76\xbf\x01\x8f\x25\x29\x2e\xdc\xa2\x7b\x9a\x86\xc8\xd6\xf8\xa1\xb9\x9b\x8a\x26\xb1\x86\x84\xdb\x75\x90\x84\xd8\xc4\x85\x9a\xf3\xbc\x9a\x46\x77\xdd\x77\xa4\x9f\xeb\xfe\x41\x41\x20\x83\xea\x7b\x00\xb5\xb3\x28\x83\xbe\x26\xf2\x83\x5e\x4f\x2a\x7e\xb3\x4e\x64\x7f\x4d\x0c\xe0\x31\xf9\x73\x94\xcf\x8c\xe4\x25\x8c\x73\x51\x52\xde\x01\xb9\x6b\x4b\x6a\x54\x5e\xf0\xa0\x5d\x09\xcd\x63\xeb\xa9\x97\x04\xc1\x96\x9d\x63\x33\xf7\x6e\xe1\x9d\x30\xba\x32\x3b\x61\x44\x77\xbd\x9d\x4c\xbc\x7a\xb2\x4f\x7e\xd2\x8a\x89\xc2\xa4\xa7\xb5\xc7\xe8\xa4\x82\xed\x93\x21\xdd\xb5\x9e\xad\x21\x7b\xeb\x86\x91\xe5\xc1\x17\x73\x17\xdd\x40\x3f\x5b\x21\x5f\x48\xf2\x62\xef\x53\x7e\xb3\x4a\x7a\x3a\x8f\x01\x35\xba\x83\xb4\x41\x1e\x81\x03\xcb\xd3\x89\xf7\x99\xf6\xfc\x9e\x05\xa8\x12\x42\x6a\x7d\x83\x5e\xf4\xe2\x14\x09\xfc\xde\x17\x69\x38\xca\x47\x3c\x8a\x53\xf8\x6e\x51\x44\xbc\xde\x21\x25\xe5\x5a\xab\x48\xc1\x6e\x5b\x11\x0e\x46\x41\x4e\xd7\x73\x77\x34\xa4\x27\x9d\x4a\x9a\xc9\x2b\x63\x6e\x04\x6a\xfd\x20\x9f\xf1\x3a\xf5\x50\x34\x16\xfb\xa3\x58\x1b\xeb\x91\xba\x63\x55\x1b\xd9\x0c\x88\xfd\x63\x3e\x97\x7a\x49\x46\x2f\xcd\xbb\xd9\x39\xfc\x63\x6f\x6c\xe1\xce\x41\x2e\x76\xfa\x93\x8f\x1c\x31\x88\xe3\x26\x4c\xa9\x43\xee\xa8\x49\xe4\x44\xad\x36\x14\x86\x78\x41\x60\x63\x14\xa7\x58\x79\x9e\x63\xb3\x5b\xc4\x0a\xf3\xdd\x93\x54\x3d\x61\x1c\xc8\x3d\x37\xd1\x2d\xde\xe5\x64\x88\x4d\x0c\xfc\xe5\xb2\xe7\xeb\x9b\x25\xfd\x49\x70\xed\x4d\x34\x54\x0d\x54\xd7\x79\xd7\xc1\x60\x31\xd4\x41\x65\xfe\x0b\xc7\x72\x31\x1e\x11\x47\x84\xe5\x50\x0f\x2f\xf7\xc6\x2e\x7b\x57\xf8\xeb\xe2\x81\xbf\xd4\xc3\x51\x0b\x2f\xb8\x5a\xf6\x65\x3c\x38\x61\xee\x24\xe8\x07\x4a\x7d\x28\x55\xa3\xf1\x60\x72\x2d\xa0\x84\x27\x28\x36\xab\xb9\x13\x7f\xb8\xc0\xf4\x86\xb7\xbc\x0a\x86\x1a\x61\x4b\x37\x58\x78\x9e\x86\x0a\xa7\x6d\x79\x19\xf4\x17\x63\x1d\x14\x21\x6f\x32\x19\xf7\x0b\xa6\xa9\x0f\x8d\xbb\xd7\xa3\xd1\x68\x80\x51\x37\xf0\x03\xdf\x78\x11\x1e\x68\xf3\xfb\x2a\x26\x9c\xb8\x60\xb4\xb8\xf6\x7a\x1a\x24\x42\xdb\xd5\x68\x08\x7e\xea\xf1\xdf\x84\x62\x7c\x17\x3c\x2d\x13\x77\x13\xa4\x0d\xf2\xd4\x58\x02\x62\x40\x56\xbf\x3b\x69\x96\x84\xbb\x20\x3d\x2c\x13\x72\x92\xb4\x20\x36\x17\xee\x11\x8d\x4b\x1c\xb3\x18\xcd\x25\x27\x4a\xa1\x8e\xf8\x77\x45\xff\x3b\xe2\xee\x0a\x8c\x07\xe9\x20\x1a\xa6\x0d\xab\x6f\xff\xb2\xad\xf5\x54\x9d\x99\x32\x1e\x4b\xb4\x1e\x89\x32\x21\x0b\xfa\xe9\x56\x06\xe3\xaa\xee\xfc\x09\x50\x7a\x67\x55\x49\x58\x6e\x50\xb8\x71\x96\xd9\x81\x35\x1c\x5d\xd2\xbc\x8e\x74\x56\x4b\x79\x71\xb2\x2e\x24\x62\xd5\x69\xc3\x1a\xdd\x09\xb3\xc6\x9a\x35\xd7\x32\xad\x39\x2a\xdf\xb8\x24\xf9\x4e\x91\xca\x53\x1a\x2a\x7f\x8d\x83\x84\x82\x3e\xf6\x30\x6f\x27\x7f\xa2\x6f\x34\xf6\x83\x95\x83\x9c\x51\x1b\xb7\x1b\x83\xf1\x17\x8e\x64\x4a\x8d\xdf\xe3\xde\x17\x96\x92\xf6\x9c\x4b\x0d\x87\xf6\xbb\x6d\x9e\x1f\x06\xbe\xfd\x7f\x8f\xe8\xff\xf6\x14\x23\x4f\xb8\xd2\xf1\x46\x35\xd1\xa8\xa7\xc6\x58\xd5\x1c\x55\x24\xf3\xd7\xdc\x44\x22\x4f\xd0\x04\x52\xd4\xe7\x6e\x81\x41\x54\xce\x31\x0d\xd9\x18\x88\xa7\xa3\x1b\x60\x68\xc3\x2d\x4c\x1e\xc9\xb8\x39\xbd\xd0\xc9\x25\xf4\x71\x56\x19\xaf\x2a\x1f\x80\x18\x82\x7f\x0d\xc4\x7f\x0d\x44\x83\x62\x4d\xee\x2a\x02\x96\x15\x42\xa7\x97\xfe\x97\xc4\xfd\x4b\xe2\xaa\x24\xae\x3a\x68\x5d\x21\x74\x08\x82\x7f\xc9\xdd\xbf\xe4\xae\x4a\xee\x2a\x57\x2d\x2a\xc4\xce\x2c\xff\x2f\xa9\xfb\x97\xd4\x21\x52\x47\x63\xda\xfa\x19\x68\x9e\x8c\xbd\x47\xcb\x5f\x90\xa0\xf9\x0e\xfb\x07\x66\x8c\xfe\xd3\x41\x9f\x58\xff\x16\x93\x30\xff\x51\x06\xc9\x63\xe9\xf4\x4a\x36\x9e\x13\x2f\xde\x06\x5e\xa6\xdf\x30\x29\xe7\x75\xc3\xcd\xaa\x53\xc4\xa8\xf5\x8b\xb8\x19\x28\x8d\xd4\x71\x82\x6e\xa4\x87\xc0\xd5\x5d\x1a\x7d\xa9\x62\x92\xa0\x16\xa0\x07\xae\xb5\xdb\x1a\xa5\x02\xa4\x0d\x8e\x59\x98\xd7\x83\xdc\xaf\xaa\xad\xba\x01\xeb\x04\x2a\xb6\x00\x77\xb0\x5c\x28\x21\xaa\xa3\xb7\x82\xe9\xab\xf8\x34\x55\xc0\x90\xad\xf9\xc4\xba\x94\x5c\x5b\x31\x96\x5a\x1c\xa6\x99\xbe\x6b\xc5\xd8\x95\x52\x2c\x4e\x95\xdf\x97\xcf\x6e\xfa\xd1\x96\xb2\x4e\xbf\x01\x1f\xb9\x09\xfd\xb4\x2d\x9c\x1a\x05\x75\xde\x04\xac\xb8\xf0\xc0\xc4\x69\xbf\x94\xa2\x62\x9f\x65\xc5\xde\x4f\x57\xaf\xc9\x61\x2f\xd9\x19\x6c\x2d\x4e\x49\x9a\x65\x1a\x7a\x82\x90\x0a\x0b\x32\x2b\xbc\x7c\x80\xcf\xa8\xa5\xd8\x19\xa2\xa5\xb3\xed\x33\x78\x55\xbc\x90\x25\xd3\x38\x00\x5a\x77\x3f\x2f\x0d\xd0\x1d\x2d\xac\x92\x5f\x6c\x2c\x82\x5f\x6c\xa3\x90\xbe\xf6\x2b\x36\xfb\x38\xd6\x9c\x7c\x2b\x80\x2d\xff\x65\x9b\x20\xe9\x42\xaa\x0d\xa7\xbd\x43\x2b\xc8\x7c\x49\x41\x4a\x7f\x95\x48\xe4\x8b\x1e\xf5\x49\x26\xbc\x3f\x9d\xde\x8a\x52\x16\x62\x8d\x9b\x1b\xf0\x35\x7e\x13\x31\x4b\xb7\xf5\x31\xcf\x2d\xd9\xe9\x7b\xe2\xd6\x5e\xbc\x82\x13\x7a\xad\xa2\xc0\x4d\x37\xdd\x80\xcc\x9d\x5e\xae\xb4\xd8\xc9\xb2\x55\xab\x58\x05\xad\x55\xa5\xcb\x0b\x97\x0b\xf5\x0b\x8b\x55\x51\x5c\x51\x9a\x16\xae\x1a\x4f\xb6\x8e\xc2\xc7\x45\x39\xab\x4a\xcb\xd4\x18\x49\xde\x25\xf8\x71\xe6\x8e\x96\x13\x97\x3c\x4d\x4b\x22\x10\x58\xcc\x02\x8e\xdf\x8e\xe6\x54\xf3\x57\x59\x4e\xeb\x23\x6b\xc5\x36\x8b\x98\xe7\x97\x59\x46\x0d\x49\x05\x90\x7a\xbe\xde\xca\xf0\x1e\x5d\x4e\xb6\x12\x54\xec\x4d\x28\x07\xa8\x6a\x98\x22\x43\x15\xa4\x8b\x3a\x6b\x41\xd5\x62\x86\xaa\x96\xcb\x95\x31\xe7\x94\xaa\x8c\x99\x3c\x19\xe8\x4f\x58\x2a\x47\x58\x4c\x4a\xdb\x08\x37\x31\x5b\x10\x9c\x2c\xca\xa5\x85\x2a\xe5\x98\x94\xb6\xf6\x35\xcd\x2c\xed\x61\xa9\x78\x19\x84\x2a\xbb\x36\xc6\x7a\xa3\x60\xb8\x44\xdc\x4e\x8a\xc3\x2e\xb8\x52\x6e\x69\x4b\x6a\x89\xac\x5c\x55\x35\x48\x75\xd3\x4f\x91\x54\xce\x17\x55\x52\x99\xac\x18\xb8\x4f\xdb\x3e\x81\xf0\x94\x23\xb0\xd1\x8e\xe2\xb7\xa3\x39\x59\x6a\xab\xca\x55\x0a\x2e\x47\x60\xed\x71\x91\x5f\xda\xdb\x2a\x92\x0a\x20\xa5\x0b\xed\x0c\x77\x97\x03\xcf\xb3\x13\x6c\x97\x63\x15\xa0\xaa\x61\xb5\xa4\x59\xab\xb3\x16\x54\x2d\x66\x9c\x20\xd6\x82\x53\x8a\x58\x73\x79\x32\xd0\x9f\xb4\xed\x06\x61\x32\x2b\x6f\x23\x1e\xc3\x6e\x45\x72\xb2\x48\x57\x14\xab\x94\x68\x56\xde\xda\xef\x3c\xbb\xb4\xbf\x15\x14\xe5\x30\x4a\xcf\x59\x19\x4d\xb6\x32\xa1\xd2\xcc\xb0\xd8\x85\x59\xc9\xaf\x68\x53\x2d\x51\x56\x2b\xac\x03\x54\x87\x0d\x27\xc8\xb1\xe0\x91\x22\xc7\x5c\x86\xac\x7d\x5e\x15\x93\x43\x7d\x6f\xf3\x4d\x4a\xe5\x2c\x23\x39\xeb\xb4\x35\x2e\xc3\x1d\xf4\xea\x07\xcd\x4a\x37\x7f\x62\x7b\x80\xd8\x96\xa5\xbe\xb6\x65\xa9\xa7\x6e\xff\xb1\x02\x71\x82\x59\xfc\x57\xde\xa9\x2a\x32\x04\xb7\xcc\xc0\x60\x9d\x6b\xac\xab\x8f\x0f\x62\xe7\xfb\xb4\xba\xd1\x17\xb7\xf8\x7d\x37\xda\x7c\x8d\x95\xcb\xc2\x2c\x0a\xca\xfa\xb7\x27\x6f\xd1\x9a\x98\x7b\x47\x25\x34\xf9\xac\xd2\x4c\x63\xe7\xd8\x8a\x54\xed\x27\x52\x8e\x17\xc3\xa9\x5e\xc6\x71\x56\x9c\x5a\x94\x19\x5d\xb1\x05\x4e\xbd\x69\x1c\x79\x78\xb1\xe2\xfc\x24\x72\x74\x13\xe8\xb9\x91\x06\x80\x23\x92\x18\xa5\x1e\xbf\x9b\x47\x06\x31\x37\x0f\x1b\x58\x0c\xf5\x5b\x03\xad\x51\xe6\x60\x3e\xb6\x31\x33\x1e\x4e\x37\xaa\x96\xa3\xce\x06\x4a\xf5\xd5\xec\x4a\x92\x6a\xe3\x3a\x28\x2f\x24\x7d\xd4\x50\x50\xea\x2f\xa2\xdd\x66\xf5\xf2\xa3\xd2\xd5\x2d\xa9\x87\x49\x7f\x45\xee\xd3\x48\x97\x32\xc4\x2f\x4e\x11\x81\x3a\x4b\x08\xa5\x37\x35\x6b\x55\xbf\xa0\x2a\xbe\xeb\x53\x36\x12\x17\xea\x30\xc6\x80\x2d\x1d\x92\xb1\xfd\xf3\x3c\x17\xf9\xd5\x49\x82\x74\x17\x6f\x53\x7a\x0e\x8a\xa6\x58\x47\x1b\x8a\xbb\xc1\x0f\x2a\xa8\x58\xf1\x54\xb3\xae\x86\x76\xcc\xa1\xf4\x9d\xb4\xa3\x0d\x99\xfa\xda\x34\xcd\x45\xc7\x9d\x91\x53\xe3\x08\x7a\xe9\xc0\x39\x91\x90\x9b\x8c\x98\x42\x35\x25\xb1\x53\x7a\x0a\x62\x22\x70\xb5\x11\x7f\x04\x4d\x27\xd5\xfa\xdf\x8d\xbd\x8d\xcc\xff\x34\xdc\xae\xac\x67\xfd\x4f\xe9\xd5\x4f\xd6\x9e\xca\x7a\x4a\xda\xf3\xe9\x7a\xe0\xd3\xf1\xf8\xd3\x71\xf1\x63\xf8\x54\x22\xfe\xbf\xab\x88\x23\x76\xfa\xf7\x90\xf0\x4f\x51\x4d\x8d\xae\xf9\xa7\x54\x63\x6f\xcd\x27\xe3\xfe\x27\xe3\xef\x27\xe3\xe0\x47\xf0\xa8\xec\x06\x15\xbb\x6c\x4b\xd7\xb0\x70\x0a\xac\xa4\xd9\x3c\xc4\x97\x7a\x84\x27\xd1\xc2\xbb\x47\x4e\x48\x6a\xc9\x61\x39\x52\xe2\xbd\xd5\x44\xfa\x52\x62\xea\xd7\xf7\xdf\x8f\xad\xb5\xad\xd9\x47\xd5\x51\xd3\x32\x7f\x44\x4f\x7e\xa2\x76\x54\xd4\x51\x66\xfd\x3e\x0d\xcb\x3f\x11\x57\x3f\x11\xe3\x5e\xcc\x9b\xc3\x7f\x8d\x24\x7f\xbc\xba\xa8\x64\xf9\xef\xac\x91\x3e\x4d\x2b\x2a\xbb\xea\xe3\x55\x60\xa9\x8d\xfb\x24\x1c\xfd\x34\x4c\x7b\x29\x5f\x2a\x54\xb5\x36\x3f\x27\x8d\xbc\xd0\x66\xfa\x46\x8e\xd4\x7f\x2a\x8d\x17\x12\xac\xb5\xcb\x65\xa0\x83\x35\x50\xa8\x0e\xad\x3a\xbe\x93\x73\x6a\x89\xb5\x12\x06\xd3\xc6\x32\xcb\x0a\xec\x92\xab\x03\x1e\xc4\xb3\x5f\x16\x44\x8c\x20\x20\xe2\xa6\x54\xc3\x23\xe0\x65\x46\xa7\x00\x27\x22\x71\x02\xf6\x1c\xbc\x1e\x76\xe2\xdf\x9d\x80\x3d\x07\xaf\x67\x30\x5f\xc8\xab\x5a\x08\x5e\x4a\x41\x2d\x7e\xd6\x42\xf0\x52\x0a\x6a\xf1\xbc\x16\x02\xd4\xa4\x89\xc7\xfc\xaa\xa5\xd5\xaa\xc7\x51\x76\xd7\x80\x96\x78\x7b\x0a\x74\x2d\xdc\x12\xd7\x4e\x81\xae\x65\x10\x5f\xc6\xa5\x9a\x62\xfa\xa2\xf2\x75\x38\x59\x53\x48\x5f\x54\xbe\x0e\xb7\x6b\x8a\xa8\x69\xb2\xc4\x93\x72\x15\x42\xa7\x2a\xf9\x4a\x19\xd5\x26\xae\x55\xa2\x51\x17\x3b\x0a\xae\x63\xaf\x21\x0a\xe5\xf5\x9d\x8c\xe0\x14\x0a\x6a\xb5\xf8\x64\x04\x6b\x7d\x95\xa6\xb2\x3f\x65\xc7\xa6\xba\x3b\x65\x68\x7b\x6f\x72\x41\xaf\x89\x1b\x83\x7e\x49\x5f\x96\xd5\x76\x6a\xf9\x53\xea\xaf\xd3\xda\x53\xcb\x57\xf5\x63\x81\xcf\x72\xd4\xa5\x58\xe0\xc2\xd6\x65\xd9\xa9\x20\x29\xbf\xc1\x7e\xd8\xce\xcd\xa8\x57\x92\xeb\xa5\x2e\xd4\xc2\xf9\xed\x50\x26\x64\xbe\x8f\x00\x6f\x1d\x0a\x5b\xb6\x28\xe8\x9c\x54\xee\x04\x57\x58\xc5\x68\x2c\xe6\x59\x28\x66\x70\x7a\xc5\x0d\xa4\x62\x63\xbb\x84\x5c\x77\x7e\xa5\xaa\x7a\x0d\x95\x01\xa0\xad\x9e\x96\xbe\x44\xa7\x6d\x16\xa8\x8b\xb3\x26\x13\x6b\xe3\x6b\xa8\x97\x34\x0a\xa2\xf0\x27\x85\x50\x44\x38\x8f\x31\xba\xf8\x24\xcc\x24\x2d\xbf\x3e\x16\x3d\xfe\xa1\xc0\x58\x58\xfc\x82\x53\x25\x65\x68\x4f\xe4\x72\x1d\x94\x8d\x53\x6e\xc3\x44\x11\xbd\x94\xd1\x2a\x75\xf9\x15\x22\xe8\x95\x6a\x0a\x8c\x4d\x9c\x5f\x74\x59\x5b\x19\xe6\x53\x85\xba\x06\x4a\x8d\xdd\x82\x34\xcb\x5e\x77\x0b\xae\x17\x8b\xb6\x42\x20\xbb\x3f\x03\xbd\x25\xae\x00\xb0\xf1\xfa\x45\x97\xcf\x59\xd1\x9e\xc8\xe8\x4a\x7c\x3a\x97\x39\x51\x96\x7d\xda\x18\xa2\x97\xb2\x58\x25\x2d\xbf\x2d\x02\xbd\xf2\x4e\x81\xb1\x30\xfa\x65\x97\xe9\x95\x61\x3e\x91\xd7\x75\x50\xea\xca\x9a\x93\x66\xd9\x3f\x6c\xc1\xf5\x52\x8e\xab\x04\x8a\x8b\x12\xd0\x5b\xfc\x64\x10\x0b\xbf\x5f\x76\x3d\x60\x09\xe2\x13\xd9\x5d\x03\xa3\xce\x6d\x4e\x98\x65\x97\x2b\x8e\xea\xa5\xcc\x16\xe4\x05\x9b\x45\xe0\xcb\xce\x65\xd5\x41\x71\xbe\xe7\xb5\xb8\x0b\xba\xa7\x5f\xdd\x67\x22\x6d\x18\x29\x7c\x1b\xa0\x01\x48\x13\x90\xf4\x90\xde\x4f\x88\x64\xb0\x9b\x08\x90\x0c\xf2\x98\x5d\x5c\xb4\xc6\x5d\x80\xd7\xb5\xcf\xd8\x15\xa2\xc4\xcb\x15\xfb\x78\xd9\x11\x7a\xe9\x70\xb2\x7c\xa1\x5f\xe1\x59\x1b\x0d\xe8\x4f\x16\x4f\xd7\x07\xed\xea\xe0\xf1\xa4\x3b\x18\x7f\x81\x40\x8f\x16\x4f\x43\x1d\xf8\x92\x40\x3e\x06\x11\xb8\xd1\xe1\x56\xb9\x27\x30\xdf\x0a\x7a\x6d\xb9\x39\xb6\xdc\xd7\x93\x9d\xcc\x60\x48\xfe\x9c\x7e\x69\x62\xc5\xbe\xe2\x0a\x50\xd6\xae\x06\x95\x98\xf7\x7b\x90\x50\xd3\xb3\x55\x07\xa0\x76\x2f\x21\x2b\xdf\x89\x8a\xed\xc7\x03\xe9\xd0\xbe\x7c\x3f\x34\x85\x4b\x37\xca\x55\xbc\x2a\x18\x8d\xc2\xb3\x0b\x65\xa5\xcb\xbe\xcb\xee\xb8\xb6\x5e\xeb\xde\xeb\xf1\xf7\x43\x94\xdd\xd5\xbd\x06\xf5\x0e\x97\x61\x04\x23\x71\xea\x46\xbb\xb5\xdb\x8a\x77\xae\x17\x66\x4f\xf3\x41\xaf\x3d\xe3\xdf\xd3\xee\x80\xd3\x21\xce\x35\xb3\x1f\xca\x36\xf7\xbc\x86\xf2\xdb\xd2\xf1\xca\xc6\x72\x65\xf9\x39\x7c\xd6\xf4\xfc\x22\xbb\xdd\x2e\x70\x13\x77\xeb\xf1\x27\xd5\x8a\x51\xac\xd5\x50\xc8\x18\xb9\xc8\x53\x1a\x09\x9b\xd8\x77\xa3\x0e\x79\xaa\x4f\xbf\x5a\x84\xe7\x15\x83\x6e\x19\x7e\x08\x7c\x3e\xe2\x78\xb4\xc9\x18\x79\xe2\xfc\x76\xbf\x37\xee\xcd\xe4\x2b\xec\x8d\x1b\x41\x45\x13\x44\x7a\x27\xf5\x12\xd0\x77\x84\xfa\x2c\xde\x7b\xeb\x59\xbc\xcf\x48\xb7\xe5\x44\x76\x97\xae\x0f\xba\x87\x11\xec\x87\x6e\x14\xaf\x0e\xc8\x85\x97\x4a\x12\x79\x5d\xb4\xd1\x1d\xf2\xab\xa8\xcd\xeb\xac\xc5\x2f\x13\x4e\x02\xb2\x61\xd2\x2b\x62\x80\xa0\x66\x03\x90\xfd\x0e\x68\x8e\xf6\xac\xb3\x49\xcb\xf3\xe3\xd2\xec\x92\x3c\xc1\x94\x70\x5b\xc6\x12\xa3\x6c\xaf\x8c\xa6\x5e\x09\x41\x3d\x1b\x35\xbd\xb6\x2c\x44\x9c\x98\x5c\x96\x3a\x1f\x44\x7f\xe7\x29\x4f\xec\x36\x6f\x95\x6a\xd3\x4e\x31\x1d\x2e\xdd\x04\x2e\x2e\x89\xa1\xc5\xf8\xd3\x7d\x48\x39\xfc\x80\x06\x72\xd3\xa4\x17\x85\xbb\x69\xa1\xc4\x55\x3d\x6c\xe4\x19\xaa\xf8\xfa\xfa\xda\x4c\x95\x15\xdf\xa0\x6d\x6a\xb8\x42\xa8\xf1\x33\x20\xe4\x95\x8a\x6b\x4d\x01\xeb\x47\x40\x70\x18\xc1\x18\xd2\x08\x72\xba\xe2\xa5\xc3\x76\xd4\xc3\x5e\x1b\xed\xf5\x74\xfc\x74\x34\x1e\x50\xc5\x25\xe9\x2d\xb3\x58\xb8\xc5\x0b\x69\xda\x8e\x17\xe3\x6f\xe2\x4a\x16\xb5\x3f\xe9\x8e\x86\xb2\x51\x2d\x3b\xc3\xf2\x19\x7d\x75\x46\xc3\x26\xee\x23\x97\xa2\x5d\xe4\x12\x72\x01\x24\x9f\x3a\x31\x4e\x06\x89\xdb\xf7\xf3\x66\xd1\xf3\x36\x86\x0c\xaa\x27\x70\x18\xa8\x7e\x2e\x84\xd0\x2d\xdd\x9c\xc2\xcc\x18\x1e\xd6\x52\x5b\xc1\x10\xd1\x87\x39\x2f\xc8\x5f\x46\xcc\x4f\xbe\x38\xdf\x20\xa0\x51\xbc\x11\x62\xa2\xc8\x1f\x86\xc4\xca\x50\xf3\x7f\x51\x7c\xaa\x2f\x33\x8a\x12\x4c\x8b\x93\xbb\xd1\x36\xa0\x29\xf7\x49\x60\x71\xda\x3a\x30\x7e\x88\x75\x67\xc3\x7c\x4c\xfc\x20\xce\xe5\xb1\x72\x7f\x34\xc3\x57\x3c\xb8\x6c\xbc\x04\xa1\xa8\x11\x96\x35\xe9\x15\xb7\x52\xd3\x17\x37\x1a\xb2\xc6\x11\xaa\x03\x1d\x80\x63\x7e\x5a\xa7\x74\x04\x5a\x80\x72\x16\x88\xdb\x71\x86\xf4\x02\x2e\x84\xf6\xeb\xeb\x81\x44\x7b\x24\xe8\xbe\x66\xf0\xdd\x2c\x8e\xa3\x2c\xdc\x21\x9c\x2b\xc6\xe9\x65\x4f\xf3\xe4\xa9\xcb\xb3\x74\x37\x61\xf4\x34\x6d\x7e\x1f\x44\x0f\x01\xb9\xcf\xaa\xf1\xe7\x60\x1f\x34\x9d\xfc\xb7\xf3\x75\x02\x9c\x72\x52\xd0\xdf\x9d\x34\x48\xc2\x25\xfa\x20\x8e\xb8\xa8\x2a\xd9\xb8\x91\xe2\x4b\x8d\x74\x5f\xaa\x78\x8f\x42\xbb\x05\x48\xfe\x9d\x66\x6e\x92\xe1\x8e\x90\xec\x7f\x15\x09\x85\xa5\xa1\x69\x51\x90\x81\x14\xd2\xa7\x76\xc8\xd0\xe1\x74\x3d\xc2\x58\xe9\x90\x07\x5b\xdf\x29\x29\x18\x14\x79\x9c\x27\x4f\x50\x9e\xed\x61\x2d\xac\xd2\x62\xac\xcd\xac\x2e\x26\x4a\xbc\x8b\xac\xea\xec\x5a\x56\x67\xd7\x05\x7c\x16\xef\x94\xf7\xff\xf2\xd1\x4a\xc7\x04\x75\x6e\x05\xa8\x72\xaf\x1a\x7f\xbc\xd6\x78\x8c\x46\x00\xf3\x5b\xcc\xac\xa8\x15\x60\xf9\x02\x36\x04\xb1\x42\x06\x08\x9c\xfa\x46\xcb\xa0\xa7\x3f\xab\x74\x75\xfa\x5d\xe8\xc4\x31\x46\x96\x26\x44\x9d\x6e\x92\xc4\x8f\x88\xf8\x6b\xb7\xb4\xf7\xd4\x59\x07\x72\x62\x91\x09\x32\x55\xa3\x4a\x1f\x34\xb4\xaa\x54\x7b\x38\x86\xb9\xa2\xc2\x10\xc9\xc6\x70\x7d\xc5\x5e\x4c\x6a\x28\xe7\x93\x64\x63\x29\xd5\x45\x71\xe8\x15\xe6\xcf\x0e\xcd\x74\xb5\x2d\x6e\x68\xfb\xb8\x3a\x29\xfe\x8a\x56\x9a\xb7\xc2\xbd\xbc\x4e\xb4\x3e\xba\x90\x04\xbc\x54\x2f\xb6\xa3\x92\x6e\xad\x49\xa9\x8d\xed\xbf\xc2\xea\xc3\x78\x2a\xaa\x13\x4e\x4e\x65\x7d\x3d\x51\xe3\x4c\xda\xe5\x81\x56\xc7\x18\x84\x55\x58\x5b\x64\x8c\xca\xd4\x08\x0e\x52\x1d\x2a\x38\xb2\x1f\x27\xf5\x20\xde\xc8\x17\xd4\x69\xed\x48\x53\x6a\x5e\x5e\xe7\x2e\xde\xd1\x69\xb2\x2d\x9e\x63\x78\xa5\x13\x6d\x32\x29\xa9\xa3\xcb\x89\xec\x0d\x0a\x0b\xf6\x71\x86\x70\xf4\xff\x53\x43\xf8\xcf\x9a\x3b\x91\xc7\xd7\x4f\x9f\x3b\xd9\x1d\xb6\x9e\xe6\x8b\x0d\x30\x87\x0d\x01\x32\xcc\x3a\x17\x4c\x6a\xa6\x65\x29\x67\x53\x4f\x91\xcb\x2c\xb3\x3c\xdc\xd5\x7c\x6e\x8c\xe5\xdb\x5e\x95\x7c\x6a\x7f\x55\x97\x5b\xce\xe7\x53\x10\xe5\x49\xfd\xe2\x6d\x30\xf5\xd4\xbb\xe5\x1d\xda\x4b\xf2\xa7\x64\x5a\xb4\x20\x7f\x34\x16\xe7\xda\xb7\x51\x8c\xd0\x62\x9e\x5d\x04\xe4\x28\x31\x39\xc4\x4d\x97\xaa\x08\x47\xfb\x3d\x75\x97\x19\x3a\xc0\x55\xa7\xf5\xe3\x0c\xba\x5a\xa5\x76\xa4\xbc\x6f\x12\xc9\x89\xca\x9f\xfd\x6f\xaa\x9a\x4b\xed\x24\xe8\xb6\x02\x31\xbf\x34\x95\x3e\x99\x8f\xaa\x7b\x9a\x65\xda\xc8\x22\x48\x20\xa5\x2a\x42\x38\x6e\x6b\x7a\xb2\x38\x66\x6c\x10\xc2\xe9\x2f\xfa\x73\x66\x08\xd1\x2c\x6f\x5c\xa3\x89\xd0\x23\xbd\x0a\x6e\xab\x8e\x0a\xb7\x68\xb9\x62\xc1\x59\x23\x95\x61\x21\xb5\x5a\xb1\xd5\x52\xbb\xe5\x74\x4b\xcb\xa9\xd9\x2d\x25\x44\x6d\x39\x6b\x29\x1b\x78\x78\x93\x15\x62\xa4\x46\xe3\x35\x31\xb4\x72\x9b\x4f\xe9\x6a\x21\xc3\xa8\xb9\x93\x18\xa1\x64\x68\x9c\xb0\xd0\xc2\x9b\xcd\xc3\x01\xf5\x7b\xbb\x94\x24\xb6\x63\x40\x52\x45\x7a\x67\xf3\xd7\xd8\x6a\xf4\xb6\x56\x8f\xec\x3e\x49\x0d\x97\x92\xad\xcd\x96\xe8\xe0\x8d\xe6\xc7\xd3\x0b\x0f\xd9\xda\xe2\x4a\x5a\x68\x8b\x3d\x17\x54\x64\x8a\x3d\x89\x5c\xe4\xf1\xc9\x8e\x2d\x18\x49\x17\x91\x8c\x28\xb9\x5a\xf8\xa6\x4b\xaf\xb7\xb0\xaf\xbb\x51\x43\x8e\xc4\xad\xc5\x5b\x4b\xfc\xc1\xc4\x06\xf5\x1d\xd4\x68\x35\x0a\x52\x91\x8f\xd3\x77\xc3\xdf\x60\x44\xf3\xc8\x73\x8c\x8a\x6f\x23\x22\x18\x6e\x14\xb1\xf7\x38\x73\xb7\xa4\x33\xf4\xdb\x4e\xcb\x08\x39\x93\xe4\x03\xce\x98\x7a\x11\xfb\x49\xd9\x1b\x94\x6a\xd0\x7e\x62\x7d\x89\xb2\x04\x9f\xe4\xd1\x2c\xc1\xff\xe9\x3c\x84\x69\xb8\x08\x23\x32\x5b\x97\x1e\x2c\xb3\x64\x89\xd2\xbb\x20\x49\x77\x01\xbb\xdd\xa8\xdf\x63\xd3\x62\x23\x09\xe7\x3f\xbf\x14\xa9\xcb\xaf\x53\x47\x41\xc8\xcb\xed\x07\xee\x09\x97\x04\xf5\x87\x7e\x8b\xc8\xa5\x63\x0b\xd1\xcb\xf9\xe5\xc4\xb0\xcb\xd6\x51\x08\xf2\x28\x7c\x3d\x5a\x3a\x55\xc4\x74\xea\x51\x53\xc2\x94\x2a\x42\xb9\x7f\x56\x8b\xdc\x5e\x19\xa9\x2c\xf3\x68\xd2\x69\x23\x71\x4b\xef\x82\xd5\x53\x29\xf3\xb4\x8b\xf7\x71\x8c\x07\x11\x4b\x3d\x01\xb1\x6d\x0e\x25\xbd\xa8\x8b\xa2\x3b\x70\xc7\x15\xcb\x2f\xba\xbb\x63\x47\x60\xe9\x06\xa3\x07\x6c\x8d\x65\x6e\x70\x59\x2d\xf2\x20\x41\xc9\x25\xc6\x20\x89\xa3\x53\xf7\x05\x8c\xe5\xb7\xfd\xaa\x9f\xf2\x33\xd7\x88\xf5\x97\x05\x27\xed\x5a\x4b\xb8\x06\xe1\x8c\x05\xb5\x5f\x0f\xa1\x0c\x57\x63\xce\x8d\x9e\x92\x00\x2a\xa7\xdf\x6e\x10\x2e\xd5\x7b\xda\xe3\x63\x31\x72\x42\x0b\x7c\x14\xbf\x43\x03\x17\xd0\x05\x0e\x8b\x26\x90\x2f\xf2\xea\x64\x4b\xad\xa9\xed\x64\x71\xcb\xa8\xab\x5d\xe3\x7d\x8f\x2c\x6e\x30\xcd\x59\x9b\x74\xde\x3d\xe4\xf1\x96\xd0\x9f\x7e\xfb\xf7\x1f\x08\xde\x5f\xc4\xa8\xef\xfe\x14\x7a\x49\x9c\xc6\xcb\xac\x9b\xd7\x41\xe7\xea\xdf\x10\xb9\x48\xb3\x64\xfe\xe5\x67\x57\x3d\xf6\xbf\x2f\x9d\x46\xb0\xf5\xa5\x8c\x5e\x91\xf1\xef\xbc\xf0\x2f\x4f\xbb\x60\xde\x57\x1a\x92\x04\xbb\x80\xec\x56\xa0\xff\x74\x3e\x20\xb2\xc0\xc4\x5c\x04\xaf\xf2\x67\x8f\xed\x5c\xaf\xec\x4c\xc6\x80\x9e\xce\xa5\x8f\x10\x8f\x13\x31\x7e\x84\x78\x30\x59\xd0\x25\x64\xfc\x72\xf1\x28\x25\xfd\xe3\xc5\xa3\x67\x13\x8f\xab\x4f\x23\x1e\xf9\x2e\x13\x3d\xbd\xde\xf3\xfc\xf6\x45\x8a\x7c\x41\x5a\x5e\xae\xd0\x6b\x69\x74\x57\xd1\xd3\x6e\x1d\xc2\xcf\x8e\xb7\x0e\x1e\x92\x78\xdb\xd1\xd4\x7f\x09\xa4\xee\xe5\xe4\xa0\x14\x4a\xb3\x6d\x6a\x66\x89\x89\x23\x53\x15\x11\x21\x1c\xe7\xee\x75\xb8\x65\x41\x1d\x1a\x5e\x30\x43\x38\x1f\xd3\xb0\x82\x20\xcb\xc4\xb0\x76\x0d\xd5\x0c\x11\x0b\x04\x45\x1d\x62\x56\x66\xa9\xa4\x26\x2b\xc5\x1a\x4e\xb1\xdc\x4a\xbf\xe5\x98\x29\x8b\x86\xaa\x13\x80\x32\x9c\xd3\x45\x00\x83\x24\xc8\xc3\x2a\x5f\xbe\x19\xf4\x86\xd7\x5f\x96\x12\x89\x96\x71\xbf\x54\x5c\x00\x3f\xf4\xdc\x0c\x46\x11\xd2\xfd\x22\x02\xd2\x93\x27\xe9\x79\xb4\x78\x3c\x13\xcb\xc0\x5f\xcc\xf0\xb7\x75\xf8\x32\x97\xfa\x76\x09\xb7\xf6\xf4\x70\x8a\xfc\x52\x0f\x42\x52\x23\x0a\x0f\xa8\xc0\x15\x81\xa4\x62\xe3\x61\x11\xb9\xeb\x8b\x25\x7f\x42\x28\xb4\xba\xc3\x96\xc0\xad\x5b\xb5\xa4\x98\xf9\x9b\x6b\x33\x5d\xd2\x64\xbd\x36\x12\x65\x95\xe2\x1e\x3c\xc4\xd7\xd7\x27\x24\x79\x83\x84\x03\xca\x1b\x30\x90\x1a\x30\x90\x43\x8f\x96\x03\x08\x45\x57\x8b\x4b\xe6\x8c\x3e\x13\xd7\xcd\x7d\x31\x93\xf7\x3e\xf2\x1b\xe7\xa4\xde\xcb\xb7\xa2\xd2\x61\x2b\x6f\xa0\x54\x36\x4d\x7e\xb4\xc7\x66\x12\x4d\xb7\x39\x1c\xf4\x40\xbc\x98\xfc\xa6\x5e\x12\x04\x5b\x36\xff\x35\x77\x21\xfc\xf7\x52\x98\x62\xfb\x41\xd1\x8b\xc3\x9e\x1e\xcc\x19\xe7\x6b\x1c\xc4\x0b\x1e\x7e\x42\xed\xa8\x2a\xc5\xf1\x27\x54\x8a\x9a\x2a\xd4\x50\x73\xd1\x4b\xb8\x5a\xe3\x51\xcb\x81\xa4\x05\xb8\x00\x0d\x6d\xc3\xe0\x20\x1f\xaf\x3b\x16\x3b\x65\x3a\xe2\x75\xb0\x9b\x22\x8d\x85\xa9\x9c\x0a\x20\xa6\xe7\x18\x14\x59\x53\x5b\xb8\x89\x5c\x50\x24\x09\x30\x2f\x02\x47\x66\x19\x7e\x10\x30\xf9\xef\x1c\x00\x98\xe2\x82\xbe\x49\x3a\xcb\x68\x0f\xae\x8a\x80\xd3\x92\x0d\x70\x03\x30\x07\xf1\xa3\xce\x3a\x4e\xc2\xdf\x48\x46\xd4\xf0\x73\x94\x46\xba\x28\x40\x03\x3c\x52\x16\x4b\x50\x78\x52\x06\x22\xd0\xc8\x1b\x8c\x44\x39\x25\x4d\x00\x6e\xdd\x07\x91\x4f\x3e\xa5\x64\xb2\xcb\x48\xec\x91\x97\x40\x94\x64\x0d\x9c\x6d\x01\xd3\x80\x79\xa2\x0a\xaa\xc2\xe4\x99\x3b\x77\x55\x94\x67\x3f\x8a\x2c\xb1\x49\xbf\xc8\xcf\x53\x04\x50\x1e\xe0\x64\x9f\xdc\x0e\x2a\xaf\xda\xc9\x31\xce\x13\x84\x50\x13\x2f\x43\x94\x2a\x24\xc7\xda\xef\x35\xfa\x14\xeb\x3e\xa9\xcb\x2c\x5d\x83\x76\x82\xca\x75\x85\xcf\x26\x53\x25\x46\xf2\xa5\x1d\xd2\x68\xf2\x78\xdf\x1a\xc6\x37\xb5\x05\x7c\xaf\x9a\xba\xec\xa4\xe8\x11\x69\x8b\x69\x27\x9f\x75\x1d\xe5\xb7\x0d\xa5\x8d\xe6\x67\xe1\x66\x17\x27\x99\xbb\xcd\x8e\xd2\x63\x86\x0c\x80\x7c\xca\xf9\xeb\xd0\x2f\x7a\x96\x98\x12\x39\x33\x5d\xc7\x8f\x2a\x55\x72\x6e\xb8\xa5\x61\x47\xf2\x76\xa1\x1e\x7e\x3c\x76\xa9\x85\xa2\xc8\x89\xfe\x9e\xf6\x5e\xf7\x1a\xee\xcc\x5c\x31\x33\x56\x94\x0d\xdb\x6d\xae\xaf\x91\x68\x0d\xab\xc6\x4a\xb8\xbb\x04\xa1\xd2\x76\x97\x1e\xff\x8d\x6c\x2a\x7e\x08\x83\x47\x02\xc6\xcd\x8f\x1f\x3c\x84\x5e\xc0\xec\xe4\xb1\xcb\xdb\xd3\x89\x56\x4e\xfe\xbd\xf1\x8b\xef\x74\x53\x7c\x7f\x48\xad\xb5\x17\x68\x58\xc7\x3a\x72\x0a\x73\xc5\x90\x24\x1d\x76\xe3\x23\x29\x7a\xe9\x3c\x49\x87\x4d\x37\x48\x8a\x5e\x3a\x4f\xd2\x61\x3f\xa4\x48\x8a\x5e\x3a\x4f\xd2\xc4\x57\x63\x47\xbe\xb3\x30\xdf\x0e\x71\x39\xb9\xa4\xfe\x08\xc2\x4a\x5d\xc8\xa8\xae\xc1\x00\x69\x86\x0c\x98\x58\xa1\x3a\x30\xf4\x64\x48\x5f\x82\x74\xb2\xb5\xbd\x1c\x79\xb8\x53\x2a\x58\xab\x25\xd8\x50\x3e\x19\x07\x63\xab\xe6\xbd\xbf\x10\x8b\x46\x90\x9c\x88\x62\xd4\xbc\x46\xee\x4b\xe6\xf5\x5c\x5f\xf7\x95\x7a\xd2\x4d\xcd\xbe\x93\x00\x4b\xfa\x4e\x87\xb2\xf7\x1d\x8c\x45\xa9\xef\x8c\x72\xd6\xbe\x3b\xb9\x7d\xb5\x7b\xf4\x74\xcc\xf5\xfb\xf9\xa5\xb8\x5f\xdc\xfb\x6c\xf7\xaf\x5e\x4f\xbf\x4f\x26\x83\x52\x45\x1b\xbf\x66\xf7\x4b\x80\x25\xdd\xaf\x43\xd9\xbb\x1f\xd4\xb2\xd4\xfd\x46\xb9\xea\xee\xaf\xdd\xc0\xd3\xfb\xbf\x3e\xea\x17\x08\xc0\xa9\xc8\x5f\x2c\x01\x7d\xba\x89\x56\x42\x19\xad\x6a\xf6\xb5\x04\x58\xd2\xd7\x3a\x94\xbd\xaf\xc1\x1c\x4b\x7d\x6d\x94\xab\xee\x6b\xa4\x29\xa7\xf7\x2a\x86\xe4\x05\xfd\x67\x47\x73\x6a\x4f\x19\xba\x9f\x39\x45\x25\x9e\xc9\xc9\xfa\x84\x63\x94\xb4\x6b\x35\xc6\x0a\x01\xe5\x28\xa5\x11\x5b\x8d\x32\xe7\x19\x2f\x2c\x89\x80\x5e\x38\x67\xeb\x2e\x09\xb7\x59\x85\x4f\xc2\x60\x2c\x45\xca\x65\x5c\x85\x2d\x11\x73\x04\xd0\x2e\xe9\x14\x58\x16\x76\xac\xb4\x2e\xef\x2a\x70\x2d\x67\x0c\x6b\x78\xd5\x88\xd0\xa0\x35\xd1\x3f\xa1\x9e\xca\x41\x83\xc2\xbf\xbc\x5d\x2f\x19\x5d\x1c\x11\x97\xb7\x52\x59\x3a\xfe\xa1\xd1\xf8\xea\x35\x0d\xc6\xde\xfc\xe1\xab\xd7\xf4\xc6\xac\x3f\xfc\xe1\x2b\x7a\xe1\xd3\x1f\x48\x9e\x1f\x3e\x34\xbc\xc8\x4d\xd3\x79\x53\x9b\xdf\x36\x6f\x20\x5f\x85\x20\xb3\x48\x3e\xcd\xe4\xb9\x90\xbf\xee\x8b\xcf\x46\xe3\xfb\xa7\x5d\x90\x00\x70\x98\x34\x92\x80\xd0\x90\x0a\xa8\xd7\x05\xd8\x57\xeb\x41\x51\x82\xae\x13\x4d\x1b\x87\x43\xa3\x4b\x3f\xff\xec\x6e\x02\x4a\x35\x2f\xc5\x41\xbf\x7a\x0d\x64\x50\x8a\xe1\x9b\x4a\x9a\xa0\x89\xfe\x28\xa8\x61\x97\x82\xe5\xe8\xbf\xca\x92\xe2\x07\xcd\x16\xe5\x1e\xf6\xd1\x37\x71\xd4\xbc\x21\x15\x7e\xf5\x3a\x5b\x6b\x60\x37\x3f\x07\x0f\xe4\x51\xa2\x27\x24\x4f\xa0\x08\x17\x14\xc3\x0f\x24\xca\xe6\xef\xbd\xe0\x8f\x18\xf0\xcd\xb7\x41\xea\x25\x21\x8d\xac\x61\xd9\x3f\xba\x4f\x41\xa2\x66\xc0\xaf\x9c\x6a\x92\x23\xb5\xe8\x2b\x76\x57\x17\xff\x75\x38\x24\xe4\xf2\x83\x46\xf7\x67\x60\xf5\x7f\xee\x23\xe8\x3b\x97\x4e\x75\xc3\x20\xcd\x99\x48\x99\x20\x48\x3e\x1c\xba\xa2\x61\xc7\x63\x53\xa5\xc5\xbf\x81\x5c\xc6\x7f\xa8\xd5\x47\x32\x8b\xa2\x16\x00\x89\x15\x56\x18\x89\x1f\x56\x18\xca\x14\x3d\x57\x66\xcb\xe1\x10\x6c\x7d\x49\x4e\x24\xb6\xc0\x0f\x7a\x23\xeb\x1f\x72\xa9\xf9\xea\x35\xcb\xfd\x8a\x55\x7c\xf3\xfa\xd5\x59\xe3\xed\xff\xda\x07\xc9\x53\xe3\x61\xd0\xed\x77\x47\x8d\xe7\x46\xcb\x6b\x37\x40\x91\x8f\x1d\xf8\xbb\x3f\x16\xd9\x7f\x22\x73\x7d\xba\x08\xe8\x34\x7e\xd8\x7a\x5d\x00\x7c\xfb\x9e\xe4\x74\xe3\x64\xf5\x3a\x82\xd9\xf9\x36\x0d\x1a\xaf\x5e\x43\x5d\x67\xcb\xfd\xd6\x23\x90\x2d\xd7\x59\xb4\x0f\x4d\x76\x11\x43\x73\x3e\xcf\x60\x4c\xc4\xcb\xc6\x06\xf8\x12\x05\xe7\xe7\x96\x8c\x6e\xf0\x81\x8e\x97\x5b\xf5\xe7\xdc\xed\xfa\xb1\xb7\xdf\x04\xdb\xec\x76\x01\x98\xcf\x7a\xed\x69\x51\x51\xfb\x10\x2e\x5b\x67\x05\x48\x3b\x5b\x83\xf6\x6e\x6c\x83\xc7\xc6\x77\x49\x12\x27\xad\x26\x6f\x47\x12\xbc\xdf\x87\x49\x90\x36\xdc\xc6\x63\xb8\xf5\x01\xe6\x31\x04\x39\x76\x1b\xa2\x64\xb3\x3d\x4b\x82\x6c\x9f\x6c\x1b\x50\x4b\xfb\x38\xa5\x7f\xb7\x9a\xd0\xfa\x60\x09\x2a\xc1\x6f\x9e\x09\x72\x59\xf9\x5b\xf6\xcf\x34\x5b\x87\xa9\xa3\xb6\xfc\xc1\x05\x69\x9b\xdf\xdd\x3b\xfe\xdc\xeb\xa6\x84\x47\x4e\x00\x5f\xa0\x5d\x3c\x37\x73\x96\xf0\xb9\xdb\xa7\x6b\x67\x05\x1f\x74\xc1\xe2\x2f\x4b\x67\x3d\x3f\x1c\x9d\x70\xbe\xee\x66\xf1\xcf\x59\x42\x9e\x2f\x7c\x0b\x3f\xd6\x6e\xfa\x97\xc7\xed\x5f\x93\x18\x74\x4a\xf6\xe4\xbc\x23\x40\x91\xc4\x10\x67\x33\x6f\xd2\xee\x6b\x3a\xdb\xb9\x4a\x03\x6f\x0b\x61\xc4\xb6\xbb\xdc\x42\x45\x61\x46\x73\x8e\x4e\x3c\x7f\xfd\xeb\xdd\x9b\xf4\xcd\xfe\x4f\xdf\xfd\xe9\x4f\x6f\x3e\x7c\xdd\xbb\xbf\x78\xd6\x7e\x7f\xfe\x7a\xe5\xec\x00\x8c\x84\x64\x5e\x3b\xef\xe7\xaf\x3b\xad\xbb\x37\xbe\xdb\xf9\xed\xbe\xfd\x7a\x15\x3a\x09\x5e\xd9\x02\xa8\xff\x8f\x1d\xd0\xfa\x8d\x9b\x06\xad\xf6\x71\x46\x6a\x9e\x6f\xbb\xbb\x24\xce\x62\xc2\xbc\xf9\x81\xc9\xce\x74\xe3\x00\x33\xd2\x2c\xd9\x7b\x59\x9c\x4c\xb7\x4e\x1a\x44\x01\xfd\x6c\x36\x9d\x28\xd8\xae\xc8\x2e\x4c\x27\x8b\xbf\x4e\x12\x50\xe8\x79\x5d\x79\x45\x7e\xd7\x73\xa3\xa8\x45\x58\x0f\xed\x59\x05\x99\x22\x11\xa2\xe9\x7b\xb0\xc3\x73\xf7\xb6\x77\xe3\xde\x12\xc8\x3b\xf7\x82\xfc\xd3\x65\xf8\xef\xa7\x2c\xed\x7e\xaa\x22\x23\x3d\xf3\x73\xe6\x7a\xef\x14\x94\xa4\x47\x17\xd0\x92\x4d\x90\xac\x02\x0a\xda\x95\x1a\xd0\x6a\x3b\x6e\x21\x3d\x74\xf7\xd2\x5f\xa8\x88\xcf\xa9\x70\x2c\x68\x80\x34\xf8\xc0\x7e\x8a\x1f\xce\xe2\xe8\x04\xae\xb7\x9e\xe2\xfd\xd6\x25\x79\xb4\x26\x87\xf5\xda\xc6\xdd\x61\xad\xa4\x28\x73\xa2\x5b\x40\xa2\xbb\x6b\xa9\x32\xb9\x70\xbc\x1c\xdc\x65\x8d\x85\x24\x82\xb4\x0d\x78\xa9\x7c\x22\x3c\xd6\x10\xfb\x5d\x77\xb7\x8b\x9e\x38\x45\xc9\x8a\xca\x5f\x4a\x10\xd0\xbb\x27\x6d\x08\x82\xf7\xad\x1e\xc0\x90\x6b\x0d\x4b\x40\x3a\x7d\x80\x09\xde\x23\x2c\x97\x7a\xcc\xf1\xe6\x17\xee\x45\x8b\x74\xe7\x62\xda\xcb\xf9\xad\xd1\xe9\xdd\xcc\x7b\xe7\xe7\x8b\x1b\xef\xf6\x8e\x76\xb0\x77\x7f\x3f\xbd\xbb\x27\xe8\xb7\xbe\xb5\x95\x79\x87\x3d\x3f\x1b\x7d\x4b\xc4\x88\xcb\xc5\x74\xe9\xa4\xa0\x92\xa6\x30\xa8\xe1\x1f\x07\xdc\x0d\xc2\x3a\xf8\x45\x3f\x8e\x0e\x74\xda\x87\x0c\xea\x99\xd3\x11\xc7\xbf\xa5\x3a\x49\x93\xa0\x33\x81\xf7\xbe\x13\x38\x4b\x50\x00\x39\x23\xef\x7a\xf7\xcf\xcf\x30\xba\xd7\xf3\x3e\xa8\x81\x3c\x59\x34\xfd\xed\xfc\xac\x3f\x5b\x12\x75\xb6\x88\xe3\x28\x70\xb7\x85\xf2\x5c\x9d\x9f\xb7\xde\xce\x57\x0a\xb2\x35\x47\x76\x71\xd1\x76\x0c\x6d\xbb\x7a\x7e\x06\x75\x90\xfe\x49\xd0\xb5\x6a\x3f\x3f\xb7\x56\xa0\x5a\xda\x50\xfb\x7c\x1e\x02\xbe\x15\x13\xdc\x75\xa7\xd3\x9e\x85\x37\xeb\x19\x41\x04\x7a\x96\x8d\xa8\x96\xab\xd4\xd4\x6e\x13\xba\x16\x8d\x10\x84\xab\xed\xcd\x57\x77\x0b\xa2\xf7\x5c\xf2\xcf\xea\x6c\x3e\xf7\x09\x79\xe7\xe7\xe4\x1f\x52\xeb\x5f\xc1\x33\xda\x32\x5e\xb7\x7c\x52\x71\x30\x27\xc9\x74\xa0\x43\x42\xbb\x7d\xdb\x0a\xe0\xff\xd0\x5c\xa2\x27\xcf\xcf\x8b\x4c\xaf\x7d\xeb\x91\x9e\x9c\xe6\xe9\x32\x2e\x9a\x0b\x4d\x26\xd5\xcf\x05\xef\x5b\x6f\x81\xc9\x80\x74\xfa\x10\x87\x7e\xa3\xc7\xa9\xa1\x20\x90\x2a\x04\x68\x55\x74\x5c\xeb\x00\x46\x07\x66\x46\xf1\x94\x9b\x8d\xe6\x45\x6b\x73\xf1\x93\x0b\x1e\x7f\x42\x92\x37\xad\x76\xbb\x0b\x6e\x5d\xe4\x7a\x41\xeb\xf5\x9b\x6f\x41\x4b\x36\x9b\x6d\x27\x4c\xff\x06\x0e\xca\xd3\xf4\xac\xe7\x04\xc4\xe8\x28\x72\xac\x1b\x24\xb0\x2a\xce\x36\x8e\x77\xb2\x30\x82\xea\xcf\xfb\x03\x19\xe4\x4d\x91\x04\x9d\x08\x8d\x23\xfd\x48\xd1\x70\xd6\x4c\xe9\xdf\x82\x51\x90\xfa\xbf\x99\x65\xb2\xeb\xc4\xf3\x73\x17\x30\xb9\x5d\x66\xc2\x08\xa2\x3f\x43\x7f\x26\xa1\x87\x94\x39\x2b\xba\xc0\x6d\x43\xc1\xce\xce\x4d\xd2\xe0\x4f\x64\xb5\x02\x12\x2e\xfa\x30\xde\x08\x02\xa9\x33\xb0\x16\x70\x21\x3c\x93\xe8\x7f\x7e\x76\xbb\xdb\xd8\x0f\xc8\x4e\x26\x26\x92\x8c\x6e\xc8\xba\x3d\xeb\x4f\x5d\x79\x14\x9e\x9f\x9f\xbd\x65\x9a\x4b\x49\x2e\x2c\x8b\xd3\x04\x12\xc4\x8f\xbf\x2c\x9b\x14\xc5\x19\xa5\xec\xbb\xcd\x2e\x7b\x42\x28\xa3\x0a\x66\x26\x09\x2f\x6f\x6f\x9f\x0b\x06\x29\x4d\xb0\xd9\xf8\x08\x0c\xbc\x75\x2f\x9a\xcd\xa9\x31\xc2\xdc\xe7\x67\xb9\xcb\x44\xea\xed\xfa\x2e\xe4\x8d\x68\xc3\x00\x15\xc5\xa6\x22\x1f\xa4\x37\x8a\x17\x6e\xf4\xdd\x83\x1b\x99\x94\x82\xfa\x0b\x20\x63\xe6\x12\x0e\x26\xe1\x06\x32\x1c\xe8\xc8\x56\x9f\xf6\x24\xf7\x23\xc0\x5f\x01\x6f\x0c\xd8\x13\x02\x62\x18\x4b\x8b\x79\xd4\xf5\x92\xc0\xcd\x82\xef\xa2\x80\x8c\xd8\x56\x93\x79\x80\x20\xb5\x0b\xba\x08\x34\x77\x9d\xa8\x4b\xfc\x6b\xa2\xdf\xc9\xae\x33\x72\xf7\x6c\x6b\xd1\xee\xb2\x35\x9d\x3f\x43\x07\x81\xc4\x6f\xe2\x87\x40\xe4\xb4\xa7\x1e\xd4\x0d\xe2\xe7\x81\xa3\x1c\x11\x53\x8f\x71\xc8\xcd\xc7\xc9\xce\x69\x82\x17\xd1\x2c\x06\xce\x7b\x27\xa1\x63\xc0\xa7\x53\x1d\xdc\xfe\x31\xd1\x20\xf9\x20\x72\xf9\x37\xf8\x17\x3f\xc6\x8f\xc2\xbf\x80\x86\x2f\xd4\x14\xc4\xa2\x12\xdb\x47\xf8\x07\x1a\x77\xde\x03\x9d\xe2\x0a\x95\xba\x9a\xa7\x40\xee\x0c\xd4\x9a\x47\x9d\xc8\x55\xfb\x40\x64\x61\xb6\xbc\x09\x66\x01\xd3\x77\x3e\xe0\x67\x56\xcf\xbd\x0b\xee\x01\x13\x28\xb6\x39\xa8\xa6\x36\x3d\xee\x77\x0c\x22\xe0\x35\x29\x13\x30\xf9\xa9\x59\xc2\x5e\x17\x93\x0d\x52\x30\x70\xc8\x3f\xf5\xea\x2b\x2f\x25\xb4\x1c\x48\x17\x91\x9a\x32\x61\x06\x51\x6e\x11\x81\x2e\x7a\x2a\x26\xea\x8d\xb8\x1e\xef\x02\xcd\x15\x93\xfc\xdc\xc5\xf3\xf3\xdd\xfd\x4c\x57\x30\xad\xb4\xc5\x55\x33\xc8\xca\xad\xf0\x9c\x3c\xa7\x99\x52\xf7\x56\x1e\x16\xc4\x09\x73\x41\xaf\xb3\x96\x78\xe0\x4b\xb5\x1d\x0f\x46\xee\xd6\xac\x53\xf2\x64\x18\xd5\x8b\xdb\x4e\x7f\xba\x12\x4e\x8d\x0b\xf9\x40\x2e\xa9\x4a\x23\x95\xb0\x8d\x91\x7b\xb1\x10\x12\xe0\x83\x40\x04\xb9\x40\xcc\xbc\x1b\x7f\xe6\x43\x67\x00\x0f\x2f\x2e\xee\xe7\x8b\x3b\x3f\x6f\x95\x80\x99\x03\x87\x61\x94\x02\x7b\x0c\xaa\x44\x05\x44\xce\xc0\xf3\x5f\x02\xee\x55\x21\x6c\xeb\xf9\x99\x37\x5b\xdd\x2c\x67\x4b\xa8\xc0\x9f\x9f\xc1\xe4\xe2\x6e\x09\x50\xd0\x57\xa0\x12\xd7\xe7\xe7\x01\x75\x61\x68\x6a\x6e\x98\x02\xdd\xe9\x93\xa5\xd9\xa8\x80\x48\x33\xb8\x0e\xd0\x15\x20\x17\x6b\x6a\x94\xa5\x1a\x45\x85\x44\x24\x59\x1f\x81\x29\x0c\x59\xa5\x7e\x7b\x96\x8b\xd6\x92\x89\x56\x65\x01\x41\x22\x97\x76\x68\x71\x48\x3c\x71\xb2\x29\xa0\xef\x80\x56\xfe\x80\xca\x0a\xf1\x7a\x78\x51\x43\x0e\x16\x20\x33\x1e\xf3\x1b\x16\xa0\x94\xdc\x39\xa9\x58\xf6\x53\x5c\xe2\x1b\xcc\xb9\xb7\x9e\x7b\x20\xce\xa0\x0d\xbc\x30\x1d\x3b\x97\x53\xb6\x60\x2e\x9d\x13\xf0\xe9\x57\x4b\x47\xd0\xa6\x3e\x6c\x97\x90\x0e\xec\x94\xfe\x21\x36\x89\xfc\x7b\x71\x01\xfd\xc4\x5d\x08\xa2\xb6\x1e\xa7\xdf\x82\x3e\x05\x9d\xf4\xe8\xa4\xfb\x1d\x99\xa3\x4e\xdf\x1d\x09\xad\xd4\x63\x6f\xfe\x91\x39\x68\x0d\xb0\xa8\x8b\x20\x69\xb0\xd9\x5c\x43\xb4\xa2\x41\x65\xba\x41\x30\x34\xfe\x16\xac\xbe\xfb\xb0\x6b\xb0\x61\xc2\xbc\x83\x26\xf5\x25\x41\x4b\x37\x40\x41\xab\x0c\x5c\xdf\x35\xef\x98\xc5\x68\x34\x2f\x16\x17\xcd\xfb\xe6\xbd\xa1\xfe\xda\x33\x51\xa6\x91\x16\x3e\x74\x93\xc9\x48\x93\xf4\x2c\xd1\xa6\xb9\x3b\x9d\x9b\xe2\x19\xe2\x67\x78\x88\x4d\x66\xb6\x46\x18\x6d\x70\xb3\x6f\xcf\x7a\xd3\xa6\x4b\x9a\xc4\x8b\xf4\x88\x52\x06\xdb\xb6\xa5\xad\x57\x7a\x77\x71\x43\x1c\xf3\x4e\x9f\x4a\xd8\x91\x90\x96\xcd\x11\x2b\x27\x7c\x63\x67\xed\x84\xce\x5b\xe7\x9d\x13\x39\x1b\x67\xeb\xc4\xce\xce\x01\xc3\xe1\xa4\x4e\xe6\xec\xe7\xcd\x34\xfc\xed\xb7\x28\x68\x5e\xf4\x5f\x11\xcf\x8a\xb0\xd3\x79\x90\x27\xc6\x8f\x30\x3c\x3e\xc0\x7f\x4f\xf3\xb5\x0b\xd3\xb3\xdf\xd8\x3f\x5f\xb3\x7f\xfe\x88\x4f\x5f\x89\x4f\x44\xa4\x30\x9a\x9f\xf5\xda\x0e\xf4\xf5\x37\xf3\xfe\x57\x5f\x0d\xfb\xce\xb7\xe0\x1c\xeb\x73\xf1\xef\xc8\x28\xff\xd3\xfc\x3b\x72\xfa\xd0\xf9\x77\xf2\x2f\x99\xd2\x7f\x2f\x3e\x7e\x80\x0f\x36\xf3\xff\x1f\x73\x9b\x26\xea\x11\x3f\x59\x68\x1f\xff\xc6\x9b\x79\xcc\x14\xb8\x30\x69\x21\xa4\x70\x87\xa4\xe1\xf1\xee\xe9\xf4\x8f\xce\xff\x9c\x37\xbd\x75\xe0\xbd\x0b\xfc\x67\x36\x67\x86\x0f\x37\x7d\xda\x7a\xcf\x64\xc7\x09\xdd\xdf\x4d\xbf\x48\x24\xf4\x99\xef\x7e\x4b\x9f\xfd\x60\x19\x24\xcf\x7e\x98\x92\xb0\x90\xff\xcc\xc2\xa6\xcf\x61\x0a\xea\xe5\x39\x02\x5f\xf4\x79\xb3\x27\x37\x35\x44\xc1\x33\xb9\x7f\xed\x19\xec\x86\x1f\x6f\xa3\xa7\x67\x1e\x34\x81\xba\x3c\xc8\xf0\x9b\xce\x8f\xf3\xe6\xdd\x9b\x37\x1f\x06\xbd\x37\x6f\xb2\x37\x6f\x92\x37\x6f\xb6\x6f\xde\x2c\xef\x9b\xce\x4f\xf3\x66\xeb\x76\xfa\x06\xfe\xd7\x7d\x06\x80\xc7\xce\xfd\xf3\xdd\xaf\x00\xd8\xeb\x75\xe0\x6f\xb7\x77\xdf\xbe\x68\x3a\x7f\x9e\xff\x94\x5b\x96\xe6\x63\xd3\x69\x3e\x7e\x06\x52\xfe\x97\x79\xf3\xcd\x9b\xbb\xe6\xc5\x8f\x17\xcd\x57\xad\xe6\xc5\x4f\x17\xcd\x36\xa0\xe2\xbf\xef\x5e\xfd\xfa\xf9\xf3\xd9\x3f\xee\x6f\xe7\x6d\x9e\x72\x3b\xfd\xb2\x55\x54\xf5\x2b\xf9\xf7\xcb\xfb\xf6\xab\xf6\x97\xcf\x6f\x9a\x7a\xc6\x9b\x26\xc9\x79\xd3\x7c\x06\xbc\x7f\x06\xbc\xed\x67\x8e\xe5\xcd\x1b\xa0\xf9\xaf\x73\xb0\x77\x79\x85\x6f\xde\xb4\x5a\xad\xd3\x51\xb7\x9f\xf5\x9c\x56\x1b\x18\x70\x7f\xff\xdc\xbc\xf8\x0b\x60\x7e\xd5\x7e\xee\x02\xdc\x1b\x52\xb5\xf3\xbf\xe6\x44\x58\xd9\xb0\x6f\x01\x1d\xc0\x93\xe6\x0a\x58\xf0\x37\x39\xbd\xf9\x2b\xa5\xf1\x82\x22\xfe\x95\x23\xbd\x6f\x8b\x5a\x00\x23\xcb\xff\x9c\x17\xfe\x19\x29\xfc\xca\x61\xff\x40\xf6\x2f\x58\x76\xeb\xee\xe6\xe2\x1f\x84\x44\xf8\xd1\xce\x41\xff\x43\x01\x9d\x0b\x50\x20\xe0\xfe\x4b\x68\xef\xab\x5b\x99\x7b\xb4\xee\xff\x94\x4b\xfc\xb5\xed\xfc\x6f\xbd\x32\xe0\xfa\xe7\x00\xf7\xf7\xf9\xe1\x87\x6f\xa7\x4a\xde\x67\x9c\xf5\x90\xfb\xcd\x8f\x5f\xff\xfc\xb3\x9a\x0b\x0d\x2d\xf2\x7f\xf9\xfa\xdf\xd5\x5c\x92\xa5\x49\x12\xd0\xcf\x80\xbf\xfe\xe5\x97\xbf\x4d\x35\x2a\xfe\xd2\x76\xfe\xfa\xf3\x77\xff\xf1\xed\x5f\xf4\x0c\x20\xf9\x9b\xef\x7f\xf8\x51\x23\x6d\xda\xa2\xc2\x4f\xe3\x1a\xcf\x24\x72\xf1\xbc\xcd\xd6\xe4\xbf\x0e\xf9\xd1\xee\xb4\xe8\xfb\x0c\xcf\xf1\xb2\x43\x94\x1b\x17\x1e\xce\xad\xe0\x01\xc6\x4f\xec\xfb\xd0\x7b\x77\x17\x30\x0a\xda\xad\x37\x6f\xfc\x57\xed\xed\x73\x21\xbf\x3c\x83\xff\x86\xec\x0b\x10\x8e\x9c\xb5\x54\x50\x9a\x21\xf1\xcf\xc1\x90\x68\xed\x26\xe3\xe2\x7f\x42\x3b\x3f\xe7\x20\xdb\x20\xf0\xd3\x6f\x58\x3c\x49\x6f\x1b\x41\xc7\xba\x79\x5a\x50\x15\xbc\x7f\x5e\x41\x9b\x58\x8b\x8a\x06\xaa\x6d\x80\x1f\x30\x6a\xfd\xf6\x2d\x25\x5d\x22\xac\x75\x3b\xbf\xfb\x15\x68\xff\x9c\x93\x78\x74\xfe\xcf\xfc\x35\xa1\x2a\xdc\xee\xf6\x19\x57\x48\xcf\x84\x18\x98\x3b\xb8\xcf\xec\xb6\xd1\xf6\xe7\xaf\x43\xe7\xff\x01\xb8\xf5\x1b\x9f\x7c\x7e\x4e\xa2\x8f\xbf\x1e\xee\x2f\xde\x1c\xde\xa4\xaf\xde\xdc\x6d\xe9\xd1\xe6\xc6\x9b\xc7\xd7\xce\xff\x65\xd8\x3e\x6b\xdd\x11\x0d\x02\x6c\x69\xbd\x79\x84\xbf\x41\x16\x78\x02\xe0\x72\x5c\x77\xfe\xfa\x0e\x9a\xf5\xda\x59\xc0\x17\x8c\xcd\x37\x30\x0b\xf7\x5c\x45\xf2\xe8\x38\x84\x61\xe8\xbb\x9d\xe5\xfd\xa1\xef\x4c\x8e\xb4\x15\xb7\xcf\xac\x89\x30\x26\x69\x0b\x88\x08\xfb\xee\x1c\x75\xb0\xe6\xcd\xde\x07\xb0\xb3\x9d\xc9\x78\x3c\x9c\x08\x77\x87\x38\x6b\xe0\x17\x78\x24\x00\x75\xe3\xdf\x32\xdb\xde\x25\xe7\x8e\xbe\x59\xbb\xc9\x37\x60\x17\x5b\xfe\x05\x2d\xd1\x9e\xa2\x99\x37\x37\xfd\xde\xf3\x78\x3c\xb8\x9e\x38\xfd\xde\x60\x78\xee\x3f\x8f\x27\xc3\x41\x8f\x4e\x5c\x64\x27\x66\x43\xa2\xa7\x59\xf2\x74\xf8\x9e\xbb\x31\xdf\xcd\x7f\x60\x7e\xcb\x43\x97\x4a\x1f\x99\x97\xa5\x6d\x47\xfd\xf5\xdd\x9d\xfc\x5b\x04\x3a\x73\x7b\x7d\x04\xf7\x07\x3c\x94\x25\xd8\xda\xef\xe7\x07\x8a\x77\xfa\x1d\x87\xba\x55\x8d\xd4\xbf\x8b\x59\x8c\xc3\xab\x85\x69\xdf\x11\xf5\xfe\x5d\xc9\x9b\x26\xd7\xc1\x44\x01\xb1\x5f\xdc\x81\x86\x7f\xda\xb3\xdc\x79\xf6\xc0\x80\x1d\x8f\xb9\x87\xb2\x72\x29\xc3\xc1\xdc\x33\x5c\x4b\xb0\xf8\xcc\xde\xc7\xd4\xce\x3f\x3a\x1f\x88\x2b\xdb\x5a\xdc\x2e\xba\xf1\xe3\x36\x48\xbe\xe5\xc6\xfd\xf9\x79\x31\x7d\x68\x93\x50\xc2\xf9\xf9\x06\x28\x03\x7f\x11\x5c\x8e\x2d\x50\xe0\x93\xa9\x88\xf3\x0e\xfc\x22\xd1\xe6\x7c\xbe\x71\x26\x4d\xce\xcf\xe0\xbf\x3e\x94\x7f\x77\x7e\x7e\xcd\xfe\xe9\xd3\x9f\xc2\xe0\xfa\xa4\xde\x33\xf0\x6f\x76\x74\x66\xd8\xe7\xb0\xad\xe5\xfc\xff\x76\x83\x0f\x01\x9d\xfe\x12\x43\xfd\x76\xbe\xbc\xeb\xdf\x53\x98\xeb\x39\x29\x4f\xbe\xd6\x50\xfb\x2a\xc8\xf8\x7c\xfb\x8f\x4f\x3f\xf8\xad\xb7\x6d\xe7\x6c\x0d\xd5\xae\xa5\x49\xb5\x52\xd7\x9a\x2e\x3a\x01\x8a\xb7\x79\x32\xf3\xb4\xd7\x20\xa0\xf9\xac\x51\x63\x03\x10\x44\xea\x52\xd2\xcc\x9a\xdb\xe7\xe7\x19\xcc\x8c\xd6\xf0\x6f\x75\x2d\x84\xfe\xe5\xdd\xe0\x5e\xe4\x0b\xe9\xf3\x1d\xb9\x4d\xe9\x1f\x9f\x7e\x71\x57\x04\x17\x61\x84\x43\x5b\x40\x79\x31\xbc\x87\x5a\x3c\x15\xf2\x1b\xb2\xea\x46\x60\x2b\x71\xe6\x90\x84\x6a\x20\x88\xcc\xcc\xbb\xef\x53\x32\x97\x3c\x7b\x0f\xdc\x7b\xdf\xcd\x82\x94\x4e\x27\x29\x9f\xd3\x79\x32\xdf\x83\x9f\xb7\x00\x3f\x8f\x77\x90\xeb\x10\x07\xf5\x5d\xb1\xc2\x74\x36\xe7\xa2\x60\x06\x0f\xda\x87\x78\xbe\x22\x53\xa6\x56\xc2\x3a\xec\xeb\x0c\x04\x05\x54\x16\x58\x94\xd0\x07\x5f\xe1\x16\x2a\xc8\x8d\xcc\xc2\x75\x40\xa9\x7c\x7e\xde\x6c\x4f\x17\xdd\x54\x07\x76\x60\xec\xa5\xe0\x19\xc1\xd4\xe1\xcb\xe6\x45\x7a\xd1\xfc\xf2\xbe\xd1\x74\xa2\x79\x2c\x9c\x3b\x36\x2e\xa2\x4e\xa7\x1d\xdf\x45\xf7\xf3\xf4\x22\x71\x5b\xe4\xab\x3d\x7b\x9c\xbb\xae\x68\x17\xc8\x9b\x0b\x9d\x2c\xc9\x08\x48\x3a\xb4\x2e\xee\xbe\x8d\xc3\x6d\x0b\x34\x56\x9b\x30\xe5\x43\x9b\x28\x06\x83\x9b\x8f\x5d\xba\xb4\xf2\x33\x5f\x49\xf9\x1a\x06\xed\x07\xca\x47\x36\xea\x9f\xda\x87\xe3\x32\xdc\xc2\x58\x86\xb2\x80\x97\x07\x75\xb4\x56\xc3\xf8\xe4\x88\xc3\x56\x11\xc1\xf9\x9b\xd3\xfc\xbc\x4f\x2c\x12\x1d\xac\xc5\x08\x26\xce\x34\x0b\x6a\x93\x69\x67\x9e\xbc\x80\x39\x7c\x20\x4d\xc4\xa8\x8c\x79\x17\x64\x4e\x73\x43\x66\x5f\xe0\xc0\xfe\x48\xf9\x72\x7e\xee\x03\xb5\x30\x13\x5a\xdc\xb9\xdd\x74\x1d\x2e\xb3\x56\x1b\x66\x7f\x77\x14\xf6\x7e\x1e\x08\x5a\x16\x45\x95\xa1\x2b\xc7\x98\xee\xf6\xf7\xe0\xab\xc3\x9c\x3c\xcf\x7f\xeb\xca\xcb\x35\x5a\xe8\xcb\x0f\x1f\x9a\xed\x59\xc1\xbd\xb3\x33\xe0\x77\x9b\x33\x28\x8f\x2c\x9c\xf5\x73\x46\xc9\x9d\x01\x73\x17\x7b\x4c\x0c\x54\x10\x99\x24\x4b\xda\xed\x9d\xab\x6a\x49\x3e\xaf\x7b\x06\x36\x4a\x31\x07\x26\x18\x01\x08\x86\xdf\x75\xa1\x2b\xbe\x77\xb7\x7e\x14\xdc\x79\x77\xc1\x3d\x28\xd0\x02\x5b\xa4\x60\x5b\x10\x51\xf7\x49\x18\x5c\x9f\x90\xf5\xe7\x73\x49\xf9\xc1\xc8\xf9\x07\x88\x6b\xbc\x4f\xbc\xe0\x07\x12\x20\x7c\x7e\xfe\x06\xdc\x97\x7f\xb8\x7a\x1a\x19\xc1\xbe\xa2\x91\xbc\x36\x23\xcd\x9b\x7b\xf4\xa0\xfe\xcf\xe1\x82\x5c\xab\x4d\xb4\x9e\x27\xcd\x4d\x3a\xfd\x3c\x44\x72\xdb\x9f\x82\x7e\xcf\x29\xde\xc8\x1d\x55\x2c\x45\xe5\x4d\xb0\x0c\x4b\x31\x13\xa5\x1e\x05\x9d\x53\x12\xbe\xd3\xb5\x43\x68\xa9\xc4\xdf\xed\x47\xe1\x6f\x49\x15\xc0\x6c\x95\x79\x2a\xf4\x57\xdb\x52\x5f\x2c\xd7\x07\x52\x28\x57\x29\xc4\x74\x7e\xb1\x70\xe4\x2c\x98\xcb\x32\x7a\x02\x12\x78\x24\x41\x12\x4f\x58\x4b\x10\x99\xd5\x7c\xa9\x8a\xc1\x0a\xc4\x00\x7a\x1e\x14\xe9\xea\xfe\x9e\x44\x43\x40\x0a\xe6\x67\x2d\x9f\xfc\x43\xbe\xc1\x04\x93\x3f\x39\x49\x3b\x65\x2c\x80\xd6\x43\xd6\xaa\x5d\x54\x6f\x83\xfc\x1c\xbd\xf9\x0a\xe4\x80\x05\x30\xc8\xba\xf2\x92\xfc\x0e\xd3\xbf\xff\xf4\xa3\x39\x2b\xa7\x01\x3d\x57\xb7\xc2\x6e\x3b\x9f\x6f\xf3\x1a\xf2\x35\xd0\xdb\xe6\xf7\xbf\xfc\xf4\xa3\xaa\x7f\xa7\x30\xb0\x9c\x0d\xad\x35\xc8\x04\x16\x24\x02\x10\x90\xb8\xd6\xad\x59\xdb\xf4\x21\x5f\xb1\x61\xb6\x9f\xd8\xdc\x95\x24\xec\x2b\x9d\x9c\xdb\xd6\x76\xbe\x72\x40\xcf\xeb\x19\x30\x04\x21\x8d\xbd\x29\xf5\x9f\x61\xf0\xe8\x40\xe9\x00\x90\x12\x61\xd9\x41\x53\x83\xae\xeb\xfb\xdf\x81\xd3\x9c\xfd\x18\xa6\x59\x00\x74\xdc\x9a\x49\x64\x6f\x40\x14\xbb\xa0\xfe\x03\xd7\x39\xeb\xb7\xa7\x01\x19\xc2\xa0\xdd\x28\x14\x09\xe9\x49\x3f\x5b\xcd\x78\x5b\x80\x83\x5e\xde\xcd\xcf\x48\x1c\x18\x24\xc2\x15\x2a\x38\x9d\xbf\x95\x84\x47\x0e\xa5\x7b\xc2\x34\xce\xc1\xed\x76\xce\x5c\xcd\x5e\xe5\xd9\xa0\xc0\x09\x46\xac\xcb\xad\xb8\xe5\xb0\xff\x8a\x6b\xcc\x6f\xe2\x0d\xd3\x98\x60\x07\x79\x75\xa6\xed\x27\x73\x46\x2e\xc0\x66\xad\xb9\x31\x9f\x7f\xce\xcc\xdb\xca\xe6\x16\xb0\x92\xc4\x5b\xb1\x90\x18\x2b\x24\x82\xd0\x51\xb4\x7b\xe7\x4c\x43\x49\x92\xc1\x4d\x40\x52\x5b\x7b\x9d\x50\x52\xdd\x6d\xcb\xef\xc2\x68\xf1\x19\x3e\xd5\xb7\x0d\x97\xe8\xce\x0f\xdd\xb3\xa3\x1e\xa2\x50\x38\x9a\xeb\x55\xec\x08\xf0\x88\x53\x54\x98\x8e\xdb\x3b\x8f\x2c\x49\x1f\x8f\x0e\xa9\x9f\x1c\xa9\xd7\x29\xc8\x47\x5d\x6e\x81\x3d\xd0\xf7\x05\x42\xb4\x1f\x4d\x17\x86\xe8\xe9\xe3\xb1\x3d\x6d\x71\x2b\x2b\x35\xf7\x93\x54\xcd\x1a\x6e\xd5\x3a\x39\x35\xcc\x7a\x9a\x69\x8c\x4a\x85\x4b\x0f\x6e\xb4\x0f\x38\xdd\x0e\xa7\x17\xa6\xff\x73\x5c\xa6\x6f\xb1\x30\x5e\x55\xbf\x49\xc5\xad\x4e\xed\x94\x3a\x9e\x90\x6f\xb8\x54\x6e\x1e\x09\x46\xe3\xdb\x3e\x89\x0a\xb2\x85\x26\x2b\x72\x62\x5e\x61\xec\x10\xfb\xd2\x3e\x08\x2b\xbb\xa4\x8b\x0e\x6d\x62\xbf\x3d\x49\xa5\x71\x07\xdd\xcb\xb9\xe4\x0b\x9f\x68\x79\x14\xfc\xa1\xe1\x13\x9d\x43\xf9\xf8\x3a\x3f\x47\x63\x9d\x3b\xbd\xf1\x85\xf7\x5d\x34\xd1\x49\x48\x73\xde\x93\xbf\x98\x2b\x5e\x0c\x66\x9d\x31\x64\x9e\xd1\xd2\xc6\xaf\x31\x70\xe9\x95\x3c\xc4\x30\xcc\x9b\x5f\xb9\x0d\xe6\x2d\xef\xc1\x5b\xbe\xf9\xea\xb5\x7b\xf3\x15\x0b\x1f\x14\xc9\x9d\x37\xcb\xfb\x2f\x1b\x9b\x14\x3c\xb1\xf8\x91\x1c\xcc\xdd\x27\xc1\xfc\x4b\x00\x8e\xd9\x49\x6b\x11\xff\xa4\x69\xaf\x59\x22\x7c\xb0\xe4\x9b\xa6\xe3\x9a\xbd\xd7\xbc\x53\xd1\xfd\x0a\x65\xef\x73\x2d\x76\x7e\xfe\x9e\xb1\xbb\x49\xc2\x8e\xf7\xf3\x22\xe2\x48\x22\x80\x6f\x68\x78\x09\x45\x2a\x28\x29\x50\x3d\x3f\x0b\x54\x45\x6c\xf3\x76\x4a\xa5\xfb\x99\x85\x70\x6c\xb8\x42\xff\x1f\x73\xd6\x7c\x0c\x1b\xe4\xe1\xe5\xa6\x3c\x2a\x8c\x94\x29\xb2\xd0\x92\xee\x67\xb4\xba\x8b\x57\x48\xd1\xee\x67\xdd\x0b\x12\x6b\xa1\x76\x45\xeb\x5d\xa6\x27\x56\xba\x8f\xcd\xfc\xaa\xf6\x4c\x9f\x26\x91\x91\x08\x33\x18\x16\x7a\xa6\xa4\x68\xeb\xcd\x2a\xf8\x96\x58\x33\xa7\xf9\xad\x8d\x4d\x24\x7f\xee\x63\x7d\x47\x4b\xb2\xe8\x57\x1e\x3c\xb6\x31\x2d\xd8\xd2\x80\x38\xc6\x34\x91\xe5\x34\xa7\x22\x6e\x6e\xc1\xf2\xca\x99\x7e\x80\x2c\x51\xd2\xe9\xbe\x9a\x12\x7e\xb5\xc9\x98\xd9\x90\xa9\x45\x90\x0a\x78\x31\x7e\x52\x98\xd3\xf1\xac\xe7\xe7\xb8\xcb\xae\xb8\xf9\x49\x85\x25\x19\x9b\xf8\x37\x24\x35\xc6\x20\x53\x2d\x91\x0c\x48\xad\xc7\xbc\x2e\xb4\xc4\x8b\x61\x10\x12\x61\xa5\xf0\xf3\x94\xaf\x86\x39\x6c\x72\xe4\x14\xbf\xef\xd2\x33\x32\x3a\x68\xdb\x12\xde\xb6\xb3\x79\xd3\xf9\x2b\x91\x85\xf7\xf3\xf7\x39\xe3\xa5\xc0\xdb\x7b\x3e\x53\x7d\x26\x7e\x43\x32\x4f\x30\x98\x44\x86\x59\x08\x8e\xc4\x5d\x2f\xde\x10\x1b\x29\x1c\xbe\xbf\xf2\xc3\xa1\x6d\x27\x23\xd1\x1d\x09\x8c\x6e\xd1\x4e\xdb\xb7\x58\x34\xea\x5a\x99\x0f\xdd\xba\xba\xe3\x37\x25\xf3\xa6\x85\x3a\x95\x9b\x49\xcb\x3f\x3e\x38\x10\xad\x33\x9f\x85\x87\x7c\x69\x7b\xca\x59\xcb\xcb\xab\xbe\x2d\x3e\x61\xd6\x44\x37\xaa\xa0\xa4\xc3\x74\x6c\x72\x6e\xcd\xa5\xbb\x9d\x74\x2b\x42\xa2\x3c\x7c\xe6\xb5\x98\x2b\xa1\x00\x92\x43\x4d\x86\xd8\x9c\x32\xcb\x67\xab\xce\x1f\xe7\x8b\x5b\x03\x8f\x2b\x2f\x21\x91\x25\x2d\xa7\x37\x63\x91\xcd\x33\x2b\x4d\x9d\xb3\x85\x2d\x2b\x37\x40\xb7\x3e\x38\x14\x73\x6c\x36\x00\x15\xea\x31\xaa\xe7\xe7\x45\xfb\xd6\xce\x82\x45\x7b\xda\x77\xfa\xe7\x84\xeb\x6c\x4f\xdd\xb7\x01\xf1\x98\x03\x9f\xf4\x90\xad\x10\xad\xc8\xbf\x25\xed\x5b\x91\x3d\x44\x4a\x85\x90\xf8\x40\x22\x5e\x0f\x8e\xdb\x26\x5b\x03\x16\x0c\x6a\x61\x83\x02\xf2\xfa\xd3\x77\xb7\xff\xa3\xf5\x0e\x0a\x74\xc8\x3f\x40\x53\x6f\x3a\x3a\xf7\x49\xe9\x3e\xd6\x41\x36\xc6\x7a\xf9\x86\x82\xa2\xdb\xa8\x1f\x20\xfd\x5c\xcf\xef\xdc\x7b\xb2\x4a\xbf\xb8\x67\x31\x46\x68\xf9\xb2\x2d\x09\xe0\x2a\x27\x1a\xe8\x0a\xc8\x8f\x25\x46\x20\x29\x4c\xfc\xa4\xbc\x2c\x0f\x10\xcc\xbc\xb9\x3b\x2b\x66\xee\x92\xfc\xac\xbb\xfb\x2d\x0b\xb1\x78\x04\x6a\x81\x43\x85\x32\x14\x83\x58\xdf\xf9\x64\x35\x32\x84\x7f\xda\xfe\xc5\x45\x21\x07\x50\x25\xc9\x73\x68\xce\x94\x83\x3d\x10\x92\x43\xf1\xdd\x9f\x82\x13\xb1\x6a\x4f\xb7\xf0\xb7\x2b\x34\x1e\xbe\xf8\x4a\xa3\xc1\x24\x86\xc2\xfe\x22\x3b\x5e\x8b\x22\xb9\xfe\x34\x3a\x03\x93\x43\x11\x19\x76\x69\x64\x38\x77\x64\xff\xc3\x69\xce\xbf\xfc\xbc\x4f\x0c\xbe\x03\x83\xdc\x50\xce\xd0\x15\xbb\xe7\xe7\xe4\xfc\x3c\x61\xba\x66\xd1\x06\x73\x40\xec\x0a\xff\xd5\xa6\x71\x37\x36\x84\x72\x35\xb9\x60\xb1\x93\xe7\x67\x44\xb9\x12\xe1\xf4\xf3\x60\x2d\x8d\x22\x17\x09\xb9\x6e\xc9\xc3\x2e\x3c\x0e\x15\xb4\x0f\xc7\x82\x27\x0b\x67\xcb\x18\x02\x72\x23\xac\xd4\x4d\x8f\xf2\x46\xe8\x20\x94\x9f\x15\x7c\x11\x5b\xc1\x01\x0d\x99\x7e\x6a\x28\xca\x0b\x53\x61\x27\x1b\x31\xa4\x80\x95\xb6\x11\x81\xec\x7f\x01\xcf\xf3\x5b\xc6\x25\x19\xd2\xd1\x20\xdb\xb7\x01\x5d\x05\x38\xdb\x09\xaf\x53\x08\x58\xbe\x67\x73\x79\xbb\x9c\xca\xb3\x64\xd2\x4f\xb7\xda\x7c\x07\xc6\x44\x8b\xec\xed\x32\xa6\x18\x0b\x62\x07\x97\x5d\x72\xa1\x6a\xb8\x0c\x03\xff\x76\xc9\xe6\x18\x53\x1a\xae\x23\xed\xa7\x3b\x36\xe7\x65\x3b\x36\x9b\x3f\x3f\x01\xa7\x3f\x34\x28\xa4\xd3\xd8\x6f\x93\xc0\x8b\x57\xdb\xf0\xb7\xc0\x6f\x04\x1f\x76\x49\x90\xa6\x64\xdf\x66\xa3\x79\xe1\x32\x96\xee\xb7\x21\xb8\x09\xe4\x44\x0a\x12\xde\x90\xa6\x08\x74\x18\x83\x06\x01\xd9\x81\xf9\x99\x97\x7d\xbb\x27\x1b\x89\xc1\x9b\x4a\x9d\x77\x73\xae\x11\x7f\xa6\x47\x39\xc8\xf4\x89\x6e\x27\x68\xf5\x88\x13\x42\x32\x5a\x7f\x6c\x3b\x91\x98\x40\xc0\x84\xed\x6e\x49\x26\x10\xd4\x46\xdc\x2d\x49\xf8\x88\x74\x11\x35\xdb\xcb\x76\x5b\x0a\x34\xba\x7c\xbb\x32\x8d\x2b\x39\xa0\xe1\x38\xbf\xdf\xd1\x08\x26\xd9\xdf\x14\x90\x18\x0d\x70\xf2\x17\xb2\x3d\x10\xdb\x87\xd8\x6c\x52\x55\xb7\x94\x4c\x2d\x69\xc9\x92\xad\x96\x10\xb5\xf4\xfc\x7c\xcd\xfe\xe9\xd3\x9f\x6c\x42\x6d\xec\xfc\xa2\x1b\x10\xbf\x61\x17\x95\xe4\x4a\x50\x4e\xa4\xbb\x33\x5d\xa8\x86\x2e\x55\x52\x57\x71\xe6\xce\x48\x82\x1c\x93\xf4\x2e\xe6\x74\x3f\xac\x58\x27\x19\xb2\xaa\x47\xb2\x7e\x64\x94\xfe\x27\xe9\x7a\x06\x57\xf0\x8d\xae\x52\x51\x1c\x8b\x62\x32\x0a\xb3\x2b\x16\xa9\x62\xba\x21\x9d\x1f\xa4\xb8\xf5\x74\xdc\x73\x98\xdb\xfb\xd7\x34\xd8\xfb\xf1\x34\x74\x1d\xaa\x4c\xa6\x7f\x77\x0a\x51\x27\xdb\x91\xc9\x04\x8d\xfc\x2b\x6e\x70\x9e\x1e\x9a\x37\xcd\xe9\xc1\x0f\x93\x69\xb3\x50\xbb\x4d\xbe\x87\x9e\xec\x38\x6d\x36\x90\x7c\x48\xbe\xc8\x93\x93\xe0\x21\x8c\xf7\x29\x6f\xbd\x52\xf6\x1f\x36\xa0\xe3\xd1\x81\xa4\x3f\xb1\x0b\xfc\x0e\x74\x8d\x1c\x0b\x22\xdc\xf5\xef\xe7\xe4\x2f\x6d\xf2\xef\xb8\x77\xc3\x7b\x30\xf9\xf0\x37\xa8\x82\xbb\x11\xfd\x7b\x4c\xb6\xb0\x4a\x7b\x05\x39\x28\x99\xa2\x50\x19\x1c\x10\x19\xa4\x05\x9b\x64\x64\xc0\x07\x5d\x01\x70\x72\x41\x76\x46\x30\x5a\xd8\xf2\x7b\x29\x2d\x8a\xbe\x70\x9a\xdb\x6c\xcd\x2a\x80\x2c\x81\x69\xd8\xbe\xe5\xd4\x89\x01\x0d\x3f\x7b\xf7\x84\xf0\xd1\xfd\xfc\xa2\x45\xfe\xb9\x25\x24\x93\xcf\x09\x80\xf5\xdb\xd3\xc1\xab\x56\x93\xac\x8b\x33\x64\x43\xba\x21\xd7\xf7\xc5\xaf\x36\x29\x3b\x66\x65\x2f\xef\x81\xfc\x2b\x03\x60\x4a\xfe\x39\x3f\xd7\x6b\x3c\x8a\xbd\x06\xd8\xc8\x39\x23\xd5\xc3\x60\x06\xee\x08\x51\xfb\x7b\x97\xf2\x80\x2f\x02\x11\x1c\xb7\x64\x20\x4e\x69\x83\x6e\x09\xe4\x5c\x65\xf9\xd4\x3b\x3f\xff\x4f\x06\x4e\xa2\xd5\x20\xc3\xab\x96\x47\x8e\x45\xb1\x1f\x5e\xb1\x17\xb8\xdd\xcc\x03\xce\x9d\x45\xbb\x23\xbe\xdb\xb4\x63\x7a\x04\x6f\xaf\xe0\xe1\x82\xb4\x18\x2a\xf3\xa4\x14\xb9\xb7\x86\xe0\xad\x12\x81\x66\x22\x44\xf6\x64\x54\x47\x8d\xf0\xd8\x3e\x8b\x7d\xdc\x1a\x7b\xf6\xce\x94\xa0\xca\xc9\x5b\x81\x81\x3a\xb6\x93\xc4\xa4\xeb\xe9\xce\xa5\x4b\x4a\x79\x7c\xfa\xf9\x19\x38\x25\xef\x18\x68\xfd\x9a\xef\x86\x01\x50\xb6\x4d\x80\xec\x73\x20\x4c\x25\xcb\xe0\x08\x5d\x0b\xd6\x07\x88\x5a\xf3\x8a\xe0\x8b\xf4\x03\xfa\xae\x32\x54\xa6\x87\xc9\x78\x6c\xb7\xd9\xa6\x63\xed\x08\x03\x46\x1b\xbb\xca\x96\xd8\x3c\x59\x2c\x3b\xcc\xb9\x7d\x6f\xf9\xd2\x01\x25\xb6\x71\x36\xb8\x25\xb3\x39\xc2\xb7\xe9\xe2\xb6\x15\x5c\x10\xa5\xde\x64\x09\xb7\xc4\xb3\xf4\xa6\x22\xff\x96\x44\xc6\xe1\xe7\xaf\xfc\x27\x88\x1f\xd9\xe5\x17\xe4\x72\xe6\xb5\xa7\xcd\x57\x45\xa6\x9c\x71\x03\xde\x60\xf3\x73\x39\x8f\x89\x53\x21\x8b\xac\xaa\x7f\x70\x10\xb2\xf1\xf1\x22\xc8\xa5\xe8\x7f\x11\x75\xd8\xa6\x7a\x43\x47\xfa\x2c\xd3\xfa\xfc\x1c\xe4\x72\x2a\x30\x5f\xf4\x29\xee\x8b\x66\xa7\x39\x25\xd1\x79\x90\x2e\x53\xdd\x88\xc3\x38\x7c\x07\xc2\x9c\x6a\x17\xea\xa7\x15\x62\xef\xac\xe6\x4d\xb2\x49\x46\x4e\xef\x8c\xc8\x61\x99\x26\xdf\x02\x44\x29\x11\xec\x25\x06\xcf\xe7\x2c\xba\x45\x8e\x53\x9c\xc9\xf3\x03\x49\xe0\x09\x25\x21\xa3\x43\xd9\xf5\x38\x5f\x9e\x91\xd9\x40\x53\xb2\x78\x4d\xc4\x0a\xbc\x57\x27\x1a\x09\xd9\x54\x6c\x5b\x04\x73\xd2\xf9\x59\x78\x7e\x7e\xb6\x26\x56\xfb\x3d\x35\xce\x4b\xe1\x49\xec\xda\x87\x28\x9f\x1d\x44\xf3\xe8\x6e\x77\x4f\xe6\x9e\xeb\xdb\xc8\x3e\xf4\x12\xba\x31\x34\xd2\x5d\xda\xb3\xfe\x2c\x9e\xef\x80\x4b\xdb\x88\x6e\x0f\x75\xa1\xca\xf8\xfc\x5c\x69\xc9\x31\x1f\xfa\x50\x49\x3c\xbf\x5b\xdd\xbe\x97\x8c\xfd\xf4\x7d\x97\x70\x9e\x7e\xdf\x3b\xab\xf3\xf3\xb4\x7d\x78\x37\x7f\x7f\xb7\x07\x45\xd8\x22\xff\xd0\x53\x4b\x6f\xe7\xef\xc0\x3b\xa6\x5b\x3f\xb6\xf3\xb7\x44\xb1\xcd\xe7\x8f\xe7\xe7\x6f\xc1\x42\x38\x1b\x25\x61\x70\xef\x44\xc4\x8d\x7d\x2f\x6d\x93\xb9\xdb\xde\xe7\xad\xbd\xb8\x80\xcc\x08\xfe\x0f\xad\x86\x1a\x36\xf3\xed\xbc\xd7\x26\xe1\x95\x5d\xbc\x6b\xd1\x2d\x1f\x6a\x43\xcf\xcf\x2f\x2e\x36\x00\x4e\x67\x84\x07\x42\xc5\xfc\xee\x11\xba\x6d\x73\x3f\x63\x5b\xf6\x73\x9f\x24\xa5\xa7\xb4\x5a\x0b\x46\xfa\x82\x93\xde\x26\x5e\x3d\x21\x8c\x91\xd8\x26\xd4\xf6\xef\x67\x92\x83\x52\x87\xa6\x13\x3b\x87\x13\x4d\x49\x6a\x45\x8c\xa0\x48\x22\x88\x34\x61\x03\x96\x8c\xb5\x4a\x3d\x45\xb0\xe9\xcc\x03\xe0\x29\x0d\x94\x6c\xbe\x20\xe7\x0c\x7a\x30\x29\x78\xed\x93\x43\x40\x47\xc4\xf2\x49\x3b\xbf\x89\x37\x4a\xbd\xa5\x94\x76\x96\x4f\x02\x7e\xcc\x21\x81\x04\x6d\xfa\x20\xd9\x71\xd0\x99\x7c\x91\x12\xbc\x6d\x86\x80\x79\xda\xf9\x16\x74\x20\xfd\x96\xce\x00\x02\x31\x3f\xea\xdf\xc2\xbc\xf6\xce\x75\x5c\x07\x94\x1a\x39\x8e\x26\xd5\xa5\xed\xe3\x6d\xb9\xfa\x7c\x44\x5e\xc0\x75\xe5\xfd\xf6\x74\xa2\x62\x59\xb6\xf5\xe7\xff\x83\x18\x89\xbb\x15\xf5\x39\x7c\xb2\x6c\xeb\x91\x7f\x68\xca\xb1\x8d\x99\x35\x82\xae\x47\xce\x2b\x00\xe1\xc4\x3d\x63\xbc\x99\x1e\xb6\x71\x36\x0d\xff\x5f\xe6\xfe\xbd\xbb\x6d\xeb\x5a\x17\x87\xff\xef\xa7\x90\x50\x6f\x85\x30\x97\x28\xc9\x49\xcf\xde\x05\x0d\xf3\x4d\x9c\xa4\x49\x6b\x37\x69\xec\xb4\x49\x69\x26\x03\x37\x5e\x24\x8a\xa4\x48\xca\xb2\x23\xf2\x7c\xf6\x77\x3e\x73\xae\x2b\x00\xca\x4e\x7f\x63\x8f\x71\xda\x11\x8b\x00\x16\x16\xd6\x75\xae\x79\x7d\x66\x9b\xaa\x15\xe6\x63\x09\x2a\x9e\x36\x7d\x33\x9c\x81\x00\xc3\x11\xf6\x01\x94\xc5\xfa\x58\x4d\xd2\xd2\x08\xda\x95\x1a\x8e\x40\xc6\x6a\xde\x08\x88\xfa\x23\x61\x6a\x82\xd8\x3e\xe6\x14\xa6\xe8\x4e\x8e\x3f\xe3\x38\xec\x0c\x3c\xb5\xdd\x79\xc8\x2c\x85\x2a\x21\xb3\xa2\x7a\x0e\x1d\xe0\x9b\x7c\x49\xf2\x0c\xaf\x58\x58\x76\x68\x0e\xea\x7d\x6c\xb1\xe4\xfb\x9a\x81\xdc\x13\x7e\x61\xc4\xd3\xb2\xef\x81\x5a\xb2\x06\x27\xa2\x9a\x15\x77\x72\x5f\xd4\x80\x8e\x88\xed\x13\x90\x7a\xe8\x3c\x81\xe4\x68\xcf\x9c\x0c\x67\x0e\xbe\x3b\xcf\x16\x93\x03\xdf\xfc\x97\xe6\xe0\xf8\xa4\x3e\xb4\x80\xf9\x7d\x5e\xbe\xaa\xd9\xc6\x1a\x91\x6e\x38\x35\xf4\xcb\xe5\x11\xfb\x5f\xc0\x78\xc3\x35\xd5\x1d\x97\xde\x5d\xcf\x13\x3c\x40\x03\xea\xcf\xe4\xbe\xf5\x29\x27\x3e\x2f\xfc\x1c\xdc\x3a\x32\x71\xe0\x77\x2c\x64\x86\xe3\xd3\x48\x8f\x75\x95\x64\xdd\xdd\x24\x76\x2a\x49\x1a\xaa\x6d\xb6\x0e\x02\xb3\x7d\x8f\xc1\x65\x91\x89\x82\xd4\xfd\xc6\xbe\x9c\x06\xb6\x40\x39\x69\x2f\x24\xcc\x8b\x41\x19\xd4\x7a\xb9\x6c\x0d\xf5\x86\xe6\x6c\x49\xcc\x29\xdc\xdf\x0f\x3d\x5f\x68\x78\x62\xad\x09\x86\x57\x19\x7f\xf4\x6b\xf6\x99\xdf\xb9\xdf\x1d\xf0\x7c\xc7\xc7\xa0\x0c\xac\xfa\xcd\x7a\xd3\x75\x45\xf2\xe4\xff\xa5\x1b\x59\xce\x3e\x33\x1c\x4e\xcc\x36\x81\x76\x86\xd5\x58\x0c\x38\x0e\x8b\x44\x49\x7d\xf9\xe1\xc2\x24\xc4\x69\x6b\x4d\x2b\x77\xfd\x91\x3e\x33\x39\xda\x4f\x9c\xa7\x0e\x14\x20\xb9\x65\x65\xa2\x3a\xf4\x23\x63\xb1\xda\x2b\xf3\xab\xbd\x6d\xbe\xfb\x93\x7f\x65\x2b\xe0\xe1\x50\xae\x42\xdd\x89\x0a\x31\x97\x41\x95\x1f\x25\xc9\x43\xbb\x6a\x97\xd3\xd3\xff\xd3\x16\x91\x29\x6d\x68\x8b\x53\xb5\xe7\x4b\x8f\xbf\xce\x11\xb2\x1a\x10\xb4\xa5\x6f\xff\xd6\xdb\xd5\x8e\x29\xe2\x69\x31\x80\x6d\x85\x7f\x6e\x29\x2c\x3e\x43\xff\x1f\xa7\xc9\xf3\x3c\x32\xcb\xcd\xbb\x95\xef\x15\x7b\x76\x37\xa3\x56\xeb\x55\x1d\xfa\x26\x7d\x01\x35\xb8\xfa\x11\x86\xcd\xfc\x3f\x54\x1f\x35\x0a\xc1\xac\x6c\x0c\x51\xc3\xbc\x53\x57\xd6\x99\x60\xff\xa5\x47\x01\xcd\x20\x11\xa1\x67\x02\x59\x7b\xec\xe9\x24\x87\xf9\xe9\x05\xca\x54\x37\xf5\x12\x4e\x86\x19\x9e\x3f\x2b\x06\x45\x37\x4f\x0a\x2e\x49\xf2\x79\xb3\x36\x2f\x82\xa6\x9f\x73\xd8\x4c\xfa\x24\xce\xea\x96\xf2\x8c\xde\x27\x79\xfd\xa1\xd7\x2f\x3e\xf0\xfa\xbc\xd1\x95\x20\xd2\x2f\xb5\x6d\xed\x9f\x9e\x82\x05\xea\x9b\x6a\xca\xa0\x9a\xc9\x47\x57\xd3\xed\x96\x4f\xf3\xf6\x5a\xd8\x5d\xc4\x2c\x70\x92\x52\x52\x6f\xb9\xdf\xd8\x28\xe6\x7b\x80\xb4\x2f\x11\x88\xce\x9b\x3f\x5f\xbe\xc3\x6f\x12\xda\x2b\xfc\x5d\x91\x28\x89\x14\x9e\xf8\x2d\x59\x2f\x68\x47\xc5\x8e\x2f\xcb\x47\xe9\x35\x3c\x22\x5d\x75\x9b\xdb\xfc\x7a\x06\xe5\x92\x5a\x57\xc4\x43\x35\xcb\x2f\xa4\xbc\x71\x49\xbb\x81\x47\xe8\xfe\x26\xf3\x20\x3f\x8c\xa7\xc9\xc6\xb5\x38\x60\xc8\x58\x0c\xbf\xc9\x88\x31\x99\x80\x17\xbb\xaa\xa0\x58\x4d\x0f\x04\x0f\xba\xb0\xb0\xf4\x37\x23\xd3\x13\xd1\xb0\x9e\xdb\xf9\xe0\x3c\xb9\xb2\x9a\xd2\x3e\xf1\x36\x1c\x12\x49\x22\x42\xd9\xb3\x0a\x30\xc3\xe7\xc4\xf7\x9d\xe3\x82\x21\x08\x5e\x89\x5b\xf7\x34\x66\x1d\x4a\xc5\x9e\xd5\x53\x5d\x4d\x05\x25\x89\x16\x56\x77\xbb\x69\xac\x74\x10\xe4\x98\xea\x45\xa0\x2a\xa0\x0a\xa8\x8a\xd7\xb6\x0a\x8e\x63\xac\x8c\x3f\xab\x1a\x4b\xf1\x7b\x51\x3b\x17\x12\x52\xce\x95\x7a\x2c\xdc\x11\x5b\xd8\xdd\x47\xad\x78\x2c\x73\x31\x41\xcc\x9c\x19\xc8\xf8\x98\x3e\xf7\x13\x31\x96\xf6\x8b\xbb\xdd\x25\x5d\x12\x65\xa7\x07\xf8\xd5\xa9\x70\xef\xc3\xad\x98\x28\x6d\x02\x21\x0e\xf4\xc0\xd7\x61\xa4\x2a\x74\xfc\xb1\x1d\xe3\xa9\x7e\x9e\x4c\x07\x4e\xfb\x15\x27\xbf\xd1\x64\xcd\x62\x3b\xfa\x7b\xb7\x2c\xd6\x99\x39\x02\x84\x44\xd2\xf2\xf4\x03\x07\xa2\xa8\x5f\x3c\xcb\xfb\x39\x22\x55\xbb\x1c\x02\x2a\x4a\x7a\xe7\xf4\xe2\xc2\x1a\xb3\x30\x4a\x23\xa7\xe3\x73\x0d\x74\x1d\xa2\x74\x9e\xc2\x14\x12\x0a\xb1\xec\xef\x9c\xbd\x2a\x97\x93\x67\x10\xc8\xdb\x63\xa7\x3f\x47\xb8\xaf\x11\xf0\x72\xcf\xf0\x6b\xed\x33\x99\x7e\xa3\x26\xb2\x4f\xa4\x25\xbc\x2a\x21\x39\x8d\x79\x41\x4e\x9a\x15\xb7\xd4\x4c\x67\xaa\xae\xc3\x5a\x75\x43\xe5\xf4\xe1\x46\x41\x66\x9f\xa5\x35\x71\x52\xd1\xb2\x65\x6b\xdc\xc9\xc9\xd4\x4a\xbd\x53\x28\x52\x3d\x4d\x38\xa4\xe0\x74\x0a\x05\x24\xaa\x80\x90\x72\xa9\xf8\x5e\xb3\x2d\x9e\xfb\xeb\x36\xf0\x35\x75\x82\x56\x30\x16\x56\xed\xd4\xe2\xdf\xcc\x30\x4d\xc3\x6a\xa4\x0b\xb6\x1c\xed\x09\xd4\x91\xee\x8b\xb7\x59\x0b\xa5\xa4\x99\x36\xe1\xdb\xfd\x4a\xc7\x6b\x8b\x7c\x00\x4b\x64\xe1\xe9\xef\x6d\x3d\x6f\x33\x5f\xcd\x63\xea\x82\x20\x44\x74\x61\x4a\x55\xce\xdc\x52\xbc\x4c\x25\xd4\x39\xb7\xa8\x27\xb0\x2a\x69\x41\x08\xb4\xa2\xe8\x8c\xb9\x1e\x5c\x4f\x8c\x75\x45\x5d\xb2\x43\x81\x44\x52\x78\xb0\x22\xb6\x09\x77\x5e\x13\x3c\x81\xa9\xa4\x1d\x0b\x71\x8d\xea\x2a\x53\x2a\x43\xa3\x02\x47\xd4\xe3\x4a\xee\x55\xb8\x87\xf2\x71\xe0\x54\xac\x69\x60\xa0\x29\x4a\x59\xf5\x41\xff\xc0\xd7\x55\xf7\x65\x05\x1b\x08\x0d\x22\xa2\x71\x1f\x47\x6a\xea\xbc\x22\xa8\x3f\xc9\x94\x65\xbf\x9b\x14\xa1\x30\xc7\x63\x44\xf2\xae\x12\x1a\xa9\x95\xba\x26\xa9\x19\xd5\xab\x75\x5a\x0c\x68\xa9\x75\xc6\x83\x2c\x59\x92\xbc\x1e\x0f\x86\xa3\x64\x92\xdc\xb0\x77\x38\xf1\xe7\x80\x71\x90\x92\x34\xed\x97\x29\xbd\xbc\x56\x0b\xba\xe8\x5c\x2a\x0c\x2c\x1e\x5c\xa5\x97\xe1\x42\xb8\x82\x68\x39\x27\x1a\x75\xc5\x23\xba\x1e\x2e\xe8\x17\xa4\xcb\x1b\xfd\x6b\x1e\x73\x88\x83\x18\x8c\xc0\x7b\xcb\x0f\x7c\x80\x03\x7b\xd6\xad\xf5\xad\xa5\xbe\x4b\x99\x83\x1b\xba\xa2\x8a\xfa\x15\x73\x3a\xe2\xc3\x76\x89\xf0\xf4\x0f\xbc\xde\xb9\x4c\xab\xc1\x5f\x69\x7c\xe7\x71\x72\x8d\x5b\x24\xf3\x21\xe8\x67\x78\x89\x16\x4e\xf0\x07\xcd\x93\x1d\xba\xe6\x0e\xb3\x9d\x7e\x6d\x0c\x6a\x4b\x65\xea\x8f\x93\x35\x4d\xe5\x40\xb7\x60\x42\x03\x35\x8b\x13\x13\xaa\x31\x01\xfc\x85\xe7\xc6\xfd\x2e\x24\x8e\x8a\x0f\x3a\x1f\xa7\xa2\xec\x19\xf3\xd1\x90\x35\xf6\xa0\xdd\x58\xba\x13\x68\x51\xec\x23\x9c\x85\xb4\x96\xe1\x37\x70\x4e\x23\xb5\x39\x20\x18\x33\x57\x39\x85\xb9\x40\xcd\x0f\x14\xfa\x2b\x90\x14\x58\xe2\xd5\x05\x69\x7d\xf9\x2a\x11\xb7\xcf\x8f\x01\x3e\x04\xe3\xf7\x31\x82\x8a\x68\xb1\xc0\xfe\x10\xbb\x95\x76\xa5\x8b\x27\x73\xfd\xc3\xa1\x64\x89\x52\xa0\xda\x8f\xfa\xe3\x67\xb3\xfe\x4c\x22\x9f\x8b\xb0\xaf\x33\xdd\xd7\x98\x1a\x40\x4d\x25\x1a\x74\x4d\x07\x6e\x2c\x0a\xb2\x7b\x5d\x5e\x0e\x45\xaf\xb4\x1e\x66\xb1\x66\xe2\xae\x3e\xe4\xe8\x55\xda\x58\x32\xd2\x55\xda\xed\xce\x02\xf8\x0d\xff\xbb\x95\xf9\x6e\xa0\xfb\xa2\xdd\x38\x7b\x46\x2b\x42\x9a\xc1\x3f\x71\xae\x59\x4d\xf1\xec\xf4\x22\x36\x20\x03\xfa\x9c\xa5\x39\x61\x73\xd1\xec\xf4\x89\x54\x39\xa0\xad\x98\x44\xd1\xde\x83\x11\x32\xc1\x35\x34\xed\xcf\x66\x27\x27\xef\x5c\x95\x33\x10\x1a\x45\x8d\x94\xbb\x56\xf9\x6c\xef\xf2\xb1\x1a\xef\xaf\x0d\xef\x6a\x4e\x68\x6e\xa1\x5b\x60\xef\xc3\xe0\x11\xab\x48\xf1\x02\x51\x9e\x9d\xfb\x20\x0a\x86\xcd\xba\x92\x77\xa0\x8a\x86\x22\xfa\x9c\xe8\x45\x74\x1e\x01\xfd\xed\xe4\x84\x36\xd5\x06\x3b\x6b\x4b\xc7\xc7\x2d\x48\x0d\x7b\xab\x1a\x87\x5d\x38\xb8\xd2\xeb\xea\x6d\x7a\xd7\x4d\x45\xe0\xd8\xd2\xc2\x0c\x90\x94\x76\xbb\xde\x85\x7a\x97\xde\x9a\x3d\x89\x79\xb9\x12\x30\x2b\x71\x36\x98\xc4\xfd\x1b\xfa\xf5\xee\xe4\x44\x03\x4f\xcd\xd3\xdb\xe1\xcd\x88\xee\xd2\x9c\x31\x5d\x38\x39\x99\xc7\xf7\xd7\x36\xf0\x70\x49\x43\x7d\x0d\x6b\x2e\x74\xc9\x1d\x6c\xbc\x29\x62\xc5\x64\x78\x88\x22\x08\x1b\x83\x6f\xdc\xa5\x6f\xe3\x7d\xc1\x0a\xd0\x14\x3a\xe9\x39\x82\xaf\x4e\x4f\xd5\x18\xde\x1f\xba\x38\x53\xa2\x55\x37\xbd\x51\x54\x10\x0d\x59\x85\xdf\xca\xe5\x5b\xcb\x0e\x82\x15\xf1\x29\x67\x03\x5f\x3d\x3b\xd7\x5e\x5c\x37\x44\x62\xd6\xd4\xe8\xdd\x6e\xc3\xff\x76\xf0\x27\xfd\x5a\x1c\x23\x66\xb4\x1f\x36\x20\x24\x9b\x78\x6f\xa8\xc3\x0c\xc1\x64\xd4\x44\x10\xe5\x8d\x9d\x1d\x6a\x9d\xc5\x2d\xc1\xc2\x0b\x9c\x0c\xa8\x1e\x6b\xc4\x97\xbe\xd1\x41\xb6\x25\x0a\xbe\xb7\xc7\x21\x6b\x04\xe3\x64\x6c\xca\x4d\xd3\x89\x78\x65\x51\x1b\x5b\x79\x6d\xed\xa5\xc0\x48\x26\x9f\x7b\x9c\xf6\x31\x75\x50\xac\x67\x13\x0e\xfe\x73\xeb\xc9\x38\x14\x51\x87\x89\xf1\xa2\x73\x67\x58\xd0\x09\x33\x86\x3a\xd2\xfa\x21\x24\x95\xf9\xd5\xa7\x6a\xe9\x7b\xef\x71\xc2\xe1\xdc\x1b\x5b\x53\x7b\x9a\x79\x2e\xce\x33\x67\x84\x0f\xc3\x74\xf9\x1c\x45\x53\x3d\x8c\x88\xb4\x0d\x74\x09\xa1\x52\xcb\x14\xa3\x49\x0d\x4e\x17\xf6\x33\x38\x5b\xc4\x8b\xaa\x62\xcb\x01\x58\x2c\x13\xaf\xc7\x73\x78\x99\x2e\xc1\x43\x2d\x3d\x1b\x29\x9d\xf4\x66\x0e\x9e\x10\xbf\xf9\xed\x97\xd8\xdd\x9d\x2b\x36\x31\xc4\x5a\xbc\xb6\xe1\x05\x12\x9f\xe2\x07\x63\xad\xb0\x43\x2c\x99\xb9\x64\xdb\x36\x93\x19\x76\xfb\x4b\xfd\x70\x84\xce\x95\xa1\x5a\xbe\xa0\xa0\x55\x99\x70\x4c\xa2\xd3\x9b\x9e\xa8\x63\xeb\x88\x56\xf5\x17\x6c\xfe\x0d\x34\x74\xca\x11\x8d\x4b\x23\x0a\x08\x6b\x6d\x7a\xba\x9f\xa5\x3f\xf5\xfc\x30\x72\x13\x8c\x48\x82\x54\xed\xf0\x9e\xd1\xcc\xa2\xa5\xe8\xef\x0c\x4a\x75\xdb\x95\x79\x7a\x15\x10\x4c\x70\xbb\xd7\xa9\x74\x07\x51\x8e\x1c\x3a\x7b\xfd\x60\x9f\x4c\x14\xe4\xa5\x39\xe0\xda\xa3\x21\x75\xec\xe7\xa5\x39\x72\x67\xea\x02\x9d\x1c\x5b\x47\x53\x22\x89\x88\xb6\xcd\xea\xd1\xa6\x58\x2f\xaa\x32\x56\x19\xbd\xc2\x3a\x0b\x12\xe8\x68\x39\x2d\x63\xe2\xf3\xd8\x09\x09\x10\x4a\x0f\xc7\x63\x52\x2d\x7b\xe5\xbb\xe6\x10\x01\xd3\xb1\x7d\x51\x6c\x1c\x73\xb4\x8b\x2b\x87\x60\xdc\xaa\xa6\x7b\x4f\x7a\x7c\x4c\x2b\x16\x4a\xd7\xc0\xeb\xf1\x40\x00\xcc\xc5\x03\x4e\xa4\xed\x31\x8e\x2d\xee\xda\x96\x75\x0f\x9d\xf0\xa1\xda\x4c\x3f\xf9\xa3\xb8\xe0\x47\x2a\xfa\xa3\xa8\x8a\x9c\x96\xae\xa6\x23\x42\x79\xc8\xaa\xbb\xdd\x55\x26\x1a\xa3\x1d\x6b\x47\x25\x45\xd8\x8e\xf1\xc0\x23\x75\xc0\x3e\x5d\x0c\xc4\xa9\x2b\xa9\x7b\x6f\xa9\xc8\x9a\x51\x43\x8d\x13\x9d\x19\x4f\x24\xa6\xc9\xf9\x7f\x35\xfc\x9a\x5b\xbb\xc6\xaa\xb1\x33\x0e\x03\xf0\x3a\x13\x3a\x99\xf3\x4e\x88\x18\xc2\x2f\xfa\x40\xbf\xa5\xa8\xed\xb8\x7e\xf3\x50\x3f\x89\xe5\x16\xd5\xdc\xf1\x61\xd5\x9c\x1b\x0b\x13\x88\xc6\xce\x49\x87\x26\x4e\x83\x74\xd5\x9a\xe5\x5c\xd3\x75\xcb\xfe\xd6\x68\x13\x4b\x4e\xfd\xc6\x0c\x40\x79\x03\x5d\xed\xa0\x36\xe2\x70\xee\x3d\xe4\x47\x57\x7a\x7e\x74\xa5\xef\x47\x17\xab\x49\xb6\x87\x6b\xe0\x82\xf7\x7c\xba\x65\x44\xc5\xd5\x3a\xdd\x3a\x0f\x2a\x7d\x6b\x48\xfc\x8f\x20\x34\xae\xd6\x56\x1f\xb4\xd0\xa7\x19\x95\x77\xc7\x1a\xdd\x15\xd0\x54\xe3\x8b\xc6\x70\x50\x3f\xbd\x7c\x41\x9b\x80\x6e\xf2\x4f\xba\x65\xdd\x20\xb7\xf6\x27\x7b\x28\xde\x9a\x8f\x30\xd1\x09\x68\x1c\xb1\x25\x67\xbf\x3c\x65\x70\x09\x40\x50\x9c\x0d\x9e\x75\x06\xc9\xd3\x37\x67\x6f\x2e\x9e\xed\x00\x31\x71\x47\x8f\x7b\xc3\x5f\x92\x3f\xbe\x19\xbe\xe9\xa9\xd1\xe3\x47\x67\x4e\x95\xf1\xce\x8c\x2b\xf0\x30\x7d\x78\xaa\xdc\xda\x56\x16\x3d\x20\x84\x05\x4e\x23\x60\x99\x8d\xfd\xdf\x20\xb6\x29\x38\x65\xc0\xb5\x62\xcf\x07\x51\xde\xf0\x08\x6d\xa9\x27\x64\xe4\xdd\xcb\x4d\x34\x2d\x6e\xe0\x9d\xf5\x5d\xb5\x55\x0a\xbb\xac\xb1\xd2\xfa\x08\x92\x76\x77\x2c\x1b\xf1\xd0\x97\x1d\xd8\x5a\xfc\x2c\x3d\x97\x26\xec\x4d\x2d\x07\xb0\x34\x60\x05\xf4\x6c\x3b\x74\x10\x47\xc9\x62\x49\xd4\x0a\xce\x36\x08\x85\x11\x05\x87\x21\xe2\xec\x42\xe1\xa4\x08\x59\x54\x75\x77\x5d\xf6\x69\x19\x90\xd8\x9f\x90\x5c\x1a\x16\x81\x81\x53\x7a\x90\xb7\xf5\x20\x0c\x9a\x66\x10\x5c\x0f\xb0\xb5\x73\xcf\x4e\x7b\x6d\xde\x5b\x3e\x18\xad\x66\x90\x70\xcb\x9f\x00\xe7\xd7\x63\x86\xbc\x0e\xd0\x8b\x40\x28\x3d\xe4\x9e\x0e\x9d\x35\xae\xc4\x5c\x1a\x3d\x18\xaf\x2e\x1b\x65\x50\x01\x15\x8d\x01\x8a\x9d\x72\x46\xab\x06\xfd\x97\x64\x14\x60\x96\x65\x10\x56\x67\x13\x4e\x1b\x20\xb9\x17\x03\xb3\xe7\x10\xc2\x50\xc6\xac\x92\xd5\x0c\x18\x17\x36\x57\x83\xe0\xaa\xcb\xbe\x7c\x88\xa2\xb0\xae\x60\x2d\x03\x5c\xfb\xda\x3b\x0d\x1a\xcc\x7c\xd6\xf1\x05\x8f\x77\xbb\x1d\xef\xc1\x17\xcf\x63\x86\x3c\x6d\x33\xfd\x1c\xeb\x92\x4d\x5f\xac\x93\x93\x5b\xcb\xd1\xe0\x8d\xc4\xb6\xc2\x44\x84\xee\xc5\xa1\xf9\xbd\xfa\x4d\xd0\x67\x88\x22\x74\x9e\x0e\xdf\xdc\xbd\xf9\xd7\xa8\xfb\x2c\x1e\xfe\xf2\x6c\xf4\x78\xa7\x11\x69\x1e\x33\x00\xcd\xe7\xa9\x05\xd4\x6e\x67\x9d\x99\x4f\x0e\xe6\xbf\x75\x8b\x8a\x6e\xa3\xa0\xb3\x4a\x84\xc4\xf3\x11\xf1\x94\xcf\xe4\xb7\x91\xcb\x4e\x2f\x46\x0e\xb1\xed\x59\xfa\xe9\x60\x28\x62\x2d\x5b\xd8\x47\xc9\x6f\x06\x8e\x44\x41\x39\x75\x5c\x0c\x51\xdc\xb0\x84\xc7\x39\x8c\xc0\x02\xb8\x3d\x80\x1a\xe8\x7d\xac\xd7\x47\x9c\x34\x50\x8e\x73\xfb\x8c\xf5\x3b\x06\xd6\x84\xf8\xc9\x23\x5a\x80\xdb\x6c\x51\xa0\xc9\x8b\x01\x76\x72\x92\x2b\x1f\x09\x9b\x2e\x18\x12\x16\x07\x2f\xbf\xa9\x72\xe3\x7a\xc4\xdb\xb7\x05\xbd\x65\xce\xb3\xa9\xde\x6a\x2f\x46\x7c\xad\x09\xe9\x9b\x0b\xb2\x70\x01\xdd\x77\x1e\x07\xb4\x56\x23\x3b\xc7\x03\xfd\x43\x84\x0d\xe9\x15\xfb\xbb\x15\x8a\xef\xf4\xbd\x39\xd8\xdb\xcd\x30\xaf\x87\xea\x16\x80\x3c\x51\x25\x87\x5b\x7a\x06\xcf\x8e\xb7\xdf\xd3\x0b\xde\x7f\x90\x08\x68\xb3\xf8\x38\xde\xe9\x5c\x05\x5b\x24\xcd\x94\xff\x39\x2f\x1a\xa9\x13\xbc\x66\xaa\x93\xe2\xe1\x67\xe2\xa4\x8e\x7c\xd8\xe6\x3a\xf8\xbe\x07\xa0\xb6\xf7\x03\xfd\x97\x57\x77\x67\x41\x27\xb8\x75\x9d\x77\x0e\xcc\xa6\x37\xae\x95\xf6\x67\xd8\x9b\xcc\xfc\x02\xa2\xa1\x05\xfe\xec\x64\x9a\xfc\xec\xfb\x9f\x7b\xb6\x1d\x6c\x04\xf5\x3e\x5d\x40\xb8\xc6\xe2\xff\x42\xb6\x90\x0c\xe2\x66\x07\x27\x35\xba\xfc\x71\xb1\x9d\xcd\x77\x1c\x24\x7a\xa6\x9e\xa7\xf7\xec\x7b\x45\x25\xd8\x4c\x25\xde\x17\x1b\xfc\xe6\xa4\xce\x30\x53\x21\x21\x34\x51\xb8\xbe\x23\xc9\x70\x6a\x6e\x3f\x5a\x98\x0a\xdb\x0e\x17\xc6\x55\x21\x63\x33\x42\x2c\x00\x3f\x6e\x0e\x8c\x32\xdd\xbb\xa3\x15\x09\x4c\x97\x67\x9b\x4e\x61\x3c\x9e\xb4\xd0\xea\x0e\x45\x18\xcb\xc5\x4e\x7d\x10\x5b\x74\x38\x6a\x31\x6a\xd7\x31\x3a\xb2\x63\x36\xfd\x16\xa6\x7e\xa7\xb3\x66\x14\x49\xef\x20\x82\x9b\x4c\xd3\xbe\xbc\x30\x93\xe1\x0b\xdf\x3e\x01\x6d\x3f\x5d\x04\xa7\x05\x87\x05\x35\xb1\x71\xc2\x08\x50\x3d\xdc\xd1\xbc\x13\x86\x04\x9d\xf9\x72\x53\xf9\xd0\xed\x61\x87\x75\xc4\x93\x7f\x2e\xc2\x2c\xa6\x26\xa9\xa5\xba\xc4\x0a\x37\x8e\xc6\x01\xd7\xe3\xb0\xd6\x79\xb9\x25\xe7\x56\xa3\xcf\xdb\x5e\x36\x48\x39\xea\x43\xd9\x8c\x21\xeb\xd7\x63\x95\x80\x0f\x64\x9d\x05\x2e\xa0\xab\x9d\x0c\x26\xe2\xba\xa2\xbd\x44\xeb\xe1\xd4\x07\x38\x09\x86\x9c\xa5\x6e\x59\x1b\x70\x60\xef\xaa\x1d\x4a\x63\x67\xfc\xb0\x47\x28\x54\x2b\xec\x3f\x80\xec\xd3\x6d\xdc\xda\xa0\x05\xf6\x56\x33\x52\x0b\x8e\xc7\x11\x62\x10\x1b\x28\x5b\x39\xf7\x0c\xf1\xc6\xd9\x90\x68\xaa\xcd\xc7\x84\xfe\xe1\x83\x0a\xe8\x99\x27\xf1\x85\x44\x7c\xec\x20\xc4\xa6\x9a\x43\x0e\xc8\x2c\x2a\x2b\xcb\x76\xac\xe5\x46\x0a\x01\xdd\xab\x20\xdd\x01\x91\x4c\x92\x57\xe5\x45\x86\x4c\xa5\xea\xbe\xa8\xa7\x49\xf0\x2b\xa4\xe7\x1d\x83\x2c\x5c\x43\xd9\x4f\x6a\xd7\x66\xc5\x42\x99\xe9\x63\x98\x7e\x29\xcd\xac\x6f\xe9\x8b\x70\x4b\x3b\x23\xb9\x86\x60\xbd\x6f\xf1\x11\x31\xae\x19\xcd\xb0\xcf\x5c\x87\x66\xf9\x27\x96\x8e\x0e\xd2\x74\xac\x15\x33\x19\x76\x47\x84\xc9\x7a\x46\xc7\xd8\xbe\xc1\x14\xef\x20\x70\x71\xcb\xab\x8c\x5b\xbc\xa8\xfb\x7a\xe8\x17\x30\x0c\x81\xd3\x6c\xbc\x17\x1a\x79\xa8\x6c\xdd\x39\x58\xd7\x4d\x2b\xe2\xc1\xae\xb4\x7c\xe2\x43\xaf\x1c\xf8\xd2\xc7\xf5\xdf\xff\x1e\x0f\x00\x6a\xfb\xc8\xa1\xab\xbb\x3f\xe3\x75\x4d\x9d\x0f\xcc\x97\x7e\x8a\x88\x41\x37\xf0\x48\x93\x10\x7b\x52\x3f\x64\x20\x65\xcf\xa7\x07\xeb\xf1\x95\x05\x78\xc9\x1c\x64\xad\x9a\x09\xfd\xd4\xf1\x40\x66\x6f\x11\xb1\xcc\x7c\x0c\x3f\x84\x58\x04\x7b\x14\x07\x02\x9c\x72\xed\x5d\xcf\xfc\xe2\x25\xfb\xc8\x9d\xf1\x33\xe2\x21\x0c\xbc\xd5\xff\x14\xb3\x8d\xb1\x60\x26\xa7\x41\x8a\x4a\x36\x36\x5a\x41\x90\xed\x9b\x3e\x53\x02\x85\x73\xe7\x39\x7b\xed\x5a\xda\x50\xc5\xea\x0b\xa7\x27\x83\xc7\xfe\xdb\x6a\xcd\x3e\x42\xaa\x46\x4e\xaa\xd8\xb0\xd8\x5f\xa5\x67\x6f\x5e\x75\xcf\x26\xea\xeb\xf4\xde\x73\x0e\xf8\x8b\xdb\x9f\x5f\xa3\xa7\xf7\x56\x6d\xad\xf7\xb3\x0e\x03\xed\x7c\xc5\x7a\x4f\x15\x7a\xe7\x82\xcf\x83\xcb\x59\xac\x72\xda\xff\xcf\x89\x78\x22\x45\xf1\x26\x88\x5b\x23\x71\xb3\x49\x7e\xbf\xe6\x0e\xe1\xe3\x89\x3b\x71\xf7\x4a\xc7\x37\x06\x40\xc4\x38\xd2\x66\x08\x9b\x5e\x12\x1b\xcc\xa6\x8f\x4b\x57\xff\xdc\x08\x6f\xd4\xcc\xea\x7a\xb9\x7e\x7f\x72\x32\x87\x57\x08\xe0\xb9\x69\x7d\x9d\xeb\x58\xbf\xa9\x13\x1c\x8f\xcf\xfb\x24\xe4\x8e\x9f\x4d\xfa\x13\x39\x87\xa7\x70\xe6\x10\x3d\xe5\x1c\x5a\xdd\x39\x18\x62\xf6\x1d\xe4\xb8\xbf\xed\x72\xf5\xdd\xe2\xeb\x6c\xbe\x21\x66\x25\x47\x22\x10\x39\x9e\x4a\x78\x9e\x50\x45\x9d\xd9\x60\x66\x45\xe7\xcb\xce\xcc\x28\x7a\xe3\x24\x1f\xa0\xe9\xc9\x95\x71\x31\x64\x0f\xae\xab\xf4\x3e\x38\x09\x04\xb4\xd0\x58\x87\x4c\x33\xfb\x36\x99\xd3\xd1\xa4\xc3\xcb\x90\xa7\x22\xaf\x65\x95\x11\x1e\x4c\xe3\x48\xd3\x0a\x0c\x10\xa4\xcb\x81\xb1\x52\x9c\x9c\x5c\xc1\xbd\x92\x4a\xec\x76\x53\x73\xca\x26\xec\xe5\x69\x1a\xee\xb8\x04\x44\x4f\x4c\x60\xcd\x8a\xf7\x1e\x4a\xb7\x2a\x07\x6e\x10\x93\x9c\x97\x6c\xa1\x2e\x19\x98\xd2\xe7\xf2\x95\x00\xb3\xb5\xa4\x7a\x01\x0c\x81\x5e\x50\x16\x3c\xbc\x45\x7e\x33\x1c\x24\xe0\xb1\x35\x04\x3d\xf0\x13\xa9\xb7\x60\x29\xe2\xa9\x51\x3d\x17\x50\x3d\x63\xeb\x8c\x9f\xc1\xfb\x64\x7c\x7a\xaa\x26\xfc\x0b\xfe\xe0\x7b\xd9\x06\x7b\x55\x67\xe1\x2c\x43\xe0\x2a\xcf\xd4\x94\x99\x95\xe3\x8e\x06\x89\x34\xaa\xf9\xba\x17\xa5\xeb\x89\x41\x98\x97\x6f\xe8\xd9\x6d\x2d\x38\x4b\x73\xcd\x1d\x87\x85\x5b\x72\xe1\x1c\x4f\xf7\x0a\xe9\xf6\x5a\xea\x99\x99\x3a\x88\x69\xf3\x56\x93\xae\x12\x2f\xb5\x56\x38\x63\x7f\xc1\xea\x5f\xb3\x6d\x7b\x96\x23\xf4\x97\x06\xec\x78\xc6\x06\x25\xce\x23\xa0\x72\x38\xee\xe7\x42\xb8\x06\xfa\x6f\x87\x96\xf2\x88\x16\x80\xb6\xe4\xe5\x71\xc2\xf3\xae\x3f\x8f\x4f\xb4\xb4\xf9\xaa\x67\xbe\x5d\xcf\x59\xe4\xbd\xd7\xd6\xea\x63\x62\xc4\x0d\x05\xba\xf2\x73\xc3\x7c\x09\x14\xed\x75\xab\x6b\xee\x70\x18\xad\xab\xcd\x72\xfe\x16\xea\xe4\x72\xb9\xa0\x3f\x1e\x31\x02\xf8\x57\x51\x1d\x09\x79\x80\xb2\x59\x97\x2d\xa3\x91\xc2\x8b\x8c\x55\xa9\xa2\x71\x46\x64\xfb\x03\xef\x5d\xb2\x97\x2d\xbf\xb7\x58\x6e\x67\xe3\xf7\x11\x0e\xc3\xe5\x04\x41\xc8\xb5\x77\xcd\x6b\x23\xc4\x0d\x44\xc0\x5a\xe1\x93\xb2\x4c\xef\x49\x9e\xdf\xb6\x0d\x59\x41\xe4\x6f\x7e\x97\xbd\xdf\xb4\x3c\xab\x7a\xe8\x96\xb7\x21\x7b\x68\x6e\xa7\x31\xaa\xdb\xa9\x7f\x70\x1a\x78\x48\x5b\xcc\x91\x76\x33\x9a\x1e\x5c\x5e\x3b\x99\xd1\x86\xbe\x49\x1a\xca\xc4\xc2\x0b\xe2\x4f\xbf\x1a\x02\x87\x75\xd4\x69\x7c\x76\x02\x50\xb8\xd6\xbc\x55\xfd\x4c\x14\x0e\xae\x3e\x88\xb5\xd7\x33\xa2\xb1\x03\xfb\xb3\x13\x4b\xa7\x8b\x9e\x9e\x30\xdd\x69\x5c\x63\x22\xc0\x68\xcb\xd0\xb3\x24\x82\xe9\x20\xaa\x46\x8d\x39\x1f\x75\x23\xac\xbc\x68\xc4\xdf\x65\x5a\x58\xb8\x5a\x25\x67\xdc\x44\x12\x5f\xd8\x26\x01\xdc\x4f\x65\x82\x23\x19\xbb\xc2\x60\x8b\xf8\xe7\x43\x39\xce\xec\x22\x85\xa6\x39\x29\xf7\x08\xe2\x76\xe7\x28\x89\xb2\x33\xf6\xc4\xc4\xe4\xa8\xe6\x18\x67\x6e\x8c\x81\xfe\x4a\x07\x1e\xb0\x5c\xfb\xa5\x0c\x6b\x3a\x01\x2f\x8f\x93\x86\x7f\xf8\xa3\x4c\xe7\xc5\x9e\xa4\xc6\x8b\x5f\xb2\x11\xbd\x67\x08\x03\xdd\x79\xc2\xd7\x20\x0c\xb1\xaa\x78\x40\x46\x2d\x39\x1a\xaa\xd6\xa1\xaa\x06\x65\xd2\xbe\x63\xc3\xf2\xd4\x2e\xb3\xc3\x19\x2c\xcc\x8c\x58\xc5\x79\x71\x74\xa2\xb3\x8a\x98\x19\x58\xec\xee\xa6\x55\x9b\xaf\x36\x1c\x11\x1b\x09\x21\x38\x59\x9f\x15\x67\x21\x1b\xc0\x13\xe9\xf0\x7a\xa9\x12\x9c\xf5\x1c\xe8\x3e\xc8\x12\x6f\x65\xc3\xa7\xf2\x00\x27\x6b\x6f\xe3\x4c\x07\xd7\xc3\x3d\x2e\xf0\xab\x9e\xfc\x8b\x04\xcd\x46\x13\x93\x8a\xe3\x35\x66\x83\x89\x5e\x77\x4c\xe7\xf0\x81\xe4\xf4\x74\xbc\xdb\x4d\xcc\x8a\xb5\xf7\x69\x49\xb0\xa9\x9c\x6d\xde\xcf\x2e\x58\xc6\x9e\xb1\xef\xad\x9c\x42\x15\xe2\xe8\x82\xcb\xab\xe0\x92\x84\x73\x51\x32\x17\xb4\xe3\x6a\x63\x81\x5b\x6e\x38\xfc\x2b\xb3\x83\xd0\x86\x2b\x1c\xa1\xb2\x81\x26\xcd\x0d\x84\x12\xf0\xd2\xe2\x0e\x58\xb4\xb9\x7a\x4f\x50\x87\x9a\x78\x9b\x43\xb3\x96\xdf\x70\xaa\x41\xd1\x83\xa5\xad\x6c\x3b\x3f\xaa\x37\x2b\x33\x2b\xcb\x11\x79\x9b\xcb\xeb\x42\xf1\x2b\xff\xca\x66\xdb\x84\xf8\xac\xe5\xbc\x94\x07\x01\x63\x39\xd0\x15\xa3\x54\xb7\x9b\xe8\xab\xce\x31\x10\xbd\xd7\x8d\xe2\x0c\x1d\x73\x7c\x3e\x38\x3d\xf5\x5e\x63\x55\x1f\x57\x0d\x07\x2a\x7b\xc1\xb8\xb6\xc7\x28\x7e\x72\x12\x94\x7f\x76\x4e\xc5\xbe\x09\x46\x65\xae\x86\x8b\x91\xd6\x1d\x11\x17\x35\x99\x54\x1a\x82\x00\x6a\x3f\x70\xa8\xb5\xbb\x9d\x88\x6b\x03\x80\x3c\x1e\x2e\xc7\x63\x7b\x27\xae\x89\xe0\xdf\xd2\x6e\x9d\x6b\xb0\xdb\x1a\xfa\xe5\x97\xdf\xbd\xd4\xb1\x53\x2f\x96\x59\x09\xa8\xac\x6f\xa1\x57\x57\x59\x7b\x71\xc1\xbe\x94\x22\x66\x9c\x60\x38\x0a\x26\x26\xf5\xc3\x85\x8c\x09\x1f\xfd\x4d\x83\x6d\x15\xc1\x1c\x0e\x4c\xc3\x88\x43\x1b\xb9\x8a\x57\x38\xd4\x06\x9b\x6a\xfb\x7a\x76\x5d\x2d\x6f\xb7\x1d\x5d\x75\x9c\x74\xe6\x2d\xd8\x9d\x87\x5b\xdf\x2c\xeb\x35\x9d\xb8\x8e\x6f\xec\x2a\xca\xd9\x72\x54\x5b\x59\xbc\x1e\xff\xca\xe1\x46\x05\x2d\xec\x1a\x01\x30\x42\x85\xf6\x1a\x6e\x73\x3f\x85\x16\x13\xf6\x02\x9b\x55\xcc\xf1\xd7\xf1\x7d\x05\xe9\x01\x7b\x77\x0a\xb5\x78\x11\x9b\xcf\x70\xed\xc4\xa4\x0e\xa7\xb0\x94\xf0\x17\x6c\xec\x69\x90\xfd\x0e\x15\x84\x79\x75\x4a\xc9\xff\x07\x47\xbf\x4b\xd6\xa1\x75\x9c\x85\xd2\x00\x1b\xd3\x20\x5e\xa6\x39\x5d\x1c\x20\x67\x97\x9e\x2e\xab\x60\xf0\x33\xad\xbd\xb7\x8e\xb4\x39\x07\x12\xc2\xc1\x98\xc8\xbb\xa1\x67\xb8\x33\x55\xe6\x51\xec\xdc\x03\x2b\x22\xa4\x97\x03\xd3\x8e\x38\x99\x21\xf5\x2b\x44\xa3\x02\x4e\x4c\x7d\xe9\xf5\x6a\xfb\x65\xb6\xcd\xda\xb6\x7b\xa8\x72\x15\x30\x12\xff\xfa\xb8\xeb\xd9\xff\xdc\x62\xff\x1b\x2d\x76\xad\x91\x12\x65\xbb\x8d\x12\x15\x4d\x25\x9c\x34\x00\x95\x7b\xae\xee\x83\xd0\x36\xf3\xdd\xfb\xfd\x5e\x33\xfe\x3d\x9d\x47\x50\x6c\xd0\xf8\xd5\xfd\x5b\x8f\x73\x09\xed\xf9\x6f\x7a\xa1\xfe\xa6\xfb\xb0\x49\xfd\xde\xd0\x6d\x2f\x5b\xea\x55\xf5\xbe\x91\xeb\xd6\xbe\x07\x75\x99\xee\xaf\x00\x50\xe5\x68\x1b\x52\x28\xf9\x2d\x18\x69\x17\x7e\x3a\xab\x75\x0b\x18\x00\x3b\x0f\x0b\xa5\x26\x30\x60\xaf\xda\x06\x60\xc6\x36\x55\x0b\x95\x5d\xc6\x8d\xf7\x0b\xe5\xb1\x20\x54\x30\x50\x9e\xf2\xc0\x91\x9c\x4e\xeb\x2c\xb8\x66\x9f\xf5\x02\x31\x68\xdb\x83\x39\xdb\xf8\x05\x1a\x07\xac\xac\x71\xea\xbd\x5e\x8d\x0e\x18\xbe\xc7\x70\x6d\x28\xfa\x66\xf5\x63\xad\x7b\x29\x00\x81\x86\x63\x9b\x1a\x54\x07\x2c\x27\x9b\x07\xab\x14\xab\xd3\x18\xfe\xf1\x7e\x26\xb0\x71\x3d\xdd\xac\x73\xac\xf4\x2a\xf3\x1a\x3d\x0a\xf1\x8c\x04\x08\x21\xc1\x19\x49\xcc\x36\x6f\xdd\xf6\xae\x37\x5f\xdb\xed\xf2\x16\xe5\x0d\xdd\xb3\x45\x8a\x41\x47\x9b\x7a\xa1\xad\xe5\x68\x65\xb7\xf7\x35\x57\xa5\x1f\x2d\x7a\x36\x7b\x1f\x43\x5b\x25\xc6\x3c\xb4\xd5\xad\x70\x6f\x16\xd4\xde\x3c\x6e\x0a\xd6\xbe\xc9\x93\x5d\x96\xfd\xa9\x9a\xf8\xc3\x21\x31\x11\xae\x27\x71\xf0\x0c\x8c\x2a\x3b\xf4\xba\x44\x93\x79\x3c\xe0\xcc\x76\xe2\x4c\x9b\xb3\x9a\xcb\x6b\x31\x9a\x0b\x85\x95\xdf\x05\xc5\x49\x1c\x89\xb8\xa4\xc3\x5c\x55\x23\xb8\xb1\x54\xc8\x08\x21\x77\xe1\x26\x50\x06\x6a\x24\xf6\x5d\x2c\x9b\xbe\x8b\x1a\x2b\x77\x32\x2c\x91\x3a\x76\xcf\x12\x3c\x36\xe6\xa1\xcc\x98\xfe\xd2\xf2\xba\x55\xdb\x84\x9c\x8f\x35\x66\xe9\xbb\xc8\xd6\xa1\x04\x59\x2b\x6a\x41\xf1\x1f\xa8\x8d\x04\x54\x0c\xfc\x0b\xe6\xd0\xfe\xa6\x5e\xea\xbf\x7f\xd7\x16\xec\x7b\x31\x5f\x3f\x7e\xb3\xdf\xbd\x19\x9a\xdf\x23\xd8\xae\xbf\x4b\xcf\x3a\xc3\xcf\x4f\xff\x8d\x34\xce\x8e\xee\x7d\x1f\xae\x3c\x7f\xae\x1a\x18\xf3\x92\x75\x30\x2a\x69\x48\x4e\xa3\xae\x43\x57\xfb\x4e\x45\xa7\xf0\x63\x6e\x44\x15\xd7\x5c\x96\xe8\x48\x69\xac\x61\xfa\x32\x68\x12\x49\xa9\xdb\xf5\x2d\x9f\xe9\x05\x27\x16\x1b\x43\xe7\xa5\x2f\x2f\x92\x08\x07\x91\x5c\x31\x40\x4e\xb7\xe8\x46\x72\xd9\x2d\x92\xbf\x1b\x40\x9c\x81\xb6\x46\xff\xf5\xd5\x77\x7f\x67\x25\x93\x07\xab\xf6\xd2\x5b\xdf\x72\x3a\x16\x69\x08\x3a\x56\xec\x03\xeb\xdb\x81\x89\x3f\x7a\xd9\xd3\x0f\xd9\xc0\xf5\xc2\xbb\xa2\x29\x0e\xdf\x91\x81\xfd\xc3\xd1\x91\x7d\xd5\x3b\xb0\x0b\xbb\xad\xbe\xac\xbf\x15\xdf\xbf\xd4\x7c\x94\x86\x6a\xfb\xb5\xb5\x62\x5d\xeb\x8b\x7a\xad\xbf\x1e\xac\xf6\x45\x50\x6d\xdd\xe4\xd8\xf8\x48\x73\x8b\xe3\x18\x9e\xc0\x05\x7c\xec\x39\xe5\x05\x8b\x46\x4e\x2a\x4f\x83\xcc\x7c\xc7\x4b\x26\x3d\x63\x71\xf6\x19\x7b\x56\xb9\xe3\x17\xf2\x44\x45\x7a\x1c\xb1\x5a\x36\xe0\x45\x69\x49\x4c\x9a\x5b\x74\x42\x3b\x93\xf5\xd9\xf8\xd1\x03\xde\xab\x3a\x67\x8f\x21\x0b\x7c\x24\xab\x53\x94\xde\x3e\x99\x28\xb5\x3e\xe9\x4f\xb4\xfb\xbf\x97\x50\x1e\x84\x4b\x11\xdf\xf1\x82\x97\x46\xbd\x09\x70\x53\x30\x27\x99\xc9\x46\xd1\xcc\xf6\x2a\xe6\x2d\x16\xaa\x3d\x96\x40\x16\x9b\x08\xb2\x40\x4d\xf8\x6b\x3d\x2b\xb7\x73\xb5\xf6\x9b\x28\x0e\x18\x63\x8f\xaa\xe7\xda\x4f\x44\x8f\x1f\xd5\xe6\xd1\x66\x97\x23\x2e\x28\x53\x3e\x50\x46\x3a\x2e\x8f\x5b\x8b\xc9\xd6\x68\xed\x94\x9c\x74\xf2\x15\xee\x4e\x19\xf7\xbd\x8e\x96\x38\x72\x4e\xc5\x3e\x67\x27\x83\x27\xc2\x7d\xe6\xe4\xc4\x1f\x19\xce\x42\xbe\xd7\x98\x8f\xaa\x29\xfa\xca\x13\x2d\x4f\xb5\xac\xe8\x5a\x2a\xf1\xc6\x1c\xe8\xb5\x6e\xa7\x41\x16\xbc\x59\xed\x37\xb7\xd5\x6d\xf5\xf0\xf9\x9b\x21\x89\x2e\x07\x51\x8d\xdf\x01\x8a\x88\x5f\x81\x16\xed\x85\x3b\x64\xe1\xd2\x76\x5c\x4a\xbe\x44\x9b\xac\x1a\x25\xbc\x4d\xe9\x3b\x53\x10\xa7\x9b\x58\x64\xef\x58\x71\xd6\x22\x07\xba\x5d\x56\xcd\x66\x41\xf1\xaf\xdb\x20\x58\xa3\xb4\x66\xb8\x94\x34\xa0\x74\x0a\x0b\xe8\x2e\x6c\xd0\x27\x95\xfa\x95\x8b\x7d\xb3\x5c\x5e\x6d\x2c\x7e\x89\x1b\xa0\x45\x4f\x7f\x4d\xa8\x41\x1f\x6e\xab\x46\x9b\x08\x55\x8c\xa8\xd9\x6d\x85\x25\xed\x3e\x84\xa8\x75\xd0\x90\x54\xbb\x31\x18\xc4\x50\xff\x5d\x2a\x2a\x87\xd8\x98\xcd\x17\xc8\xbe\x29\x12\xc5\x84\xe3\xd9\x8e\x49\x12\x61\x02\xc2\x1a\x6e\x56\xe3\x40\xd1\xe5\xb5\xb5\x3d\xd3\xac\x1e\x7e\x2e\x11\xf5\x2d\xed\x93\x89\x28\x98\x14\xdb\x21\x2f\xd4\xbd\xe8\xcf\x0f\x2b\x54\xeb\xea\x2c\x8f\x34\x0e\x73\x3b\xd5\xc5\x48\xf2\x6e\xd4\x49\x65\xdb\x2c\x49\x3b\x9f\x18\x4b\x5c\xc3\xf3\x81\x5d\xf4\x91\xdc\x14\x03\xa8\x40\xcc\x1a\x6b\xfe\x29\x1d\x6f\x7a\x6e\x0d\xb5\xb5\x88\xec\xcc\x3d\xe2\x6e\xf2\xc0\xee\xf4\xdf\xe6\x0d\xd6\x0f\x57\x81\xde\x0b\x4a\xcf\x21\x12\x87\x78\x33\x87\x2d\xca\x3e\x06\x6e\x69\xb8\xcd\xd3\xb2\x36\x1f\xde\x80\xad\x95\x14\xf3\x2a\x5b\xff\xe3\xc1\x7a\xf4\x9a\x94\x15\xaf\x38\x7f\x7f\x53\x0b\xea\x47\xab\x5c\xa8\x2a\x54\x11\xc8\x59\x65\xf8\x50\x9b\x25\xd7\x6b\xdb\xe9\x69\x09\xdc\x30\x5f\x91\x32\x56\xc8\xbf\x4b\xdb\xe0\xf0\xc4\x19\xba\x99\xa5\xba\x75\x7e\xf2\x16\x4d\x14\x80\xfa\xa3\xb2\x60\xb1\x32\x91\x28\x64\xbd\xe3\x58\xea\x76\x95\xbe\xe2\x45\xe8\xc5\x8d\x4e\xa9\xf1\x95\xaf\x62\xd0\x2a\xae\x7f\x20\xed\xdd\xe9\x68\x00\x06\xaf\x7c\xfc\xa6\xb7\x8b\xdf\x94\x5d\xba\x18\x56\x5f\x8d\xf8\x01\x5d\xee\xe2\x33\x9d\xda\x47\xfd\x90\x0e\xa3\xd7\xcb\x55\xa4\xa2\x1f\xe0\x99\x4f\x7f\xbf\x58\x6e\xb7\xcb\x6b\xfa\xf1\xa2\x1a\x6f\xa3\x91\x7a\x75\x28\x0b\x2a\x11\x1a\x58\xe7\x61\xc5\x60\xe5\x43\xc1\xfb\x09\xbe\xe6\xc8\x2a\x0a\x6c\x99\x63\xcf\x73\xa8\x86\x15\xcb\x16\xf4\xd7\xc2\x88\x1a\x0c\x82\x1d\xa3\x12\x20\x11\xa0\x33\x2b\x5a\x1d\xbd\x49\x50\x6e\x2a\xf8\x7a\x9d\x4d\x38\x94\x01\xba\x87\x10\x25\xbe\x91\xcb\x5c\x82\x1d\x88\xc9\x6c\x3c\x31\x30\xf4\x45\x3b\x0c\x3d\x37\x28\xe2\xf8\x8b\x10\x6d\x4f\x43\xe5\xab\xc8\x81\xe6\xd7\xcb\x68\x68\x7a\x49\xa1\xee\x37\x8f\x84\xa6\x2b\x01\x5d\x79\x3e\xa7\xc1\x83\x00\x83\xbf\xec\x3f\x4f\x27\x58\xed\xca\x02\x9b\x19\x9c\x16\x95\x07\x01\x0c\x26\x8d\xe2\xb3\x77\x4f\xcf\xec\xef\x88\xbe\xb0\x58\x72\xf5\xcf\xe5\xad\x94\x1d\xca\x0f\xd4\x1c\x44\x16\x68\xd5\xd4\x8f\x7e\xc6\x8e\xfe\x55\x8f\x41\x73\x66\x8b\x2f\x6e\xf3\x7c\x5e\x6d\x80\xd6\xa6\xef\x70\xbe\x60\x7e\xe5\x9f\x34\x9d\x24\xd7\x9d\xa9\x7f\xc9\xbc\x5e\x2f\x6f\x37\xd5\x6e\xb5\x9c\x2d\xb6\xd5\x7a\xa7\x1d\xb8\x68\xdc\x6f\xe3\x5d\x41\xfc\xd5\xd5\x99\xfa\x49\x0a\xea\x9a\x24\x2d\x2d\xff\xbb\xbc\xdd\xe6\xf3\xdb\x35\x64\x11\xce\x1d\x39\xfc\xa5\x37\x7a\xcc\xe9\x27\x7b\x9d\x1e\x12\x61\xfa\xbe\xf6\xff\xf6\xa1\x21\xed\xdd\x47\x1d\x3f\x53\x97\xb9\xfb\x6b\x47\x84\x08\xbd\x8a\xe7\x21\xda\x8f\x16\x02\x88\xca\xec\xc1\xe1\x43\xbd\x97\xde\x4b\xb6\x7d\xc0\xb3\xd6\x5d\xa3\x02\x50\xc0\x5a\x2a\x62\x9d\x88\xd8\x9c\xff\xcc\xae\xad\x01\xae\x3f\xb5\x2a\xd7\x71\x5a\xd0\x9a\x1c\x9b\x3b\x44\x9a\x5c\x78\x1b\x27\xa0\xe1\xec\xd2\x1d\xf9\x91\x9a\x2c\xd3\xb1\xea\xcc\xd2\xb5\x34\x6e\x03\x9d\x9c\xbb\x92\xe0\xfe\x09\x5d\x4b\x95\xa2\xb1\x33\x57\x6d\x4a\x53\x4d\xb7\x16\x44\xce\x7f\x64\xbb\x37\xea\x31\x6a\xe0\xaa\x64\x7f\xa7\xad\x38\xd7\xcb\x23\xec\x6e\x0e\x94\x30\x89\x1f\x3d\x63\x83\xe6\x4c\xb0\x21\x99\x13\xa2\x93\xd3\x13\xa5\xa3\x08\xfe\x10\xb5\x30\xc0\x4b\x22\x87\xd3\xf4\x67\xf1\x4f\xce\x87\x97\x23\xf1\xdd\x58\xa6\x37\x29\x00\x09\xd4\x2a\xed\x00\x83\x40\x2a\xd3\xf1\x53\x3d\x13\x40\x15\xab\x25\xa7\x61\x36\x6d\xe3\xa8\x93\x6c\x3e\x5c\xb2\x18\x4d\x95\x74\xaa\xc1\xbc\x07\x0e\x63\x42\x7b\x1e\x42\x44\x32\xef\xe5\xc4\x70\xb2\x80\xba\xdb\x2d\xd5\xc1\x77\xaf\x52\x77\x80\x33\x06\xc6\x52\x2d\x69\x50\xb8\x8e\x1b\x91\xdd\x4a\xa5\xe7\x2d\x29\x24\xa1\xb9\xcc\x93\x32\x33\x98\x54\x61\xde\x55\xf6\x2b\x3c\x10\x69\x22\x52\x69\x45\x9c\x03\x11\x0d\x1a\xe0\xa2\x4a\x56\x3a\x38\xac\x07\x67\x29\x92\x86\x3a\xd7\xe9\x8c\x5a\x17\x33\xb6\x1f\x7e\xc1\xb8\x7f\x6d\x7b\xf7\x7c\x79\x4b\x6b\xf5\x5c\xcd\x41\x85\x6e\x57\x27\x27\xfa\x87\x0b\x22\x59\xa9\x09\xc2\x48\x8e\x2f\x00\x55\x55\x57\x5e\xc3\x10\xd6\x50\x68\x2f\x69\x49\x43\x97\xad\x58\x31\x8e\xa1\xc6\x5f\x53\xe3\x15\xc8\x98\x1e\x02\xb3\x54\xc3\x1b\xa9\x8c\x08\xe0\x0a\x06\xd7\xc6\x1f\xa2\xd6\x64\x3a\xe0\xce\xa9\xaa\x44\x07\x27\x5f\x31\xdb\xcd\x33\x22\xdb\x0e\x1d\x05\x5b\xdf\xaa\x57\xfa\xb8\xfd\xe7\xa4\xee\x93\x93\x60\x37\xc2\x27\xc6\xed\x24\xf0\xce\xbf\x67\xd9\x72\x0e\xcf\xff\x7c\xe5\x02\x3f\xf3\xf0\xc2\x2d\x3f\xb0\x70\x65\x09\xf0\x17\xa7\x8c\xd2\x11\xe4\xce\x00\x4c\x2d\x72\x40\x47\x5d\xb3\x8a\x90\x28\x79\x90\xf4\x1e\x23\xff\x74\x0c\xf9\xa4\x83\x5f\x00\xae\x05\xa3\x9f\x5e\x87\xdd\x1b\x53\xf7\xae\xd2\x6b\x24\xf6\x47\x7a\x53\x04\x35\x5f\xf5\xcc\xfa\x67\x5f\x0c\x99\x59\xbe\x2f\x53\x3f\x05\x4e\xa8\x2c\xe3\xab\x9e\x5d\xc5\xd4\x56\xb8\xcb\x73\x39\xcf\xc5\x3c\x7a\xfc\x38\x92\x14\xb9\xc7\xee\x3e\xaf\x6c\xb3\x4a\xc6\xf0\x9a\xf1\xdf\xa9\x2d\x9b\xd3\x53\x65\xcc\x4d\x58\xea\xf2\xcb\xad\xcc\xb8\x3f\xa1\xf6\x5c\x3b\xb5\xc2\x9c\x9a\x96\xad\x4b\x62\x41\x50\xdc\xfc\x36\x2f\xac\x94\xa5\x98\x7a\x87\x2c\x7c\xe3\x14\x42\x3f\x5d\x09\x23\xb2\xf0\x6e\xdc\x5b\x4d\xf0\x12\x1a\xc4\x59\x6c\xa6\xd4\x4a\x08\xcb\x2e\x16\x07\xaf\x54\x5a\xc7\xfd\xba\x2e\x70\xc6\xda\x07\xa9\xd1\x7c\x42\x79\x02\x46\x24\xab\x33\x62\x54\x65\x4d\x97\x43\x64\x99\xc6\x0e\xb8\xd2\x71\xf8\x43\x1a\xdf\x39\xf2\x32\x5d\x9a\x50\x2c\x0d\xdd\x35\x10\x9a\x9e\xe4\xb4\x3d\xdc\x33\x3b\x69\x5c\xc0\x5e\x79\x6b\x37\x19\x0a\x68\x4d\x3a\x4d\x39\x87\xee\x5c\x7d\x1a\xa4\x3f\x39\x39\xf9\x9f\xda\xf5\xf1\x4f\xb2\x24\x6e\xba\x8d\xa3\x05\xfd\xbe\x71\xd2\x3f\x55\xff\x0c\x20\xa1\x9d\x75\x7a\xe3\x7d\x92\x5a\xbf\xb6\x62\xe5\x5a\x6f\x1e\xd8\x9c\xbd\x57\x93\x28\x7e\x7a\x8e\x64\xae\x8b\xa8\x7b\x83\x54\x0e\x43\x6b\x4d\x19\xc1\x47\x97\xf6\xc5\xa2\x27\x13\x79\xa3\x1a\x6a\x19\x04\xa1\x80\x43\x9b\x6d\x5e\x4b\xd3\xd2\x6a\xf0\x24\xf9\x54\x79\x43\x90\xae\x1d\x2d\xf6\xef\xff\xba\x06\xf3\x66\x2f\x07\xad\x3b\x70\xfd\xc1\x1d\x98\x88\x56\x03\x12\x06\x31\x61\xd6\x85\xaa\x27\xc8\x88\xf0\x79\xd2\x3f\x11\x52\x52\x18\xdb\xdf\x60\x98\x23\x9e\xcd\xd3\x16\x28\xb8\xba\xa8\x65\x83\xaa\xdc\x08\x55\x81\x3d\x6b\x69\xc6\x1f\xc0\xb0\xfa\xa7\xcd\x0c\x5b\xc8\xe2\x97\xd0\x69\xec\x7b\x2a\xbe\x58\x0a\xc3\x47\x17\x58\xb9\xff\xa2\x41\x5f\xde\x01\x81\xe6\x5e\x1c\x03\x96\x01\x95\xda\xed\x6e\x94\x9e\xf1\x59\xf7\x46\xb8\x8f\x89\xef\x8b\xdf\x9f\xf4\x6b\x77\x56\x42\xf7\x27\xf0\x81\x98\xf4\xa7\x08\x94\x2f\xeb\x81\x40\x8c\xba\xa0\x81\x73\xfc\x74\x8c\xec\x24\xc8\x55\x49\xbb\x10\xab\xbf\x1f\x5b\xe8\x05\xfa\xf8\x4a\xb2\x1d\x50\xeb\x31\xc1\xb0\x52\x65\x13\x86\x91\x7c\xb5\x5d\x12\x47\x4e\x02\x60\xac\xb3\x78\x8e\x9f\x5d\x0c\x66\xc9\xd2\x52\x59\x74\xe5\x3a\xed\xc8\x79\x31\x71\xdb\x90\x15\xf4\x43\x79\x69\x64\xce\x93\x09\xf4\x81\xd8\xb9\xb4\x3e\xae\x41\xab\x0c\x82\x4b\x01\x50\x94\xab\x93\x93\xc9\xf0\x6a\xe4\x3d\x01\x27\xe0\x6c\x79\xd4\x79\x88\x8d\x66\xfe\x83\xb7\xed\x5d\xf1\xf2\xcc\xd9\x1b\x1e\x1e\xc2\x32\x0a\x1d\x0f\x29\x45\xfa\x71\x83\x79\x46\x67\x75\x89\xef\xa5\x3c\xba\x8a\x39\xff\x55\x0f\xdf\xc9\x89\xfb\xad\xbf\xb7\x12\xdc\x55\xb3\x0c\x58\x7a\xf3\x1a\x09\xf3\xef\x55\xcd\xa1\xa3\x04\xcc\x46\x7d\x69\x30\x2a\x5a\x89\x0e\x83\xf0\xe2\x87\x98\x86\x55\x83\x04\x50\x63\x51\x43\xa7\xed\x91\xde\x05\xb6\x8a\x69\xec\x06\x63\xcf\x06\x12\x66\x43\x43\x0b\x89\x5d\xfa\xe3\xd9\xbb\x8e\xe7\xa1\x1b\xf8\xe7\x36\xfd\x78\x2e\xcd\x3c\x4b\x70\x60\x38\xd5\x82\x87\x38\xd2\x19\xc3\xeb\x7b\xcb\x3e\xbd\xdf\x0b\x4e\x16\x47\x6a\x65\x6e\x57\xc8\xc6\xe5\x8a\xe9\xac\xa3\xd9\xfb\x52\xb7\x1c\x1e\x92\xde\xa5\x1f\xcf\xa1\xf7\xe1\xfd\xd4\x7e\x4e\x73\x55\x1b\xbf\x94\xba\x04\xa3\x6d\x17\xfb\x98\xd8\x80\x5c\x2f\xf6\xec\xd0\x62\xbf\xcf\x7a\xc5\xed\x1a\x3b\x46\x37\x6c\xdc\xa3\x86\x5e\xab\xc2\xdf\x34\x56\x20\xd9\x70\x82\x76\x53\xe1\xb7\xd7\xd7\x55\x39\x43\x32\x8b\xb6\x9a\x3b\x54\xc6\x27\x8c\x60\x32\xfd\x6b\x93\x10\xd0\xb1\x06\x0c\x1a\xac\x3f\x45\x87\x61\x3a\xc1\xb0\xc1\x50\x3f\xe1\x3f\x24\x0d\x75\x3a\xf5\xe1\x9e\x58\x2e\x44\x2c\x65\xfa\x75\xb8\xff\xe8\x36\xc7\x7a\x35\xeb\x8e\xcd\x3c\xcd\x75\xc5\x1f\xd4\xfb\xa9\x32\x8e\xd3\xec\xa1\x15\xee\x29\x25\xce\xd4\x5e\x3f\x3b\xb1\x73\x1f\xa6\x69\x5b\x6e\xb6\x66\xde\xe0\xb2\xec\x5f\x07\xf3\xa8\x32\xb7\x62\xcd\x98\x1e\xb6\x9a\x18\xa8\xb1\x3c\x64\x75\xd8\xf3\x43\x0e\x00\xce\x01\x7f\x72\x32\xf3\x33\x37\xd3\xb8\x0b\x12\x28\x71\x9a\x2c\x55\x8b\x47\x3f\x63\x63\x68\xd7\x0a\xba\x21\xd1\xa5\xe9\x2c\x88\x69\xe0\xe8\x30\xac\x5a\x8b\x2d\xcb\x8e\x44\x2d\x15\x31\xb5\x2f\x05\x5a\xfa\xbc\x3f\x65\x34\xcc\x6e\x3c\x4e\xe1\x55\x1f\x88\xad\x08\xfc\x55\x56\x09\x89\xd4\x31\xbc\x81\xab\x11\x2c\x39\x9e\xc0\x33\x58\x74\x2a\x89\x4e\xd3\x81\x58\x33\x1c\xff\x3a\x3e\x5b\x3f\xd2\x09\x8d\x66\x36\xa1\x11\xb1\x5e\x5c\xa1\xc5\x89\xe9\x97\x96\xc3\xd3\x28\x6b\xf7\x98\xf5\x64\xe6\x46\xbb\xdc\xdb\x89\x9b\x3e\xcd\xdb\x8b\xf3\xc7\xec\x1b\xc6\x99\x78\x0a\x3f\xcb\x09\x2b\x14\x57\x9b\x24\xca\xe6\xdb\xbf\x55\xef\x8f\x72\xd1\x7f\x1c\x15\x08\x75\x9d\x63\xd0\x8e\x8a\xed\x7a\x8e\x47\xc1\xce\x3a\xe2\x25\xf5\x3d\xc9\x1e\xd0\x23\x6f\x33\x14\x60\x20\x94\xaa\xd4\x05\x98\xab\xc1\x6d\x99\xdb\xa3\xed\xec\xba\x7a\xb5\xcd\xae\x57\x47\x6f\xe9\x6c\x03\xb6\x5f\x31\x8d\x0c\x2b\x84\x8c\x28\x44\xd4\x44\xe7\x0d\xf9\xb4\x7a\xaf\x7f\xeb\xe6\x15\x53\x2c\x24\xfa\xe7\x39\x4d\xed\x11\x3d\xc6\x7f\xf8\x5d\xab\xa2\x16\x8b\xed\x29\xf4\x0c\x72\x04\x7f\x98\xf7\x05\xff\x32\x50\x77\x3d\x53\xf9\xc0\xfd\xa4\xb1\xd2\x5f\x41\x42\x93\xbd\x62\x85\x4f\xd8\x2e\x59\x9b\x47\xf2\x87\x86\x6d\x3e\xa3\x61\xf9\x49\xff\xfd\xf9\x68\x39\x1e\x93\x98\xfa\x93\xfe\xfb\xf3\x11\x6d\xb8\xea\x27\xfe\xf7\xe7\xa3\x4d\xb1\xae\xaa\xc5\x4f\xfa\xef\xcf\x47\xdb\xa5\xd6\xd2\x7c\xb8\x4b\xbe\x2d\x32\xd7\xfb\xa3\x5f\xeb\x27\x7f\xca\x60\x46\x41\x37\xc6\x2d\x63\x54\x4e\xb3\xdf\x1a\x8c\x08\x5b\x50\x9a\x49\xa2\x8b\x5e\xbe\x2c\xdf\x2b\x5d\xa7\xab\xac\xdb\xe1\x60\x61\xea\xc0\x72\x3e\x87\x3a\x95\xe1\xaf\xaa\xe0\xc6\x79\x7c\x2a\xa5\xe4\x1d\xaf\x94\x7f\x83\xd3\x39\xf1\xb0\xd8\xda\x7f\x0e\x6a\x7f\xbd\x5c\x05\x95\xf3\x75\xad\x6e\x57\xc6\xbb\x3e\xe7\xec\x2d\x3c\xd5\xbb\x9d\xdd\xb9\x63\xe2\xdd\xcc\x02\xb8\x38\x41\x6e\xb9\x27\xf4\xef\xa7\xc9\x67\xf4\xef\x93\xe4\x5c\xa6\x9b\x16\x64\xdd\xed\x28\xf3\x78\x6f\x8b\x88\xe9\x47\xca\x68\x8a\x02\xe4\x3a\xa3\x74\x37\xeb\x1a\xae\x3a\x13\xe3\xfb\xe3\xdd\x4c\x27\xe9\xbf\x8c\x82\x44\x6c\xa8\xde\x3a\xfb\x67\xf8\xc4\xed\x0b\xf8\xfa\xa6\xec\x02\xba\xda\x98\xc0\x42\xfa\x69\x9c\x45\xf4\x93\x38\x71\x8f\xe0\x54\xed\xc9\x0a\x63\x1c\xaf\x35\xcf\x8f\x9c\xb5\xf7\x25\x60\x13\x32\x38\x26\x8d\xe9\x1f\x6b\x01\x74\x0c\xbb\xf9\x99\x12\xd7\xf3\xa9\x60\x2a\xcb\x7a\xf2\xe8\xb6\x2d\x63\x1f\xfa\x80\x4c\x13\x1d\x65\x35\x98\xd8\xa0\x47\x35\x8e\x93\x6c\xaf\xf4\x51\x98\xdc\xc3\xdb\x10\x69\x00\x84\x41\xe7\xc4\x4e\x02\x6c\x7e\xdf\x10\x13\x03\xa3\x09\x51\xf5\x5f\x81\xf8\x2c\xc3\x8c\x37\x74\xc4\xf9\x58\x50\xcd\x39\x47\xb9\x33\x32\x7a\x3a\x88\xc8\x68\x7c\xf7\x0a\xca\xd9\x0f\x7d\x28\xf5\x3f\x84\x17\xf4\x77\xf0\xf3\xc3\x9f\x59\xde\x6e\x23\xd8\x80\xe8\x20\x7a\xe0\x43\x91\xb1\x1d\xc0\x04\xc1\xb5\x0b\xbc\x96\x38\xc5\xe0\x65\xb0\xac\x06\x59\x47\x33\x78\x5a\xe9\x6f\x02\xed\x51\xaa\xd6\x1e\xc3\x1a\xb7\x87\xf6\xd9\xea\xcc\xd4\xa9\x28\x8b\x20\x9f\xe7\x15\x9d\x93\x95\xe4\x6f\x27\x0a\xe8\xb1\x05\xa1\x4f\xb9\x8b\xbb\x17\xf6\x00\xda\x37\x30\x36\xb3\x45\x36\xd7\x59\xe1\x3b\xb5\x3b\x3d\xf9\x3a\xab\xe8\xed\x7b\x31\x92\x69\x6c\x66\xd7\xb7\xf3\x20\x50\x43\x6b\xc6\x5c\xf8\x9f\xd6\x64\x7a\xab\x1b\x66\x4f\xd6\x01\x64\x6a\xb6\x79\xa5\x6b\x60\xc0\xe7\xe0\xab\xb4\x8d\xf6\x74\xca\x0e\x6a\xfc\x39\x1d\xd0\x3a\xfb\x62\xd2\xd0\x0b\x6b\x75\x02\xdc\xe9\x5b\xa5\x10\x8e\x68\xaf\x31\x5c\x7b\xf1\x8f\xb5\x0a\x97\x86\xfb\x68\xab\xaf\x30\x46\xad\xcd\x85\x18\x9d\xa7\xc9\x44\x9d\xcd\xda\x82\x15\x1a\x60\x56\x48\xe1\x41\x87\x83\x02\xb6\x0e\x88\x21\x18\x10\x03\xc3\xc0\xb2\x96\x26\x65\x7c\xa3\xd9\xd5\xd4\x22\x36\xd9\x5b\x1e\x81\x6d\x3e\x94\xee\xb8\x49\x06\x7b\x3a\xf8\x77\xf2\x48\x93\x28\xf9\x22\x30\x33\x02\xb7\x44\x98\xea\xe5\xb9\x61\x1f\x52\xe9\x80\xb9\x84\x2e\x6b\x41\x82\x99\x30\xc2\x62\x2b\x76\x34\x1a\xba\xd5\x38\x50\x91\x88\x17\x91\xbe\xf2\x9d\x4c\x9b\x3d\x4c\x1e\xa9\x36\x39\x83\x6f\x3f\x20\x2d\xd0\xf3\x70\x01\x34\xe3\x80\x9a\x03\xdf\x3f\x34\xca\xff\x96\x28\x8e\xb0\xc6\xe6\x1d\xf8\x0d\xd4\x98\xfa\xdf\xf3\xd9\x66\x2f\xcc\x87\x6b\x95\xb6\xdc\x32\x9f\x6e\x1b\x92\xdf\xd3\x86\x07\x86\xd4\x6f\x4c\x5b\xb1\x87\x9e\xe9\xf8\xbc\x96\x56\xef\x4d\x0c\xd0\x3d\x1f\xb8\x18\xef\x75\x12\xf1\x6f\xda\x74\xeb\x48\xf8\xbd\x79\x95\xbd\xad\xcc\x6d\xa2\xab\x4a\x1b\xfc\x74\x71\x7d\x25\x2f\xe8\x0b\xfd\x8a\x79\xc4\x94\xbe\x1e\xce\x5c\x93\xb3\x47\xe9\x7d\x70\x48\xe4\xca\x68\x6a\xe8\xa7\xf0\xee\x8d\xb8\x1d\x18\xfc\x79\x8f\x08\xc5\xf4\x98\x6f\x06\xce\xb5\xa2\xa7\x3e\xc1\x39\xcd\x6e\x25\xfe\xef\xbe\xe5\xda\x00\x39\x67\x5a\x53\x64\x65\x50\xdf\x78\xd7\x1e\x3e\xa6\xf4\x3b\x70\xfe\x61\xa7\xef\xba\x1d\x15\xbb\x53\x86\x58\xce\x6e\x7b\xc4\xca\x09\xeb\x1f\x85\x6d\x1e\x24\x7e\x8f\xed\x90\x69\x6a\x0e\xe8\x2d\x73\x3e\x85\x7a\x11\xf6\x93\xea\xd7\x87\x38\xa7\x21\x66\x93\x51\x7d\x4d\x6a\x5f\xe1\x1a\x2f\xac\x07\xd6\x7a\xd2\x94\xec\x17\x0d\xa8\xe1\x86\x1d\x09\x4e\x36\x08\x1b\xf0\xcb\x2a\xc0\x36\x9f\xc7\x5d\xd0\x69\xa3\x8e\xff\xcf\x3f\x7c\x7a\xd1\xaf\x06\x41\xf5\x15\x10\xea\x5a\x8f\x07\xd7\x1a\xad\x64\x47\x05\xf1\xbe\xe1\xb7\x13\x24\xed\x68\xd8\x9a\xc2\xd0\x0b\x07\xd5\xd4\x70\x09\xc9\x59\xa2\x28\x76\x3b\x84\x45\x68\xaf\x10\x07\xd6\x9f\x89\x8f\x33\x7d\x62\xc2\x9f\xc8\xe0\x12\x52\x85\x80\x44\x70\x4e\x17\x9d\xaf\x48\x2b\x70\xd2\x26\x61\x1c\x48\x63\xb6\xc6\x44\x3f\x80\x71\xa5\xe1\xfa\x8d\xd2\xb0\x34\x9b\xb2\xfa\xd2\x6b\x10\x78\x65\xd6\x39\x95\xe9\x23\xeb\x11\x7f\x5c\x06\xd8\x54\x5e\xcc\x44\xc5\xc6\xeb\x92\x5e\x6a\xe3\x8f\x3a\x12\x2a\x04\x47\xfc\xf6\x5d\x81\x14\x15\x6c\x1f\x1c\x1b\xbb\xe1\xb8\x66\xe2\x36\xd1\x11\x0d\x37\x21\x59\xb2\x70\x85\xd1\x4a\xb0\x92\x06\x4d\x7c\x03\x97\x8b\x36\x16\xc8\xf7\x16\xf2\x26\x12\xcb\x8e\x1a\x79\x28\x9c\x00\xb3\x7b\xe0\x58\xb1\x54\xc3\x26\x64\xf6\x49\x09\x90\x4f\x6a\xca\x3f\x19\x8d\xd2\xb3\x13\x94\x96\x82\x74\xa3\x5e\xd4\xf5\x1e\x25\xee\x91\x87\xb4\x46\x3f\x8d\x76\x4b\x89\x22\xa7\x7d\xed\x31\x62\xb5\xbf\xaa\xe8\xbb\x15\xdc\x25\x49\x88\x6a\xc3\xb8\xe2\x4c\xf1\xd0\xf4\xb6\x00\xe2\xe6\x92\x9f\xc2\x5b\x23\x1c\x49\xc8\x1a\xb3\x22\x7d\xf4\x81\x09\x0a\xdc\x29\xed\x0c\x35\xb8\xf8\x06\xba\xcc\xa1\xfa\x0c\xdf\x89\x59\x62\xad\x91\x57\x9d\x0e\x56\x3b\x18\x6b\xe1\x63\x0a\x36\x18\x59\x59\x0f\x44\x0e\x0c\xeb\xaf\xbd\xa8\xb2\x2c\x3d\x7b\xda\x19\x1c\xc3\x9b\x66\x97\xc3\x79\x65\xbe\xab\xae\x73\x62\xe1\xa6\xeb\xdd\xec\x7a\xb2\x63\x19\x62\x37\x9f\x2d\xae\x76\x50\xef\xec\x48\x78\xcb\xae\xe3\x0e\x00\xe0\x92\x51\x57\xf0\xe0\xe2\x37\x67\xcf\xce\x26\x33\x95\x73\x65\xfa\xc9\x99\x2a\x70\xb9\x3b\xf9\xe3\xe0\xcd\x5d\xb7\x7f\xa6\x4a\xf9\x54\x42\x72\xfb\x6c\xb5\xdd\x6d\xb6\xef\xe7\x15\x57\x1c\x9f\xcd\x54\x45\x0f\xb5\xdf\x0f\x00\xe7\x06\xc9\xf0\x97\x74\xb4\x4b\xe9\xb7\x71\x07\xea\xa1\xd8\x98\x8a\xfd\xf2\x68\xf7\xe6\x8c\x4a\x5c\x66\x6f\xb3\x5d\x55\x5c\x67\xb1\xd4\x48\x8f\x27\x78\x0c\x9f\x79\x2a\xd0\x7b\x4c\x4d\x98\xe2\x06\x55\xf2\xf4\x18\x2e\x35\xc3\xe7\x5f\x7e\xfe\xfa\xf3\x37\xc3\x1d\x49\xb7\x3b\xdc\x18\xbd\x19\xe1\xf7\x33\x2a\xf1\xe8\x6c\xa2\x66\x59\x7a\x2f\xa9\xa1\x92\xe1\x85\x8a\x9e\xca\xba\x3c\xa2\x63\x66\x3b\x5b\xcd\xab\xf4\x13\xf3\xeb\x13\x40\xc3\x3e\x3d\x93\xe7\xcf\x22\x60\x11\x56\x24\x09\xf1\x4b\x0c\x82\x2b\xcf\xf5\xcf\x91\xa2\x51\x4d\x86\x4f\xec\xc3\xa7\x74\x3d\x21\x76\x60\x25\xc5\xec\x95\xf7\xc6\x76\x1d\xbc\xb0\x85\xde\x45\x57\xca\x3f\xfd\xa2\xf4\xe1\x4f\xeb\x45\x9f\x6e\xd7\xba\xf8\xfa\x59\xcb\x3b\x56\xee\x1b\x9e\x23\x27\x60\x14\x8d\xf6\xfd\x19\x49\x62\xab\x2d\xb7\x24\x95\xdf\x34\x10\x34\x26\x3d\x7e\x1b\xb7\xb6\xe3\xe5\x72\x8b\x1f\xa6\xc5\xfc\x3b\xe3\x82\xfc\x1c\xa3\xc0\x6f\x4c\xf9\xb2\x74\xae\x4b\x97\x59\xa8\x83\xf3\x64\x4b\x15\x71\xb3\xa2\x38\x90\x60\x9b\x18\x44\xb9\x8f\x4b\x13\x6d\xd7\x51\x2c\x59\xcf\xb5\x7a\x6a\xf3\xc5\xfb\xd7\xd9\x84\xdf\x8d\xb8\xc5\x11\x10\xa1\xd9\x07\xc4\xf3\x49\xab\x79\xe7\xd5\xdd\xe4\xf4\x8b\x50\x40\xd8\xa6\x5f\x85\xa9\x3e\x98\xcf\xe9\x88\x36\xed\x50\xca\xa8\x6e\x74\x16\x75\xb5\xd4\xe4\xd5\x34\xcf\x5c\xa4\x35\x12\xc5\x30\x56\xa1\x28\x9e\xad\x75\x6b\x60\x38\xa9\xe1\xc5\x28\x31\x72\x5f\xe3\x0b\x7e\xad\xd7\x59\x1d\x76\xed\x5c\x95\x2e\xe5\x48\xa9\x95\xd8\xe2\xd1\x0f\x6d\x8e\x8a\xc4\xe5\xe4\xab\xb7\xd9\x3c\x52\x80\x45\x14\xab\x50\x5e\x7f\x16\x7b\xa0\xf9\x8b\xac\x45\x8f\x2f\x8e\x28\xfd\x46\x46\x16\x56\x91\x85\x0e\x29\x74\x8e\x3a\x67\x64\x38\x63\x48\x7b\x00\x67\x00\xf4\x18\xe7\x9c\x62\x02\x8e\x8c\x8f\xc0\xc4\xf9\x7c\xf5\x2d\xe1\xbf\xd4\x98\x68\xe8\xe9\x25\xf2\x13\xd4\x3a\xeb\x1f\xa0\x00\x47\x47\x19\x00\x20\xee\x5f\x86\x8d\x9a\xa6\x2f\xbd\x46\xcd\x52\x1f\xf9\x66\x1a\xab\x97\xba\x8d\x33\xf0\x4d\x76\x28\x96\x41\xfe\x80\xf6\x35\x78\x68\x69\x4a\xf6\x11\x5a\x5f\x3d\x86\x32\x33\x90\x6b\x9f\xcf\xe7\x83\xe6\x2d\x5b\x7a\xd8\x12\x35\xc7\xe1\x6f\xc1\x3e\xca\x11\xec\xa3\x61\x94\x32\x0e\x0d\xf5\xd2\xbe\xac\x6a\x49\x0f\x0e\xe4\x64\x73\x29\xd4\x88\x09\x7b\x6d\xd2\xbc\xf1\x12\x65\x7d\xb8\xf8\x58\xda\x5c\x7a\x49\xc7\x7b\x41\x27\x4a\xc3\x51\xc2\xd7\x62\xed\xf5\x7d\x2e\xd3\x10\xdc\x39\xf6\xa2\x8b\xd8\x65\xf3\x10\x9b\xa2\xcd\x9a\x59\xe8\xd8\xc9\xf3\xf5\x80\xdf\x2d\x47\x7a\x76\xea\x0e\xa2\xbb\x5d\x88\x97\xa6\xe1\xce\xfc\x70\x58\x87\xab\x8c\x98\x52\x5e\x6a\x93\x94\x66\x7d\x0a\x37\x6a\xcc\x7e\xac\x81\xfe\xc6\xf5\xdc\x3b\x34\xca\x08\x91\x54\x13\x84\xd1\x30\x8a\x31\xc3\xf2\x71\x15\x63\x28\x9b\xe5\xed\x09\x72\x95\x48\x85\x07\x2a\x5a\x04\x15\x31\xa7\xca\x3b\x70\xea\xf2\xe9\x70\x8b\x54\x24\x87\x1f\xfc\x9b\xbc\xec\x08\x44\x13\x26\x0a\x39\x8d\x79\xad\xda\x32\xb1\x02\x3e\xc5\x2d\x11\x42\xe3\x55\xdc\xc2\x49\x1a\x3a\x12\xa6\x17\xcb\x0f\xbb\x25\xcf\xd9\x43\x8f\xfa\xb1\x74\x54\x67\xf9\xec\xba\x7f\x2d\x68\x4e\x15\xb2\x50\x8c\x60\xae\xe7\x1c\xd0\x71\x6b\x2c\x77\x85\x28\x54\x59\xbb\x73\x55\x79\xb9\x79\xaa\x51\x52\xc5\x96\x55\x2f\x32\xa3\x06\xa7\x76\x62\x3c\xaf\x02\xea\x9e\x1f\x70\x88\x9e\xa4\x9d\x5c\xd3\xdb\x4a\x7c\xdd\x70\xe4\xc5\xcd\x6c\xfa\x38\xb7\x48\x32\xd9\xed\xe8\xf8\x32\x67\x24\x71\xf7\xce\x0f\x19\x2e\x6f\x5e\x42\xee\x8c\x06\xf7\xe9\xa3\x0b\x3a\x5a\x1f\x3d\x79\x16\xc5\x5d\x78\xa8\x11\x39\x43\xb6\x29\xcf\x83\x6e\x8c\xf9\x35\x4e\xc8\x7d\xd7\xcf\xb1\x8f\x74\x46\x4b\xeb\xca\x3f\xe1\xc6\x7e\x36\xd6\x34\x8a\xc4\x03\x6b\xae\x21\x7f\x74\x47\x01\x03\xce\xdb\x81\x06\xa4\x7f\x55\x7b\x43\xb9\xec\x1c\x55\x3a\xb7\x99\x40\x38\x34\xe7\xf4\x82\xc7\xde\x60\x2e\x71\xd2\x09\x76\x13\xf4\x51\x96\x6b\x3b\xaa\xd2\xcb\x3f\x1c\xf3\x2a\xf6\xd6\xe0\x8c\x97\xde\x18\xce\x15\xc8\x51\xe4\x3e\x3f\x1e\x5e\xe2\xf3\x63\x33\x7f\x26\xb9\x63\x14\x5b\xe4\xcf\xca\x59\x9e\x25\x26\x62\xd1\x88\x6d\xf2\x93\x02\x89\xd1\xab\x26\xdc\xd3\x4c\x9f\xf7\xad\xda\x19\x16\x2e\x24\x1c\x66\x5c\x31\x01\x28\xf7\x1c\x3d\x98\x3e\x55\x69\x31\x7c\x61\xb5\x84\x1c\xcb\x93\xd3\xd1\x64\x62\xa0\x75\x7e\x85\xdc\x1c\x4f\x2e\x14\xda\xde\xa1\x0d\x3a\xa8\x89\x03\x9c\xe2\x27\xf4\xac\x43\x7b\x73\xe3\x59\xd7\x77\x1f\xb0\xd1\xad\xee\xd6\x5e\xdf\x79\x69\xe2\xc2\x87\x2f\xfd\x48\xd7\xba\xf8\xde\xc8\x88\xa9\x07\xb1\x1e\x5f\xe7\x9e\x38\xdd\xec\x40\x20\xe5\xb9\xa4\x56\xbf\x4a\xae\xd0\xb8\x21\xa1\xf0\x09\xcf\x25\x1c\x9d\xbc\x68\xb9\xf7\xe7\xfa\xad\xd8\x40\xed\xfa\x8b\x33\x73\x51\x6e\x59\x23\xe2\x07\x60\x9a\xbc\xc0\x0e\xd8\x5b\x7a\xe5\xf2\xfa\x65\xb6\x98\xad\x5a\x81\xcb\x78\xc2\xfe\xe3\xc6\x6a\xee\x8c\xd8\x55\xed\xda\xd0\x0f\x63\x1a\x32\xc4\x9f\x30\x32\xe3\xff\x43\x0d\xa4\xcd\x5a\xad\xb7\x5f\xb0\x51\x06\x74\x3c\x40\x62\x44\x73\xc5\x5e\xf3\x1f\xb6\x56\x0c\x87\x1e\x0e\x74\xed\x46\xfd\xf3\x56\x6e\xcd\xc6\xdb\x83\x36\xb3\xff\x8d\x8f\x06\x28\xc3\xfb\x43\x11\xfa\x3e\x58\x6f\x36\x58\x38\xb3\xa3\xdb\x04\x80\x28\xec\xeb\x1c\x4b\x05\x3b\x77\xc4\x9c\x17\x2b\x17\xde\xa1\x08\x58\x05\x4b\xa9\x3a\xcb\x8c\xc3\x17\x8b\x10\x34\x9b\xb9\x34\x4b\x53\x8b\x1a\x4d\x05\x11\xba\x96\x57\xfd\x63\xda\xaf\x43\xd3\x11\x13\x53\x13\x2a\x38\x9a\x98\x78\x16\xdb\x98\x9d\xa6\x74\x2f\x44\xdd\x0e\xbf\x49\xc6\x2c\xaa\x43\x30\x77\x6a\xdd\xc8\xc4\x1d\x3e\xab\x1d\x28\xb5\x4f\x37\x59\x36\x2f\x68\xca\x40\xdd\x1e\x5f\x24\x99\x06\x4d\x41\xb0\x5e\x96\x88\x62\x83\x21\x0c\x9a\x4b\x63\x21\x1c\x5e\x18\x0c\x3b\xdd\x5e\xb7\xa2\xae\xb6\x50\x38\xd9\x1c\x5a\x1b\xc2\xde\xa0\x22\x23\x78\x41\x6f\x61\x64\x76\x23\x67\xb7\xf5\x32\xb4\x67\x7e\x3b\x58\x3d\x72\x15\x7a\x99\x71\x8e\x89\x6f\xb0\x3c\x46\xf6\x10\x8f\x31\x82\xff\x5e\x76\x88\x83\x60\x30\x12\xf6\x66\x32\xa2\x8c\xee\x4e\x21\xdd\xb9\xa8\xe5\x50\xaa\xcf\x5c\x2e\x33\xe7\x87\x4e\x81\x44\xa4\xe7\x5e\xd8\xff\x3e\xd7\xdb\xc9\xd0\x7a\x21\x70\x1c\xad\x7f\x98\x24\xeb\x06\x87\xe0\x85\x0d\x3c\x3b\x4f\x09\xf5\xc1\x6d\x9e\x63\x24\x6a\xfb\x5a\xd5\xfa\xc3\x9b\x52\x03\x98\xe9\x16\x68\x56\xcf\xd0\x19\x3c\xeb\x18\xbe\x93\xbd\xf1\xcc\x54\x7a\x91\xa1\xfa\x60\xe6\x88\x4d\xe4\x16\x3a\x18\x68\x69\xfd\xd1\x39\xc4\xda\xb4\xbe\xb6\xc8\xb3\xb4\xd2\x0a\x5f\xc0\xd5\x8a\x22\x0d\x07\xbc\xe5\x97\x11\x9f\x12\x04\x5a\x5e\x8b\x7d\x66\x99\xce\x4f\x2f\xd4\x8a\x93\x1b\xa8\x9b\x10\xc0\x6f\xc5\xf2\xc2\xcd\x6e\x37\x07\xbe\x6c\x63\xc1\xad\x68\x8d\xf9\xd1\x74\x27\x27\x95\x5e\x7e\xab\x38\x3e\xac\x5a\xb4\x98\xa4\xd7\xbd\xea\x06\x88\xa4\x37\x18\x2d\x78\x6f\xae\x3c\x0f\xbe\x02\x9a\x57\xda\x65\x70\xff\xa3\x9f\x6e\xd2\x78\x07\xa2\x5d\x73\x56\x87\x2e\x7a\x81\xf0\xa0\x89\x26\x90\xb7\x43\xaa\x76\xac\x61\xfb\xd9\x8d\xc8\xe3\x69\x05\x7f\xdc\x31\xbd\x2e\x6e\xa1\x80\xcf\xb7\x71\xb7\x1e\x6b\x24\xdf\x90\x2a\xaa\x2b\x96\x9c\xac\xa8\x34\x7f\x76\xd9\x27\xa6\x32\x9e\x02\xf7\x94\xc8\xf2\x92\xe5\x79\x43\x41\x90\xa9\x91\xcd\x1f\x13\xd0\x5f\xe1\xb8\xc7\x2a\x14\x99\x78\xa3\xd8\x51\x40\xf4\xc2\x54\x5d\xc6\x92\xaf\x56\xdc\xbe\xc7\xc3\xb1\xcb\x3c\x51\xeb\xa4\xb4\x71\xac\xe6\x19\x34\x18\xe7\xfd\x89\x6d\x0f\x52\x64\x2a\xc3\xea\x4e\x7d\x56\xf7\xd8\xea\x40\xa6\xa1\xa6\x25\x38\x24\x66\x24\xe6\xa1\x33\xbd\xcd\x1a\x9a\xdc\x5f\x2b\x2a\xf2\xe3\x7a\x8e\x32\xe6\xb7\x3c\x04\x97\xe9\x6a\xc1\xa7\x1c\xbd\xb6\x14\x66\x9a\x21\xa3\x53\x0d\x16\x56\xc2\xfe\xd9\x20\x27\xbb\xff\xf5\x32\x89\xe4\x57\x64\xb8\x1b\xdc\xd2\x3f\x23\xe5\x9f\xb7\x49\x24\x0c\x85\xb9\xfb\x39\x1f\xf4\x11\x9f\xf7\x91\x21\x14\x80\xca\x8e\x3c\xa2\xd1\x62\xfa\xac\x21\x39\x67\xe1\xe1\xcc\x99\x0c\x16\x22\x2e\x57\x76\x16\x90\xa2\x96\x86\x3a\x15\x14\xad\x22\x9d\x72\xce\x51\xb7\xd3\x65\xf6\x31\xf1\x8b\x4e\x85\x4c\xb5\x74\xe8\x21\x12\x75\xec\xdc\xff\x05\xbb\x3d\x38\xcc\x3c\x7c\xe6\xd2\x46\x18\xdf\x64\x6a\x9d\x05\xd0\xcc\x9b\xac\x13\x80\x31\xd1\xfe\xaa\x49\x9c\x79\x6c\xc8\xe9\xeb\x65\x47\xdc\xe5\x62\x36\xc2\xd2\x37\xb5\x71\xe5\xf9\xf2\x7a\x75\xbb\xad\xca\x57\x50\x80\x33\x24\xc7\xc1\xa7\x9c\x6c\x3b\x8e\x07\x65\x4f\x07\x1b\x27\x12\x7d\x8c\xdb\x5e\x00\x72\xdf\x61\x92\x32\x75\x43\xb8\x77\x3d\x55\xb1\x9c\x8c\x40\x62\x5e\x67\x34\xea\xd6\x52\xc0\x79\xb1\x25\x8b\x74\xac\x83\x9c\x05\x95\x02\x4f\x6e\xb2\x94\xfe\x23\x2e\xa7\x13\x3d\x9d\x8d\xd7\xd9\x75\x75\xc4\xff\xe6\xcb\x75\x59\xad\xd3\x4f\xce\x3f\x39\xe2\x0c\x67\xfc\x4b\x52\x9e\xe1\xe7\x19\x1d\x64\xde\x30\xe4\x75\x4f\x42\x38\x9c\xdd\x70\xea\xd6\x1a\x0e\x38\x6d\xc7\xbb\xf5\x6c\x0b\x49\x9c\x83\x78\x35\x64\x8e\x69\xde\x4d\x66\x3b\x18\x2b\xee\x06\x20\xbc\x8b\x3d\xa7\xb7\x82\xa6\xff\x9a\x4e\x99\xd9\xe2\x4c\xbd\x15\x0f\x37\x13\xa3\xf2\x4b\x27\xea\xfe\xa3\x1b\xc5\x9d\xc1\xf1\xea\x5d\x3c\xcc\x4e\x7f\xfb\xaf\x51\xf7\x11\x9d\xcf\x33\xa2\x2a\x77\x59\x5b\xbc\x68\x2d\x49\x8b\x1f\x8d\xd1\x5b\xae\x60\x5f\xad\xe7\x71\x09\x8a\xd0\x7c\x86\x13\x99\x2b\x81\x8d\xcb\x0e\x3e\xf2\x96\xd9\xbb\xec\x90\xfe\x8b\x8d\x26\x76\xee\xa0\x72\xbb\x63\x85\x12\x10\x37\x26\x29\xaf\x6c\x83\xd1\xc6\x1a\xb6\x0e\x72\x23\x16\x1c\x2f\x83\x22\x11\xe6\x76\xc2\x5c\xeb\x61\xb5\x19\x47\xb3\x2c\xe4\x53\x92\xde\x80\xc6\x53\xbb\xb5\x13\x59\xba\xcd\x4c\x12\x2d\x5e\xbb\xd3\x1e\xaf\x00\xda\x0c\xd3\xde\xf5\x6c\xf1\x2f\xbe\x00\x32\xf5\x75\xf6\x4e\x2e\xdc\x7d\xef\xae\x79\x2f\x9d\x28\xb4\xfb\x4e\x97\x94\x7b\xa5\xff\x4e\xa5\xbc\xb7\x00\x96\x61\xc5\xfb\xc9\x60\xd2\x8d\xa2\x64\xd2\xcc\xec\xaa\xe1\xe7\x5a\x41\xe9\x8e\x32\x93\x6b\xce\xc7\x95\x42\x51\x9b\xd8\x21\xcd\xe3\x03\x06\xdd\xfd\xbe\x1e\xb0\xcf\xaa\x88\x74\xde\xe2\x2c\xdb\x1e\x9d\x4f\x63\xd3\xfe\x80\x61\x6e\x64\xd4\x91\x7a\x83\x7f\xf4\x80\xd2\x01\x4b\x0b\x89\x9f\xf3\xd9\x2a\x8d\xf4\x7e\x39\x85\x23\x20\xd4\x47\x41\x9c\x7b\xfb\x2b\x08\x91\x67\x84\x09\x66\x1b\x78\xc9\x85\xf5\x30\xfa\x50\xdb\xbb\xaa\xd2\xb7\x89\xe4\x40\xd1\x94\x46\xb2\xef\x93\xf3\x3e\xcf\x13\xfd\x95\x3d\x4f\x3f\xb6\xcb\x15\xfd\x3b\xaf\xc6\xdb\xe4\xf4\xcf\xf4\xbf\xd5\xbb\xbe\x6c\xc6\x53\x3c\xb9\xa0\xcb\x95\x4e\xd1\x98\x64\xf9\x66\x39\xa7\xe5\x1f\xa9\x2a\x10\xad\xc7\x1e\xcc\xe6\xa4\xe3\xc6\xc0\x7e\xfd\xf4\xae\xca\xaf\x66\xdc\xe8\xd3\xcd\xec\x37\x24\x9e\x91\x06\xe1\x4e\xff\xf4\x7a\xf9\xdb\x81\x47\xed\x77\x0d\x49\xcd\x01\xcb\x1b\xb4\xf6\xbf\xfa\xfa\x8f\xee\x2f\x37\x3f\x2b\x81\x17\xcd\xbf\xa5\xf7\x9f\xb5\x77\xca\xd7\x16\xd2\xe0\x97\x35\x65\x59\x5f\x70\x85\x5b\xe8\xc0\x58\xe8\x00\x31\xeb\xd1\xc5\x7f\xf1\x46\xed\x01\x2a\xa6\x48\x23\xfa\x12\x66\x69\xa2\xb7\x49\x19\x48\x84\x55\xbc\x6f\x56\xe6\x39\xcf\x5d\xa9\xfb\xd5\xec\x5d\x35\x37\x29\x32\x5b\x76\xc4\x04\xf4\x76\xaf\x68\x50\x5e\xf1\x28\xfd\x50\xcd\x67\x07\x10\xd4\xad\x83\x06\xde\x29\x20\x15\x48\xd1\x97\x3c\x7c\x0c\xad\x51\x97\x0e\x72\x76\x1f\xfa\x08\xdc\x0a\x4b\xd7\x6a\x13\xff\x31\x0b\xc1\x5b\xd0\x8d\x95\xe0\x3f\x3b\x70\xbb\x6d\x2d\xd0\x7a\xb6\xeb\xdd\xcc\xfe\x79\xa4\x4c\xeb\xae\x5d\x8f\x53\x73\x4f\xc8\x17\x72\x42\x8f\xc3\x3b\xb4\x6a\x9a\x4b\x81\x4e\xc1\x63\xc6\x66\xfb\x7a\xbe\xcc\x60\x66\x69\x2c\x89\x42\x96\x84\xff\xad\xb8\x31\xfd\xf4\xad\x50\x43\x40\x73\x09\x78\x1e\x0e\x37\xdb\xdc\x65\xab\x06\xe4\xaa\x76\x98\xe5\x48\x1c\x6d\x55\x1b\x0b\xbe\xe3\x04\xf8\x83\xfa\x98\x41\x54\xb4\xfb\x99\xe6\x80\x2d\x44\x08\x80\x01\x44\x10\x98\x26\xff\x6d\xaf\x34\x2a\xb2\x6c\x89\xa0\xf3\xfd\x86\x13\xba\x03\x0e\x63\xc7\x06\x5f\x3a\x8d\x4f\x8b\x61\x95\x8d\xe2\x1e\xbc\x05\x3e\x3f\x70\x66\xf7\x1e\xc7\xe6\xa8\xfe\xa2\x5e\x04\x38\x2f\x71\xaa\x4b\xea\x42\xcf\x89\x65\xb3\xdb\x32\x72\xfb\xf2\xed\x6c\x33\xcb\x67\xf3\xd9\xf6\x7d\x12\x4d\x67\x65\x59\x2d\x22\x65\xa6\x3d\xe2\x79\x27\x0e\xf5\x4b\x7a\x99\x0e\x05\xe2\x63\x5f\xad\xb2\x02\x33\xce\x93\x49\x2b\xe5\x5f\x42\xe9\xa2\xcf\xce\xcf\xa9\xdc\x57\x59\x3a\x8c\xfe\xc5\xab\x90\x3e\xfb\x1d\xfd\xf7\x72\xf9\x1b\xfd\x7b\xbd\x89\x46\x8e\x8a\x7d\xad\x8f\x23\x68\x90\xc5\x5d\xc5\x70\x17\x1a\xb4\x2a\xe7\xec\xbe\xcb\x1f\x69\x59\x68\xed\x40\xd7\x44\xe5\x20\x99\x42\x9a\xd3\x31\xf2\x55\x16\xba\xe6\x57\x12\x92\x9f\xd3\x83\x61\x35\xea\x16\xaa\x5e\xb5\x71\xd7\x71\xc7\xe2\x5f\x42\x7e\x22\xfd\x5c\xeb\x29\x72\x97\x11\x71\xc0\xa9\xc8\xe9\x9c\xed\x9c\xab\x72\x78\x31\x3a\xed\x14\x1c\x32\xd1\xed\x94\x12\xdc\x4f\x0b\x38\x4e\x72\x57\xe7\x37\x99\xef\x2c\x66\xf8\xf6\x71\x5a\x70\x64\xeb\x40\x1f\x15\x51\x62\x8e\x9a\x28\x1e\x7c\x96\x44\x92\x0f\x97\x61\x9b\x2e\x18\x25\xfc\xbc\xff\xd9\xb3\x71\x7f\xdc\x4d\x9f\xc4\x91\xac\x72\x6d\x7b\xec\x4c\xba\x16\x6a\xa7\xe8\xfe\xc0\x21\xfa\xe7\x9c\x89\xa5\x1c\x74\x6c\xa5\xa6\xec\xa9\x83\xe5\xd1\x5b\x35\x0a\xde\x31\x75\x1f\x37\xcb\xeb\x86\x72\x71\x40\xa9\x73\xc2\x5e\x79\x2d\x4e\xfc\x56\xb4\xd5\xec\x6e\x1e\x37\x5a\xfd\x60\xcd\xd6\x8a\xe7\x46\xf4\xdb\xda\x2c\xa1\x64\xea\x8f\x58\xd6\x93\xe8\x21\xae\x29\x31\x57\xdf\xf0\xc2\x24\xb6\xe2\x4e\x9b\x16\x23\x77\xc6\x05\x78\x45\x96\xbc\x47\x90\xcf\xc7\xcc\x70\x9c\x3f\x03\x96\xbb\x10\x75\x9d\xfa\x2d\xd5\xdc\x27\xa0\x38\xce\x9f\x79\x4f\xd9\x5a\x62\xb6\x38\x38\xca\xb7\xce\x18\x67\x76\x7a\xbf\x44\x8e\x81\xce\x55\xaf\x71\x96\x20\x2c\xb7\x62\xb5\xa3\xab\xa0\x4a\x3d\xf2\x07\xc3\xdc\xb9\x05\x17\xec\x9a\xf5\x05\x6e\xb4\x6d\x35\x41\xdd\x12\x77\xb1\x2c\xdd\x08\xfe\xb5\xee\x09\xa1\x8d\x44\x9c\x81\xed\x9c\x19\x68\xbd\x95\xa6\x3a\xd9\x4c\xc9\x06\x22\xb8\xa0\x69\x61\x0c\x50\x55\x1a\xca\xa6\x54\xd1\x72\x5e\x5a\x21\x8b\xe1\x51\x85\xa8\xeb\x7b\x2a\x1f\x70\x79\xda\x1d\x56\x6e\xa2\xe6\xd6\x4a\xa5\x36\x9d\x72\xed\xc1\xc9\xc9\x2b\x89\x22\xd6\xdf\xb4\x4e\x9d\xfe\x67\x15\x22\x92\xad\xb1\x3e\x8e\x05\xea\xf5\x15\xc3\x86\x1a\x44\x2a\x5a\x77\x15\x7c\x38\x36\x8d\x46\xab\x6a\x50\x68\x91\xb1\xf4\xe4\xc5\x58\xe7\x4a\x9d\x70\x8c\xe3\x81\x91\x00\xb8\xae\xe9\x56\xa3\xe5\x51\xcb\xdd\x96\xae\xe7\x03\x3d\x3e\x34\x73\x5c\x57\x1c\x66\x27\x33\xb6\xff\xcd\x46\x07\x33\x2d\x41\x75\x89\x42\xdf\x37\x41\x85\xd9\x98\xae\xdd\x17\x78\x89\x46\xba\xb0\x95\x7f\x35\xfa\x69\x74\x11\x25\x70\x42\xde\x2b\xaa\xf7\xef\xb7\xd7\x39\x9d\xe0\xf7\x05\x9d\x02\xd7\x0b\x8e\x33\x45\xf0\xc7\x78\x36\x9f\x7f\xa7\xbf\x85\xcb\x79\xf5\xee\x2f\xeb\xe5\x9d\xf9\xfd\x6a\xba\x9e\x2d\xae\xf8\xca\x91\x7e\xba\x9a\xcf\x16\xd5\x37\xf6\x6a\xe9\x2a\x10\x3e\x81\x7f\xac\xa6\xd9\x82\xd3\x37\xd2\xce\x5d\xde\xf1\xaf\xdf\xbe\xe5\x44\x78\xf8\xb5\x5c\x5e\x73\x04\x13\x35\xed\x7b\x0e\x1c\xbc\x8f\xc6\x58\xfe\x58\xda\x9b\x0d\xef\x84\x08\x5e\xf4\xef\xe7\x6d\x4e\x9e\xe2\xad\xf9\x69\xcd\x7f\xe1\x7f\x6a\xd7\x99\x91\x22\x3c\x2b\x7e\x1d\x1d\x78\x56\x17\x26\x73\x21\x14\xdc\xa8\xe1\x74\xc4\xd0\xfb\xde\x75\x4a\x67\x19\xd4\x52\x20\x30\xfc\x40\x82\xd6\x72\xce\x81\x65\x2f\xa7\x23\xe5\x81\x2f\x13\x25\x88\x68\x1e\x81\x9b\x35\xf1\x10\x2f\x69\xfd\x4e\x34\x44\x21\xd1\xa1\x32\x46\xc2\x88\x19\x40\x1e\x3a\x63\x0b\x80\xeb\x61\xe2\x02\x59\x95\x5e\xf9\x42\x9f\x59\x45\x2c\x0e\x9b\x9d\x0a\x96\xf8\x8b\xf8\x71\x45\xe7\x53\xd7\xa3\x23\x86\xde\x41\x6e\x1d\xa7\xd1\x82\x17\x00\xa0\xfd\xd9\x12\x02\xc5\x86\x3e\x34\xcc\xa3\x63\x8e\x02\xe4\xd7\x64\xb5\x48\xf7\x8b\x6e\xca\x87\x5e\x53\x7c\xc2\x7a\x96\xbd\x7e\xce\x3e\x6a\x16\xa0\xc3\x89\x4f\x11\xe3\x55\xc1\xd5\x9c\x7a\x3f\xad\xd6\x33\x76\xd0\x80\x5a\xb7\x36\x1e\x29\x5b\xa9\x27\x1a\x88\x17\x93\x6c\xdf\x2c\xac\xac\x1b\xcb\x5a\x3e\x14\xf8\xd4\x3a\xc3\xbf\x63\x5e\xf5\x4a\xf8\x98\xd9\x0d\xa7\xd4\x9f\xc9\x73\xe5\xda\x6b\x91\x32\xf5\x51\x02\x64\x24\xda\xff\xeb\xeb\x6c\xae\x51\x34\x99\x67\xf9\x32\xe3\x42\x5f\x72\xea\x1a\x21\x91\x34\xa6\x05\x11\xd5\xf0\x5c\x10\x87\xdc\x73\xf1\xcb\xa1\x29\xa2\xe1\x2c\x48\x5a\x1c\xd0\xac\x9d\x27\x55\x9c\x54\x9e\x36\x73\x18\x89\x48\x4a\xbc\x98\x9c\x9c\xa3\x86\xd6\xd1\xeb\x5e\x5a\xa7\x33\xbe\x2b\x75\x31\xf8\x4d\x1f\x70\x4d\xc8\x3f\x5a\x83\x12\xdc\xe4\x9d\xc8\x03\xe1\xb6\xa9\xdc\x73\x2f\x51\xb8\xad\xee\x5b\x33\x16\xfb\x38\xb1\xbf\x6d\x20\xde\xa6\xa5\x1d\x12\xd5\x56\x9e\x9c\xf0\xc9\x6e\x26\x94\x99\x39\x7a\x3e\xd0\x27\x64\xa9\x3e\xee\xc0\x47\xa0\x5a\x9c\x9c\x9b\x00\x00\x33\x0a\x81\x1c\xf3\x1e\xce\x1d\x2d\x22\x9d\x6a\x35\xf2\xe5\xae\xc7\xf7\x96\x93\x9e\x2d\x40\x24\x4f\x0d\x43\xfd\x2e\x53\xc3\xcc\xb0\x5f\x82\xbc\x38\xf2\x00\xd4\x6c\xdc\x8d\x48\x5c\x24\x2f\x1b\x49\x8b\x7e\x6a\xe9\x4b\x73\x4e\x4d\xf5\xb1\x9d\xc8\xac\x8b\xa9\x14\x1f\x89\xc4\x37\x7d\x18\x46\x40\x9c\xac\xee\xf7\x20\x08\x0d\xb0\xed\x41\xe1\x85\x59\x27\x08\x74\xfd\x4c\x3b\x61\x55\x54\xf3\x0f\xc3\x72\x84\xea\xe1\xe7\xb1\xdb\xd1\xbf\xa7\x4f\xf8\xef\xb9\x27\xde\xec\xd5\x6d\xe6\xf2\xbb\x76\x6a\x2d\xc3\xde\x4e\xff\x02\x8f\x87\xd0\x71\xa3\xbe\xa3\x0f\xdb\x35\x6b\xba\x40\x74\x04\x47\xb7\x06\xf3\x37\x10\xf1\x06\xbc\x40\xf8\xc0\xca\x41\x79\x55\xfa\x88\x1f\x0f\x73\x3a\x8d\x47\x76\x81\xe0\x4a\x48\xb0\x43\xf3\x0f\x5c\x44\x18\xec\xde\xd3\x04\x2a\x36\x38\x18\xf2\xba\x87\x81\xb6\x05\xa2\x18\x51\x60\x53\x3a\x4b\x9b\x5b\xe0\xaf\xda\x69\x81\x6d\x6b\x24\x83\xb5\x29\x18\x74\x19\xb8\xbd\x2f\x27\x93\x79\x1b\x24\x2a\x2d\xec\x25\x6c\x84\x3e\xe4\xb4\x06\x9d\xc6\x87\x75\x3e\xa9\x1e\x3e\x60\x7e\xd7\xbd\x59\x5e\xc9\x47\x06\x92\x3a\x3b\x36\xef\x99\x4b\x79\x75\x1f\xa6\x7e\xf9\x5b\x20\xf1\x18\x7d\x08\x80\xe6\x33\x17\x3e\xc8\x69\xd0\xbd\x72\xc4\xe5\xbc\xbe\xab\xaa\x45\xfa\xb7\x4c\xf9\xe5\xd2\x7b\x2f\xdb\x78\x42\x0f\xf1\x5e\x4b\x1c\x0e\x32\x51\x49\x0f\xe6\xd5\xb5\x09\xca\x44\x14\x77\x5a\x98\xc8\x84\x0d\x2d\x67\x70\xf1\xd1\xe6\x8e\xf7\xba\x84\x44\xb0\x53\xf6\x26\xcd\x4d\xcc\x5b\xb6\xde\x1a\x4f\x92\x3b\x9d\x8b\x80\xa3\x93\xa5\x92\x45\x99\x96\xf2\xf3\x96\xd3\xb8\x9b\x55\xac\x0f\xc4\x62\x34\x00\x0b\x87\xe3\x90\x4e\xa2\xdb\x75\xd3\x00\x2c\x7d\x5b\xc9\xaa\xb7\x8d\x74\x31\xe3\xe0\x4a\x88\xd6\x8a\x5b\xac\xf6\x37\xf2\xdf\x71\x20\x3d\xf6\xf9\x5e\xad\x6f\x5b\x72\x54\xd1\x69\xf0\x81\x8f\xf9\x03\xd0\x2b\x6f\xd7\x1c\xe6\xa7\x43\xe3\x97\x34\x24\x70\x1a\xe3\x51\x1b\x7a\x23\x38\x32\x4e\x24\xf5\x17\x1f\x67\xea\x5c\x5d\xb4\x3f\x33\x51\xf5\x5c\xab\x71\x42\xa1\xf1\xed\x98\x51\x3d\x75\xa3\x1f\x3f\xce\xbb\xee\x2a\xac\x6f\xb3\xad\x56\xda\x26\xef\xdf\x72\xb6\x49\x01\x79\x31\xf5\x9b\x74\xd7\x70\x9d\x23\xe2\x32\x28\x2c\x80\xf8\xa1\x41\xb5\xcf\x25\xbf\xd3\x5e\x35\xd6\xac\xb7\x34\xfd\x67\xca\xaf\x2f\xbd\xb7\x71\x03\xb5\x83\x53\xcf\x4d\x1d\x7a\x02\xad\x1e\x4a\x05\xec\x89\x8f\x6b\x23\x60\xe8\x54\x6d\xde\x3d\x53\x12\x08\xe3\x9a\xcc\x48\xbf\xe5\x3e\xac\x98\x08\x0b\x8e\xb2\xdb\xed\x12\x0c\x58\x3e\xc8\xe9\x3c\x4b\xc2\xcf\xd4\x8f\x52\xb6\x33\xbe\xe3\xe1\xb4\xf5\x37\xee\x70\xaa\xf8\xa0\x75\x9d\x96\xe6\x79\x8c\x93\x7e\x2f\xe4\x8f\xf4\xcd\xd8\x91\xcc\xa0\xf9\x60\xd1\xef\xba\x9c\x02\x74\x5b\x6f\x35\xf3\xef\x77\x7b\x3b\x31\x7a\xfe\x2c\xc4\x45\xda\x72\x1b\x80\x19\x1c\xc9\x18\x62\x43\x49\x8b\x7d\x69\x80\x6f\x04\x3e\x49\x6d\x1f\x37\x61\xb0\x4c\x4e\xee\x71\x88\x67\xeb\xd6\x54\x9d\x34\xc2\x77\x61\xd2\x77\xf3\xac\xf7\xa7\x53\x56\x23\x15\x4b\x9a\xba\xc7\xfc\xf3\xfb\x6f\xe3\xb3\x27\x5c\xf3\xf8\x5d\xda\x58\x74\xca\xce\x04\xf4\x90\x9c\xc2\x23\x53\x2f\x33\xf5\xf7\x4c\xf0\x72\xe5\x08\xd8\x81\x3a\xef\x40\x93\x39\x65\x47\x5d\x09\x38\x48\xb4\x1e\x70\x17\x1b\x9d\xa1\x98\xf8\x9c\xe2\xf0\x7b\xaa\xcf\x81\x4f\x53\x25\xff\xc8\xd2\xe1\x3f\xb3\x91\xfa\x21\x4b\xef\xa3\xc7\x51\x32\x3c\x14\x54\x65\xfc\x6c\x41\xc3\x1d\xb6\xbc\x90\xce\x2a\xfd\xce\x2a\xd2\xe8\x54\x86\x4b\xc6\xf0\xd3\x51\x8d\x74\x66\x8e\x74\xc2\x0d\x39\x7c\x24\x7a\xb5\x63\x96\x71\xba\xd0\x05\x98\x0a\x65\xf9\x17\x7a\xfd\xc0\x6f\x3b\xbd\x20\x99\xed\x09\x1f\xfa\xc8\xe2\x48\x1f\xc2\x6b\xda\x0b\x1a\x97\xd4\x9c\x8a\xc1\xbb\x26\x69\x17\x4e\xee\xfd\x72\x79\x34\x4d\xa7\xf4\x89\xde\x9f\x22\x35\x39\x4b\xa7\xca\xac\x4b\x53\xaf\x9a\x74\xc7\xb1\x56\x2b\x4e\x21\x99\x4d\x4d\xdf\xce\x4a\x9d\x57\x7c\x8a\x6c\x6b\x33\x97\xf4\x41\xdb\x19\xe5\x3c\xe9\x4e\x76\x3b\x7c\x8b\x78\x7f\x7d\x6e\x00\xc4\x9b\xce\x12\xc8\x66\x83\x49\x37\x90\xd1\x92\x2e\xfe\x85\xd1\x60\xe4\x99\x3a\x5f\x65\xee\xe8\xf7\x72\x95\x79\xe7\xcb\x0b\x83\x31\x4e\xfc\xd3\x0b\x20\x9f\x71\x90\xbf\x53\xfa\xbc\x0e\x03\x53\x84\xd3\xd3\x76\xa9\x4c\x94\xdb\xb9\xa8\x1b\x35\x5f\x97\x3e\x39\xcd\xe3\x22\x05\x63\xa7\xaa\xa1\xd1\x0c\x76\x8b\x11\x35\xdb\xe9\xf8\xe8\x32\xf3\x52\xa2\xc3\x19\x5a\xc4\xfd\xd4\x28\xf5\xc1\x64\xb9\x66\xfc\x68\xb5\x77\x96\xe9\x04\xb2\xd7\x0f\x19\x4b\x51\xc3\x51\x6c\x00\x59\xe8\x0e\xad\xb8\x51\xcc\x09\x6b\x9d\x67\x43\x7f\xc2\x7a\xd0\xae\xe4\x93\x81\x0e\x5d\xa8\x7f\x01\x1e\xcb\x2a\xd8\x3c\xa5\xee\x3f\xdb\x8d\xc4\x06\x19\x56\x1c\x8e\xae\x53\x86\x59\x35\x12\xde\x2a\xd0\x13\xbc\x02\x9f\x78\x63\x13\x37\x44\xe3\x77\xd8\x68\x0c\x12\xce\x9b\x85\x56\xf2\xb4\x91\x31\x81\xd3\x3e\x28\x21\xf0\x53\x9a\x75\x7e\x58\xb2\xb7\x8a\xb9\xe0\x24\x6e\x53\x2f\x97\x81\xf2\x2f\x7c\xc8\x79\xf7\xce\x6e\x37\x03\xc3\xa5\xdc\x9d\x6e\x17\x70\xbc\x9c\x7e\xd5\x5f\x0e\x6d\xf7\xdc\x4b\xa7\xa7\xca\x25\x82\xe0\xa6\x5a\xc7\xb0\x69\x98\x5c\x81\x93\xb2\x35\xfc\x20\x8d\xf4\x08\x73\x06\xed\x1c\x11\x21\xd9\xb6\x01\xa5\x43\x0f\xc1\xfd\xe3\x39\x1d\xf0\xc3\xa5\xfd\xad\xdc\xcf\x9f\xbc\xdf\x3f\x23\x0e\xa0\x29\x38\xaa\xab\xd4\xea\xed\x2e\x07\x76\xe8\x7d\x45\xe3\x6e\x07\x8f\x0d\xa7\xf3\x4b\x2e\x95\x96\xaa\xf0\xd2\x95\x51\xcb\xf9\x92\x9e\xa8\x90\xd0\xc6\xa5\x53\x3b\x06\x92\x18\xfb\x94\x9a\xb6\x71\x39\xdb\x17\x6b\x0d\x69\x1b\x5a\xaf\x9c\x7b\x1f\xde\x27\x5e\xaf\xfd\x27\x17\xfe\x93\x9f\xfd\x27\x4f\x46\x7b\xad\x76\xd4\xb9\xc4\x58\xd9\x8c\x5c\x62\x44\xee\x4d\x6c\x06\xab\xb8\xb4\x5d\x9e\x1f\x31\x79\x8b\xe4\x1c\x60\xdd\x81\x82\x12\xb9\xb3\x1a\xa0\xd5\x15\x11\x56\x59\xb2\xfc\x9e\xfc\x96\xf4\xa4\xc7\x37\x1e\x06\xc9\x0d\x82\x68\xa0\x39\x9e\x2d\x6e\xab\xfe\x0a\xe9\xd1\xaf\x91\xc8\xec\xe6\xe4\xe4\x86\xc5\x3a\x27\xe3\x94\x1a\xe9\xf6\xd2\x24\x42\x6a\xc9\x98\x76\x1d\xc7\xde\x84\x74\xbc\xf9\xac\x4f\x5c\x38\x23\x97\x12\xc7\x72\x7f\x33\x30\x43\x4e\xe3\x00\x7f\xbc\x55\x7a\xd3\x93\x3b\x71\x72\xe3\xa7\x49\x31\x5b\x52\x01\xe5\x69\xcc\x40\xb2\x52\x2e\x3d\x5e\xc5\x6a\x35\xc0\xd9\x6b\x64\x97\xb9\xa4\xf0\xf4\x83\x8a\xf1\xd4\x88\x32\xaa\xf9\x5c\x58\x36\x1f\x83\xd7\x52\x00\xa6\x9a\x98\xa6\xeb\xd8\x97\xff\xae\xa1\xa9\xd9\x7b\xb3\x78\x1d\x4f\x52\xa2\x7c\xab\x01\xc6\x31\x39\x27\x89\x65\x4e\x27\x24\x9e\xdc\xc0\x7d\x08\x83\x3c\xd1\x0c\xef\x0a\x47\x07\x9f\x0e\xe6\x8e\xfe\xeb\xd9\x38\x88\x0c\x98\x1d\xc8\x39\x82\x89\x68\x07\x91\x77\xff\x6a\x0b\x42\xe4\xd6\x14\x62\x04\x63\xe2\xe9\x2b\xc2\x0a\x96\x84\x65\x25\x71\xec\xa3\x93\x98\xc7\x62\xd1\x40\x4e\x5f\xfd\x30\x85\x58\x4f\x1b\x45\xa7\x86\xcc\xd0\xfc\xb1\x81\x41\x46\x81\x9a\x7e\xac\x14\x85\x98\x28\x1e\x58\x27\x86\xf3\x78\xa2\xa3\x35\x10\x06\x63\xdf\x2d\x47\xae\x99\xe3\x58\x5a\x0b\x00\x2d\x03\xae\xa5\x38\x6f\x7f\xa5\x57\x1f\x1a\x9c\x7a\x87\xcb\x4f\x4d\x5a\xcf\x87\xc7\x3f\x32\x97\xc9\xc3\xcf\xf6\xd1\xb2\x91\x0d\x98\x33\x1f\xfd\x7b\x28\x80\xbd\x87\xd8\x8a\xb1\xc9\x21\xd0\xb7\x51\x36\xe9\x0b\x6a\x23\x4e\x68\x92\xb9\x3c\xfb\xe0\xa5\xcc\x1b\xce\xea\xee\xa5\x95\x85\x4e\x85\x37\x3a\x73\x77\xc0\x18\x8c\xd3\x8b\xd3\x92\xad\x2f\xb3\xf4\xb2\xb7\x05\x1b\xe5\x1c\xb1\xb5\x5e\xc2\xdc\x47\xd6\x7f\x12\xf9\xe0\x08\x62\x90\x0c\xfd\x6c\xbe\x99\x1a\x5e\xd2\x7c\x63\x16\x2e\x9e\xd1\x66\x98\x0d\x8a\x84\x4e\x1d\x3f\x5f\x09\x8a\x8c\x62\x01\x45\xba\xa4\x23\xc8\x64\x0d\x11\xf8\xc3\x4c\x43\x1c\xfa\x41\x9e\xd4\x68\x92\xb8\xbc\x7b\xc7\xe7\xea\x5e\x07\x13\x7d\xc5\xbc\x30\xa0\xa1\x80\x50\x6b\xa0\x6a\x5c\x0a\xc8\x24\xb7\x37\xbf\x13\xa9\x2d\x29\x94\x1d\x9a\xc4\x0e\x9e\x19\x8f\xa4\xb0\x43\xa3\xa4\xc7\x09\x80\x26\x1d\x83\x19\xe0\x5d\x1b\x33\xa0\x56\x20\x50\xdf\x2e\x21\x1c\x6e\x58\x33\x20\x3f\x7b\x41\x43\x99\xd1\xd0\x0f\x84\x8d\xb7\xe3\x68\x47\x9e\x03\xad\xe0\x69\x2b\x48\x3d\x89\xef\xf9\xe6\x62\x87\xf3\x41\x6d\xaa\x12\xa6\x83\x55\x00\x93\xc1\xb1\xb8\xc8\xbe\x6a\x1c\xd5\xed\x34\x16\x32\x8d\x17\x5e\x50\x73\x73\x9a\x14\x51\x92\x64\xaa\xf3\x1e\x07\x77\x95\x71\x50\xbd\xa2\x15\xc3\x33\xc6\xdf\xa2\xbd\x7f\xd5\xda\xef\x38\x64\x9d\xfe\x91\x59\xde\xe9\x92\x58\x5c\xf3\x8e\x63\xa1\x5c\xca\x75\xf8\xef\x5e\xa9\x1f\x19\x61\x36\xf0\xc5\x36\x9f\x61\xb9\xfd\xe4\xc4\xbf\x34\x50\xea\xfc\x0a\x09\x2f\xc0\x9f\x5a\x77\xec\xf2\x99\x29\xb3\xd6\xb2\xc5\xec\x9a\x8e\x6e\xc9\x0f\xa4\x6b\xe0\x0b\x30\x1e\x97\x2e\xd1\xb3\x7e\x64\xae\x75\x26\x66\x7d\x17\xbf\x4d\xa7\x4d\x8e\x5f\x9d\x33\x5a\xdf\xc5\x6f\xbb\xdf\xf5\x3d\xb9\x82\xee\xe9\x73\x6a\x04\x2f\x38\x17\xd9\xfc\x53\xa6\xee\x79\xa2\x1a\x50\x12\x61\x3e\xef\x78\xa0\x33\xfc\x08\xbb\x9a\x20\x68\xc1\xe9\x49\xfb\xbe\xa7\xee\x39\x03\x0f\xd5\x22\x58\x11\x7b\x57\x42\xc2\x02\x61\xe3\x7f\x59\x3a\xe1\x5f\x36\x47\x56\x2e\xb1\x54\xad\xd8\x96\xf9\xe0\x1f\x99\x2d\x48\x02\x3a\x5d\xf1\xf2\xcd\x74\xea\x29\x5a\x04\x55\xd9\x40\x50\x93\x4d\x83\x24\x4e\xcd\xbc\x74\xfe\xc6\xa7\x0a\xef\xcd\x88\x26\x05\x31\x0c\xc5\xc9\x49\x2e\x26\x06\x6f\x0c\x48\x7c\x76\xdb\x37\x53\xb2\xad\x12\x29\x9a\x6b\x40\xe8\xaf\xdd\x1e\xa2\xfb\x5e\x92\x79\xf3\x62\xca\x0b\x65\x39\x1e\x0f\xce\x13\x63\x74\xb2\xad\x72\xc5\x06\xee\x67\xe2\x7e\xe2\xa4\x10\x29\x19\xdd\xdd\x0c\xbc\xdf\x43\x57\x0a\x08\xe9\xf6\xbe\x8b\x5c\xd5\x78\x3a\xa5\xe1\xe7\xf5\x0f\x36\xa7\xb0\xfb\xa6\xbe\x16\xa6\xbe\xec\x11\x1b\x0a\xd8\x68\x3d\x2c\xca\xfd\x0c\x73\xa4\xf9\xc8\xd8\x78\x27\x06\xf4\xe6\x72\x5e\x3a\x7d\x15\x2a\xe3\xaa\x1b\x79\xb3\xf4\x7d\x04\x57\xec\x43\x7d\xf8\x38\x23\x36\x7c\xf9\x01\x68\x1b\x1d\xad\xf5\x2a\x66\xd6\xd7\x9a\x80\xd5\xb9\xe1\x83\xc0\x61\xe0\x00\xe4\x85\x4f\x94\xdf\x18\x69\xf3\xbd\x12\xb3\xca\x5e\xe9\x67\x0f\xe0\x08\x86\xfc\x5e\x26\x99\xe3\x78\x70\x25\x13\x41\x2d\x6b\x9c\x1c\x96\x3f\x69\xed\x76\xb8\xca\xe0\x68\xd1\xa9\x0c\xc4\x02\x17\x88\xc6\xb3\xc5\x6c\x33\x65\x2b\x52\xce\x70\x64\x9c\x20\xdd\xba\x84\xf4\xe4\x79\x3a\x41\xcc\xf4\xd8\x4d\xd9\x85\x97\x58\x71\xa2\x55\x8f\x32\xb2\xba\x10\x92\x5c\xd7\xe8\x7a\xb0\x2b\x9a\x91\x52\x82\x96\xd6\x37\x6c\x8a\x24\xa7\xcb\x89\x6b\xda\x3f\x94\xb2\x4d\xe0\x72\xfc\xec\x5f\xb4\x17\x38\x39\xfb\x85\xd6\x62\x36\xf2\x95\xb5\xc3\xe8\x48\x23\xd8\xd1\x45\xeb\xdb\xa8\x9e\x20\x4f\x18\x8f\x3c\xd3\xd8\x0d\x63\x46\x58\xed\xb0\x1c\x48\x13\x0e\xa1\xc5\xbf\xdc\x74\x5a\x87\x9d\x89\x84\xeb\x99\x74\x15\x0c\x17\x31\x69\x16\xfc\xde\x3a\xaf\xb8\x97\xe4\x48\x73\xb1\xf8\xa7\xa7\xfd\x78\x8c\x57\x40\xd2\x35\xb8\xb4\xf8\xc3\x70\x4b\xf9\x11\xb7\x15\x06\x78\xa0\x3b\xe1\x06\x56\x97\x4c\x6a\xc1\x1e\x7e\x17\xf0\x05\x94\x64\x1f\x95\xba\x20\x11\x08\xa8\x0e\xc7\x45\x7c\x20\xa3\x9c\xcc\x7d\xab\xe2\xed\xd8\x00\x79\x9b\x54\x6b\x0f\x8d\xaa\x2a\xfc\xd1\x02\x67\x36\x34\x23\x1b\x41\x57\xe4\x2e\x65\xa0\x47\xe1\x48\x97\x83\xd2\x9d\xfd\xcc\xb9\x9a\x55\xc9\xe9\xd2\x83\x8c\x7a\x98\x5e\x41\xe4\xe5\x91\x95\xbf\x5e\x74\x11\x82\x31\x72\x37\xac\xb9\x0c\x6b\x2e\xc3\xaa\x03\x5c\x31\x9a\xf9\xc8\xae\xf5\x8c\xdd\x62\x72\x7f\x34\x51\x8b\x1d\xc9\x9c\x47\x52\x74\x3b\x08\x07\xc9\x39\xac\x11\x78\xb5\x34\x9b\x78\x4f\x1a\x1b\x5c\x78\xd4\xc9\x2c\x78\xd3\x29\x9b\x07\x53\x4c\xc8\x5a\xdc\x54\x22\x50\x2a\x11\x35\xeb\x86\x64\x93\x5c\x70\xbc\xa0\x4f\xf4\xf5\x5f\xff\x38\x0a\xcc\x44\xa2\x10\xa7\x69\x6b\xb1\x5d\x15\xed\xce\xe6\xb2\xc1\x0d\x21\x7b\xcd\xb1\x7d\x00\x24\x16\xbb\x92\x67\x3c\xdd\xcc\xa9\x7d\x5f\x02\x57\x8e\x0a\x69\x81\x58\xf1\xcd\x1f\x57\x7c\x8b\xdb\xaf\x6f\xbd\x16\xab\x1a\x6e\xeb\x6e\xd2\xb0\x12\xe5\xfd\x76\xe1\xbc\x6f\xa4\x8e\x3d\xdf\xff\xee\x76\xeb\x3d\xe0\x9a\xe4\x81\xae\xc8\x3d\xd3\xd5\xed\x3f\x1c\xe7\xd3\x24\xeb\xa6\x97\xb9\x21\xd2\xdc\x3d\x59\x8d\x70\xdf\xd2\xac\x56\x71\x55\x27\xbb\x1c\xe5\x8a\x64\x21\xba\x30\xaf\x09\xa7\x26\xec\xe7\x4f\x0b\xbb\xee\x68\x85\x64\x69\xc1\x98\xc6\x1d\x1d\x16\x21\x1b\xb7\xb0\xcb\xea\xf4\x94\x16\x56\xbf\xb0\x4a\x23\xad\x9f\xe6\x7c\x11\x4e\x11\xe9\x71\x7e\x35\x64\x42\x69\x84\xe1\x53\xf0\x1d\x63\x6c\xc8\x90\xd0\x25\x71\x25\x50\xa5\xae\x88\xc1\x21\xdf\x66\xf3\xf4\xe2\x53\xe5\x4a\xfb\x3d\x7d\x09\xea\xf2\x32\x4b\x37\xd5\xf6\x5b\x5d\xb8\x63\x87\x24\xac\x24\x36\xb5\xa2\xd5\x7e\x1d\xec\xc4\x62\xdf\x7e\x49\xad\x7b\x29\x51\xba\xa6\x3c\xf3\x0e\x29\xad\xa6\xe5\x5d\xf2\x7f\xce\x49\x74\xcb\x36\xdb\xe4\x09\xfd\xb0\x46\x9f\xcf\xce\xcf\xf5\x99\x4d\xfb\x27\x7b\x7f\x28\x5f\x22\xaa\x0b\xf8\x14\x28\xba\x33\x0e\x03\xd6\x39\x5b\x95\x77\x48\xe4\xaa\x4d\xea\xf1\x74\xc1\xd0\x7f\x22\x6f\x61\x5b\x7f\x4c\x19\x1d\xe7\xde\x30\x4b\x1e\xca\x83\x48\x4d\x69\x3c\x12\x34\x2f\x76\xf4\xcb\x1f\x76\x57\x17\x1b\x1d\x9c\xd9\x34\x58\x93\x43\x67\x36\x19\x0f\xbf\x5b\xa4\x91\xe4\x15\x78\x8b\x38\x1c\xba\x4d\x2f\x09\xb4\x4f\x05\x0b\xc2\x46\xff\x54\xb9\xcd\x49\x00\xca\xca\xc5\xbe\xb4\x37\x0a\xfb\x50\x3d\xd0\x17\xfd\x8d\x34\xda\x46\x06\x87\x53\x27\x74\xa4\xfa\xf8\xc7\x3f\xcd\xf3\xd4\xb6\xc8\xa4\x3f\xfc\x39\x53\xff\xce\xd4\x23\x4e\x29\x82\x9c\x6d\x48\x61\x2d\x48\x73\xfd\x80\x3b\xc3\xfd\x07\xdd\x15\x16\xfc\xea\x61\x9f\x00\x87\x64\xf5\x3b\xb2\xa5\xba\x97\x0e\xa5\x2c\x6e\xb4\x2b\xd4\x92\x38\xed\x6e\xdf\x39\xcf\x8d\xc5\x67\x8e\xfe\x3c\x61\x23\x4a\x98\x23\x30\xc4\xf4\xa2\x11\xfb\x11\x39\xd4\x49\x0e\x35\x2e\x10\x0c\xde\x30\x96\x14\x31\x16\x26\x08\xe9\x8b\x90\x43\x30\x80\x93\x81\xf4\xce\x03\x6a\xdd\xa9\x3a\x41\x6a\x3c\x1c\x06\x26\x9a\x6a\xf0\xef\x2c\xf9\x19\xa6\x9e\x3f\x1c\x1d\x79\x4e\x74\xa5\xf3\xb8\x2a\x8d\xd1\x14\x2e\x74\xa5\x4d\xb7\x0c\xff\x39\x4e\xff\x8f\x94\x12\xfc\x39\x31\x54\x69\xbf\x5d\x89\x75\x62\x47\x29\xfd\xb6\x54\xba\xb1\x95\xfa\x9e\x79\xa5\xf5\x44\xd3\x15\x67\x61\xb6\x4f\x1a\x80\x2e\xec\xb0\x85\x76\xe2\x09\xa6\x88\x5b\x73\x60\xa6\x03\xb5\x5d\x0a\xc5\x10\x12\x52\xd9\x04\x74\x3a\xc9\x77\x2d\xb7\xbe\xce\x71\x9e\x12\x63\x05\xf4\x18\x0c\x27\x26\xe2\xeb\xd9\x3b\x16\x27\x0b\x75\x60\x34\x19\xda\x85\xd5\x77\xc7\x17\x92\x9c\x24\x44\x51\x43\x46\x78\x3b\x2f\x89\x00\x84\xd7\x2c\xa9\xda\xe5\xf4\xd8\xdf\x41\x34\x6a\xb2\xaf\x24\xd5\x73\x08\x62\xa7\x77\xa3\x83\x05\xe3\x6d\xe6\x40\xf3\xdb\xf2\xae\xea\x5c\xd9\x66\x03\x4b\xe8\x06\x3b\x68\xfd\x3b\xab\x9b\x76\x83\xfc\xf6\x02\x68\x39\xa8\x8d\x7e\x01\xb3\x72\xf0\x9d\x42\x71\x80\xa4\x05\x38\x6e\x8e\x97\xa4\xc7\xd5\xf3\x70\xf6\xe6\xae\x7b\x36\x89\x5b\x39\x9d\x47\x99\xf6\x07\xb4\xcb\xac\xcf\xb7\x42\x09\xdc\xf9\x24\x5a\x39\x18\x8c\xb1\xbc\xad\xe4\x85\xca\xb2\xfb\x85\x7e\x67\x50\xdb\x38\x92\x29\x4c\x57\x0f\x33\x9b\x8e\xc8\xfd\x55\xdb\x85\x05\x94\x52\x68\xe8\xce\x60\x8e\xed\x24\xfd\x05\xa7\xd5\x0d\x48\x17\x96\xcc\x07\x48\x97\x18\xe8\x1f\x26\x5d\xdf\x87\xd5\x3c\x4c\xba\xbc\xd8\xc2\xa1\x5b\xb4\x7c\x10\x8e\xea\x24\x4c\x3f\x85\x2b\xf0\x12\x3e\xee\x88\xc4\xff\x9a\x7e\xa9\xa8\x98\x67\x9b\x0d\x5c\x83\xf1\x17\x0b\x2d\x92\x34\x2d\x0f\xe1\xa4\xb5\x93\xbc\x89\x90\xbc\x89\x90\xbc\x89\x21\x79\xe3\xf4\x42\x22\x42\x8f\x03\x62\xc6\xb6\x86\xdc\xdb\x6d\x98\xf9\x9c\x53\x4a\x3b\xc7\x1b\x0e\x01\x70\x7e\x62\x95\xa3\x29\x95\x4f\x53\xca\xb4\x0a\x68\x4a\x99\xf0\xb4\x16\xc8\x13\x6a\x28\x5b\xe5\x28\x1b\x8a\x3b\xca\x26\x85\xa5\xd3\x66\xb3\x66\xb9\xb8\x53\x37\x5c\x50\xec\x56\x9b\x66\x1b\x7f\xab\x65\x39\x7b\xe8\xc2\xb2\xf6\xab\xf1\xd3\x73\x56\x1a\xf8\xa5\x4c\xd7\xd5\x18\xc0\x8b\xa6\xea\xd3\x8b\xbd\x46\xb1\xf6\x4e\x6d\x26\xde\x9e\x13\x86\x39\xcc\xdb\x5d\x61\x38\xf1\x8a\x71\xb9\xf0\x0c\xc9\x79\xe0\x89\xe1\x5f\xd9\x1a\xb9\x0d\x4c\xbe\x43\xa9\x44\xb7\x0e\xe9\x9a\xab\xac\xfc\x6e\x31\x7f\x8f\x88\xa3\xec\xdd\x0b\x5e\xa9\x58\x2e\xd5\x7c\xae\xe3\x96\xf4\xd5\xf7\xda\x9c\x4d\xaf\x2c\xef\xe8\xd1\x02\xf7\x97\x73\xfd\xeb\x76\x53\xbd\xcc\x90\x12\x9b\x83\xba\xbf\x90\x18\x0b\x65\x62\x2c\xbe\x2a\x67\x02\xcc\x39\x52\xc1\x99\x6c\xd6\x84\x80\x3a\x05\xd0\x26\x2c\xca\x19\x64\xd9\x3c\x3d\x1b\xbe\xd9\xbe\x59\xbf\x59\xbc\x19\x8f\xce\x26\x35\x76\xa2\x2c\x9f\x63\x51\xb7\xf9\x77\x39\x74\xc9\xa6\xb7\x26\x14\x04\x6a\x46\xe7\xc7\x65\x1d\xd3\xa5\xa6\xb9\x7b\x00\x13\x03\x32\x89\x76\xf4\x33\xcd\xe8\x64\x9e\xbc\xaa\x7d\xe6\xec\xa6\x8b\x35\x06\xc6\x34\x16\x81\x93\xf5\x1a\x61\xf2\xd4\x51\xff\xf2\xd9\xac\x3f\x13\x1d\xb4\x86\xe3\x9d\x8d\x90\x87\x3d\xf5\xf1\x82\xd8\x88\x6c\xeb\x1d\x40\x93\xda\xf5\x6e\x20\xa9\x54\xec\x90\x61\x72\xc5\x1e\xa9\xf8\x07\x76\x25\x07\xa6\x96\x4b\xb6\xbf\xd2\x79\x9e\x53\x3d\xf2\x36\x12\x44\x76\xca\x6e\x2a\x57\x7d\x98\xab\x68\x04\xaf\xa1\xf3\xf7\x3e\x24\x94\xc0\x6f\x0b\x91\x84\x00\x1f\x42\xd3\xbc\x8f\x99\x23\x76\x84\xae\x91\x4d\x78\x23\xfe\xef\xce\x9c\xd7\xbe\xff\xa7\x27\xef\xc0\xdc\xc9\x65\xdb\x0c\x3e\x4b\xcf\x63\x68\x61\x4d\x4d\xf6\x89\xd2\x33\xca\xa8\x6d\x32\xa7\xf0\x92\xfe\x7d\xd3\x2a\x42\x7a\x7d\x5a\x3d\x9f\x27\x3d\x59\xfd\x43\xae\xb6\xb9\x8f\x4d\x43\x64\x3f\x17\xa5\xa4\xdb\x48\xb1\x8f\xb8\x13\xde\xd3\x2c\x48\x68\x65\xf0\xfd\xb5\xcd\xe4\x7a\xad\x0c\x26\xb7\xa8\x4d\x2e\x18\xa8\x3c\xde\x27\xa1\x29\xd3\x6f\x9f\x59\xb0\x62\xa4\xd0\xf5\xb3\x5c\x10\x2c\x00\x9d\xf5\x08\x5e\xde\x98\x9d\x0a\x47\x88\x7c\x9e\x18\xf3\x2a\xe8\x4c\x1e\x27\x95\xeb\x6e\x2e\x16\xdb\x0e\x42\x14\x7e\x0c\xd4\x3b\x82\x7f\x1a\xb6\x17\x79\x34\x37\x56\x0d\xfc\xeb\xaf\xf6\xc1\xaf\xbf\x46\xf5\x75\x5b\xbb\x4e\xc3\x4b\x3a\xb5\x84\x05\x8c\xa2\xc4\x57\x2d\x87\x75\xc6\xbc\xd6\x19\x43\x4b\xf7\xa7\x1d\x4e\x31\xc5\x22\xcb\x78\x91\x35\xf1\xb2\x8c\x7d\xcf\x43\xad\x83\x09\xc7\xf7\x9a\xa1\xb7\xcd\xed\x87\xf7\x83\x5d\xef\x39\xaf\x73\x93\xcc\xbe\x6f\xf3\xd7\xeb\xc3\x23\xa7\xc3\xe3\xcd\xba\x7e\x68\x10\x97\x7c\x88\x16\x59\x04\x74\x8e\x91\xaa\xa3\x57\x59\x04\xfb\xda\xe2\x6b\xd3\x9f\xea\x25\x53\xf5\x1b\x70\x7c\xec\x2e\x50\x0e\xc2\x05\x69\x96\x2c\x94\x2a\xc0\x8d\xb6\x62\x17\xc9\xdb\x51\xd3\xdc\x43\xf7\xbb\x78\xe0\xdc\x10\x74\x60\xa5\x58\x23\xab\x36\xbc\x46\x03\xa5\x46\xaf\xd1\x1c\x45\xb0\x1f\x82\x37\xa3\x2f\x7a\x1e\xd0\x3a\x3d\x67\xfd\x76\x3b\xcc\xef\x88\xfd\x68\x35\xb7\x96\x7b\xdc\x5a\xee\x96\x67\xa5\x22\x96\x4a\x38\x94\x89\xeb\x12\x21\xc5\x52\x54\x87\x95\xe6\x37\xa6\x6a\x69\x49\xf5\x60\x33\x26\xcd\x66\xc0\xc2\xc0\x8b\xda\x35\x22\x86\xb5\xbf\x20\xe6\x50\xf4\x29\xad\x61\x1c\x66\xb1\xe5\x39\x7c\x85\x13\x93\x40\x98\xc6\xad\x30\x61\x2f\xde\x52\xb2\x21\x87\x6c\x71\x3b\xc0\xc5\x85\x52\xb5\x69\x8c\xef\xe7\x7c\xcc\x7e\xc8\x9a\x24\x6b\x3c\xcd\x8c\xb3\x58\x0b\x3f\xd7\xac\x39\x40\x31\x4d\x0d\xd2\xba\x64\x6f\x09\x79\x40\x84\xab\xf0\x8d\x53\xed\x62\x94\x69\x30\xa9\xf3\x67\x15\x4c\x50\x03\x34\x20\xe1\x64\x9a\x63\x5a\x58\x17\x89\x51\xda\xe3\xa0\x7d\x56\x0d\xa6\x09\xdd\x06\x4c\x87\x7f\xbe\x95\x38\xdc\x8e\x3b\xc7\x4e\x09\x75\x72\x32\x13\xaf\xa9\x4e\xa0\x7f\x1a\x38\xf5\x93\x55\x1d\xd4\xf0\xce\xcd\xf3\x08\x61\x6b\x01\x68\xa1\x79\x12\x88\xc9\x7e\x09\xc4\x6f\x0a\xda\x7c\x64\x50\x56\x81\xa7\xa4\x77\x92\x1a\xbb\x80\x76\x9d\xc3\x32\xb7\x47\xd9\xa4\x11\x2f\x15\x28\x17\xdc\x88\x0a\x90\x98\x49\x1c\x9d\xfb\x48\x52\x9a\xe4\x4f\x4e\x4f\x63\xb8\x5b\x4e\x46\xaa\x53\x3a\x9e\xde\x21\xe3\x96\x7a\xc1\x8d\x99\x60\xb1\xf1\x0b\xe9\xcd\x3d\xf8\xa4\xda\xa4\xa5\xa7\x17\x80\x5f\xda\x07\xbc\xbb\x56\xc7\x39\x3d\x61\x8d\xa7\x0e\x36\xed\xa8\x29\xfa\x7b\x00\x89\x2e\xe0\x67\x60\x61\xb8\xbd\xf6\xb2\xd3\x97\x0c\x21\xd3\x58\x9b\xef\xc1\x69\x26\x59\x90\x09\xbf\xc8\xa8\x37\x07\x49\x4f\x03\xe6\x5e\x6f\x83\x01\x52\x91\x27\x46\xa1\x18\xbb\x0e\x47\x48\xea\x73\xc4\x39\x7d\x8e\x74\xa2\x9f\x23\x93\xe1\xe7\x08\x49\xe3\x8e\xd6\xd5\x66\xf6\x5b\x75\x24\x9e\xec\x47\x92\x49\xee\x88\x33\xd4\x1d\x95\xf9\x5c\x7e\x70\xa6\x25\xe4\xcb\x91\x5f\xb7\x2b\xf9\x8b\xa3\xf8\xc8\x26\x67\x3a\x32\xf9\x98\x8e\x5c\xee\xa6\x23\x97\xaf\x09\xa9\x42\x17\x13\xfa\x90\xa4\x72\xd8\xdc\xe6\xd7\xb3\x2d\x52\x86\x72\xbd\xf4\x77\x05\xa7\x0b\xfc\xa0\xea\xab\xf5\x7a\x49\x8b\x48\x32\xb7\xd2\x01\x72\x1b\x26\xe0\x6c\x5a\x35\x42\xed\x87\x53\xcf\x34\xb4\x08\xe7\xc2\x25\xb1\x8e\x5b\x43\x2c\x16\x26\xdf\x99\xce\xd0\x91\xc7\x0d\x68\xdf\x29\x3a\xf8\x40\x16\x11\xd7\x63\x4c\xba\xeb\x34\x2c\x8c\x00\x73\x84\xdc\x7b\x48\x83\x64\xda\x93\xe9\x0c\x77\x0a\x3a\xb1\xdb\x45\xe3\x95\xda\x0b\xc8\x77\x63\x72\xe2\xb9\x74\x86\x1f\xce\x47\x63\x0d\x3b\xf4\x8d\x03\x6f\xd9\x77\x2e\x5a\x04\x8a\x81\xf7\xf9\xe8\x31\x30\xf1\xed\x0d\xaa\x1a\x30\xf9\x8f\x23\x74\x41\xf3\x0f\x45\x6e\x2c\x40\xaa\x04\x2b\x31\x38\x23\x4e\x82\x83\x4a\xff\xfa\xea\xbb\xbf\xb7\xad\x74\xdc\x97\x12\x1d\x1c\xb2\x6c\x45\xe1\xcb\x9f\x5e\xbe\x68\x1a\xce\x55\xc1\xe0\xf2\x99\x93\x73\x9c\x81\x3c\xf6\xf6\x0e\xc3\x79\x16\x1c\xb0\xf0\xe5\x77\x2f\xbf\x47\x7d\x6b\x3a\xbc\x0b\xa9\xfa\xeb\xf5\xf2\xfa\x15\xbf\x8e\x5e\x61\xd1\x9d\xbd\xbb\x9e\xd3\xb7\x05\xab\x93\x46\xd1\x24\xa5\x31\x89\x6c\x90\xac\x21\x3f\x90\xf4\x82\xab\x5c\xf3\x1a\xb6\x6e\xcf\x6c\x65\xe6\x5b\x9d\xe8\xdb\x05\xed\x53\xaa\x8c\x3a\x94\x80\xdd\x83\xb2\x91\x07\xab\xa2\x11\xfa\x63\xef\xf1\xa3\x33\x35\xa6\x5f\x9d\xe1\xe0\x64\x14\xff\x9a\x0e\x7f\x39\x19\x3d\x3e\x53\x93\x1c\x2a\xb7\xde\xe3\x41\x9c\x0c\x8f\xde\x6c\x47\x8f\x3b\xc3\x5f\x20\xd3\x23\xba\xe2\x6c\x72\xad\xa6\xb9\xa8\xe4\xb2\x9c\xf6\xe0\x2e\x5b\xad\xf0\xdf\xe9\x66\xbb\x5c\x67\x93\x6a\xd7\xeb\x9e\xf2\x62\xde\xc0\x1d\x70\x4c\x04\x77\x47\xdb\x6d\x77\x37\x2b\x91\x2f\x28\xa1\x2f\xce\xf4\xeb\x7f\xf9\xea\xf5\xee\x9b\xaf\x3e\xff\x12\x11\x1e\x97\xb8\xf7\xe6\xec\xcd\xd9\x99\xba\xe2\xc7\xc3\x37\x77\x54\xd1\xa8\x9b\xc4\x48\xda\x72\xc6\xd9\x5f\xa8\x15\x67\x83\x3f\x8e\x1e\xff\xff\x76\x71\x47\x7e\x27\xd4\x24\x7a\x90\x74\xde\x94\xdd\x78\x47\xff\x3f\x53\xf3\x1c\xfe\xef\xd7\xfc\xef\x82\xb8\xdc\xc7\x67\x91\x71\xc3\x47\x5e\x05\xb5\x84\x9a\x66\xbe\x2c\xd8\x87\x86\xb5\x40\x6a\x95\xa7\x57\xb9\xb8\x23\x2f\x6b\x5a\x49\x11\x15\xac\x53\xe6\x4d\xee\x2d\x9f\xd0\x86\x75\x20\x39\x16\xbc\x26\xf0\xdd\xbe\x09\x0f\x60\x35\x78\xf8\x91\x50\x2e\xa9\x4b\xc7\x45\x6c\x24\x47\xa3\x13\x8f\xba\xec\x2a\x4b\xac\x2f\xb2\x5f\x95\x16\x3d\x86\x33\x47\x28\x51\x82\x67\xec\xe4\x8c\x18\x04\xe3\x4e\x55\x00\x47\xa2\xf6\x8c\x0f\xd9\xc2\x77\xb7\x5d\xe7\x75\xd7\x18\x0e\xa1\x85\xe4\x71\x9d\xfb\x60\x5d\x53\x79\x3e\xb3\x21\xb1\x88\x2c\x67\x47\x01\x3e\x0e\x32\x0e\x3c\x1f\x06\x16\x74\xfd\xca\x65\x3a\xd5\x2e\x35\x87\x1c\x4e\x2e\x77\xbb\xf1\x6e\x57\x0d\x2f\x47\x83\xf1\xe0\xb8\x33\x4b\x2f\x4d\xfc\x70\x02\x64\xc1\x6c\x9b\x81\x37\xdf\xd8\xae\x5d\xd2\x29\x8f\x7f\xe0\x04\x1a\xab\x99\xe5\x19\xfc\xc2\x70\xf3\xdd\xed\x8e\x2b\x76\x6d\x03\x96\x15\x66\xc5\xf5\x7b\x93\xd7\x59\x8a\x45\x2f\xbb\xcc\xde\xbd\xaa\xb6\x5b\x6a\xdb\xa6\x37\x9e\x67\x5b\xed\xf2\xc9\x19\xf1\xad\x6b\x6f\x1e\x3b\x56\x9a\xa4\x21\x9a\xf5\x4e\x85\xe8\xc9\x2c\x81\xfa\xb0\xa4\xf1\x8b\x63\xf8\xc3\xe1\xa1\x03\xdf\xf1\xd0\xba\x68\xd0\xe0\x84\xee\xe7\x77\xd9\xe6\x87\xd0\x00\xb5\xa2\x6e\xc3\x68\x0e\xb6\x73\x9a\xb3\xa1\x2e\xd1\x3c\x21\x51\x7f\x3c\xeb\xc9\xd0\x78\xf1\xf9\xa5\x06\x9e\xbc\x9e\x5d\x6b\x24\x6b\x26\x2b\x3f\x54\x9b\x15\x75\xaa\xfa\xa6\xca\x4a\x3a\x55\x22\x8d\x25\x7a\xfa\x5a\xf2\xda\x60\x3d\x96\xb1\x75\xab\x99\x82\xa1\x9c\xb2\x67\x0d\xfe\x15\xd5\x2a\x40\x5c\x67\x76\x36\xaa\xb8\x9f\xaf\xab\xec\x0a\xc9\xdd\xd0\x16\x7a\xab\x88\xc7\xdc\x2c\x71\x86\xb7\x95\x15\x62\x6f\x99\xe9\xa4\x3d\xd4\x37\x3a\xfc\xb6\x48\xce\xcf\xa2\x64\x17\x0f\x46\xd0\xa5\x54\xba\xc6\x09\x03\x15\x56\x34\x6f\x1c\x02\x65\x26\x7a\x3c\xe8\x8c\x8f\xa5\xe3\xc8\x20\x6f\x1a\x82\x9c\x04\xc3\xb1\x8b\x3d\xb7\xc3\x7b\x5b\x5f\xe4\x1e\x8c\x2f\x12\x90\xfb\x43\xab\x77\x17\x8f\xc3\xd5\xf0\x62\x14\xbb\xfc\x76\x5e\x83\xe3\xcb\xe1\xa4\xae\x18\x0d\x3a\x34\x21\x2a\x92\x5e\x99\x49\xd1\xf3\x35\xc6\x60\x72\xc2\x5b\x9e\x81\xaf\x67\xd5\xbc\xdc\x50\x8b\x41\x39\x86\x2d\xf7\x47\x48\xb6\x88\x14\x1f\x9c\x50\x15\x4d\xfc\x9a\x7d\xe3\x58\x73\xef\xdf\xe0\xfc\x88\xa6\x0b\x31\x7b\x7e\x2b\xef\xf3\x9c\x8f\x83\xd7\xca\x18\x13\x63\x53\x6d\xd0\x3d\x0c\xa3\xc8\x06\x63\x9e\x9c\x49\x7a\x39\x9c\xf1\x64\x8c\xe1\x6a\x4c\xbb\x87\x7f\xaa\xe3\x49\xec\x65\xe6\xc1\x9a\x80\xce\xdf\x71\x4e\x48\x9a\xa1\x81\x3c\x5c\x15\xc8\x91\xe1\x6a\xe1\x2b\x5a\x39\x13\xf6\x4d\x1c\x4c\x38\xab\x4f\x82\x7f\x38\x55\x3f\xe7\x0f\x42\x19\xe2\x62\xcd\x8c\xa2\xd6\xd8\x5b\x5e\x13\x2e\x19\x4b\x80\x5c\x36\x8c\xb6\xd3\xf5\xf2\x6e\x13\x8d\xe2\x3c\x9d\x00\x10\x83\x3b\x86\xf3\x58\xae\xf5\x21\x3b\xb7\x68\x91\x9b\x2d\x78\x92\xe0\x18\x55\xfc\x27\x99\x0c\xe6\x49\xf4\xf7\xe5\x91\x4c\x21\xce\xb2\xa3\x31\x1d\xdd\x58\x94\xd4\x95\xed\x12\xa3\x40\xfc\x7e\x58\xcf\xe6\x96\xa3\x38\x22\x85\xa1\x4f\xf2\xbd\x87\x77\x93\xd1\xca\x7b\x4b\x72\x99\x42\x52\x90\x97\xcb\x72\x36\x9e\x91\x88\x45\x8b\xad\xda\x66\xf0\x37\x57\x3e\xb1\x49\xee\x6f\xd7\xf3\x64\x99\x2b\xb6\x52\x46\x74\x50\x46\x6a\xb6\x79\x41\x87\xd6\x3c\x99\xe6\x1a\x02\x1a\xd9\xa2\x88\xee\x31\x14\x30\x70\x66\x56\xeb\x25\x3e\xce\x09\x34\x40\x52\x36\xef\x17\x05\x7e\x68\x8a\x21\xe9\xa7\xe1\x75\x34\x93\xb3\xef\xec\xdd\xe9\xdd\xdd\xdd\x29\xcd\xe2\xf5\x29\x7d\xae\x5a\x14\x24\xa1\x95\x7d\x4e\xb4\x0f\xf8\x82\x1f\x5f\x7f\x7d\xfa\x3f\x91\x92\xec\x19\x00\xad\x79\x1c\x25\x0b\x6a\x12\x72\x4f\x08\xe3\x42\x92\x37\xb2\x79\x32\x56\xbb\xdc\xc1\xcf\x48\xbd\xc3\x75\xf0\xa5\xeb\xb9\x3a\xb2\xbc\x8e\xba\xdc\x30\x4c\x9b\x57\x00\x77\x74\x09\xa4\x78\xd3\x60\xcd\x7b\xd3\x76\xfa\x3a\xea\xc4\xdb\x67\xf2\x39\xfe\xd2\x99\xd4\xc4\x6f\x9f\x41\x7d\xed\x6f\x17\x79\x25\x32\x37\x89\x03\x8a\x74\xdb\xcd\x2d\x00\x0b\x9a\xc6\x98\x7b\x60\x09\xe5\xbb\x7a\xe3\xa2\xdf\xdc\xb0\x28\x11\xb6\x4d\x98\xb6\x23\xee\x29\x86\x57\x2e\x51\x0b\x34\x3c\x96\xdf\xd4\xf7\xd1\xdf\xc4\x71\x95\x74\x94\xba\x63\x44\x66\xd9\xcc\xd0\x3b\xe0\x0b\xed\xed\x3a\xb8\x3d\x60\xbe\xcc\x07\x74\x52\xf1\x61\x15\x9e\x4f\x10\xfd\x12\xba\x1f\xde\x85\xf3\x04\xd7\xf8\xbd\x75\xb8\x26\x16\x66\x4e\x54\x04\x37\x5f\xaf\xb3\x05\x75\x7b\xbd\xc5\xcd\x6b\x7d\xb3\xf6\xd9\xa6\x4b\xb5\x10\x1b\xdf\x11\x14\x2e\x3e\x3a\x96\xb7\x96\x26\x8c\x48\xa9\x6d\xd0\xed\x4a\x07\x5f\xcc\x89\x10\xe9\x2e\xef\x76\x57\xea\xda\x5d\x52\xd5\x73\x2f\xd1\xc2\xbc\x77\xc9\xe9\xb1\x80\xd9\x30\xb7\xe9\xb8\xd5\x32\x88\x7b\x51\x2b\xba\x7c\x9e\xcd\xe7\x40\xe2\x81\x7b\xf0\xa2\x20\x51\x91\x24\xc6\x35\x42\xef\x6e\x40\xf4\x68\x73\xde\x6e\x9e\x53\xb5\x0c\xa7\xbf\x06\x89\x47\x6a\x31\xb5\x25\x66\xec\x36\x8d\x0a\x64\xc9\x86\x42\x43\xbd\x4d\xef\x61\x66\x7b\xff\x8a\xb7\xf3\xb9\x6a\x9c\x8e\x2d\xe1\xef\x44\x7b\x9e\x40\x6b\x28\x47\x19\x47\xe7\xd2\x58\x18\xe5\xf2\x24\xb7\x61\x6e\x80\xe2\x68\x24\x06\x20\xae\xe0\xc9\x68\x0f\x25\x74\x56\x7b\xb2\x0f\xc4\xf1\x5c\xd4\x3e\xf9\x1e\x6d\xfa\x7c\x3e\x0f\x9b\xb5\x69\x01\xd5\xe0\x46\x0d\xaa\x44\xdc\xbd\x36\xe8\x09\x0d\xe6\x66\xdb\xe8\x88\x9f\xd6\x2c\x4c\x0c\x66\xe4\x39\x28\x3c\x52\x68\x7a\x53\xc9\x49\x90\x29\x04\x32\xa7\x3a\x3b\xf7\x5e\x41\x64\x5d\xcf\xca\xea\xa5\x66\x2c\x5a\x2d\xe6\xac\x69\x32\xac\x47\x9a\x99\x77\xdd\xe4\xb4\x8f\x2d\xc7\x77\x3d\x79\xb6\x8d\x6d\x78\x5a\x16\xdf\x40\x08\x1f\xde\xb0\x57\x1f\xfd\x23\x5c\xc5\xd1\x5b\x13\x11\x91\x0d\xdf\xea\x39\xaf\x65\x06\x55\x24\xb0\xac\x5b\xed\xb6\xbb\xdd\xad\x55\xef\x00\x61\x81\x0b\x42\x79\x84\xd8\x27\xd3\xcf\x3d\xda\xb3\xb4\x01\x46\x6f\x63\xe7\x2a\xbf\x82\x75\x40\xd1\x67\xe5\x00\x48\xdf\x4a\x14\xc7\x5b\x91\xc3\xe8\x12\x21\x1b\x38\xc7\xd6\xf3\xb4\x03\x73\x14\xff\xdc\xed\x96\x79\x0c\xc1\xd3\x6a\x31\x2b\xd6\x62\xda\xcb\xcb\x5c\x31\x99\xef\x46\x67\x67\x8c\x4a\x25\x69\x02\x7b\xd7\xd5\x76\xba\x2c\xc1\xbf\x89\x6a\xf0\xca\xde\x91\x22\x54\xd2\xf2\x2f\xc6\x1a\xe8\x6e\x49\x82\xb9\xc3\x22\x48\x14\x8d\xb4\x46\x9b\x36\xe6\x7a\x49\x47\xca\xf2\x9a\x08\x3d\x43\xed\x1b\x39\x89\xdb\x5f\x13\x95\x54\x50\x3c\x3d\xee\x1c\x23\x04\x57\xf8\x00\xee\x06\x58\xc6\x27\xfa\xea\x09\x98\x9c\xa9\xc4\xce\x47\xd3\xed\x76\x95\x80\x1d\x41\xe9\x41\xf4\x3f\xe7\x51\x12\x7d\xf6\xd9\xa7\xc4\x7d\x72\xe0\x67\x5e\x2f\xc6\xb5\x05\xe5\xf8\xeb\xe8\xe0\xc9\xc9\x55\xcf\x3b\x09\x9d\xe5\xca\x0a\x17\xa6\x9c\x1e\x91\x94\xa9\x73\x66\x06\x08\x83\x0c\xcd\x1d\x16\x08\x3c\x2b\xd5\x1a\xf4\x52\x5d\x11\xbb\xf8\x36\x56\xb2\xd3\x0d\x60\x4e\x7f\x66\x72\x51\xe1\xab\x72\x12\x23\x1d\xd6\x39\xc7\xe9\xca\x89\xdf\xed\x32\xa7\x1f\x24\x66\x8d\x98\x22\xc2\xe1\xd3\x4d\xaa\xfc\x09\x81\x41\xe9\x19\x6c\x38\x3a\x17\xcb\xf1\x4c\x9f\xfc\x52\x14\x9e\x66\x3c\x0b\x41\x29\xde\x65\xba\x7f\xfa\x79\x37\xed\x94\xb9\xe1\xd3\x07\xd1\x09\x8d\xd9\x20\x8a\xbb\xba\xbb\xda\x69\x45\xae\x78\x0a\x91\x80\xca\x64\xc3\x95\x15\x3b\x76\xaf\x3b\x1b\xe5\x98\x96\xea\xa3\x8b\x5f\xd3\xa8\x5b\xc0\xcb\x36\x29\xbb\xad\x9f\x89\x6c\x09\x54\x3e\x1b\x1b\xd6\x87\xd3\x98\xf8\xbc\x10\xc9\xa4\x27\x27\x6f\x7b\x75\x42\xd5\x89\xbe\x1d\x9f\x9a\x32\xa7\xaf\x66\x44\xaa\x23\xd5\x78\x93\xb5\x90\xc4\x48\x3d\x54\xc9\xdf\x69\x47\x02\xab\xa2\x98\x46\xae\x34\xb5\xaa\xe3\x16\x8e\x1b\x47\x5c\x79\x8c\xd3\xb1\xe4\x12\xce\xfd\x7b\x71\xfb\x97\x02\xf1\x49\x05\xb5\xc4\xaa\xed\x85\xcf\x99\xc1\x8a\xfc\x3d\xcb\x72\xcc\x95\x4e\x5c\xb6\x19\x86\x4f\x46\x83\x83\x4f\xba\x9a\x83\x0f\x6f\x0f\x22\x45\xdc\xea\x22\xef\x46\xfd\xa3\x9b\xf4\xbc\x77\x7e\x11\xc1\x46\x9d\xb8\x6a\x38\xda\x8b\x25\xda\x4b\x50\x58\x1a\x08\x39\x56\xe2\x96\xf6\x5e\x2a\xfb\x18\x81\x97\x2c\x16\xf5\x24\x37\xc4\x2b\xe2\x74\x05\x09\xd4\x5e\x8a\xdd\x6c\xae\xde\xaa\xab\x58\x27\x64\x96\x3d\x64\x37\x91\xa6\xb5\x71\x9f\x4e\x62\xfe\x19\xd9\x86\xdc\x6b\x72\x9a\x5c\x68\xa6\xfc\x42\xd9\xf0\xad\x8b\x7d\xfc\x96\xbe\x4f\x22\x99\x6e\x44\x91\xae\xc1\xc4\xe8\x9d\x4a\x94\xbd\xe7\x8e\x72\x00\x69\x9c\x9c\x5c\xd7\x36\x20\xe7\xb8\x18\x52\xcb\x46\x58\x9a\xcc\x2f\x63\xd4\xb7\xe2\x5f\x8c\x94\x8a\x24\xba\xb4\x03\x54\x98\x56\x47\xba\x30\x74\x87\xf6\xcd\x58\x32\xfa\x6c\xe9\xab\xb0\xb7\x10\xf7\xbf\x56\xef\x8c\xec\x71\x27\x7c\x02\x1f\x69\x31\x8b\x2b\x47\x77\xfd\x77\x9d\xd3\x0b\x05\x34\x16\x3e\xc8\xf8\x0a\xb2\x87\xe5\xcf\x22\x0f\x92\xea\x9d\x20\xb5\x5a\x65\x8a\x5a\xab\x8d\xba\x55\x77\xea\x5d\x9a\xf7\xe1\xe8\x05\x2e\x6a\x9b\x3e\x41\x98\x72\xe0\x2f\x3d\x89\x6d\x9a\x74\x20\xf7\xc3\x4c\xac\x82\x41\xca\x9e\x9d\x0f\x3e\x4b\xe0\xac\x91\x3d\x4b\x9f\x9c\x53\xff\x3f\x3d\x3f\x7f\x46\x87\xd5\xa7\xe7\x9f\x41\x3d\xcb\x1e\x62\xb7\xe9\x36\xef\x5c\xd1\x7c\x02\x96\xff\x36\xbd\xc5\xc5\x2d\x5d\x5e\xc6\xea\x72\xd0\xa9\xed\xf0\x3b\x3a\xf9\x5a\x34\x0c\x2f\x68\xf3\xda\x3d\x8d\x74\x0c\x6d\xc4\x20\xbd\xa3\x07\xed\xef\x63\xef\xda\xd7\xf4\x46\xa6\xe2\x44\x9e\xa5\xa1\xd4\x35\xe8\x15\x19\x3a\x81\x69\xe5\xe0\x1d\x10\x18\x0c\x8e\x6c\xa2\xfb\x23\x77\xb7\xd7\xa6\x21\x49\xe7\x5d\x7a\xcb\x9c\x43\x45\x4c\xe2\xad\xd0\xc7\x0d\xfd\xe0\xc5\x47\xc3\x72\xbc\x81\x0a\x6d\x93\xbe\x53\x38\xc2\x8f\xdf\xc1\x34\x44\x75\x68\xb9\x91\x86\x8a\x03\x75\xce\x71\x18\x19\x0e\x84\x46\xcd\xfc\x64\x1c\x73\xa8\xe9\xdf\xe1\xcc\xa7\xd1\x5a\x06\x01\xb2\x73\x35\xa4\x65\xa2\xde\x8e\xe2\x64\xe9\x87\xc8\xce\xb1\x44\xdf\xa9\xcd\xc8\x55\x0a\x6e\xa9\x73\x03\xe6\x56\x4f\x67\xb0\xb8\x2f\x07\xb2\xbc\xb5\x2c\x9a\xf0\xd5\x57\xd2\x46\xac\x76\xfa\xf2\x3a\x41\x75\x2b\xc6\xc5\xf0\x3e\x32\xe2\x64\x8e\x9d\xda\x3e\x79\xae\xb7\x9c\xdd\x2b\xa7\xa7\xe6\x70\x83\xc5\xb7\xf5\x68\x5b\xae\xfc\xec\x33\x6f\x99\x6b\x85\x54\x74\x48\xfd\xbf\x30\xfe\x7f\xaa\x50\x11\xcb\x52\x31\xbf\xf3\x8a\x05\xc1\x43\x66\x31\x79\x47\x8f\x41\xee\x72\xfc\x04\x66\x38\x98\x9a\x55\xb4\x5a\x6e\xb6\x4d\x5c\xc8\xba\x31\x27\x8c\xdf\x09\x95\xb0\x6c\xb1\x47\x3c\x25\xe2\xaa\xec\x4e\x8a\xb5\x18\xd6\x61\x59\x2e\x13\x81\x3d\x57\x86\xfc\x26\x95\xa8\x02\x0a\x65\x48\x59\x69\x3c\x41\x4d\x56\x9f\x56\x13\x5c\xb3\x4e\x51\x02\xd8\x7a\x4d\x5f\x8d\x98\x7f\x61\x15\x01\x44\x3a\xb4\x16\x04\xf2\x64\x5c\x0b\xb8\xbc\x5b\x67\x2b\x64\xe9\x39\x0c\xe3\x55\x73\xd5\x79\xd8\x23\x4b\x57\x17\x7a\x63\xc1\x59\x40\x12\x6b\xf0\x39\xc6\x36\xde\x03\x59\xa3\x62\x64\xa8\x3a\x8f\xbd\x0c\x3e\xa6\x58\xe8\x31\x19\x64\xfe\xd3\x45\x90\x2f\xa6\x96\x51\x4e\x02\x40\x38\x54\x5d\x04\xb0\x4c\x32\x51\x69\xcb\x89\x64\x47\x44\x50\x73\xe3\xae\x83\x28\xb6\xa9\xd1\xb8\x87\xb1\x4e\x39\xa6\xd0\xd3\x6f\x17\x8b\xea\x03\x91\x0c\x07\x3d\x9d\x6a\x83\xc6\x55\x35\x86\xad\x91\x46\xc1\x7a\x2f\xc1\x39\xc2\x28\x43\x3a\x2e\x5a\x69\x50\xb8\x29\x88\x93\xdc\xcb\xea\xa6\x9b\xdc\xea\xde\x10\x34\xb1\xff\x60\x22\xb1\xfa\x44\xe7\xa1\x2b\x4c\x9c\xc8\xa7\x6e\x17\xe1\xc7\xc2\x91\x91\xb9\x6c\x49\x30\xea\xb9\x09\x88\x2b\x93\xa4\x62\x47\xf2\x21\xe3\xf1\x67\x73\x49\x69\xb7\x2a\x97\x3c\x77\xaf\xe3\x7e\x8d\x93\xc7\x6a\xad\x23\x85\x37\x06\x30\xa5\xd5\x51\xd8\x43\x6f\x7d\x9a\x9e\x43\x8f\xea\x63\xaa\xd3\xad\x7d\xbd\x36\xce\x22\x30\xaf\x5a\xaa\x3b\x6e\xfd\x2e\x86\x9f\x95\x21\x6f\xf3\xf4\xec\xbf\x9e\x9c\x9f\x4d\xd4\x1d\x0c\x92\xc3\x37\xa3\x47\x67\xea\x1d\xbb\x39\x0d\xde\x2c\xe8\xf6\x7b\x6d\x09\x13\x13\xb5\x76\x66\xdf\xcd\xae\x61\x46\xa3\xb3\xa1\xda\xb2\xfd\x0c\xde\xed\xea\xb7\xfc\x21\x37\xf8\xab\xea\xfd\xa4\x5a\xc4\x67\x33\xc7\x27\x7c\x5e\xd7\x71\x37\xb0\x43\x35\x89\x0c\x82\xb1\x88\xfc\x21\xc1\x50\x6e\xa0\x4d\x07\xb4\x98\x80\x21\x8b\xda\xba\xd1\x30\xea\x76\x1a\x0a\x21\xe4\xe9\x8f\xc0\xe9\x8f\x22\x55\x89\xc1\xd7\x4b\xde\x4c\x67\xb1\x7e\xe1\xd8\x26\x7e\xa6\x6f\x97\x4c\x81\x6b\x21\xbb\x79\x6c\x3f\x53\x71\x75\xf9\xb0\x1a\x49\x8d\x5a\x48\x4b\x5b\xfd\x3f\x24\x6d\x58\x0d\x49\x20\xad\xc5\xe9\x0f\xf2\x8e\x71\x0f\xca\xe1\x1e\x44\x44\x7a\x68\x5c\x67\x46\xa9\x68\x3f\x7f\xfc\xe1\x5b\x9c\x76\x44\x8b\x90\xe8\x8e\xba\x44\xb2\x4b\xcb\x93\x3c\xde\x07\x19\x25\x73\xed\x39\xef\x6b\xde\x20\xf5\x05\xf6\x23\x5f\xaa\xf4\x10\x69\x32\x76\x46\x17\x3d\x97\x06\x17\xf8\x1e\x6a\x55\x1b\x87\x6e\xa6\x29\xc0\x17\x96\xfd\xd2\x5b\xc0\x1f\xd2\xf9\x69\xd9\x81\xf7\xd0\x71\x68\x44\x0b\xc5\x28\x38\x98\x5c\x07\x54\x70\xb9\x9c\x2d\x3a\x24\xa5\x39\x65\xc3\x5b\x3a\x41\xbb\x51\xfd\xc0\x20\xba\x3b\xcb\xe6\xb3\xdf\x5a\x13\xc3\x68\xc9\x59\x20\x2e\x4d\x41\xe9\x17\x82\x82\xc2\x5b\x87\xa8\x43\x2b\x0d\xd7\xd1\x57\x42\x15\x2a\x6d\xf8\x76\x4e\x58\xf0\x87\x75\x4e\x3e\xda\xd7\x94\x08\x82\x86\x0a\x68\x3d\x12\x78\xed\x05\xd4\x6e\xc1\xee\x99\xc7\x86\xd8\xcc\x36\x9d\x28\x71\xde\x4d\x27\x27\xbf\xe9\x6d\x10\x78\xd5\x21\xa3\xdf\xfb\xdc\x65\x01\x35\x74\x49\x27\x9a\x3f\x36\x09\xf4\x71\x0a\x86\x7d\xf3\x43\x88\x7d\x0f\xc2\x10\x41\xb3\x10\x4d\x9f\x5b\x21\x05\xa7\xf8\xa7\x8a\x8a\x16\x47\xc1\x7b\xf4\x81\x08\x3f\xaf\x04\x5e\x04\x89\xcb\x33\xfa\x8e\x66\x14\x76\x7b\xe6\x88\x92\x96\xa2\x45\x7b\x51\x49\x96\x27\x74\x35\x58\xc3\xef\xa6\x6b\x3f\x1c\x13\x52\x8e\x87\x89\xfb\xd3\xcb\x17\xdf\x6c\xb7\x2b\x2d\x2e\x6a\x79\x27\x43\xf2\x51\xa6\x86\x5f\x20\x6a\xf7\x39\xdb\xe5\xbf\xa4\x7f\xcf\x39\xce\xf4\xe2\xc9\x93\x4f\xe9\xc7\x67\x7b\xf5\x55\x7d\x07\xe1\x6b\x1d\x84\x5b\x66\x5b\xe4\x7f\xfb\x4a\xf4\x2c\xc1\x25\xb4\xbd\xe2\x47\x14\xf9\xbb\xc3\xa6\xc3\xc5\x16\x78\x9e\xc7\xcf\xf3\x61\x36\x62\x40\x2c\x88\xe3\xeb\x4d\x7a\x7c\xfc\x15\xbc\x10\xef\xe8\x58\x79\xbe\xae\x88\x64\x6f\x69\x9d\x6e\xe0\x91\xf8\x55\x0e\x51\x90\x5a\x91\x52\x7b\x50\x4c\x0f\x81\x15\xc5\x3a\x07\x39\x27\xa9\x7b\xb7\x43\xd5\xc7\x99\xaf\x0a\x1b\xdc\x6f\x82\xc4\xd1\xbe\xdd\x91\x98\x11\xee\x27\x20\x1c\xbb\x5f\xe4\x92\x11\x0c\xd9\xe6\x3a\xe2\xf7\xa7\x32\xd6\xf1\x64\x22\x9f\xe2\x8a\x76\x15\x4f\x21\x82\x4d\x36\x9b\xbb\xe5\x1a\xa6\x63\x54\x22\x76\x0f\x67\x96\x0b\x6e\x12\x25\x4d\xbd\x1b\x74\xd9\x77\x96\xe0\x93\x93\x71\xaf\xae\xc4\x6d\xbb\xd7\x71\xaf\xe0\x9b\x5e\x17\x11\x5a\x1d\xfd\x74\xaa\xe7\xbe\x2a\x4f\x39\xfd\x23\x63\xea\xb7\xdd\x4f\xa3\x70\xb1\x68\x70\x19\x6d\x14\x1e\x37\xb5\x0e\x74\xb0\x30\x5c\x43\xde\x76\xa8\x7b\x53\x0f\x52\xac\x55\x5a\xcf\x19\xeb\x1a\x20\x04\x4b\x5e\x22\xfc\x43\xf4\xb1\xec\xcc\xa4\xb5\x0d\x2c\x09\x8e\x8d\x16\x22\xd1\xd2\x1c\xdf\x2d\x39\x39\x1b\x24\x2e\x35\xf6\x84\xb8\x38\x29\x3b\x5f\xe6\x43\x73\x0b\xd0\xe0\x6d\xc5\x9a\xfe\xaa\xe3\x9e\x6f\x7a\x1a\xe8\x34\xee\xc1\xcd\xbd\xb6\x55\x53\x4d\xad\x8a\x7e\x64\x6b\x45\xb4\xbd\xe9\x53\x0e\xb7\x49\xdb\xaf\xbc\xa3\x9b\x0f\xa3\x0c\xf7\x1f\xb7\xa4\x9f\x3a\xcd\xb0\x28\x24\xb2\x40\xd5\x25\xa6\x62\x41\xb9\x30\x7a\x8a\xa9\xce\xbe\x21\x2a\x8a\xe9\xbe\xa1\x3c\xe7\xb1\xce\x41\x26\x7c\x68\x77\xcf\xd6\x63\x0d\x87\x22\xaa\x68\x0b\xa1\x33\xef\xa9\xa3\xc0\x02\x78\xe0\x7e\x55\x5c\xb7\xde\x7f\x77\xea\x9e\x04\x86\x42\xfd\x35\xf8\x0b\xa1\xce\x1d\x8a\xc5\x72\xf3\xac\x66\xd8\x63\x0b\x9d\xae\xa2\x8d\xad\x0f\x12\xad\x22\xb4\x7f\xef\x68\xa2\x35\xa8\x75\xac\x28\x16\x50\x06\x9b\x6d\x5a\x14\xaa\x1c\xf1\x29\xaa\x55\x09\x4f\x0d\x15\xeb\x26\x84\x1b\x42\x5e\x6c\xbf\xe1\x88\x4e\xeb\x37\xd8\x77\xc0\xab\xc7\xf9\xa9\x19\xab\x74\x40\x75\x58\xb6\x85\x44\x11\x3d\x95\xda\x9e\xd1\xe1\xcf\xa7\xec\xbd\xb3\x15\x8b\xed\x17\x21\xa5\x5c\xe4\xb9\x5c\xab\xcd\xba\x48\x98\x10\xd1\xe1\x40\x55\x45\xec\xba\xa9\xf5\x1e\x45\xb0\x25\x73\x9b\x77\x19\x08\x0d\xec\xf6\x78\x72\x52\x75\xbc\x6d\x25\x1a\x99\xcf\xce\x3f\xe3\x03\x40\x2e\x05\xac\x10\x6a\xc5\x20\x0a\x1f\xb9\xb2\xe2\x96\x95\x07\x1b\x0d\x56\x9e\x71\xfd\xfb\x3a\x07\x0b\xf8\x17\x78\xb2\xa5\xf1\x9b\x41\x67\x90\x9e\xec\x1e\xc5\xbb\x37\x03\x71\x02\xf4\x16\x25\x74\x0b\xab\x24\x2a\xb4\xbd\x50\xcc\xbf\x2b\x63\x3e\x6c\x62\x9c\x7f\x9d\x0b\x6c\x03\x6b\x3a\x18\xe2\x6f\xd9\x8d\x7e\x15\x8d\xb6\xcf\x4b\xc0\x1e\x06\xa3\x7b\xeb\x02\xc1\x37\xd8\x42\xbc\x8a\x02\xe0\x83\x7a\x36\x8f\xbc\xc7\x85\x0c\xe6\xcb\x5f\x34\x97\x91\x63\xe0\xe3\x41\x44\xff\x02\xfc\xb2\x46\x54\x72\xad\xbd\x3e\xee\x04\xda\x69\x89\x78\xb2\xa1\x46\x1f\xb4\xfb\x83\xdf\x71\x1f\x64\x63\x00\x9d\x90\xf8\xeb\xb8\x2e\xe8\x0c\xa5\x1b\x9c\x91\x3c\xd0\x31\x23\xcc\xa9\x17\x0c\x66\x8d\x01\x0f\x1f\x22\xfc\x37\xb8\xd1\x81\xf8\x1a\xdc\x51\xd3\x41\x0e\x9f\x32\xfc\x63\xf9\x94\xbf\xb0\xd5\x81\xb8\x72\x5b\xdc\x8c\x56\x5e\xb3\x75\x98\x51\x33\x86\x08\x5d\x5c\x78\x7a\xce\x35\xeb\x9c\x73\xf4\xf6\x12\x2b\xfe\x28\x6d\x32\xaa\x9c\x3f\x55\x7c\x2a\xe1\x99\x74\x97\x6d\x8e\x16\xcb\xed\x11\x96\x11\x6b\x30\x27\x34\x04\x7b\x15\x0e\x49\x2a\x8a\x2c\xc6\x99\xac\x60\xa9\xac\x82\x9a\x27\xce\xdf\x75\x8f\x34\x81\x0d\xf4\x46\x79\x81\x65\x20\xee\x5e\x38\xb8\x45\x6d\xb0\xb0\x50\xe1\xcc\x07\x6f\x9f\x89\xe0\x14\xd8\xb1\x07\xea\xe5\xb8\x33\x61\x9d\xc9\x24\x1d\x3b\x6c\x65\xab\x31\xf3\x49\x38\xfb\x2a\x70\x2a\xcb\xba\xb2\xee\xe3\xdc\x5f\x5b\xe3\xc7\xb4\x27\x24\x68\x1f\xbb\x0b\xcc\xc5\x1f\x32\x7d\x6b\xb2\xe7\x93\x00\x07\x38\xb6\xe1\xc8\xa5\xa7\x1b\xe6\x35\xf4\x0b\x24\xa9\x8b\x47\x09\xc3\x7d\x86\x49\xc9\x69\xfb\xb1\x7c\x23\x98\x44\x26\xc3\xf8\x82\x46\xc3\x91\x23\x93\x11\x7c\x88\x8c\x57\x9e\x1e\x41\x0b\xeb\xdf\x70\xe0\xc7\xa2\x07\xd2\xd6\xb7\xbf\xda\xc6\xa0\x0d\x1f\xeb\x9b\xdc\x8c\xc1\x37\x79\x3b\xb4\x4f\xdf\x8f\xd7\xe6\x67\x70\xe7\xf3\x62\x01\xdd\x36\x7b\x96\x72\x44\xa7\xb1\xdc\x66\xda\x05\x0d\xb9\x7a\x18\x91\x8f\xaf\xce\x39\x77\x4f\x5d\xc8\xd5\xe3\xac\x95\x93\x49\xde\x82\x89\xc7\xc8\xd6\x69\xf4\xfd\x77\xaf\x5e\x63\xe5\x5a\x77\x75\x23\xb1\x06\x6a\xc7\xca\x53\x39\x8a\x73\x8f\x76\x6d\x8a\x6b\xd0\xb2\x88\x71\x71\x2b\x9a\xaa\xe5\xdc\xf2\xe5\x00\xc7\x4d\x39\x7b\x8b\xb3\x46\x2b\xa7\xbc\x15\x06\x29\x89\x83\x6d\x10\xd7\x08\x4d\x92\xb5\xa8\x77\x68\x2d\x84\x82\xd3\x44\xc4\x60\x12\x82\x76\x3b\xcf\x37\x8e\x39\xad\x5c\x65\xc0\xa8\xd5\x2e\x05\x56\xf5\xeb\xcc\xac\xca\xe9\xa5\x55\x4d\xa9\xed\xab\xc7\x03\xc5\xb9\x72\x56\xa2\x66\x42\xa1\x7a\x20\x40\x9b\xf3\x7b\x9b\x66\x4a\x83\x1e\x95\xed\x5a\xdf\x09\x91\xb9\x8e\x45\xe4\xf2\x75\x87\x16\x68\x07\x84\x57\xe0\x5c\xf5\xc4\xc9\xea\xfd\x96\xfd\xff\x6c\x5a\xea\x30\x31\xb1\x53\x0a\xfd\x35\x0f\xbe\x37\xdb\xfc\x8b\x06\x7f\x79\x07\x45\x4f\x96\xfc\x39\xad\xe7\x14\xf3\xd2\x5b\xef\x17\x5a\x4f\xc6\x81\x2a\xdf\xf1\xcf\x87\x20\x09\x3c\xff\x1f\x93\x4a\x51\x27\xe8\x8c\xe0\x01\xc4\x91\x78\x40\x2a\xef\x47\xe0\x98\x67\x85\xc6\xb9\x36\x89\xa9\x7a\xa6\x74\x1a\xad\xab\x79\x06\x63\x03\x9c\x0a\xd3\xb9\x6e\x45\x47\xf0\xf9\x74\xd5\x6c\x6f\x50\x33\x77\x03\x49\x89\x23\xa4\xe8\xef\xb8\x6c\xa0\xf8\x00\xa0\x88\x66\xef\x88\x64\xe3\x82\xf3\xf0\x75\x67\xfe\x29\x89\x2c\x13\xf1\xb3\xd3\x0b\xd8\xb2\x90\xe1\xd9\xb4\x82\xe5\xb3\x92\x73\xf3\x02\x2f\x05\xd5\x23\x51\xa4\x9f\xb3\x6a\x8c\x5c\x86\x61\x7a\xc3\x19\x6e\x35\xf6\x28\x2b\x8b\x72\x83\x29\x5a\xc8\x36\x96\xa0\xb2\x1e\x83\xa9\xc1\x00\xb3\x5c\xc9\xd5\xe9\x14\xff\x76\x27\xae\x08\xbe\xcd\x65\xf0\x43\x5f\x53\x29\xfc\xc1\xb9\x16\x21\xf0\x66\xc2\xc1\x75\x74\xc4\xf2\x85\xf9\xd4\x35\x00\xa3\x31\x40\xd7\x92\xf7\xc1\xd3\xf2\x2c\xeb\xf3\x19\x3f\x14\x53\xe9\x98\x5b\x2f\x09\x7f\xd3\x46\xa0\xa7\xaa\x67\xd7\x8b\x01\x8f\xcb\x63\x13\xf2\xc9\xd1\x70\x5a\x9f\x0f\x0c\x7f\x4e\x29\xad\x38\xa5\xf4\x39\xdc\xce\x4b\x46\x99\xf4\x2d\x06\x2c\x20\xbb\x28\xc4\x71\x23\x09\xb7\x97\xe7\x9c\x61\x46\x3a\x16\x74\x93\x04\xaa\x2f\x90\xa8\x8d\x86\xe4\xf9\x7c\x46\x65\x7f\x20\xba\x48\xec\xc3\x8f\x12\xe4\xd9\xfe\x1c\x7e\x2d\x45\x4a\xfb\x66\x1c\x2b\x6e\x5e\xc5\x13\x82\x68\x8e\x49\xf5\xb3\xf4\xeb\x14\x89\xeb\xf1\xc2\x6b\x5a\x1f\xdc\xf8\x4a\xe6\x43\x4a\xfd\x54\x2b\x85\x24\x1e\x7b\xa4\x30\x53\xab\x96\xfc\xcc\xd4\x3f\x63\xe0\x30\x68\x67\xaa\xb0\x63\x54\xd6\xc6\xc8\x78\xd0\xdb\x55\xad\xb3\x48\xf8\xdb\x6d\x90\x4b\x0c\x5f\x5b\xe7\x92\x8e\x56\x8e\xc9\x5c\x7d\xaf\x35\xf5\x74\x84\x78\x77\xf9\xf0\x74\xb8\x37\x68\x87\x1c\x06\x31\x3b\xb8\x67\xb6\x18\x20\x40\x31\x3a\x66\x23\x72\x49\x49\xe9\x45\x43\x63\xb3\xa1\xa2\x18\x8f\x4f\x4b\x39\x0c\x8e\x2b\xa8\xc7\x5c\xb6\x02\xd7\x7d\x6a\x3b\x28\x49\x1c\x5e\x83\xa4\xa3\x4a\x1e\x10\xbd\x1d\xa4\xfa\x7a\x51\x54\xcd\x65\x91\x73\xc5\xef\xef\xef\xd2\x4c\x36\x46\x6b\xb7\xfb\x36\x37\xe6\x26\xd6\xe0\xfa\x08\x41\x32\x4c\xec\x85\x64\xa8\x5c\x0b\x41\x64\x9b\x94\x5f\xa7\xd5\x73\xa2\xf2\x7d\x88\xfc\x67\x13\xc1\xc0\x6f\xd9\xae\xae\x48\xd9\xc4\x31\x72\x5f\xaf\x4d\x3f\x87\x9a\x87\xb5\x16\x14\x41\xe0\x7a\x13\xcd\xb0\x3a\x98\x9c\x2c\x97\x1c\x55\x92\xd5\x9c\xb6\x86\xcb\x3c\x68\x29\xc3\x78\x30\x19\x4c\x86\xc5\x28\x01\xfb\xca\xdc\x65\x87\x6e\xd8\xe4\x36\x1d\x84\x54\x7b\xad\x4f\xc6\xaa\x1c\x8c\x93\xcc\xdf\x55\x31\xbf\x9b\x8e\x11\xd4\x46\x1f\xac\x13\x23\x49\x93\x5d\xc3\x70\xc4\xf1\xce\xb4\xff\xe1\x14\x80\x9c\xf3\x2e\xc8\x90\xae\x5a\x63\xfa\x0a\xf0\x53\x92\xd0\xd0\xa5\xbe\x85\x3e\x16\xb1\x77\xee\x6c\xa0\x2a\x39\x2b\x6d\x52\x38\x46\xda\x9b\x31\x9d\x3d\xd4\x66\x29\x94\x5c\xbe\x1a\x01\xbf\x89\x9c\x28\x2f\xd9\x9c\x78\x9c\x59\x3e\xea\x66\x46\xc5\x91\xc0\x45\x30\x89\x96\x74\xa4\xe1\xb6\xf7\x3e\xcb\x93\x3c\x8d\xa5\x37\x8d\x2c\xf6\x4b\x9e\xe6\xfa\x10\x82\x2d\xf7\xf0\x0b\x2c\x3f\xcb\x58\xb7\x9c\xd6\x56\x27\x61\x14\xf4\xe0\x81\xc9\x9b\x92\x98\xdc\xbc\x76\xde\x9b\x2b\xc4\xb3\x3b\x35\xd9\x0d\x58\x63\x0e\x72\x2b\xc3\x48\xc8\x24\x75\x6e\xc4\x3c\x49\x6e\x79\x12\x91\x32\xeb\x14\xdf\xc2\xd4\xe7\x3d\xd8\x0f\x59\x9a\xa3\x55\x86\xf7\x91\xec\xc5\xbb\x32\x05\x64\xab\x99\x02\xe1\x95\xfb\x78\x6c\x66\x93\xf3\x12\xc8\xb6\x45\xc7\x26\x70\x45\x96\x04\x09\x82\x44\x30\xe1\x25\x3a\x1e\x94\x56\x79\x67\x17\xa7\x09\xef\x44\xe4\x6b\x8b\x5c\xe9\x61\x2e\xe8\x13\x39\x5b\x94\xaf\xaa\xf9\x58\x64\x11\x5a\x03\x5f\x40\xb8\x8b\xcc\x9b\x1e\x86\x74\x45\x7c\x33\x31\x69\xf2\xb7\x97\x5d\x97\xe6\x77\x27\x12\x6b\x12\x30\x78\x5b\x72\x52\x2e\xf4\xd9\xfb\x37\x70\x8c\x97\xff\x40\x49\xf5\x02\xbf\x1f\xb9\x89\x5a\x2c\x9f\x2f\x17\x63\x12\x33\xbc\x00\x61\x8f\x09\xed\x3d\x02\x19\x63\x66\xed\x51\xfa\x22\x17\x28\x60\x5d\x97\x7d\xa2\x2f\xff\x06\x54\xba\xbd\x32\xb2\x47\x2a\xc7\xad\x7d\x8c\x1a\x16\x28\x11\xf7\xff\x70\x74\x74\x76\xf6\xc7\x23\x01\x27\x7b\x49\xc2\x02\x2d\xff\x1f\x7f\x78\x91\x4a\x6f\x7a\xd7\x33\xb6\x82\xfc\xe1\xe9\x99\xd6\x5e\xfd\xc1\xa8\xb1\xfe\x70\xf6\xf8\xf8\x0f\x47\x8f\x8f\xbe\x58\x2e\xb7\x24\x9a\x65\xab\xa3\xb7\x9f\xf6\x3e\xed\xfd\xe9\xa8\xc3\x0e\xa3\x67\x67\x74\xf6\xe5\xe6\x19\x24\x8c\x18\xa5\x9f\x2f\x57\xef\xd7\xd8\x90\x47\x4f\xce\x2f\x2e\x4e\xe9\x9f\x3f\x1d\xbd\xbe\x9b\x21\x0f\xbc\x3a\xfa\x76\x51\xf4\x50\xe8\x05\x49\x5a\x24\x64\x94\x47\x88\x60\x5d\xd3\x74\x55\x47\x2f\xbf\x7d\x7d\x34\x97\xdb\x54\xe2\xec\x0f\x10\x08\xf1\x14\x43\x5f\xba\xf9\x91\xfe\x69\xf5\x29\xac\x23\x5f\x49\x44\xa6\x6d\xe4\x27\x9b\xa3\xbf\x66\x6f\x33\xf1\x70\x39\x5a\x57\x37\xb7\x33\x92\x69\xf4\x7b\xb4\xb3\xba\x3e\x33\x06\xd8\xa6\x23\x88\x9d\x24\xc8\xf5\x0d\xd6\x14\x2d\x10\x3d\x36\x2e\xee\x06\xae\x13\xfa\xaa\x17\xb1\x5f\x1c\x74\x68\x4f\x9f\x9c\x9c\xc0\x65\xf6\xe9\x9f\x77\xbb\x8b\x94\x53\xd0\x9f\x9c\xfc\x19\x3f\xe0\x94\x0b\x67\xdc\xa7\x17\xff\x69\x53\x8f\x4c\x78\xcc\x45\xef\xcf\xbd\x8b\xa3\xe5\xfa\x68\x4a\xa3\x0a\xe2\xb0\xef\xe8\x41\x50\x87\xfb\x62\x25\x93\xdc\x1e\xb0\x96\x2e\xd4\xa0\x2f\xed\x14\xb2\x76\xfb\x5e\x32\xf1\xb3\x8a\x54\xe7\xfd\xbf\xab\xdd\xf9\x0a\xfe\x7d\x2f\x97\xbf\xf9\x65\xb6\xf6\x37\x7b\xff\x7d\xe7\x3f\x5b\x06\xaf\x1e\x2d\x6b\x65\xb7\x07\xab\xd9\x3b\x64\x7c\x9b\xe6\xc6\xc6\x04\x9a\xe4\xe7\xc5\x48\x73\xad\xf7\xd0\xca\x22\x18\x70\xef\x20\x50\x78\x32\xab\xeb\xdb\x39\xd2\x42\xf8\xad\x08\xf6\x9f\xd8\x0e\x91\xbd\x53\x7c\x5c\x74\xda\x4c\xa8\xff\x69\x78\x36\xb5\x9e\xfb\xfa\x52\xa4\xbf\x91\x6d\x1f\x50\x21\xa2\xf1\x19\x89\xde\xd6\x7b\x8b\xda\x7a\xbb\x82\xc2\xb9\xe7\x3a\x08\x27\x0b\x07\x54\xee\xb9\x43\x56\xd6\x31\x5e\x65\x81\xde\xaa\xa5\x12\xb6\x53\xb4\x3d\x90\xc4\x74\xec\x42\xa6\x13\x3c\xf4\x6a\x1d\x49\xef\x11\x9f\xce\x1a\x88\x43\xcd\xb3\x31\xe9\x0f\x97\x9a\x32\xc4\x69\xd2\x46\xd1\xe8\xe8\xd8\xd2\xd9\x46\x4c\x07\xac\xc0\x3c\xaa\x74\x42\xc9\x0b\xdf\xe5\x97\xfa\xd7\xfa\x00\x68\xb3\x81\x5b\x80\x2b\xcc\xef\x5b\xf3\xf9\xc3\x88\x82\x3a\x2c\x43\xfb\x00\x55\xc4\xc6\x43\xfb\x82\xb9\xee\x65\xd4\x1c\x18\x75\x2a\x60\x70\xd4\xee\x22\x78\x95\xb6\xb1\x75\x61\x6a\xea\x8c\x91\xb6\x2e\x37\xd9\xc6\xd0\x6c\xf9\xd2\x27\x43\xd4\x74\x5a\xce\x36\xd7\xb3\xcd\x26\x8d\xa4\xba\xd1\x27\x2a\x5c\x87\x34\x5c\x62\x06\x60\xcc\x86\xc8\x41\x34\x2d\x37\x15\x2d\x95\xb2\xf7\xcf\xaf\x7e\x78\xf5\xed\x77\x7f\x4f\x23\xa6\xc3\x11\xb1\xfb\xaf\x7f\xf8\xfc\xef\xaf\xbe\x7d\x4d\x37\x7f\xfd\xf2\xc7\x1f\x3e\xc7\x8f\xf4\xe2\x4f\xe7\xf4\xc4\x65\x07\xe4\xf7\x83\x0f\xd9\x91\x2a\xa0\x30\xed\x95\x15\x2c\xbf\x1d\xb7\x5e\x23\x7e\xa5\xec\xb9\xf1\xb0\xea\xbe\xbd\x2c\xf6\xcc\xa2\x3f\x55\x02\xe8\xc2\x2a\xed\x53\x99\x6c\x58\x1d\x19\xa9\xd2\x3c\x43\x34\x38\x50\x1f\x10\xb6\x38\xb6\x3a\xe7\xb3\xde\xe3\xce\x20\xfd\xe3\xf0\x97\x37\x9b\xd1\xe3\x47\xf1\x19\x42\x34\x64\x33\x4d\xa8\xfe\x71\xdc\x17\x88\xbf\x35\x2f\xe3\x2f\x45\x65\xd2\x71\x9a\x35\x09\x59\x95\xde\x6d\x40\x97\x75\x53\x51\xc2\x02\x41\x10\x99\xd0\x16\x6d\x2e\xe7\xf5\x08\xaa\xea\xd9\x46\x57\xfb\xbd\x7c\x04\x71\x4f\xa8\x36\x00\xa9\x22\x4e\x31\x3a\xb4\xc9\x26\x0e\xdc\x2a\x02\x90\x37\x09\x85\x93\x03\x64\xa3\x88\x5b\x09\x51\xa7\x75\x0e\xe3\xa4\xe8\x18\x05\x6a\x25\x47\x12\x37\xbb\xef\x7e\xa6\x08\x45\x35\x17\xbd\xe7\x2e\x03\x6e\x5a\xfa\x0f\xda\x58\x0e\x8f\xe3\xb0\xb5\x55\x96\xe4\x94\xd6\x87\xd0\x2e\x45\x3b\x6c\xbc\x23\x4e\xb3\xd5\x0c\x8b\xb3\xb1\xc6\xfe\x17\x76\x69\xe9\xed\xd2\xd2\xed\x47\xf1\xe8\xe2\x25\xd5\xa6\x87\xcd\xfb\x9c\xa0\xa3\x5e\x5c\xef\xdf\x42\x33\xd5\xd8\xc1\x36\x1b\x5a\x3e\xa8\x34\x54\x5a\x87\xd5\xbb\x0c\xb4\xc9\xfe\xdb\x70\x4b\x32\x1b\xd9\x63\xc4\x4b\x9d\x4c\xf8\x91\xf6\xa2\x49\xb1\x7b\xc3\x84\xc1\x99\x97\xbd\xa2\xe8\x7d\xf9\xd5\xd7\x9f\xff\xf8\xe2\xf5\x2b\x84\xa4\x73\x31\x44\x9e\x66\x10\x46\xe8\xe8\xd9\xf7\x8b\xc6\xee\x76\xaf\xa4\xf7\x73\x29\xf9\x9a\x03\x2d\xf5\x45\xaf\xd7\x83\x85\xd6\x9b\x05\xd3\xe4\x96\xd3\xcd\xc1\x0b\x19\x48\x32\xd3\x70\x1e\xd9\xd9\xc6\x62\x60\x0f\x00\x49\x13\x19\xb5\xf4\xd8\x0c\x3b\x6d\xc7\x6e\x1a\x49\x6c\xa7\x78\xd4\xb0\x85\x9d\xce\x2d\x0e\x30\x34\xa3\x6d\x6f\xd1\x77\x48\xcc\x84\xee\xc2\x3b\xdb\x38\x69\xe9\xbb\xf7\x01\xba\x2b\x4a\xe9\x0a\x89\x76\x0e\xfc\x11\xa4\xeb\x64\x2c\x19\xed\xbd\x01\xe0\xd9\xea\xd4\x87\x10\x34\xcf\x42\xc9\xd1\x66\x63\xca\x03\xcc\x5e\x0d\x6f\x62\x8b\x1a\xd7\x22\x7f\xf8\x55\x19\x6c\xf9\x22\xf6\xc1\x80\x0b\xf8\x5c\xc9\x22\x44\xb2\x6d\x7f\xc0\x65\xc5\x34\x80\xf4\xd1\x9a\x3c\x1c\x65\x4b\xa7\xf4\x59\xa0\xdf\x8c\x64\x69\x6e\xe8\x30\x10\xae\xd2\xa8\x04\xfd\xbc\xa9\xb6\x0e\x56\xe9\x9b\x79\xea\x5b\x00\xe5\x42\xcc\xcd\x02\x84\x0c\x5b\x85\xbe\xd6\xce\x53\x9c\xcc\x30\x13\x1b\x91\xae\x42\xfb\x99\x47\x21\xf6\x63\x64\xee\xaa\xf0\xb3\x76\x58\x6d\x81\x38\x71\xf0\x4b\xf5\xef\x33\x6a\x62\xad\x01\x3a\xe1\x87\xab\xd2\x91\x4d\x53\xa5\x6d\x63\x58\xd0\x87\x2f\x74\x9f\x57\xf5\x2f\xa8\x0f\x55\x1f\xc3\x5e\x5e\x78\x27\x1c\x63\x19\x45\x3a\x49\x5c\xad\xbf\x7c\x68\x65\xeb\x59\x76\xca\x90\x46\xa8\xff\xf8\xc3\x1f\xf8\x88\x86\xef\xb5\x79\x8e\x09\xaf\x4c\x7d\xdf\xfb\x6d\x68\xba\x5c\x05\x44\xbd\x08\x9e\x7c\x98\xaa\xeb\x0a\xcb\x0f\x91\x75\x5d\xa1\xa3\xeb\xc1\xfa\xfc\xc5\x2c\x50\x30\x2b\xbe\xff\xb2\xa1\xcd\x85\xe1\xef\x88\x3b\x71\x63\x92\x6f\x17\x5a\x87\x59\x7a\xe7\x33\xdf\x65\x0b\x31\xd8\xa3\x52\xb9\xa4\x19\x5e\x3d\xa0\x44\x9f\xf0\x0a\x1f\xfa\xe8\xfb\xb4\x3d\xc0\x53\x1f\x2e\xe6\xd0\xc0\x3e\x11\xf8\xb4\x1a\xdb\xa0\x1d\x2c\x18\x39\xab\xa5\xdf\x47\x40\xd9\xfa\x4f\xc7\x43\x58\x37\xdb\xb4\x5a\x8f\xc3\x95\xc0\x0d\x88\xd4\xd9\x2f\xfc\xa3\x33\x5b\xc4\x83\x47\x67\xc6\xb2\xce\x2e\x1b\xff\x2b\xdc\xee\x81\x73\xb4\xc8\xd6\x8c\x74\x15\x09\x8e\x67\xfb\x71\xa5\xe9\xbf\x6a\x3d\x69\xa1\xd2\x6a\xf2\xc1\x83\x3c\x19\xf7\x38\x47\x4a\xed\x24\xb6\x1f\x6c\x39\x8b\xeb\xf8\x8e\x72\x24\x03\x24\x74\x32\x00\xaa\x1c\x1d\xcc\x63\x9b\x9b\x03\x27\xf4\x2a\xbb\xe5\x18\xdb\xe2\x7d\x31\x97\x3c\xb4\x8d\x53\xba\x38\x7c\x4a\x3f\x22\x4a\x08\xd7\x0d\x38\x2e\xb6\x91\x59\xdb\xd6\x53\x57\x30\xaa\x9d\xf0\x9a\x43\xe7\x86\x94\xe2\x96\x23\x4e\xbb\xd4\x75\x9c\x2c\xee\x8e\x4d\x4c\xe2\x6e\x3d\x12\xaa\xe0\xdf\x99\x6d\xab\xeb\x8d\x77\xc3\x64\xb0\xbf\xaa\xde\xe7\xcb\x6c\x5d\xea\x94\x50\xb6\xa5\x58\xd2\x1a\x80\xad\x17\x8c\xae\x39\x68\xb9\xb8\x2e\xa1\x8c\xd8\xc2\x58\x68\x91\x26\xc9\xe6\x13\xdc\x07\xb8\xbb\x44\xcb\xc5\x76\x79\x5b\x4c\x39\x73\x0a\xa7\x35\x38\xa0\x50\x8c\xdb\x5a\xe3\x70\xd4\x1e\x68\x10\x7f\x4b\x37\xc7\xbd\xc5\x78\x6b\x0f\xbc\xc5\xd3\xac\xdf\x6a\xe7\x97\xda\xa4\x21\xa4\x5f\xf1\x39\x29\x33\x11\xc9\x9f\xaa\x4f\x15\x37\x24\xd1\x03\x22\x81\x1d\xc8\x1c\xa2\x47\x1b\x81\x3e\xc1\x71\xaf\x07\x32\xad\xd9\xf3\x8e\xcf\x24\x7a\xc0\x84\x0d\x9c\xcd\x0c\x32\xba\x90\x04\xfa\x33\x11\xfc\xe4\xfb\xcd\xdd\x8c\xbd\x77\x7b\x77\xd3\x59\x41\xa7\x7c\x91\xd1\x96\xfe\xf4\xbf\x85\x45\x01\xcd\xea\x68\x14\x96\xbe\x3c\xf9\xb3\x3c\x59\x00\x09\xd3\x3c\x31\x29\x64\x64\xcf\xef\xb3\x26\xad\x0b\x5b\xcd\xe3\xd6\xa6\x70\xcc\x0d\x1a\xa9\x5e\xbf\xf6\xf4\x75\x9b\x2c\xcc\x74\x13\x3c\x0c\xb7\x82\xf7\xce\xb1\x57\xa7\x65\xb6\xcc\xf2\xf7\xd3\xee\x04\xb3\x8b\x2e\x6a\x2e\xab\xb5\xde\xd8\x28\x45\xfc\xae\xd1\xe0\x7e\x4b\x5b\x46\xc0\x22\x0f\x79\x0d\xe8\x5d\x95\xb9\x78\x19\xf6\x52\xa1\xdf\xb4\xc9\xf1\xcc\x32\x3c\x5c\x50\xcc\xd6\x88\x44\xf4\x77\x69\xdc\xfa\xe1\xaf\x97\xeb\x2f\x67\xeb\x8a\x3f\xdb\x16\x43\x21\x5b\xcc\x6f\x65\x87\x53\xbb\x46\x98\xb2\x88\x73\x73\x71\x6a\x92\xdd\x2e\x5a\x08\x67\x0b\x2e\xc5\x30\x4b\xd2\x1c\x61\x08\x4f\x2f\x18\x30\xca\x8c\xae\x19\x1d\x2c\x59\x87\xee\x29\xe2\xa2\xad\x7c\x70\x7a\x91\x5c\x10\x61\xef\x14\xdd\x2a\xfe\xaf\x66\x9d\xfd\xe6\x28\x21\x6e\x6c\xdc\x60\x72\x5b\xb2\xdd\x49\x9c\x52\x4b\xff\x02\xd2\xd6\x4a\x57\xf1\x21\xcb\x80\xba\xd0\x83\x67\x6d\x9d\x06\x3c\x6b\x66\xd2\xae\xf8\xa4\x75\x50\x27\x3d\x24\x73\xe3\x51\x48\x3f\x7c\xaf\x5a\x9c\x25\xf0\x85\x49\x0a\x63\x60\xaf\x1f\x20\xee\x03\x55\x27\x7b\x56\x0c\x64\x4e\x12\x19\x4f\x55\x1b\x25\x04\x22\x04\xc3\xc4\x95\x7d\xd4\x36\x3b\xaf\xf3\x8a\x7a\x60\x78\x0b\x1c\xf1\x76\xb6\xa8\x83\xb0\x00\xb4\xaa\xf7\x6a\xdc\xe6\x87\x34\x8d\xca\x91\xd0\x0e\x1b\x80\xc3\x6d\xf9\xc1\x7d\x1e\xf6\x15\x2d\x3d\x64\x76\x31\x13\x54\x9f\x34\x9a\x20\x1e\xcf\xfa\xb0\x51\x6f\xff\x83\xaa\x64\x90\x6a\xe2\x2f\x1e\xd5\x64\x74\xd9\x12\x1f\x5e\x87\x10\x74\xf5\x8e\x6f\xd9\xdb\x1c\xc1\xa5\xfd\xcb\xec\xc0\x20\xa7\xc2\xc2\xc8\xa3\x62\x1e\x4d\xa2\xb5\xd8\x22\x67\xa2\x49\xe6\xa8\x83\x16\x59\xa1\xa5\x93\x44\x7d\xfb\x82\xe2\x37\x66\x6c\x2e\xa7\xb9\xe2\x6e\x85\xeb\xfa\x9e\x9d\x77\xaa\xf2\x35\x9f\x2f\xc9\xa5\x2a\x4d\x4b\x93\xa9\x20\x4a\xb7\x2f\x8f\xab\x58\x1d\x5f\xb5\xaa\xbd\xac\x83\x84\x6b\xcf\x39\x1c\x1e\xfd\x7d\xd2\xe0\x9b\xac\xb0\xda\x78\xf0\x51\x62\x26\xf7\x77\xae\x39\xd3\xe0\x75\x4b\xa0\xe3\x61\x93\xc2\x8c\xe3\x51\xdc\xa7\x73\x66\xde\x22\x98\x32\x07\x78\x1d\x8e\xdd\xef\x1a\x3a\x97\x63\xa8\x65\xd3\x1d\x92\x01\x79\x86\x20\x79\x8f\x7d\x34\x7b\x35\xe6\xb8\x5c\x17\x17\xa9\x3c\xb0\xfb\x29\xe2\x0b\xfc\xab\xea\xc3\xe6\x86\x71\x30\x8c\xc3\x5c\x4d\x47\x3a\xde\x0c\x69\x2d\x5a\x46\x43\x85\x70\xfb\x43\xf3\x20\x7c\x51\xcd\xbc\x35\xa8\xda\x81\x19\x66\xcd\xb5\x74\x4d\xbb\xef\x9c\xa3\x45\xdb\xd4\x9a\xad\xcc\x18\xc2\xfc\xab\x03\x2a\x87\x71\x5b\xfb\x6b\x1b\xa4\x2e\x62\xdb\x96\xc4\x76\xa9\x6a\x52\x6e\x90\x85\x3c\x71\xdb\x2c\x81\x7e\x70\x65\x44\x6e\x73\xdd\x26\x74\xdb\x67\x1f\x16\xbb\x6d\xb5\x5a\xf0\xae\xdb\x86\x9c\x33\x9f\xa7\x42\xcf\x3a\xad\x4a\x74\x16\xa0\x43\x15\x3a\x67\x07\x6e\xd3\x9f\x77\xad\xfe\xbc\x46\x72\x9c\x84\x67\x1c\x4b\x7c\x31\x6f\x6c\x64\xbb\x4a\xff\x80\x2f\x60\xd0\x18\x5e\xda\xa7\x70\xdf\xeb\xc3\xaf\x61\xe2\x8e\x0c\xd1\x27\xb1\x2c\x3f\x56\x13\x7a\x11\xba\xfd\x16\xc9\x12\xe7\xee\x54\x34\x36\x75\x36\xb5\x7f\x50\x2d\x61\x87\xdc\x09\xe2\xd1\xd0\x35\x08\x21\xb1\xbf\xef\x0d\xea\x02\xbf\xa4\xb2\xce\x1d\x3b\x4b\xb8\x80\x8b\x60\x8f\x65\x46\x41\x87\xf8\xac\xd4\x0d\xdf\xe8\x93\x66\x98\x75\x60\x46\xea\xeb\xb1\x28\x54\x61\xc6\xf2\x3f\x33\x5c\x99\xe0\xdb\xfc\xc0\x9a\x28\xec\x13\xbb\x26\x8a\x07\xd7\x84\xa5\x69\x48\xed\xe8\x99\x7e\xfe\x73\x23\x59\xb1\x9c\xcf\xb3\xd5\xa6\x6a\xa8\x0d\x4a\xa7\x36\x28\x1e\x56\x1b\xf4\x8f\x39\x12\x4e\x74\x23\x27\x27\x67\x48\x93\xba\x43\x4a\x54\xa3\x0c\x61\x2f\x52\xa3\x60\xc5\x5a\x0b\x2d\x72\xb6\x09\x81\x51\x4e\x14\x09\x07\xcc\x72\x56\x43\x50\x7e\xa4\x86\xa0\x4d\x8f\xef\xf7\xd0\x1c\x88\x9a\x0e\xa5\x59\x5d\xb9\x6b\x1b\x39\x1a\x62\xae\xd2\xe8\x8f\x9f\x74\xf3\x1e\x67\xf4\xf8\x24\x1a\xa9\x83\x85\xbd\x29\xaf\xbd\xf3\x89\xfe\xa6\x3b\x95\x42\x35\x83\x93\xe6\x21\xea\x68\x26\x59\x2e\x2c\xaf\x6e\x9c\x11\x75\x52\xdc\xb2\xfc\x7c\x3d\xcb\x3e\x5f\x94\xcf\x75\x03\x34\x15\x0e\x8d\x04\x41\x4f\x6b\x22\x9a\x99\x44\x69\x99\x36\xa2\x7c\xbc\xbd\xf2\x53\xb6\x57\x3a\x09\x5d\x6a\x60\xe1\xdb\x37\x31\x95\x74\x2a\x31\xf8\x75\x53\xdd\x7e\xe8\x5c\x16\x57\x30\x2f\xba\x59\xdf\xb1\x3e\x63\xe1\x17\xb0\x06\xd3\xd0\x65\xf4\xb8\x39\xda\x46\x04\x6b\xf9\x1e\x2c\x85\x26\x5a\xcc\x30\x9d\x32\xf8\x86\x77\x90\x2b\x5f\x00\x5d\x65\x0b\xa6\x92\xbe\x4c\xba\x20\x29\x40\x2f\x07\x2c\x64\x26\xea\xc7\x9d\x20\x06\xa3\x93\xa7\x55\xeb\x86\x64\xa3\x69\xd0\xe0\x38\xb6\x8e\x6a\x96\x2d\xa2\x9e\xf6\x82\xf7\x0e\xf3\x8c\x63\xe2\x19\xc7\x07\x78\xc6\xb0\x49\x85\x50\xc0\x4a\x99\x2c\xc9\x24\xf9\xb4\x35\x52\xbc\xb8\x8c\xa9\x97\xbf\x6a\x27\xb7\x13\xf7\xc3\x66\x04\xdc\x82\x6b\xaf\xc7\x2d\xf8\x23\x05\x35\xe1\x79\xec\x6b\xf0\x25\xba\x8c\x55\xf8\xe7\xb5\x0d\xdb\x5e\x77\x19\x7d\xe8\xfd\x70\xf3\x09\xdb\x3e\x0d\x02\xb8\x3f\xd8\x03\x6e\x6c\xb3\x0f\x08\xd4\x95\x4e\x44\x51\xeb\xc7\xce\x0f\xb0\x40\x3c\xa3\x8b\x70\x4a\xf7\x82\xab\xdf\xc2\xc9\x1a\xf9\x23\xc8\xe3\xcd\xa8\xe3\x1c\x57\x79\x5d\xcd\x19\x28\xcf\xfa\xf8\xa9\x89\xe1\x17\x4f\xc1\x62\xb4\x88\xde\x0d\xb6\xd5\xe8\x76\xa6\x46\xcd\xf7\x3b\x8c\xdf\xe8\x7f\xf0\x0d\xe2\xa3\x87\xb3\x11\x07\x26\x06\x1b\x76\x1a\xc8\x7b\x87\x37\xec\x47\xec\x57\xb7\x37\xa6\x46\xda\xfa\x88\xbd\x01\xd8\xe8\x76\x37\x82\x40\x01\x74\x70\x75\x0f\x8b\x7a\x4f\x0b\x98\x4c\x9d\xdc\x20\x3e\xae\x07\xed\x71\xc1\x6a\x6a\x5d\xcd\xbc\xa0\x0e\xac\xe7\x8b\xfa\x7e\x68\xae\xc7\xc3\x9b\xe1\xe2\x81\xcd\x50\x35\x36\xc3\xc3\xab\xf8\xf7\xec\x90\xc8\x73\x53\x11\x5c\x98\xfa\xaa\x7f\x40\x84\x13\x4d\x42\x63\xc4\xcf\x0f\xf9\x7a\x99\x55\x5c\xfd\x07\xab\x38\xa9\xbc\xdd\x55\x5f\xb9\x4d\xc3\x31\x8a\x0d\x1f\x5a\xa8\x03\xa1\xaa\x3a\xa3\x3c\xb8\x99\xa0\x46\x7b\xb0\xb7\x89\x26\x9d\x16\xe6\x40\x47\x88\x1d\x66\x59\xf8\xbe\xe6\x1d\xa2\x4f\xba\x2d\x55\x08\x47\xa2\x71\x54\xea\xa6\x7d\x2f\xd5\x01\x38\xcf\xfe\xc3\xdc\x46\xde\x41\x94\xa1\x31\xb4\x1b\x08\xa2\xa0\x87\x87\xde\x6d\x55\xbc\x66\xb5\xd1\x13\xbc\x8b\xe6\x3a\x46\x9e\xe0\xd0\x42\xe7\x96\xbe\x3a\x2e\x0e\xac\xfe\x22\xf4\xcd\x31\xaf\xf4\x83\x2b\x2b\x3e\xea\xeb\x36\x27\x1d\xfb\xec\x23\x44\x4b\x53\xed\x07\x5d\x75\x6c\xa5\x07\xac\x98\xfe\x2c\x7b\x66\x4c\x6f\xba\xe4\x44\x38\x20\x95\x96\x0d\x49\xae\x2f\xec\x05\xcf\xe1\x24\x1d\xb7\xf2\x25\xd3\x74\x32\x30\x16\xdf\xc4\x88\x9b\xfd\xc2\x08\x90\xd3\xff\x5c\x56\x6a\x97\x94\xfa\x45\x8b\xac\xa4\x8a\xb4\x20\x61\xe3\x8f\xc3\xcf\x4f\xff\x9d\x9d\xfe\x36\x3a\x73\x39\xae\xdb\x65\xa8\xd0\x2f\xad\xc4\xdb\x19\x15\xf7\xd2\x4d\x18\xac\xa3\x41\x99\xe4\xd6\xc2\xe0\x8b\x59\x05\xc7\xd5\x7f\xca\xf9\x2f\xd9\xea\x03\xd8\xe7\x20\x82\x16\xce\x6e\x1f\xb4\xda\xe6\xc8\x3b\x3a\x4e\x6b\xea\x2b\x51\x32\x78\x39\x16\x23\x60\x9c\x88\x13\xc6\xc9\x89\x76\x24\xc4\x97\xb7\x1c\x7a\x78\xc0\x50\x55\xd4\x0d\x55\xd0\x3a\xdb\x70\xaf\x0a\xfa\x48\x6b\x79\xa7\xd6\x57\x96\x02\x17\xcd\x63\xb3\x5c\x2f\x57\x30\x92\x45\x2c\x8b\x15\x87\x7c\xec\xca\xf6\x8d\x15\x8d\xb3\xf9\xa6\xa9\xb9\xd2\xbd\x6a\xa3\xfc\xc1\xf7\x20\x73\x7b\x83\x5f\xfe\x3e\x19\xb7\xf4\x65\x5c\x5b\x6f\xdc\x2f\x03\xc9\xd3\x7d\xb0\x64\xc9\x73\xf2\x90\x3b\x68\xd9\x74\x07\xa5\xed\x67\xeb\x38\x45\x8c\x39\x2e\xe0\x68\x55\xdb\xa3\xf6\x3b\xb4\x47\x27\x0f\xf8\x89\x86\x83\xe0\xc9\x60\x44\xa3\x26\x0d\x11\x6c\xf2\xc0\x21\xd4\x20\x00\xe0\xa7\x2a\xf6\x0d\xb3\x39\xe8\xd4\x91\x07\xe5\x64\xe4\x0a\xbb\xf1\xeb\xcb\x90\x01\x64\x69\x85\x1f\x4f\x80\x78\xff\x91\x76\x65\x12\xb0\xc6\x9e\x13\xc5\x22\x7b\x9b\x67\xeb\x53\xfa\xe3\x1b\x45\x3a\x87\xdc\xd9\xcb\xd9\xdb\x50\x19\xda\x1c\xeb\x58\xe3\x1e\x7e\x3e\xe6\x74\x5f\x1d\xcf\x10\x6d\x3c\x6f\x63\xcd\xd4\xb7\x6e\x37\x56\xb1\x99\xa5\x58\x36\xa5\x2a\x37\x1b\x53\x0e\xdd\x6b\xe5\x0f\x65\x59\xf6\xdd\x5e\xd2\xae\x21\x07\x4e\x9c\x88\x0e\x0e\x51\x93\x06\x87\x55\x7d\x5f\x58\x31\xc0\x6f\xc3\xde\xa5\x04\x0d\xe6\xbf\x61\xce\x96\x38\xfc\xb3\xce\xa7\xff\xb3\xfb\xec\x7c\xf7\xe4\xbf\x77\x9f\x3e\x89\x0d\x89\xd4\x16\x6b\x9a\x9c\x8f\x25\x22\x35\x1a\xc6\x6b\xa1\xe9\xce\x5b\xf4\x36\xdb\xe5\x0a\x09\xe1\xb3\x49\x26\xdb\x52\x1d\x97\x1f\x5c\x74\x9a\x20\xc2\x03\xb8\x6d\xd1\x1d\x23\x3b\xfb\x7f\x1f\x3b\x92\xcb\xd7\x96\x04\x1b\x01\xc8\xbb\x05\x49\x96\x19\xa2\x71\xdc\x98\x12\x84\x5f\x3a\xd7\x68\xac\x10\xb3\x3e\xa2\xa3\xf9\x2c\x59\x2c\xb7\x1d\xdb\xd6\x38\xd1\xb8\x86\x47\x19\xcc\x40\x95\x31\x85\xd8\x65\xc8\xc9\xf0\xba\x53\x6e\xe6\x2c\x70\xf7\xbb\x4c\x67\xda\xf8\xec\xdc\xaa\x3e\xfd\x1f\xaf\x85\x97\x40\x13\xb8\x3c\x3d\x55\x9f\x9d\xfb\x77\x9f\xce\xac\xbd\x94\xae\xba\x5d\xf5\x7f\x2f\x89\xc2\x5e\xa6\xe7\x50\xed\x57\x37\x9d\xcb\x66\x8f\x20\x4a\xe9\x2e\x30\x73\x61\x5a\xd7\x0f\xae\x0c\x97\x62\xae\x03\x0e\x66\x52\x7b\xf6\x61\x0e\xc6\x56\x3b\xfd\x10\x07\x63\x2b\xf5\xfc\x8d\x3f\x5c\xc4\x0d\x32\x90\xfa\xae\x43\x54\x9f\xac\xb9\xce\xf6\x1f\xae\x72\xdc\x42\x30\xe3\xba\xdb\xcd\x07\xdf\xd3\x65\x3f\xe6\xc5\xfa\x42\x69\xad\xe7\xf7\x32\x4a\xf5\x24\x82\x6d\xc7\x60\xe8\xd3\x6f\x4f\xbb\xeb\x65\x99\xc1\x3d\x6c\x72\xc8\x3d\xac\xfa\x80\x9e\x77\x1c\xe8\x80\xa4\x3a\x60\x0c\x38\xe7\xaf\x49\xeb\xd9\x39\x80\xe3\x2f\xf0\x2b\x26\xac\x97\x83\xb2\x18\x7f\xa1\xc3\x7e\xc0\xcf\xab\xe6\x98\xf5\x08\x71\x89\xa9\x77\x58\xe0\xba\x66\x7d\xf7\x5d\xc2\xca\x59\x36\x5f\x4e\xda\xcd\xc5\xdc\xf4\x53\x29\x61\x3d\x46\xcc\x99\xe2\x7b\x7a\x6d\x5e\x81\x08\xfb\x4a\x59\xda\x7c\xb3\x45\x36\xff\x82\x3e\xfe\x7d\x16\xf8\x89\xb1\x7e\x85\x8e\x37\xb6\x0f\x1a\xb9\x78\x36\x59\x2c\xd7\xd5\x17\xba\xea\xe7\x58\x9e\xd6\xf8\x65\x04\x30\x70\x47\xdb\xaa\xae\xda\x08\x9a\x6a\x70\xb9\x63\x46\x5c\xe9\xb4\xbc\xae\x5a\xfc\xb1\x0f\xe8\x97\x50\x85\x44\x84\xe8\x15\xb1\xff\xdd\x9e\x58\x9f\xb2\x27\xd6\x17\x9f\x3f\xff\xdb\x97\x3f\x7c\xf7\xfd\xaf\x87\x42\x57\x7c\x67\x2d\x33\xbc\x35\xaf\x2c\x85\x95\xd0\xf0\xce\xaa\xb3\x33\x35\x37\x20\x3d\x2f\xa2\x13\x07\xb7\x6a\x1d\x3e\xa6\x8c\xd4\x51\xf3\x25\x08\x74\xc1\xb9\x39\xcb\x78\xc1\x56\xcd\x23\x5f\xaf\xeb\x1a\xbb\x90\xef\xeb\xca\x32\x33\x9e\x55\x1c\x2c\x16\xec\x91\x03\x8c\x72\xb0\xa6\x8e\xf5\x0a\x61\x6f\xd7\x57\x66\xf1\x18\xcb\xfc\x86\x81\xbd\xc3\x7b\xbc\x03\x3c\x6e\x48\x96\x86\x1c\x94\x3a\x65\xf7\xa6\xc8\x56\xd6\xba\x2f\xc9\x64\x3b\x75\x0f\x15\x47\x27\x75\x10\x93\xd7\xe9\x7a\x74\x93\xdc\x26\xae\x35\xf0\xef\xc2\x88\x1b\x0f\x44\x7f\xb3\x39\xff\x3f\xa1\x84\x8d\xea\xfd\x58\x81\x9a\xd6\x51\xe7\xb2\x7d\xe8\xa5\x9a\x6f\x2e\xb1\x15\xae\x12\x48\x49\x65\xfb\x6e\x3b\x67\xe3\x9d\x34\xd4\x2c\xc2\x16\x8a\xd9\xea\x25\x50\xb6\x69\x70\x24\x3a\xa8\xef\x3d\xb3\xde\x68\x26\x9c\xc9\x7b\x26\x90\x3e\x88\xe7\x97\x09\x04\x07\x62\x1f\xf2\x7a\x8d\x6d\xcc\xff\xaa\xc3\xc0\x0f\x59\x79\x79\xbb\xd9\x7e\xc9\x63\xda\x61\xc0\xa6\xd2\xd7\x9f\x06\x7e\x08\x65\x9b\x2e\x91\xc3\x9c\xca\x5e\xb5\xa0\xb3\xb3\xa8\xbe\x66\xf7\x64\x23\xd9\x07\xeb\x7d\xf1\xf0\x82\xaf\x06\xa5\x37\xb7\x1f\x70\x69\x28\x5b\x48\x8d\xe1\x83\x9d\x01\xe2\xf7\x39\x19\x24\x1f\x5b\x69\x6d\xcb\x87\xda\xe4\x5c\x80\x18\x9b\x0c\x6b\x8b\xaa\xd8\x1c\x92\x07\x95\xc4\xfe\x26\x26\x0e\xba\x5d\x65\xec\x02\x53\xf4\x66\xbf\x78\x70\x83\x06\xcc\xd3\x78\xac\xbb\xf8\xff\x27\xef\xda\x9a\xdb\x36\xbe\xfb\x7b\x3e\x05\xc9\xa4\x32\x10\x82\xba\x38\xd3\x3e\x80\x86\x38\x49\xe3\x07\xcf\xb4\x49\x26\x71\xda\xe9\xa8\x6a\x03\x80\x00\x09\x99\x12\x19\x49\x8e\xe3\x11\x95\xcf\xfe\xdf\x73\xdb\x3b\x48\x4a\xce\xf8\xe5\xff\x22\x11\xc0\x62\xb1\xd7\x73\xce\x9e\xcb\xef\x74\x37\xfd\x0d\x0a\xa2\xda\xe8\xbd\x9e\x7d\xcd\x4f\x7b\xf7\x98\xbf\x8d\x75\xe1\xf8\x3e\xee\x0b\xa1\xeb\x53\x79\x72\x38\xdd\x53\x6c\x0d\x9a\xce\xfc\x27\x7c\x71\xa7\xca\xb6\x67\xe5\xb8\x35\x24\xfe\x0a\xb1\xf7\x46\xe1\x38\x0d\xec\x9d\x0a\x13\x7d\x60\xdf\x0e\x19\x70\xe9\x71\x60\x00\xbc\x43\x70\x47\xdc\x60\xe2\x93\x6a\x0d\x97\xf6\x32\x36\x84\xa4\x87\x85\x8b\xe8\x2f\x8c\xdb\xed\x1a\x2e\xb2\x40\x6f\xaf\xd7\xac\x23\x3d\x08\x2b\x0e\x66\xc7\x48\xb7\x21\x49\x8e\x75\x15\xce\x5f\xa5\x9c\x63\x2c\xc6\x2c\x6d\xcc\x5d\x26\xe9\x7d\x0e\x46\xba\xf7\x7b\x5e\xff\x68\xdb\xf4\xf5\x6f\xe6\x7a\x85\x50\xe1\x48\xdb\xa9\x89\x18\xb4\xfc\xeb\x66\x0e\x09\x4d\xb8\x9d\xd6\xfb\xd0\x2a\xbf\x82\x08\xa5\xc1\x15\x16\x37\x65\x7b\x32\x03\x0d\x49\x3f\x2f\x2a\x99\xc9\x3b\xdb\xdb\xe1\xf3\x25\x45\xea\x7d\x8b\x2c\x02\x83\xab\x13\x7d\xd3\x96\x18\xca\xc8\xaa\x31\x9a\x36\xe9\x4a\x30\xb2\xf0\x59\xe1\x9f\xa1\x19\x54\x9a\x2c\x5b\x5d\xae\x8d\xfe\x33\x22\x4a\xbb\x9f\xa8\x82\xca\x7d\x81\x6c\x0f\x15\xa1\xff\xf9\x68\xa4\x4d\x79\xf1\x85\x2d\x1f\x32\x06\xf3\x18\xc9\x6a\x8c\x41\x50\xb7\xec\x09\x0a\x29\x9a\x1a\x79\x73\x00\xb0\x99\x86\xe1\x1b\xa1\xed\x29\x22\x58\x6c\x6f\x39\xb2\x6f\x28\xe3\xa0\x29\x2c\xd9\x71\xde\xa0\xf8\x7b\x4d\x5e\x08\x73\xf7\xfd\x2d\x08\x2d\xc4\xed\x15\xbf\x32\xf0\x4b\xd1\x61\x9c\xf9\xa4\xec\x98\xa2\x9e\x2c\x42\x8b\xc0\xcb\x22\x17\xb6\xfe\x1a\xf1\x05\x17\x6f\x05\x79\xc2\xcb\x50\xc0\x22\xa7\xed\xcc\x2b\x19\x67\x1c\x55\x2f\x77\xd8\x75\x4a\x49\x73\x80\x67\x96\x4c\x0c\xc3\xc8\x72\xfa\xca\xac\xa3\xe8\x9a\xb7\xed\x52\xe4\x04\xe1\x88\x44\xee\x8e\x4a\xc8\xa7\x03\x3c\x6a\x3e\x81\x83\xee\x19\x89\xc5\x33\x47\x62\x21\x23\xc1\x4d\x74\xc9\x9c\x45\x28\x03\xba\xe0\xca\xab\xee\x8b\xf6\xb3\x3d\xde\x3e\x08\xcc\x82\x24\x8c\x4c\xe5\xe7\x7d\x5a\x65\x06\x89\xa3\x52\x1e\x85\x05\x04\x22\x41\x86\x42\x04\x30\x9a\x54\xd8\x85\x6f\xee\x7e\xfc\xa3\xb9\x6d\x57\xeb\x0f\xe8\x49\xc0\x81\x03\xee\xb9\x5d\xd1\x95\x8c\xdf\xfe\x19\x21\xa9\xfa\xde\x1e\xf6\xbd\x1e\xd2\x54\x97\x5c\xf7\x3b\x97\x04\x4d\xf7\xdb\x12\x56\xee\x1e\x1e\xc3\xf1\x25\x4e\x76\x8c\x00\x59\xd8\x40\xf2\x23\x11\x47\x89\xde\x01\xee\x81\xc2\x9b\x96\x45\x75\x8c\x6e\xf1\x13\x44\x94\x2a\xab\xbb\x84\xf0\xe4\xd2\xc7\xf8\x40\x15\x8e\xba\x86\x27\x8e\x32\xcb\x94\x51\xbd\x09\xde\xbb\x6e\xca\xbb\xf7\xb7\x8d\xc5\xcf\xc2\xe0\xf8\xfe\x4e\x23\xbc\xe4\x9b\x9b\x7b\x8b\x00\xe3\xd8\x8e\x78\x30\x27\xe4\xd8\x8f\x60\x94\x67\xa7\x7c\xac\xf7\x15\x3b\x6e\xbb\x19\x70\xd3\x9a\x0c\xcc\x0d\xd7\xb7\x38\x76\x7f\x38\x2b\xc7\x91\x9e\xc7\x96\x4d\xb4\x93\x7b\x2a\x8f\xf5\xc6\xab\xdb\x1f\xde\x70\x08\x77\x32\x40\x45\xbb\x6a\x20\x4b\x60\x19\x60\x15\xc1\x44\xf7\x65\xc2\x95\x8f\x1c\x9d\x85\xe4\x5c\xd2\xc0\x4c\x16\x27\x98\x94\xf6\xb2\x70\x03\x99\x10\x8b\xec\xf4\x52\x68\x2d\x22\x9e\x97\x8a\x88\x3a\xde\xe0\xd8\x82\xa9\xf9\x29\x7e\xe0\x78\x11\x73\x02\xa7\x07\xfb\x95\xdc\x54\xdb\xde\xb8\x6b\xaa\xae\xd7\x40\xaf\x75\x28\xb1\xa0\x6b\x31\x09\xcf\x7d\x78\x95\x52\x9b\x55\x3d\x93\x3d\xfa\xe9\xed\xf4\x1b\x77\xed\xf6\x2c\xea\x19\x83\xbd\x51\xfe\x92\xe6\x30\x1f\x9e\x7c\xc9\x96\x21\xb0\x16\x37\x96\x2b\xb9\xc4\x0b\x83\xb2\x03\xac\x38\xe5\x08\xad\xeb\xc1\x39\xba\xe5\xa0\x2d\x57\x83\xe6\xaa\xec\xe3\x3a\x31\x7e\xd3\x97\x4c\x5d\xbd\x02\x66\x9d\x61\x53\xcc\x08\xfd\xe6\x83\x83\x10\x68\x78\x8c\x07\x3b\x67\x24\xfb\x7c\xc1\xd7\xf7\xeb\xf5\xea\xbe\xdb\xec\x40\x31\x49\x9a\xed\x76\x78\x32\x57\xa3\x7c\xbb\xfe\xe8\x7a\x47\x63\xde\x3c\x27\xb4\x5a\xaa\x8b\x44\x56\xf7\x3a\x44\x47\x74\xe9\xe8\x43\x43\x56\x64\x08\xac\x0f\x5c\x8b\xad\x3b\xcd\x0d\x5a\xbc\xac\x3b\x9c\xa9\xd3\xba\x83\xa1\xb5\x04\x4a\x62\xc5\x39\x8b\xea\xdd\x8e\x8f\xf6\x0b\x75\x37\x80\xb6\xa6\x7b\x85\xf0\xb6\x07\xeb\x9a\x7d\x45\x32\xe1\x43\x43\x90\x0f\x64\xf4\x87\x6d\x00\xdf\xcf\x09\xda\x92\xb2\x7e\xad\x6f\x21\xc9\xdf\x7d\x73\xbd\x01\x31\x28\x7f\x01\xf0\xda\x03\xa4\x59\x85\x6e\xc5\x40\x11\xac\xc6\x5c\x9e\x47\xca\x4c\xca\xdb\xdb\xf5\x07\xf5\xe8\x04\xe0\xb9\x63\x05\x08\x79\x52\x0a\xe0\xdf\x17\x19\x2f\x4e\x8e\x45\x1e\x30\x4c\xc0\x7d\x77\xbf\x6a\x80\xa5\xcf\x9b\x55\xf9\x31\x3f\xa5\x24\xfd\xc3\xb3\x8c\x9d\x33\x1a\x6c\xf3\x1f\x5d\xf3\x01\xd3\xcd\x3f\xe8\x9e\x50\xc6\x37\x91\x04\xf2\x53\x2f\x24\x18\xc6\xb6\xf0\x51\x25\xe5\x50\x23\xd3\x2a\xca\x66\x4a\x8e\x1d\x18\x4d\x6a\xcf\x4b\x1e\x2f\x14\xbd\xe1\x2c\xfc\x89\xc4\x1c\x7e\x25\xcd\x73\xcf\x08\x72\x17\x6c\xf9\xa5\x8d\xe4\x1c\x2d\x95\xce\xa2\xb7\xad\x9c\x79\x4e\xf3\xf8\x80\x11\x14\x97\xf1\x61\x55\x42\xf0\x15\x77\x2d\x3e\x20\xb5\x86\x11\xc6\x49\x81\x1f\x38\x2f\xea\xc7\x63\xe6\x4b\xa1\x9d\xe2\x18\x90\xf0\x1e\x30\x24\x35\x23\x34\x6c\xc4\x0f\xdc\x95\x96\x84\xf0\x80\xbf\xc9\xa3\xdf\x06\x54\x78\x70\xad\xc4\xc0\x41\xa5\xa8\x0f\x20\xb9\x41\x4a\xd5\xc1\x87\x65\x73\x33\x80\x49\xc4\x3c\x60\x6a\x86\xd5\x29\x52\xcf\xd5\x78\x34\x58\xdf\x20\xa6\x22\x4b\x72\xd2\x9e\x01\x11\x99\x21\x67\x05\xb2\x42\x23\xb5\x27\x3f\x3b\x82\x1a\xe0\x43\xb4\x06\x72\xb8\x70\x3b\x99\x4c\x25\x8a\xa8\xb9\x68\x2f\x41\x2e\xd4\x2e\x46\x8b\xb4\xef\xb8\x6a\x35\x2d\x8b\x8e\x81\xab\x5e\x21\x96\xc3\x47\x42\x9d\xf0\x6e\x74\x5d\xde\xbc\x57\x44\x7e\xa8\x3e\xf4\xc0\xb6\x77\xc1\x31\x58\xcc\x2c\xd8\x01\x75\xca\x67\x35\x1b\x98\xdf\x83\x32\x08\x32\x20\x65\x20\xc3\x70\xe0\xcd\x9c\x2c\xc7\xa3\xa7\xb6\x19\xbf\xec\x5a\x37\xac\x0a\xbb\xa7\x57\x88\xcd\x14\x45\xdd\x63\xf4\x05\xda\x11\xff\x1f\x0b\x52\xb1\xcb\x67\x0f\x9a\xb4\xf0\x10\x1a\x7a\x07\x67\x03\xda\x29\x6d\xf7\xe7\x5b\xa0\x35\xbe\xd0\xac\xf6\x33\x73\xe0\xbb\x88\xc0\x63\x28\x6c\xf0\x16\x53\x81\x68\x3c\x74\xd8\x56\xeb\x33\x81\xe9\x89\xc5\x0a\x80\x43\x3d\x46\x32\x78\x74\x14\x42\x85\xc8\x93\x84\x7f\x15\x0f\x68\x22\xe4\xab\x0c\x58\xa7\x5c\x00\xd3\x8f\x74\x92\x90\x0e\x83\x66\xcb\xa9\x07\x8c\xde\x45\xd8\x56\x47\xf2\x94\xb9\x00\xef\x39\x94\x03\x9c\xbb\x36\x20\xb1\xa2\xb6\xf5\x45\x79\x39\x04\x20\xf6\x04\xb2\xa8\x15\xf3\x34\x6c\x17\xae\xaa\x08\x96\x57\x35\xb0\x88\x0d\x7e\xc3\x22\x34\xb3\x2a\x07\x83\x97\xa3\xa9\x49\x8d\x94\x60\xad\x43\xdd\x78\xf2\x94\x04\x12\xe4\x57\xe6\x57\x64\xcd\x96\x33\x5e\x10\x38\x78\xe0\x57\x01\x91\x2b\x73\x7a\xc0\xe6\x14\x0c\x20\x61\xd2\x7b\xa1\xf7\x30\xc0\x14\x63\x62\x23\x96\xda\x04\xac\xe3\x12\xc3\xe8\x6b\x25\x71\x6c\x92\xd4\xf3\xf5\x55\xc7\x2c\x7c\xb3\xb6\xa4\x0f\x52\x77\xd9\x77\x0a\x2c\x9b\x27\x4e\x32\xef\x5a\x27\x1b\xcf\x82\xb2\xea\x8e\xec\x41\x5e\x6d\xde\x0d\xb4\xcc\xc9\x87\x44\x14\x8a\xc7\xd3\x86\x0d\x84\xda\xc8\xb2\xf7\xe8\x7f\x08\xef\xa7\x69\x2e\x05\xbc\x3d\xda\xdd\xbd\xa1\x51\x7b\x7b\xfb\xde\xd1\xb3\x38\xf9\xfa\x6c\xce\x96\x6a\x2d\x28\x0f\x77\x29\x20\xaa\xc3\x53\x03\x9e\xea\x7c\x04\x09\xd2\x3f\xf3\x5a\x04\x5e\xb1\x63\x31\x9e\x91\xaf\xab\x35\x13\x49\x2a\xb8\x05\x07\x2e\x31\xf8\xc2\xfe\x35\x06\xa4\xec\xc0\x35\x46\x4d\xf6\x17\x99\x58\x58\x62\x15\xe3\x22\x63\xb5\xec\x2e\x7f\x88\x20\x68\x46\x4e\x71\xce\x94\xca\x2a\x33\x39\xf1\x12\xc1\x0c\x62\x19\xb3\xcf\xdd\xa4\x4a\xf5\x59\x5d\xbb\x21\x07\x6a\x3f\x27\x7f\x45\x80\x5e\xee\x17\x67\x78\xbd\xf8\x89\x72\x38\x17\xcd\xb1\x11\x8a\x94\xe4\xc3\x67\x9a\x4d\xa2\xb1\x1f\xd4\x52\xfa\xf5\xcd\xf7\x89\xd5\x49\xd2\xca\x34\xf7\xba\x87\x10\xc9\x8e\x67\xf0\x0e\xf5\xaa\x7e\xec\x8e\x71\xee\x54\xe7\xba\xfa\xb6\xab\x9a\x79\xf5\xd1\x14\x94\x39\xd1\x07\x16\x70\x7c\x32\x7a\x6e\x76\x23\x60\x01\x28\x84\x2f\x77\xea\xd0\xe7\x9c\x59\xfc\xb6\x25\x3d\x23\xe6\x44\x30\x64\x79\xfc\x3d\x25\x57\x9d\xfc\xef\xdd\x0c\xb2\xba\xcc\xd4\xff\x93\x2e\x03\xcf\x45\x3c\x98\x2e\xd3\xe9\x95\xda\x3c\xcb\x62\xa9\xd5\x0d\x1d\xe8\x17\x14\x49\xa6\x64\x32\xad\x41\x9b\x45\xd5\xa5\x9d\x75\x23\x9b\x77\x4a\xf0\x54\xe7\x9c\x51\xb5\x5a\x2b\xa1\xf2\x31\xb5\x11\x12\xe2\x3b\x98\xce\xd5\x4e\x3b\xf5\xd9\x08\xd2\x4f\x3a\x76\x95\xa0\x04\x21\x8a\x19\x5f\x60\xf7\x10\xd1\x17\x6b\x47\x6f\x90\x37\x94\xb3\xe0\x61\x5a\xde\x99\x38\x5b\x93\xe4\x66\x55\x04\x58\x10\xd7\xf6\x2d\xd6\x4a\xab\x15\x7a\x45\x5b\x0b\x7c\x24\xd7\x61\x4d\xee\x81\x2a\x9d\xaa\x35\x50\xad\xef\xef\xd7\xd7\x6a\x05\x2c\x8f\x8e\xde\x1d\xd3\xd5\xf8\xfa\x7c\xcd\x3f\x67\x38\xee\x74\xd0\xe5\x32\x90\xed\xe3\xfa\xd5\x1a\xfe\xcf\xe4\x75\x01\x2e\xe1\x22\x78\x31\x5e\xa9\x5a\x30\x60\x56\xa3\x9b\xe0\x3f\x2e\x83\xa9\x40\x56\xaa\x1e\xf8\x31\xe3\xf7\xf3\x65\xe6\xa2\x54\xdc\x38\x73\x88\xca\x86\x8d\xee\xd7\xbf\x97\xab\x1a\x8d\x0e\x73\x4e\x64\xb3\xcc\xde\x65\xab\xec\x5a\x82\x85\x00\x15\xfa\x27\x59\x75\xc9\x26\x5b\xd2\x10\xff\x1e\xea\x1e\x1b\x8b\xc8\x4d\x9b\x5d\xf1\x91\xa3\x71\x43\xb3\x95\x35\x81\x72\x82\x29\x66\x49\x51\xad\x8a\xe1\x25\xcd\x1e\xab\x8b\x22\x0e\xa1\xc5\xa5\xed\x31\xb2\xfc\xfe\x34\x67\x84\xdf\x03\x24\x2f\x77\x40\x3c\xff\x47\x63\x0f\x65\x92\xd5\x14\x73\x7f\xd1\xb5\xf6\x2d\x8e\x2d\x5c\x18\xdd\xf7\x9c\x94\xc3\x94\x8e\x62\x42\x1b\xf6\xec\x14\x62\x77\x7a\x8a\x70\x3e\x28\x50\x88\x77\x77\x3f\x94\x3f\x24\x0b\xd0\x4b\x2d\xd0\xf3\x18\xaf\xc1\x61\x5c\x51\x83\x53\x8a\xb2\xda\x8c\x8b\x45\x56\x71\x8e\x9a\x65\x56\x86\x99\x8c\xa0\x79\x99\x39\x1e\x60\x9e\x25\x27\x7d\xd2\xdc\x90\x0d\xb4\x26\xdc\x82\xc5\x01\x8c\x94\xeb\x0d\xe7\xaa\x71\x6e\x93\x99\x01\xc6\xb1\x02\xf4\x56\x1b\x23\xd6\x98\xdf\xba\x70\xa0\xae\xc2\x81\x9a\xf2\x1e\xaa\x8f\x8e\xae\x86\x80\x64\x9d\x54\x26\x9f\xd4\xb8\x9d\x5c\xf9\xfb\xff\xbf\x78\x9b\x92\x1d\xa7\x99\x2b\x39\x45\x11\xb0\x3a\xab\x20\x83\x57\x3a\xa5\x1d\x34\x93\xe1\xa0\xcb\x9c\x87\x09\x77\x29\xe3\xe3\x9c\xa8\x9f\x5b\xda\xa7\x3a\x5e\x49\x91\x8f\xd5\xec\xe5\xd7\xbc\x0b\x9b\x71\x97\xc3\x05\xec\xec\x76\x7c\x95\xdd\xa8\x87\x23\xab\x3b\x90\xd7\xc4\xea\xc9\x68\x3a\x97\xd4\x42\x95\xf6\x2a\x42\x62\xfd\x2d\xe8\xae\x92\xeb\x0c\x3a\x7f\x71\x73\x99\xad\x02\x03\x83\x29\x16\xa4\xf0\xa3\x3d\x8b\x35\x10\x71\xaf\x35\xdd\x40\x35\xdb\xbf\x9e\x7e\x9d\x9c\x4d\xca\x93\x2a\x1d\x8f\xfe\x65\xa4\x8b\x10\x7d\xc2\x82\xc0\x29\x02\xa3\x0d\x33\xd6\x1e\x3b\x20\x2d\xf5\x4a\x0f\x3a\x9f\x62\x41\xb3\x4f\xbe\xb0\xae\xd6\x8d\xf1\x84\x84\x11\x80\x3a\x6d\x46\x48\xc7\x94\x47\x77\x74\x09\x43\x52\xba\x76\x5a\xd8\xd6\x28\x42\xaf\x37\x03\x9a\x87\x01\x34\x77\xc0\x26\xa1\x3d\x5e\x64\x56\x34\x12\xc9\xfd\x43\x87\x5a\x21\x6a\x0a\xb3\xc4\xac\xf1\x9d\xb5\xbe\x8d\x8b\x0b\xd1\x48\x28\x43\xd9\xd8\x18\xeb\xc8\x32\x82\xb2\xa4\xc6\x82\xbc\xb9\x3d\x1f\xb6\x98\x30\x1e\xe7\x7f\x0b\x40\x58\x8f\xc9\x51\x5a\xde\x6d\x0f\x06\x50\x6f\x0f\xa7\x9e\xf3\x27\x3a\x01\x8a\x22\x21\xa6\x81\xf6\xe6\x4c\xb4\x1f\x7b\x6c\xcd\xd3\x44\x82\x48\x51\x2f\x8b\x52\x4d\x90\xb3\xd2\x36\xc0\x88\x45\x6d\xc2\xe5\x53\xce\xb3\xde\xf3\x3c\x0b\xab\xd7\xe1\x40\x5c\x22\xd8\x20\x46\xb6\xee\x03\x51\x33\x9b\x22\xd0\x7a\x88\x5c\xe1\x7a\x3d\x42\x1e\x51\xb7\xdf\x7c\xd4\xa3\x44\x69\xa3\xef\x7e\xfc\xfe\x7f\x28\xa6\x90\x02\x7d\x10\x1b\xa6\xcf\xf8\x4b\xc8\xde\x0d\xc9\x11\x98\x10\xce\x56\xfe\x34\xd9\x03\x3e\xc8\x1b\xb6\x10\x53\x82\xb7\x8c\xe0\x39\xd4\x5d\xda\x6e\x13\x4c\x0e\xf7\x98\x8a\x3b\xea\x7c\xe6\x66\x6b\x53\x54\x53\x67\x54\x5b\x14\x9c\xca\x2b\x9f\xcf\x7a\x4d\xd5\xda\x77\x76\xbb\xf5\x6c\xb6\x3a\xd9\x57\x65\x39\xd8\xaa\x91\x5b\xc2\x47\xa9\xad\xc6\xd7\x0b\xaf\xd5\x37\xb9\xb9\xe6\x01\xdd\x50\xef\xe5\x98\xba\x55\xdb\x07\xed\x9e\x43\x2a\x47\x1f\x6a\x31\x22\x13\x79\x64\xd6\x84\x72\x18\xc9\xaf\x9c\x99\x6c\x6e\xe3\x8a\x3f\x6e\x27\x6e\x53\x37\xb1\xa9\x27\x2f\x27\xf5\xc9\xcb\x47\x91\x06\xed\xf7\x26\xf3\x9d\x2f\xb0\xe0\x17\xfd\x92\x2a\x34\x3f\x79\xe9\x24\x8a\xab\x1f\xf3\x83\x0a\xca\x77\x1e\x83\x61\x88\x32\xcf\xc8\x58\x10\x8d\xf3\x92\xf7\x69\xb7\x1c\x23\x2a\xf3\x14\x34\xbc\x82\x7a\x4c\x11\x71\xab\x01\x5b\x51\xc0\xf4\xbf\xd8\x2f\x93\x43\x04\x1d\x2e\xe6\x2d\x34\x87\x39\x76\x99\x8a\xd6\x9a\x46\xbb\x9d\x48\xd2\x36\x75\x98\x12\x09\x42\x6e\x8d\xe7\xd3\xe5\xab\x05\xca\xe7\xb8\xf0\x8b\x05\xa5\xac\xcc\xbb\xf3\x05\xa5\xad\xe4\x01\x85\xfd\x64\x0a\xe8\xdb\x93\x8e\x9c\x72\x38\xa8\x8c\xe7\xa4\xcd\xde\xf1\xcf\x71\x3b\xae\xa7\x57\xaf\x16\x24\x80\xd0\x96\x2b\xe8\x6a\x72\x95\xbf\x53\x1f\xb9\xd5\xb5\x5b\xcf\x54\xfd\x38\x59\x93\x77\x12\x51\x38\x68\x82\x79\x8b\xd3\x51\x1f\x0d\x5f\x74\xa9\x3c\xd4\x7a\x83\xb8\xa1\xdc\x3e\xf9\xdc\x6e\x93\xc8\x91\x17\xd4\x20\xea\xf1\x8c\xff\xd3\xa1\x16\x33\x9c\xe7\x7c\x2b\xdc\x64\xea\x0c\xef\xc4\x89\xcc\xd7\x83\x72\x5c\xfc\xf5\x57\x72\xd6\xfc\xdb\xd7\x24\x40\x42\x4a\xf2\x6b\xb0\x62\x53\x0a\x42\x4d\x26\xd4\xdb\x4c\x45\xbe\xfb\xf8\x06\x1c\x0b\x0c\xbc\x90\x17\x8e\xd2\x6d\xa2\xd8\x24\xc0\x81\x35\x7e\x27\x14\xf2\xd0\x19\xc4\x02\xa9\xc4\xea\x61\x61\x4e\x19\x1c\x28\x18\xd8\x8b\x6c\xb3\xcf\x6f\xf2\xae\x6b\x3a\x02\x25\x5a\xa7\xfe\xab\xc1\x6a\xfe\x2c\xeb\xfb\xd5\xc7\xc1\x19\x08\x33\x4a\x7c\xff\xa3\x59\x0d\x78\x4e\x86\x23\x8f\xef\xab\xaf\x7a\xc7\x0f\x57\xec\xf3\x50\x76\xe9\xa9\xf5\x9b\xb9\x08\x69\x68\x3d\x69\x8c\x8c\xa4\x81\x7b\x35\x28\x85\x02\xb7\x15\x63\x8f\x74\x8b\x73\xc4\x65\x7f\xf9\xb3\x58\x7c\xd0\x6b\x7e\xda\xfb\x96\x7d\xb5\x3b\xc0\xc8\x41\xf9\x9d\x52\x36\xee\x43\xf5\x9d\xd9\x67\x57\x74\x2a\xb1\x70\x66\xb4\x9a\xc7\x35\xb9\x79\x7a\x37\x22\x4a\xcc\x9a\xec\x10\xea\xd0\xa1\xf6\x13\x9d\x8a\xeb\x94\xf6\x56\xa8\x7a\x9f\x99\x22\xb9\x79\xd1\x9b\x37\xf2\x67\xe8\xf1\x7d\x76\x74\xa5\xbc\x80\x58\x5d\x4a\xe2\x1c\x68\x27\x5d\xef\x67\xc7\x21\x5c\x75\xbb\xa4\x21\x66\x21\xf4\x7b\x33\x1e\xfc\x00\xfc\x9c\x71\x13\xd2\x7f\x23\x7e\xd3\x35\x89\x89\xa5\xac\x68\xb9\xd2\x66\x6c\xf4\x4f\x76\x53\x39\xf0\xb2\x9e\xda\x17\xe2\x51\xc4\x97\x31\x9f\x22\x79\xb4\xdf\xab\x48\xea\x64\xbf\xa2\xcf\xe6\xa3\xb2\x59\x6f\x50\xc3\xfd\x37\xf9\xa8\x48\x75\x7f\x9b\x8f\x0a\x39\x89\xe8\x6a\xc9\x49\x84\x60\xaf\xcc\xa8\x85\x36\xf6\x9f\xe8\x05\x93\x73\x4f\x66\xe2\xea\x0e\x90\x43\x76\xa5\xe2\xb1\x85\xb8\xbe\xf9\x35\xd1\xb1\x0f\x96\xaf\x89\xf8\xda\x89\x39\x56\xb0\x06\x38\xff\x28\xb8\x06\x46\x9d\x4f\xa4\x77\xbb\x9c\x4f\x5c\xa7\x93\xe5\x37\xde\xbb\xcc\x41\xd5\xf3\xe5\x37\xe7\x91\xba\x75\xac\xa8\xeb\x95\xf2\x98\xda\x1b\xf7\xb0\xae\xeb\xe2\xa9\xeb\x74\xea\xac\xfe\x4f\x37\x31\x3f\x57\x31\x60\x59\x71\xb5\xc6\xde\x28\x0b\xdc\xe1\x3a\x54\x59\xe0\xbd\x6c\xe2\x6e\x0d\x8c\xb1\xd1\x7a\x23\xb0\x51\xac\x62\x7f\x03\xd4\xfa\x5b\xa4\xc4\x36\x1f\xad\xe3\x1a\x8a\xa8\x7a\x62\xc0\x87\xef\x78\x07\xf1\xd3\x60\x00\xe9\x2f\xa0\xad\x45\xcf\x3b\x73\x1a\x4c\x6d\x3d\xdc\xe1\x91\x67\xe7\x44\x6a\x99\xb1\x8a\xcb\x8c\xb6\xc4\xa8\x87\x3e\x2e\x2a\x56\xc7\x5c\x60\xa6\x7f\x71\x12\x77\x14\x17\xf5\x4d\xdf\x1d\xfd\xd3\xe5\x1e\x91\x77\x6c\xa6\xc1\x43\x3d\xb5\x2f\x84\x69\xf0\x65\x8c\x69\xc8\xa3\xfd\x4c\x43\xea\x7c\x1e\xd3\xa8\x4d\x8a\xb3\x5d\x51\xf4\x74\x64\x79\xad\xdd\xc2\xc0\x31\x0c\xc3\x6c\x9d\xc2\x33\x3a\x19\xe7\xbe\xd3\x98\x4d\x52\xaa\x30\x45\x9a\x78\xaa\x14\x9e\x88\xcc\xc1\x70\xa3\x51\xaa\xa4\x5e\x40\x88\x19\xac\xba\xc1\x39\x20\x6e\x50\x39\x3c\x39\xdf\x15\x17\x6c\xd3\xa2\xf2\xe6\x9a\xf0\xa5\x49\x60\x0a\xa2\xf1\x49\x47\xaa\x31\xea\x9c\xfe\xa1\x57\x13\xdd\x01\x9d\x19\xfd\xba\xdb\x7c\xf4\xf3\x9b\xdc\xae\xeb\xe6\xee\xce\x71\x08\xba\x6d\x5a\xc5\x68\x96\xa2\x95\xe2\x22\x01\x54\xd4\x33\xf9\xb4\x69\x49\x94\x53\xd7\x47\x47\xb5\x97\x89\xc7\x6a\x3b\x31\xe3\x6a\x07\x33\xae\x81\x19\xd7\x84\xa0\x5b\x05\xdc\xb1\xb2\x1c\x2d\x69\xe8\xf3\xb3\x53\x98\x4f\x67\x97\xff\x62\x8f\x6e\xdf\x66\x72\x46\xdb\x8f\xed\xd8\x6e\x75\x4a\x6a\xb3\x2e\xfd\x42\xd9\x1e\xa5\x0f\x95\x4a\xdd\xe6\xf1\xe4\x84\x06\x6e\x1c\x92\xba\x90\x5c\xd6\xd9\xbc\x38\x9d\x1e\xb4\xc4\x9c\xb5\x24\x24\xd0\x1e\x02\x14\x37\x75\xe6\xee\x78\xef\x09\xee\xd9\x24\xb4\xd7\xa9\xfb\xdc\x45\x69\x29\xaa\x9c\xa8\x7f\xa4\x3d\xce\x3e\x4a\x63\xb9\xf7\x2b\x1b\x65\x8c\x17\x88\x71\x1d\xaf\x7c\x27\xf3\x93\xff\xfb\xf2\xd8\x72\xfd\x06\x28\x33\xa1\xc5\x98\xde\x53\x20\x9a\xda\xc0\x05\xfb\xe2\xa2\xc5\x45\x84\xca\x8a\x79\xd6\x5c\x5e\x6e\xb7\x24\x4c\x1f\xdf\x29\xc1\x3a\x71\xe5\x3b\xa1\x64\x6a\x1c\x26\x70\x9c\x7f\x0c\x31\xd2\x44\xed\xa7\xb6\xd3\xfb\x3b\x72\xb7\x82\x51\xcb\x24\xde\xdf\xbe\x7f\x76\x89\x91\x8b\x95\x93\x7a\x02\xf7\x60\xbf\xb6\xa2\x77\x98\x5d\x30\x44\x6a\x84\x25\x59\x78\xf3\x3c\x2f\x22\xc5\xc7\xf5\x24\xf6\x11\xd1\x1c\x4a\x4c\x23\x77\x50\x3b\x23\x50\xbf\x44\x0f\x65\x13\x32\xed\x6e\x61\x2f\xbd\x21\x98\xab\x3c\xfa\x53\x9d\x17\xe2\xee\x30\x58\x0c\x8b\xa4\x2c\xda\x8b\x56\x23\x08\x5d\x8a\x8b\x06\xd6\x0d\xf9\x2f\x4b\xd4\x69\x2d\x94\xb0\xff\x0a\xa0\xe0\x9c\xe4\x15\x3d\x94\x14\x0f\x71\x09\xb9\x99\x96\xc6\x81\xb4\x04\x07\x52\xf5\xc9\xf6\xa2\x84\xfc\xd8\xe7\x45\x83\x3f\x12\x9d\x0e\x5e\x5d\x8f\xcf\xd4\xaa\x80\x2f\xc1\xaf\xa0\x2d\xf0\xa6\x37\x8b\xf2\xcc\x39\x97\x87\x8d\xab\xdc\x96\x59\xe8\xac\xb2\x39\xc6\x2f\x5c\xe0\xed\x17\xe3\x0a\x61\xba\x19\xfa\xd2\x2a\x46\x60\xde\xfc\x1c\xb2\xf8\x22\xd3\x23\x40\x07\xb5\xe6\x57\xdd\x28\x96\x8d\x61\x3a\x17\xcc\x07\x1f\xe4\xc7\xe0\x9a\xb9\x29\xf3\x56\x9d\x05\x43\x17\x4b\xc3\x98\x7d\x61\x85\x35\xc8\x40\xb8\x9c\xc9\x1b\x2d\xec\xbf\x1b\xbb\xee\x51\x08\xee\xc6\xaf\x37\xf7\xdd\x2a\xc6\x76\xb3\x7d\x69\x3d\x1c\x21\x47\x37\x64\xea\x5e\x8a\x34\xa3\x6f\x38\xa2\x4e\xe5\x3f\xdc\x2f\xec\x98\x9a\x4d\xec\x8d\x8f\xf4\xef\x8c\x8c\x8d\xd6\x14\xc1\xff\x87\x9a\x04\xff\xb8\x0f\xfc\x5f\x53\x4e\xc1\xb1\xac\xb2\xea\xd3\xc0\xff\x9f\x1b\x4a\x52\x56\x94\xb3\xda\xbb\xe7\x9c\xb3\x0f\x81\xc6\xaf\xc3\x5d\x64\xc3\x24\x3d\x35\x00\x63\x9f\xff\x98\xfd\x81\x0c\xc0\x3a\xf5\xd2\x7f\xbf\x62\x58\x35\x7b\xa3\xa4\x80\x50\x12\xf0\x28\x4c\x8c\x85\xc9\x32\x3c\x5e\x35\x2f\xe6\x7d\xf9\x32\x34\xae\x27\xe0\x37\xcb\xae\xc4\x7d\x1b\xc9\xd6\xc3\x46\x86\xda\xcd\x6a\x93\xab\x52\xf7\x4a\xe4\xa4\x1c\x08\x9e\x35\x15\x07\xdf\x07\x47\x41\x26\x66\xdb\x5e\xc5\x6b\x2e\x56\xba\xc1\xd2\xd0\xb7\xc6\x86\x62\xaf\x6c\x33\xec\x30\x6e\x87\x45\x00\xc5\x7e\x50\xea\xa5\x8d\xc7\x2b\x84\xb5\xb2\xa9\x0e\x00\xa5\xa6\x99\x5b\x60\x99\x2d\x35\x64\x8d\xbd\x61\x4c\xeb\x1e\x60\xa2\x73\xcb\x20\x8d\xdd\x8a\x8e\x41\xe5\xbf\xa4\xdd\x73\x22\xef\xd0\x48\x3c\x22\x86\x72\xbd\x9b\xf0\x67\x4a\xaa\xb0\x2c\xee\x2d\xa6\x37\x8f\x12\x29\x9e\xcb\xf3\x81\xbb\xc2\xd4\x21\x62\x0f\x75\xa3\x03\x7c\x14\x3b\x19\xda\x0e\xa4\xa2\x17\x30\xbb\x8a\xd0\xf0\x67\xd4\x04\x1e\x39\x33\x34\x71\x38\x3e\x2b\x95\xe7\xdb\x02\x07\xda\x40\x4b\x00\xa8\xfc\xfb\xd9\x50\x75\x38\x0f\x7a\xf6\x78\x9c\x22\x48\x91\xa4\x94\x5f\x28\x72\xa6\xa7\x44\xe7\xff\x59\x16\x4d\x6f\x02\xb4\x85\x6e\x6d\x98\x85\x7d\xbb\x1d\x0e\xad\xfa\xe8\xa6\x98\x50\xa6\xe6\xcd\x65\x6f\xba\xf6\xf6\x69\xde\x06\x2d\x26\xa6\x0f\xbc\x1e\x5c\x25\x71\x59\x4d\xe5\x87\x56\x0e\x97\x55\x54\x31\xac\x6e\x1f\xa0\x14\x56\xf5\xf4\xe7\x19\x8a\x84\x5c\x72\xb0\xa3\xb0\x10\x42\x12\x4f\x77\xa4\xe1\x81\x76\xf4\xc6\xa8\xd2\xf4\x06\x89\x78\x76\xbe\xb3\xe9\x90\x9d\x66\x9f\x31\x57\x7c\xd9\xb6\xdd\x9f\x07\xa7\x8a\xa7\xd2\x4f\xd1\x4f\xef\x4a\x0e\x7f\x60\x26\xf8\xaf\x58\xe4\xf4\x2d\x81\x6c\xd1\x71\x95\x0e\xd8\x42\x6b\x84\xdd\x1c\xa9\x10\xdb\x2f\xa6\x69\x41\x40\x72\xa6\xe7\xf0\xd7\xff\xbb\xbb\x5f\x22\xa3\xfa\x8f\xf5\x7a\x13\x0d\x6e\xb2\xa0\x13\xb1\x5a\x27\x16\xf4\xfd\xcd\xa6\xb3\x51\x10\x37\xe0\x81\x25\x4e\x0d\xd6\x51\xc1\xfe\x64\xd2\x23\x61\xfc\xfc\xfa\x97\xd7\x6f\x8b\x11\x7e\x64\x80\x7f\xc1\x3b\x91\x7f\xb1\x1f\x84\x13\xef\xc9\x6a\x88\xd3\x8c\xc6\x30\x27\x49\x30\xd0\x3c\x7a\xd9\xf2\x3d\xaf\x02\x7b\x6e\xec\xd3\x9f\x1c\xc6\x6c\xc3\x93\x38\x9f\x38\xef\xc8\x61\x0e\xb8\x38\xf4\x18\x4f\x63\xec\x7c\x61\x8f\x9a\x1c\xa9\xea\xf3\x86\xfd\xe1\x86\x98\xee\xd3\xb8\x78\xc4\x4a\x73\x8d\xb3\x66\x6c\xc6\xfb\x55\xd1\xa2\xdf\xc0\xf0\x2c\xd7\xae\xbd\xe5\x64\xae\x4e\x5a\xe3\x85\x7d\x93\x3d\xc8\xc9\x3b\xc7\xae\x3c\xeb\x8a\xe5\xac\xc9\xb1\x96\xec\x4a\xfd\x5e\xe4\xd5\xd4\xfd\xe0\xd1\x51\xad\xea\xe3\x86\xd2\x3d\x25\x67\x75\xe3\xab\xf3\x42\x7d\xca\xb8\x14\xfb\xf6\x57\x70\x9a\xb0\xd7\x80\x6b\x1c\x0f\xd6\x88\x73\xce\xb4\x1f\xec\x48\x10\xc3\x2b\xc5\xe1\x53\xb4\xfd\xa7\xb6\x46\x39\x32\xa5\x7e\xba\x7e\x99\xd2\x69\x5f\x2b\xd8\x91\xa3\x8c\x60\x6b\x44\x37\x90\xdd\x5d\x2b\x5e\x63\xdf\xee\xcd\xce\x62\xe8\x1d\xa1\xe3\x96\x19\x43\xdd\x05\x57\xfd\xe2\x88\xdc\x06\x2d\x66\xa7\x8e\x02\x09\x29\x2c\x84\x56\xfd\xa7\x69\x55\x4b\x5c\x2b\xe1\x6c\xb6\xa1\x2b\xf2\xd5\xc4\xfa\x49\x3a\x15\xfa\xab\x9d\xe5\x20\xfa\xad\x2d\xd4\x47\x14\x7d\x0d\xb5\xf5\x0d\xba\x8b\x61\x03\x3c\xc7\xfc\x68\xf1\x16\x2b\x93\x76\xfa\x6f\xf0\x82\xd7\x1a\x1a\xd8\xf8\xc9\x42\xed\xf7\x46\x91\x77\xad\x3a\xe1\x4d\x30\x2c\x96\xe9\x03\xad\x6c\xb3\xb5\x7c\xa0\x1d\xf4\x83\x46\xc7\xd6\x91\xf6\x23\xe6\xd5\x36\x4e\x96\xb3\xd1\x64\x34\x06\x68\x97\x54\xed\x22\x11\xf8\x21\x10\xd4\x70\xa4\xfe\xb4\x32\x57\xea\xa5\x9d\xa8\xe1\x0e\xc9\x5d\xda\xf4\xd6\x8a\x07\x98\x49\x67\xed\x5d\x97\xa4\x79\x18\x87\xbf\x67\x0f\x75\xc6\xdd\xb4\xd3\xa7\x29\xee\x6a\x36\xe2\x66\x80\x2a\xde\xea\xdc\xa3\x13\x98\x10\xdd\x5b\xe8\xb4\xb5\x98\x54\x93\x16\x64\x7b\x5b\x52\xc2\x3a\xa6\xe6\xa7\x48\x4b\xc4\xbb\x22\xf2\x12\x3d\xd8\x2f\x31\x51\x6d\xfd\x0a\x82\x1d\xaa\x00\xea\xd7\xde\x34\x80\x26\x89\x40\xaa\xbd\xac\x0b\xf9\xb1\xdd\x2a\xfe\xcf\x14\x93\x6f\x7d\x87\xa3\x84\x40\xa4\xec\x0c\x4f\xe3\xe6\x15\x48\xbd\xd7\xde\x02\x9e\x9a\x79\x07\x7c\xc0\xac\x47\x5a\xd2\x03\x66\xe6\x28\x22\xa6\x5f\xbc\x3a\x01\x37\xe2\xcd\xfd\xb9\xfa\x05\xd6\xbf\xf3\x2f\xfe\x11\x00\x00\xff\xff\x24\xe0\x09\x32\x6e\xbe\x03\x00") + +func templatesAnalysisTemplateHtmlBytes() ([]byte, error) { + return bindataRead( + _templatesAnalysisTemplateHtml, + "templates/analysis-template.html", + ) +} + +func templatesAnalysisTemplateHtml() (*asset, error) { + bytes, err := templatesAnalysisTemplateHtmlBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "templates/analysis-template.html", size: 245358, mode: os.FileMode(420), modTime: time.Unix(1457780870, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +// Asset loads and returns the asset for the given name. +// It returns an error if the asset could not be found or +// could not be loaded. +func Asset(name string) ([]byte, error) { + cannonicalName := strings.Replace(name, "\\", "/", -1) + if f, ok := _bindata[cannonicalName]; ok { + a, err := f() + if err != nil { + return nil, fmt.Errorf("Asset %s can't read by error: %v", name, err) + } + return a.bytes, nil + } + return nil, fmt.Errorf("Asset %s not found", name) +} + +// MustAsset is like Asset but panics when Asset would return an error. +// It simplifies safe initialization of global variables. +func MustAsset(name string) []byte { + a, err := Asset(name) + if err != nil { + panic("asset: Asset(" + name + "): " + err.Error()) + } + + return a +} + +// AssetInfo loads and returns the asset info for the given name. +// It returns an error if the asset could not be found or +// could not be loaded. +func AssetInfo(name string) (os.FileInfo, error) { + cannonicalName := strings.Replace(name, "\\", "/", -1) + if f, ok := _bindata[cannonicalName]; ok { + a, err := f() + if err != nil { + return nil, fmt.Errorf("AssetInfo %s can't read by error: %v", name, err) + } + return a.info, nil + } + return nil, fmt.Errorf("AssetInfo %s not found", name) +} + +// AssetNames returns the names of the assets. +func AssetNames() []string { + names := make([]string, 0, len(_bindata)) + for name := range _bindata { + names = append(names, name) + } + return names +} + +// _bindata is a table, holding each asset generator, mapped to its name. +var _bindata = map[string]func() (*asset, error){ + "templates/analysis-template.html": templatesAnalysisTemplateHtml, +} + +// AssetDir returns the file names below a certain +// directory embedded in the file by go-bindata. +// For example if you run go-bindata on data/... and data contains the +// following hierarchy: +// data/ +// foo.txt +// img/ +// a.png +// b.png +// then AssetDir("data") would return []string{"foo.txt", "img"} +// AssetDir("data/img") would return []string{"a.png", "b.png"} +// AssetDir("foo.txt") and AssetDir("notexist") would return an error +// AssetDir("") will return []string{"data"}. +func AssetDir(name string) ([]string, error) { + node := _bintree + if len(name) != 0 { + cannonicalName := strings.Replace(name, "\\", "/", -1) + pathList := strings.Split(cannonicalName, "/") + for _, p := range pathList { + node = node.Children[p] + if node == nil { + return nil, fmt.Errorf("Asset %s not found", name) + } + } + } + if node.Func != nil { + return nil, fmt.Errorf("Asset %s not found", name) + } + rv := make([]string, 0, len(node.Children)) + for childName := range node.Children { + rv = append(rv, childName) + } + return rv, nil +} + +type bintree struct { + Func func() (*asset, error) + Children map[string]*bintree +} + +var _bintree = &bintree{nil, map[string]*bintree{ + "templates": &bintree{nil, map[string]*bintree{ + "analysis-template.html": &bintree{templatesAnalysisTemplateHtml, map[string]*bintree{}}, + }}, +}} + +// RestoreAsset restores an asset under the given directory +func RestoreAsset(dir, name string) error { + data, err := Asset(name) + if err != nil { + return err + } + info, err := AssetInfo(name) + if err != nil { + return err + } + err = os.MkdirAll(_filePath(dir, filepath.Dir(name)), os.FileMode(0755)) + if err != nil { + return err + } + err = ioutil.WriteFile(_filePath(dir, name), data, info.Mode()) + if err != nil { + return err + } + err = os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime()) + if err != nil { + return err + } + return nil +} + +// RestoreAssets restores an asset under the given directory recursively +func RestoreAssets(dir, name string) error { + children, err := AssetDir(name) + // File + if err != nil { + return RestoreAsset(dir, name) + } + // Dir + for _, child := range children { + err = RestoreAssets(dir, filepath.Join(name, child)) + if err != nil { + return err + } + } + return nil +} + +func _filePath(dir, name string) string { + cannonicalName := strings.Replace(name, "\\", "/", -1) + return filepath.Join(append([]string{dir}, strings.Split(cannonicalName, "/")...)...) +} diff --git a/cmd/clairclt/clair/templates/analysis-template.html b/cmd/clairclt/clair/templates/analysis-template.html new file mode 100644 index 00000000..f5704b7f --- /dev/null +++ b/cmd/clairclt/clair/templates/analysis-template.html @@ -0,0 +1,98 @@ + + + + + + + + + Hyperclair Reports + + + + + +
+
+

+ Hyperclair reports +

+

+ Image: {{ .ImageName}} +

+
+ + + + + + + + + + + + + {{range .SortVulnerabilities}} + + + + + + + + {{end}} + +
NameSeverityIntroduceByDescriptionLayer
{{.Name}}{{.Severity}}{{.IntroduceBy}}{{.Description}}{{.Layer}}
+
+ + + + diff --git a/cmd/clairclt/clair/versions.go b/cmd/clairclt/clair/versions.go new file mode 100644 index 00000000..180cecdd --- /dev/null +++ b/cmd/clairclt/clair/versions.go @@ -0,0 +1,32 @@ +package clair + +import ( + "encoding/json" + "fmt" + "io/ioutil" + "net/http" +) + +func Versions() (interface{}, error) { + Config() + response, err := http.Get(uri + "/versions") + + if err != nil { + return nil, fmt.Errorf("requesting Clair version: %v", err) + } + defer response.Body.Close() + + body, err := ioutil.ReadAll(response.Body) + if err != nil { + return nil, fmt.Errorf("reading Clair version body: %v", err) + } + + var versionBody interface{} + err = json.Unmarshal(body, &versionBody) + + if err != nil { + return nil, fmt.Errorf("unmarshalling Clair version body: %v", err) + } + + return versionBody, nil +} diff --git a/cmd/clairclt/clairclt b/cmd/clairclt/clairclt new file mode 100755 index 00000000..1d560ce0 Binary files /dev/null and b/cmd/clairclt/clairclt differ diff --git a/cmd/clairclt/cmd/analyse.go b/cmd/clairclt/cmd/analyse.go new file mode 100644 index 00000000..64b30f31 --- /dev/null +++ b/cmd/clairclt/cmd/analyse.go @@ -0,0 +1,81 @@ +package cmd + +import ( + "fmt" + "os" + "text/template" + + "github.com/Sirupsen/logrus" + "github.com/coreos/clair/cmd/clairclt/clair" + "github.com/coreos/clair/cmd/clairclt/docker" + "github.com/spf13/cobra" + "github.com/spf13/viper" +) + +const analyseTplt = ` +Image: {{.String}} + {{.Layers | len}} layers found + {{$ia := .}} + {{range .Layers}} ➜ {{with .Layer}}Analysis [{{.|$ia.ShortName}}] found {{.|$ia.CountVulnerabilities}} vulnerabilities.{{end}} + {{end}} +` + +var analyseCmd = &cobra.Command{ + Use: "analyse IMAGE", + Short: "Analyse Docker image", + Long: `Analyse a Docker image with Clair, against Ubuntu, Red hat and Debian vulnerabilities databases`, + Run: func(cmd *cobra.Command, args []string) { + + if len(args) != 1 { + fmt.Printf("hyperclair: \"analyse\" requires a minimum of 1 argument") + os.Exit(1) + } + + ia := analyse(args[0]) + + err := template.Must(template.New("analysis").Parse(analyseTplt)).Execute(os.Stdout, ia) + if err != nil { + fmt.Println(errInternalError) + logrus.Fatalf("rendering analysis: %v", err) + } + }, +} + +func analyse(imageName string) clair.ImageAnalysis { + var err error + var image docker.Image + + if !docker.IsLocal { + image, err = docker.Pull(imageName) + + if err != nil { + if err == docker.ErrNotFound { + fmt.Println(err) + } else { + fmt.Println(errInternalError) + } + logrus.Fatalf("pulling image %q: %v", imageName, err) + } + + } else { + image, err = docker.Parse(imageName) + if err != nil { + fmt.Println(errInternalError) + logrus.Fatalf("parsing local image %q: %v", imageName, err) + } + docker.FromHistory(&image) + if err != nil { + fmt.Println(errInternalError) + logrus.Fatalf("getting local image %q from history: %v", imageName, err) + } + } + + return docker.Analyse(image) +} + +func init() { + RootCmd.AddCommand(analyseCmd) + analyseCmd.Flags().BoolVarP(&docker.IsLocal, "local", "l", false, "Use local images") + analyseCmd.Flags().StringP("priority", "p", "Low", "Vulnerabilities priority [Low, Medium, High, Critical]") + viper.BindPFlag("clair.priority", analyseCmd.Flags().Lookup("priority")) +} diff --git a/cmd/clairclt/cmd/health.go b/cmd/clairclt/cmd/health.go new file mode 100644 index 00000000..faeb48ac --- /dev/null +++ b/cmd/clairclt/cmd/health.go @@ -0,0 +1,38 @@ +package cmd + +import ( + "fmt" + "os" + "text/template" + + "github.com/Sirupsen/logrus" + "github.com/coreos/clair/cmd/clairclt/clair" + "github.com/spf13/cobra" +) + +const healthTplt = ` +Clair: {{if .}}✔{{else}}✘{{end}} +` + +type health struct { + Clair interface{} `json:"clair"` +} + +var healthCmd = &cobra.Command{ + Use: "health", + Short: "Get Health of Hyperclair and underlying services", + Long: `Get Health of Hyperclair and underlying services`, + Run: func(cmd *cobra.Command, args []string) { + ok := clair.IsHealthy() + err := template.Must(template.New("health").Parse(healthTplt)).Execute(os.Stdout, ok) + if err != nil { + fmt.Println(errInternalError) + logrus.Fatalf("rendering the health: %v", err) + } + + }, +} + +func init() { + RootCmd.AddCommand(healthCmd) +} diff --git a/cmd/clairclt/cmd/login.go b/cmd/clairclt/cmd/login.go new file mode 100644 index 00000000..a2bea886 --- /dev/null +++ b/cmd/clairclt/cmd/login.go @@ -0,0 +1,76 @@ +package cmd + +import ( + "encoding/base64" + "fmt" + "os" + + "golang.org/x/crypto/ssh/terminal" + + "github.com/Sirupsen/logrus" + "github.com/coreos/clair/cmd/clairclt/config" + "github.com/coreos/clair/cmd/clairclt/docker" + "github.com/spf13/cobra" +) + +var loginCmd = &cobra.Command{ + Use: "login", + Short: "Log in to a Docker registry", + Long: `Log in to a Docker registry`, + Run: func(cmd *cobra.Command, args []string) { + + if len(args) > 1 { + fmt.Println("Only one argument is allowed") + os.Exit(1) + } + + var reg string = docker.DockerHub + + if len(args) == 1 { + reg = args[0] + } + + var login config.Login + if err := askForLogin(&login); err != nil { + fmt.Println(errInternalError) + logrus.Fatalf("encrypting password: %v", err) + } + + config.AddLogin(reg, login) + + logged, err := docker.Login(reg) + + if err != nil && err != docker.ErrUnauthorized { + config.RemoveLogin(reg) + fmt.Println(errInternalError) + logrus.Fatalf("log in: %v", err) + } + + if !logged { + config.RemoveLogin(reg) + fmt.Println("Unauthorized: Wrong login/password, please try again") + os.Exit(1) + } + + fmt.Println("Login Successful") + }, +} + +func askForLogin(login *config.Login) error { + fmt.Print("Username: ") + fmt.Scan(&login.Username) + fmt.Print("Password: ") + pwd, err := terminal.ReadPassword(1) + if err != nil { + return err + } + fmt.Println(" ") + + encryptedPwd := base64.StdEncoding.EncodeToString(pwd) + login.Password = string(encryptedPwd) + return nil +} + +func init() { + RootCmd.AddCommand(loginCmd) +} diff --git a/cmd/clairclt/cmd/logout.go b/cmd/clairclt/cmd/logout.go new file mode 100644 index 00000000..15ed961c --- /dev/null +++ b/cmd/clairclt/cmd/logout.go @@ -0,0 +1,44 @@ +package cmd + +import ( + "fmt" + "os" + + "github.com/Sirupsen/logrus" + "github.com/coreos/clair/cmd/clairclt/config" + "github.com/coreos/clair/cmd/clairclt/docker" + "github.com/spf13/cobra" +) + +var logoutCmd = &cobra.Command{ + Use: "logout", + Short: "Log out from a Docker registry", + Long: `Log out from a Docker registry`, + Run: func(cmd *cobra.Command, args []string) { + + if len(args) > 1 { + fmt.Println("Only one argument is allowed") + os.Exit(1) + } + var reg string = docker.DockerHub + + if len(args) == 1 { + reg = args[0] + } + ok, err := config.RemoveLogin(reg) + if err != nil { + fmt.Println(errInternalError) + logrus.Fatalf("log out: %v", err) + } + + if ok { + fmt.Println("Log out successful") + return + } + fmt.Println("You are not logged in") + }, +} + +func init() { + RootCmd.AddCommand(logoutCmd) +} diff --git a/cmd/clairclt/cmd/pull.go b/cmd/clairclt/cmd/pull.go new file mode 100644 index 00000000..40a61346 --- /dev/null +++ b/cmd/clairclt/cmd/pull.go @@ -0,0 +1,62 @@ +// Copyright © 2016 NAME HERE +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package cmd + +import ( + "fmt" + "os" + "text/template" + + "github.com/Sirupsen/logrus" + "github.com/coreos/clair/cmd/clairclt/docker" + "github.com/spf13/cobra" +) + +const pullTplt = ` +Image: {{.String}} + {{.FsLayers | len}} layers found + {{range .FsLayers}} ➜ {{.BlobSum}} + {{end}} +` + +// pingCmd represents the ping command +var pullCmd = &cobra.Command{ + Use: "pull IMAGE", + Short: "Pull Docker image information", + Long: `Pull image information from Docker Hub or Registry`, + Run: func(cmd *cobra.Command, args []string) { + //TODO how to use args with viper + if len(args) != 1 { + fmt.Printf("hyperclair: \"pull\" requires a minimum of 1 argument\n") + os.Exit(1) + } + im := args[0] + image, err := docker.Pull(im) + if err != nil { + fmt.Println(errInternalError) + logrus.Fatalf("pulling image %v: %v", args[0], err) + } + + err = template.Must(template.New("pull").Parse(pullTplt)).Execute(os.Stdout, image) + if err != nil { + fmt.Println(errInternalError) + logrus.Fatalf("rendering image: %v", err) + } + }, +} + +func init() { + RootCmd.AddCommand(pullCmd) +} diff --git a/cmd/clairclt/cmd/push.go b/cmd/clairclt/cmd/push.go new file mode 100644 index 00000000..d217fe4c --- /dev/null +++ b/cmd/clairclt/cmd/push.go @@ -0,0 +1,86 @@ +package cmd + +import ( + "fmt" + "os" + + "github.com/Sirupsen/logrus" + "github.com/coreos/clair/cmd/clairclt/config" + "github.com/coreos/clair/cmd/clairclt/docker" + "github.com/coreos/clair/cmd/clairclt/server" + "github.com/spf13/cobra" +) + +var pushCmd = &cobra.Command{ + Use: "push IMAGE", + Short: "Push Docker image to Clair", + Long: `Upload a Docker image to Clair for further analysis`, + Run: func(cmd *cobra.Command, args []string) { + + if len(args) != 1 { + fmt.Printf("hyperclair: \"push\" requires a minimum of 1 argument\n") + os.Exit(1) + } + + startLocalServer() + + imageName := args[0] + + var image docker.Image + if !docker.IsLocal { + var err error + image, err = docker.Pull(imageName) + if err != nil { + if err == docker.ErrNotFound { + fmt.Println(err) + } else { + fmt.Println(errInternalError) + } + logrus.Fatalf("pulling image %q: %v", imageName, err) + } + } else { + var err error + image, err = docker.Parse(imageName) + if err != nil { + fmt.Println(errInternalError) + logrus.Fatalf("parsing local image %q: %v", imageName, err) + } + err = docker.Prepare(&image) + logrus.Debugf("prepared image layers: %d", len(image.FsLayers)) + if err != nil { + fmt.Println(errInternalError) + logrus.Fatalf("preparing local image %q from history: %v", imageName, err) + } + } + + logrus.Info("Pushing Image") + if err := docker.Push(image); err != nil { + if err != nil { + fmt.Println(errInternalError) + logrus.Fatalf("pushing image %q: %v", imageName, err) + } + } + + fmt.Printf("%v has been pushed to Clair\n", imageName) + + }, +} + +func init() { + RootCmd.AddCommand(pushCmd) + pushCmd.Flags().BoolVarP(&docker.IsLocal, "local", "l", false, "Use local images") +} + +//StartLocalServer start the hyperclair local server needed for reverse proxy and file server +func startLocalServer() { + sURL, err := config.LocalServerIP() + if err != nil { + fmt.Println(errInternalError) + logrus.Fatalf("retrieving internal server IP: %v", err) + } + err = server.Serve(sURL) + if err != nil { + fmt.Println(errInternalError) + logrus.Fatalf("starting local server: %v", err) + } +} diff --git a/cmd/clairclt/cmd/report.go b/cmd/clairclt/cmd/report.go new file mode 100644 index 00000000..16fab6fd --- /dev/null +++ b/cmd/clairclt/cmd/report.go @@ -0,0 +1,87 @@ +package cmd + +import ( + "fmt" + "os" + "strings" + + "github.com/Sirupsen/logrus" + "github.com/coreos/clair/cmd/clairclt/clair" + "github.com/coreos/clair/cmd/clairclt/docker" + "github.com/coreos/clair/cmd/clairclt/xstrings" + "github.com/spf13/cobra" + "github.com/spf13/viper" +) + +var reportCmd = &cobra.Command{ + Use: "report IMAGE", + Short: "Generate Docker Image vulnerabilities report", + Long: `Generate Docker Image vulnerabilities report as HTML or JSON`, + Run: func(cmd *cobra.Command, args []string) { + if len(args) != 1 { + fmt.Printf("hyperclair: \"report\" requires a minimum of 1 argument") + os.Exit(1) + } + + analyses := analyse(args[0]) + imageName := strings.Replace(analyses.ImageName, "/", "-", -1) + "-" + analyses.Tag + switch clair.Report.Format { + case "html": + html, err := clair.ReportAsHTML(analyses) + if err != nil { + fmt.Println(errInternalError) + logrus.Fatalf("generating HTML report: %v", err) + } + err = saveReport(imageName, string(html)) + if err != nil { + fmt.Println(errInternalError) + logrus.Fatalf("saving HTML report: %v", err) + } + + case "json": + json, err := xstrings.ToIndentJSON(analyses) + + if err != nil { + fmt.Println(errInternalError) + logrus.Fatalf("indenting JSON: %v", err) + } + err = saveReport(imageName, string(json)) + if err != nil { + fmt.Println(errInternalError) + logrus.Fatalf("saving JSON report: %v", err) + } + + default: + fmt.Printf("Unsupported Report format: %v", clair.Report.Format) + logrus.Fatalf("Unsupported Report format: %v", clair.Report.Format) + } + }, +} + +func saveReport(name string, content string) error { + path := viper.GetString("clair.report.path") + "/" + clair.Report.Format + if err := os.MkdirAll(path, 0777); err != nil { + return err + } + + reportsName := fmt.Sprintf("%v/analysis-%v.%v", path, name, strings.ToLower(clair.Report.Format)) + f, err := os.Create(reportsName) + if err != nil { + return fmt.Errorf("creating report file: %v", err) + } + + _, err = f.WriteString(content) + + if err != nil { + return fmt.Errorf("writing report file: %v", err) + } + fmt.Printf("%v report at %v\n", strings.ToUpper(clair.Report.Format), reportsName) + return nil +} + +func init() { + RootCmd.AddCommand(reportCmd) + reportCmd.Flags().BoolVarP(&docker.IsLocal, "local", "l", false, "Use local images") + reportCmd.Flags().StringP("format", "f", "html", "Format for Report [html,json]") + viper.BindPFlag("clair.report.format", reportCmd.Flags().Lookup("format")) +} diff --git a/cmd/clairclt/cmd/root.go b/cmd/clairclt/cmd/root.go new file mode 100644 index 00000000..9b3dafd3 --- /dev/null +++ b/cmd/clairclt/cmd/root.go @@ -0,0 +1,61 @@ +// Copyright © 2016 NAME HERE +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package cmd + +import ( + "errors" + "fmt" + "os" + + "github.com/coreos/clair/cmd/clairclt/config" + "github.com/spf13/cobra" +) + +var ( + errInternalError = errors.New("client quit unexpectedly") +) + +var cfgFile string +var logLevel string + +// RootCmd represents the base command when called without any subcommands +var RootCmd = &cobra.Command{ + Use: "hyperclair", + Short: "Analyse your docker image with Clair, directly from your registry.", + Long: ``, + // Uncomment the following line if your bare application + // has an action associated with it: + // Run: func(cmd *cobra.Command, args []string) { + // }, +} + +// Execute adds all child commands to the root command sets flags appropriately. +// This is called by main.main(). It only needs to happen once to the rootCmd. +func Execute() { + if err := RootCmd.Execute(); err != nil { + fmt.Println(err) + os.Exit(-1) + } +} + +func init() { + cobra.OnInitialize(initConfig) + RootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.hyperclair.yml)") + RootCmd.PersistentFlags().StringVar(&logLevel, "log-level", "", "log level [Panic,Fatal,Error,Warn,Info,Debug]") +} + +func initConfig() { + config.Init(cfgFile, logLevel) +} diff --git a/cmd/clairclt/cmd/version.go b/cmd/clairclt/cmd/version.go new file mode 100644 index 00000000..2d9e8e97 --- /dev/null +++ b/cmd/clairclt/cmd/version.go @@ -0,0 +1,36 @@ +package cmd + +import ( + "fmt" + "os" + "text/template" + + "github.com/Sirupsen/logrus" + "github.com/spf13/cobra" +) + +const versionTplt = ` +Hyperclair version {{.}} +` + +var version string + +var templ = template.Must(template.New("versions").Parse(versionTplt)) + +var versionCmd = &cobra.Command{ + Use: "version", + Short: "Get Versions of Hyperclair and underlying services", + Long: `Get Versions of Hyperclair and underlying services`, + Run: func(cmd *cobra.Command, args []string) { + + err := templ.Execute(os.Stdout, version) + if err != nil { + fmt.Println(errInternalError) + logrus.Fatalf("rendering the version: %v", err) + } + }, +} + +func init() { + RootCmd.AddCommand(versionCmd) +} diff --git a/cmd/clairclt/config/config.go b/cmd/clairclt/config/config.go new file mode 100644 index 00000000..bf601942 --- /dev/null +++ b/cmd/clairclt/config/config.go @@ -0,0 +1,312 @@ +package config + +import ( + "bytes" + "encoding/base64" + "encoding/json" + "errors" + "fmt" + "io" + "io/ioutil" + "os" + "os/exec" + "os/user" + "strings" + + "gopkg.in/yaml.v2" + + "github.com/Sirupsen/logrus" + "github.com/coreos/clair/cmd/clairclt/clair" + "github.com/coreos/clair/cmd/clairclt/xstrings" + "github.com/spf13/viper" +) + +var ErrLoginNotFound = errors.New("user is not log in") + +type r struct { + Path, Format string +} +type c struct { + URI, Priority string + Port, HealthPort int + Report r +} +type a struct { + InsecureSkipVerify bool +} +type h struct { + IP, TempFolder string + Port int +} +type config struct { + Clair c + Auth a + Hyperclair h +} + +// Init reads in config file and ENV variables if set. +func Init(cfgFile string, logLevel string) { + lvl := logrus.WarnLevel + if logLevel != "" { + var err error + lvl, err = logrus.ParseLevel(logLevel) + if err != nil { + logrus.Warningf("Wrong Log level %v, defaults to [Warning]", logLevel) + lvl = logrus.WarnLevel + } + } + logrus.SetLevel(lvl) + + viper.SetEnvPrefix("hyperclair") + viper.SetConfigName("hyperclair") // name of config file (without extension) + viper.AddConfigPath("$HOME/.hyperclair") // adding home directory as first search path + viper.AddConfigPath(".") // adding home directory as first search path + viper.AutomaticEnv() // read in environment variables that match + if cfgFile != "" { + viper.SetConfigFile(cfgFile) + } + err := viper.ReadInConfig() + if err != nil { + logrus.Debugf("No config file used") + } else { + logrus.Debugf("Using config file: %v", viper.ConfigFileUsed()) + } + + if viper.Get("clair.uri") == nil { + viper.Set("clair.uri", "http://localhost") + } + if viper.Get("clair.port") == nil { + viper.Set("clair.port", "6060") + } + if viper.Get("clair.healthPort") == nil { + viper.Set("clair.healthPort", "6061") + } + if viper.Get("clair.priority") == nil { + viper.Set("clair.priority", "Low") + } + if viper.Get("clair.report.path") == nil { + viper.Set("clair.report.path", "reports") + } + if viper.Get("clair.report.format") == nil { + viper.Set("clair.report.format", "html") + } + if viper.Get("auth.insecureSkipVerify") == nil { + viper.Set("auth.insecureSkipVerify", "true") + } + if viper.Get("hyperclair.ip") == nil { + viper.Set("hyperclair.ip", "") + } + if viper.Get("hyperclair.port") == nil { + viper.Set("hyperclair.port", 0) + } + if viper.Get("hyperclair.tempFolder") == nil { + viper.Set("hyperclair.tempFolder", "/tmp/hyperclair") + } + clair.Config() +} + +func values() config { + return config{ + Clair: c{ + URI: viper.GetString("clair.uri"), + Port: viper.GetInt("clair.port"), + HealthPort: viper.GetInt("clair.healthPort"), + Priority: viper.GetString("clair.priority"), + Report: r{ + Path: viper.GetString("clair.report.path"), + Format: viper.GetString("clair.report.format"), + }, + }, + Auth: a{ + InsecureSkipVerify: viper.GetBool("auth.insecureSkipVerify"), + }, + Hyperclair: h{ + IP: viper.GetString("hyperclair.ip"), + Port: viper.GetInt("hyperclair.port"), + TempFolder: viper.GetString("hyperclair.tempFolder"), + }, + } +} + +func Print() { + cfg := values() + cfgBytes, err := yaml.Marshal(cfg) + if err != nil { + logrus.Fatalf("marshalling configuration: %v", err) + } + + fmt.Println("Configuration") + fmt.Printf("%v", string(cfgBytes)) +} + +func HyperclairHome() string { + usr, err := user.Current() + if err != nil { + panic(err) + } + p := usr.HomeDir + "/.hyperclair" + + if _, err := os.Stat(p); os.IsNotExist(err) { + os.Mkdir(p, 0700) + } + return p +} + +type Login struct { + Username string + Password string +} + +type loginMapping map[string]Login + +func HyperclairConfig() string { + return HyperclairHome() + "/config.json" +} + +func AddLogin(registry string, login Login) error { + var logins loginMapping + + if err := readConfigFile(&logins, HyperclairConfig()); err != nil { + return fmt.Errorf("reading hyperclair file: %v", err) + } + + logins[registry] = login + + if err := writeConfigFile(logins, HyperclairConfig()); err != nil { + return fmt.Errorf("indenting login: %v", err) + } + + return nil +} +func GetLogin(registry string) (Login, error) { + if _, err := os.Stat(HyperclairConfig()); err == nil { + var logins loginMapping + + if err := readConfigFile(&logins, HyperclairConfig()); err != nil { + return Login{}, fmt.Errorf("reading hyperclair file: %v", err) + } + + if login, present := logins[registry]; present { + d, err := base64.StdEncoding.DecodeString(login.Password) + if err != nil { + return Login{}, fmt.Errorf("decoding password: %v", err) + } + login.Password = string(d) + return login, nil + } + } + return Login{}, ErrLoginNotFound +} + +func RemoveLogin(registry string) (bool, error) { + if _, err := os.Stat(HyperclairConfig()); err == nil { + var logins loginMapping + + if err := readConfigFile(&logins, HyperclairConfig()); err != nil { + return false, fmt.Errorf("reading hyperclair file: %v", err) + } + + if _, present := logins[registry]; present { + delete(logins, registry) + + if err := writeConfigFile(logins, HyperclairConfig()); err != nil { + return false, fmt.Errorf("indenting login: %v", err) + } + + return true, nil + } + } + return false, nil +} + +func readConfigFile(logins *loginMapping, file string) error { + if _, err := os.Stat(file); err == nil { + f, err := ioutil.ReadFile(file) + if err != nil { + return err + } + + if err := json.Unmarshal(f, &logins); err != nil { + return err + } + } else { + *logins = loginMapping{} + } + return nil +} + +func writeConfigFile(logins loginMapping, file string) error { + s, err := xstrings.ToIndentJSON(logins) + if err != nil { + return err + } + err = ioutil.WriteFile(file, s, os.ModePerm) + if err != nil { + return err + } + return nil +} + +//LocalServerIP return the local hyperclair server IP +func LocalServerIP() (string, error) { + localPort := viper.GetString("hyperclair.port") + localIP := viper.GetString("hyperclair.ip") + if localIP == "" { + logrus.Infoln("retrieving docker0 interface as local IP") + var err error + localIP, err = Docker0InterfaceIP() + if err != nil { + return "", fmt.Errorf("retrieving docker0 interface ip: %v", err) + } + } + return strings.TrimSpace(localIP) + ":" + localPort, nil +} + +//Docker0InterfaceIP return the docker0 interface ip by running `ip route show | grep docker0 | awk {print $9}` +func Docker0InterfaceIP() (string, error) { + var localIP bytes.Buffer + + ip := exec.Command("ip", "route", "show") + rGrep, wIP := io.Pipe() + grep := exec.Command("grep", "docker0") + ip.Stdout = wIP + grep.Stdin = rGrep + awk := exec.Command("awk", "{print $9}") + rAwk, wGrep := io.Pipe() + grep.Stdout = wGrep + awk.Stdin = rAwk + awk.Stdout = &localIP + err := ip.Start() + if err != nil { + return "", err + } + err = grep.Start() + if err != nil { + return "", err + } + err = awk.Start() + if err != nil { + return "", err + } + err = ip.Wait() + if err != nil { + return "", err + } + err = wIP.Close() + if err != nil { + return "", err + } + err = grep.Wait() + if err != nil { + return "", err + } + err = wGrep.Close() + if err != nil { + return "", err + } + err = awk.Wait() + if err != nil { + return "", err + } + return localIP.String(), nil +} diff --git a/cmd/clairclt/config/config_test.go b/cmd/clairclt/config/config_test.go new file mode 100644 index 00000000..39c7aac8 --- /dev/null +++ b/cmd/clairclt/config/config_test.go @@ -0,0 +1,204 @@ +package config + +import ( + "fmt" + "io/ioutil" + "log" + "os" + "testing" + + "github.com/spf13/viper" + + "gopkg.in/yaml.v2" +) + +var loginData = []struct { + in string + out int +}{ + {"", 0}, + {`{ + "docker.io": { + "Username": "johndoe", + "Password": "$2a$05$Qe4TTO8HMmOht" + } +} +`, 1}, +} + +const defaultValues = ` +clair: + uri: http://localhost + priority: Low + port: 6060 + healthport: 6061 + report: + path: reports + format: html +auth: + insecureskipverify: true +hyperclair: + ip: "" + tempfolder: /tmp/hyperclair + port: 0 +` + +const customValues = ` +clair: + uri: http://clair + priority: High + port: 6061 + healthport: 6062 + report: + path: reports/test + format: json +auth: + insecureskipverify: false +hyperclair: + ip: "localhost" + tempfolder: /tmp/hyperclair/test + port: 64157 +` + +func TestInitDefault(t *testing.T) { + Init("", "INFO") + + cfg := values() + + var expected config + err := yaml.Unmarshal([]byte(defaultValues), &expected) + if err != nil { + t.Fatal(err) + } + + if cfg != expected { + t.Error("Default values are not correct") + } + viper.Reset() +} + +func TestInitCustomLocal(t *testing.T) { + tmpfile := CreateConfigFile(customValues, "hyperclair.yml", ".") + defer os.Remove(tmpfile) // clean up + fmt.Println(tmpfile) + Init("", "INFO") + + cfg := values() + + var expected config + err := yaml.Unmarshal([]byte(customValues), &expected) + if err != nil { + t.Fatal(err) + } + + if cfg != expected { + t.Error("values are not correct") + } + viper.Reset() +} + +func TestInitCustomHome(t *testing.T) { + tmpfile := CreateConfigFile(customValues, "hyperclair.yml", HyperclairHome()) + defer os.Remove(tmpfile) // clean up + fmt.Println(tmpfile) + Init("", "INFO") + + cfg := values() + + var expected config + err := yaml.Unmarshal([]byte(customValues), &expected) + if err != nil { + t.Fatal(err) + } + + if cfg != expected { + t.Error("values are not correct") + } + viper.Reset() +} + +func TestInitCustom(t *testing.T) { + tmpfile := CreateConfigFile(customValues, "hyperclair.yml", "/tmp") + defer os.Remove(tmpfile) // clean up + fmt.Println(tmpfile) + Init(tmpfile, "INFO") + + cfg := values() + + var expected config + err := yaml.Unmarshal([]byte(customValues), &expected) + if err != nil { + t.Fatal(err) + } + + if cfg != expected { + t.Error("values are not correct") + } + viper.Reset() +} + +func TestReadConfigFile(t *testing.T) { + for _, ld := range loginData { + + tmpfile := CreateTmpConfigFile(ld.in) + defer os.Remove(tmpfile) // clean up + + var logins loginMapping + if err := readConfigFile(&logins, tmpfile); err != nil { + t.Errorf("readConfigFile(&logins,%q) failed => %v", tmpfile, err) + } + + if l := len(logins); l != ld.out { + t.Errorf("readConfigFile(&logins,%q) => %v logins, want %v", tmpfile, l, ld.out) + } + } +} + +func TestWriteConfigFile(t *testing.T) { + logins := loginMapping{} + logins["docker.io"] = Login{Username: "johndoe", Password: "$2a$05$Qe4TTO8HMmOht"} + tmpfile := CreateTmpConfigFile("") + defer os.Remove(tmpfile) // clean up + + if err := writeConfigFile(logins, tmpfile); err != nil { + t.Errorf("writeConfigFile(logins,%q) failed => %v", tmpfile, err) + } + + logins = loginMapping{} + if err := readConfigFile(&logins, tmpfile); err != nil { + t.Errorf("after writing: readConfigFile(&logins,%q) failed => %v", tmpfile, err) + } + + if l := len(logins); l != 1 { + t.Errorf("after writing: readConfigFile(&logins,%q) => %v logins, want %v", tmpfile, l, 1) + } +} + +func CreateTmpConfigFile(content string) string { + + c := []byte(content) + tmpfile, err := ioutil.TempFile("", "test-hyperclair") + if err != nil { + log.Fatal(err) + } + if content != "" { + if _, err := tmpfile.Write(c); err != nil { + log.Fatal(err) + } + if err := tmpfile.Close(); err != nil { + log.Fatal(err) + } + } else { + if err := os.Remove(tmpfile.Name()); err != nil { + log.Fatal(err) + } + } + return tmpfile.Name() +} + +func CreateConfigFile(content string, name string, path string) string { + if err := ioutil.WriteFile(path+"/"+name, []byte(content), 0600); err != nil { + log.Fatal(err) + } + return path + "/" + name +} diff --git a/cmd/clairclt/contrib/.hyperclair.yml b/cmd/clairclt/contrib/.hyperclair.yml new file mode 100644 index 00000000..743c73e3 --- /dev/null +++ b/cmd/clairclt/contrib/.hyperclair.yml @@ -0,0 +1,8 @@ +clair: + port: 6060 + healthPort: 6061 + uri: http://clair + priority: Low + report: + path: ./reports + format: html diff --git a/cmd/clairclt/contrib/README.md b/cmd/clairclt/contrib/README.md new file mode 100644 index 00000000..df8ac4e8 --- /dev/null +++ b/cmd/clairclt/contrib/README.md @@ -0,0 +1,11 @@ +CONTRIBUTION +----------------- + +# Running full dev environnement + +Update the configuration file `hyperclair.yml` with your clair container IP + +```bash +# Running Authentication server, Registry, Clair & Postgres Clair db +docker-compose up -d +``` diff --git a/cmd/clairclt/contrib/auth_server/config/auth_config.yml b/cmd/clairclt/contrib/auth_server/config/auth_config.yml new file mode 100644 index 00000000..f205f685 --- /dev/null +++ b/cmd/clairclt/contrib/auth_server/config/auth_config.yml @@ -0,0 +1,29 @@ +server: + addr: :5001 + certificate: /ssl/server.pem + key: /ssl/server.key +token: + issuer: auth_service + expiration: 900 +users: + "": {} + jgsqware: + password: $2y$05$oGKwJ8QJDLBOoTBmC/EQiefIMV1N9Yt9jpX3SqMoRqZRRql6q7yym +acl: +- match: + account: jgsqware + actions: ['*'] +- match: + account: /.+/ + name: ${account}/* + actions: ['*'] +- match: + type: registry + name: catalog + actions: ['*'] + comment: Anonymous users can get catalog. +- match: + account: "" + name: /.*/ + actions: [pull] + comment: Anonymous users can pull everything. diff --git a/cmd/clairclt/contrib/auth_server/ssl/old/server.key b/cmd/clairclt/contrib/auth_server/ssl/old/server.key new file mode 100644 index 00000000..937d2b07 --- /dev/null +++ b/cmd/clairclt/contrib/auth_server/ssl/old/server.key @@ -0,0 +1,28 @@ +-----BEGIN PRIVATE KEY----- +MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQClbJbUWDCY31g5 +hyFlhCpgXOntcqR72vVRew6vw9ooN7LKjC/ev1AbBD3JYca1R9vd/7D6wI5rYNR0 +ZtCMxaQLEgvDf166VdrZewkq8UmbVSFwqtBvcZCG7mTapzgap6jD5H/fFoFoSkFa +V3dGWlEaS5emtk7fLjXTKO0OpByuO2mmRqAoTsnN4O3tYfrW7ReBHueibVIpjZo9 +0qyFK3sZ2ewKG98m8OGh1jzOhxM8PZDKs9KjkZ/SJiGwxIQ/Ny+rXci7q3cshQna +n7ac2Wf0nG21j7eNk0lSKOkT3unb2+1B2+59mEtLauoYs1VcEmM55RnVdawvCmIy +LRowuLlDAgMBAAECggEAP3ELz1gbGyXcwgNPDY3Iarh3hncHGfD5UExvb30fN3lU ++lUVLsoUQKg5wffbqz5p1hPvndsnQ4sZL6MWrEZICW7cUBeTDsdKbUnAVFXBMu9N +KdZ4paTaFsVqrGihHafbE3WYjMgmzQZdVfZhafvNStZezLLyQKmKPvddItZRoYfN +sc+iFpT94hPp9Hjs9ClLQv/w9Xt8lVgD1FUh6yAlLUAn77HzbZuyC2nF4gbD2LiS +4G+xHcH77FyAU5W6BRv1DqNsuu0ksX/93GiYx0EebzT/IXa7xc0mYE0758EXk72y +yoznglkPkSOyyhcuI75FKMyYdQGKpyvw+y4aEv5JwQKBgQDTAaQ827Tpn/aMhP7L +jngFgTdfeq/7Q3eZjGgtr5RFnen6YS6WzWigvh5/70ASDziFd4fyd0P41/MjPkO6 +FTFWisRCpW14+mSTUSDmgTQfsONy1Xr2ib4v4CX2NEy+nUsvpdl72dwZAG/fSu3K +MfkVksd5Z56WJ4wxKrB4riHukQKBgQDIsren8ljtxrLepMHvaNLx5Gl1EtrgX3gy +zTuUM2CSQktwBYNsp68AloOi6/tuH8t1xcBc8ywgCZ2WXzYdRL/koXsd2IpOTsLd +m/zGILgRPVow70yoxKxqxW8YYuQ1gLeAOshj8IHGGfnXTvvpNQNvrnja0NzavjFU +tR3aZQb8kwKBgQCOqNx2vQCKt7kEdmKiE1e4OQ3MAvH6SjoRWWmSAdSYYNSxkITk +NkpX61JJouNJknrfWdpTJymQk8hx+oXlyLBL15Qrjxb9pSTcqQw6a/5msryEhisV +hjlMuxpPZDrC4SvVMidhYgE58h6w9ELi4niKimtM/K6uzFwvXbJkVS7h0QKBgErT +Zum0zzcHZ9TedHfACzWoRTEi8HvK3FOEdPwSE6U0FlATniY6dmKvuzBY7wrly8OD +EO8WspLXQuu3X8OVyD2DfxVnkFkVwE1DRQDRXg7/YsrvzRL3EJlWNs9Ov2q7LK8g +O2oXVyr2sFF33y/ZVgijceeTC2R6mIXOaOzt0acFAoGASB7aF8PTT7YzFCGK/x2O +kg4GLJJSlDyhAZzQqe5LBZB+RhkoHZjdQHcMW84iHp8CsFqb3/D8X+5FsDkwBSMP +bN1fCFE03BsqubtKhI9kMz5hP1OhxlMZdMxRscbdRZqo57f3imtXg6laOktYyPOy +uOzr/Cxm5YUQqyAJ/S4zVuc= +-----END PRIVATE KEY----- diff --git a/cmd/clairclt/contrib/auth_server/ssl/old/server.pem b/cmd/clairclt/contrib/auth_server/ssl/old/server.pem new file mode 100644 index 00000000..73fd3cae --- /dev/null +++ b/cmd/clairclt/contrib/auth_server/ssl/old/server.pem @@ -0,0 +1,21 @@ +-----BEGIN CERTIFICATE----- +MIIDXTCCAkWgAwIBAgIJAOMN706JOuJOMA0GCSqGSIb3DQEBCwUAMEUxCzAJBgNV +BAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBX +aWRnaXRzIFB0eSBMdGQwHhcNMTYwMTI4MTcwNjE4WhcNMTcwMTI3MTcwNjE4WjBF +MQswCQYDVQQGEwJBVTETMBEGA1UECAwKU29tZS1TdGF0ZTEhMB8GA1UECgwYSW50 +ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB +CgKCAQEApWyW1FgwmN9YOYchZYQqYFzp7XKke9r1UXsOr8PaKDeyyowv3r9QGwQ9 +yWHGtUfb3f+w+sCOa2DUdGbQjMWkCxILw39eulXa2XsJKvFJm1UhcKrQb3GQhu5k +2qc4Gqeow+R/3xaBaEpBWld3RlpRGkuXprZO3y410yjtDqQcrjtppkagKE7JzeDt +7WH61u0XgR7nom1SKY2aPdKshSt7GdnsChvfJvDhodY8zocTPD2QyrPSo5Gf0iYh +sMSEPzcvq13Iu6t3LIUJ2p+2nNln9JxttY+3jZNJUijpE97p29vtQdvufZhLS2rq +GLNVXBJjOeUZ1XWsLwpiMi0aMLi5QwIDAQABo1AwTjAdBgNVHQ4EFgQUWCDpNrvl +IPntyV7Y4uyoAq+aPiQwHwYDVR0jBBgwFoAUWCDpNrvlIPntyV7Y4uyoAq+aPiQw +DAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEAROOTzaxkx9YdvnAEj8Pt +Ej1FgiN1ogxrL4RMwyXs5cAdHi0G71En9onB/8CaWXVrrJbu6DosNn2RQmNapxPG +CkT7QfuYVyZF5jtigsxc+W7aLzASLZHHRA0FcgxUAlEUVaxD3xs6U2jMMntp53ij +kOWmalMi5qOBps8PCD9sd9MDejLFihPAIz15l3TgVkbRvtcUlfmMio5AJYzjbm4/ +0c8brR9tOp3qapeT78AhOmsF7zOVygd/BRIBG+Ynzo2DudBUs/j/4VOt9D9XO4I7 +e3UaqN2OMcL5RYZ5cHemAAy9jjq9/NAYUyLLP0DiCe6OY7SKsDlGfkYVLpZMbUth +9w== +-----END CERTIFICATE----- diff --git a/cmd/clairclt/contrib/auth_server/ssl/server.key b/cmd/clairclt/contrib/auth_server/ssl/server.key new file mode 100644 index 00000000..45340de1 --- /dev/null +++ b/cmd/clairclt/contrib/auth_server/ssl/server.key @@ -0,0 +1,28 @@ +-----BEGIN PRIVATE KEY----- +MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDP8wLYKQgqxNRw +Liy4ZuYGHvDfK/NT0CIlvMJuobPt6NIGi6NRISLyR7eZvo6oHTN3i0ElpblzL0Hq +JmF87d7o7tqVxO2Fq+faslXrKTgMpDiPj+WxUR3igTy2+DZ4ZP00Y4jwaPYtvwSi +sOP2YeM6r+3sSETj5XonIr+/U3mQYkU9GgFQIbPmJnyPb+WaS0fBZ686zeIKvY3Y ++enSCKOjss1QFyTb0TmmwQUcTBCiEXV10FSgzV383ghj+Fq9+nKo3cwooHNYwU+a +/6gpI1GGWR074J7PGeBId4DNItcpR1x58BGmgaVHabsEW+9RdMNnh17QFk3Wt2eT +S5Knl4UTAgMBAAECggEAcmSoZ+kKiRyGEMAV8csJNszGjL5MuQqB/mh8PQfPR00Q +XHFsgjDMXKN/KKBfMbP+oACG8gLcpbSVeg1rC6J/QXxD2qfeUe5jOTdpdFfUcX/V +bYQnQwfwfK3DjJO2wzwq3irzJe1Xn4q5LhZJETyAF8S4CYcn/oY6UFUZTlLJSNcH +chQOFWvjk13DBjGAmZmjwWKxHoZsKs0ioHtShgONpPM8TZU6SmtJxdFD2pBNp+ba +Lj5IQUYWrfCudBlzqvpXmqBlZe1J1MG+FafvAKx2CFbYkVObjRa/5DtQs99qac8y +rhn8uloK9gljiszwwUVq/ImrUICP+20rHW+kLfHeYQKBgQD9U2XqXz0d2asD72wS ++6yhxY4KZ3TD6W3GgfADC/kTfY+pME7KAXr//7paJJP/GtOxsLGRDHV347c3o3js +OGlFWuUSsuJxGq4SwKuo9eRVbOMEXiVlgCuUL5HAk2co1MbKVhSJ5RGbrp6785JO +JJcuNUTlaUsgQExEsIFJmZpbdQKBgQDSJPwl3uZIg0GC4QbQTAG1ueiQ9oPJ9kyz +cjT31ar9L6VrLwY/MMHYKgBD5JLxkq8qL1h9ii/LJKjX7rX3yttu/qtTMO4Y82CP +XnmR5kbODUUfiirQjTQFS3YP390nAewLwRgYPcvpyNIWA6Im6UdFJECLOTUBeiYg +VumEhSe1ZwKBgAEj6faHHThQLYPkBQGE3n8P65bCZnUnTNYy6Yip+iILU6U4UXJ5 +VTtnxEf5mCzyyvcmy3XSr4itnrqCYt31Vwv338YYxgoqS5RMB7nH+ZIk3lS7s8Fk +NU4CdM6AG1vEsWxhvM/uFwkzXQWNkCAH7CJKHRhHRA5OG8nHXZ2eMmKtAoGBAJ0J +1IA8fVys8bTrkprwYcq6/ifugHfZnmHvM9QNEXWZOIXLo2BvgDyYzo/t7T2nv0zI +Ctnt/V9SqvaKxeNB7g+ZMtC9XQC6R2t8T18PddQfqIs0RmCJVNmsFbMxOOQglJQI +HYhoDc1MLGsVFgT8CS2LNMyV2J2c+YbrTCCjHRR7AoGAICzoSClfvjmRg+4TP9/d +rixJF1UX77TnEhcHaFNBDnmSEX0K4rUr1o6GVZCwI+urL7ZmziDdmTDdbXWjqviJ +73COPw798Ox50VoVWssMGZQkXfbkk2yilLbok08ohlvVhzpiyecgbxAe4C6KRWWg +WEALyN3lILlyj1cYknRJ7gk= +-----END PRIVATE KEY----- diff --git a/cmd/clairclt/contrib/auth_server/ssl/server.pem b/cmd/clairclt/contrib/auth_server/ssl/server.pem new file mode 100644 index 00000000..07464fd0 --- /dev/null +++ b/cmd/clairclt/contrib/auth_server/ssl/server.pem @@ -0,0 +1,21 @@ +-----BEGIN CERTIFICATE----- +MIIDezCCAmOgAwIBAgIJAJXlshcLjIlpMA0GCSqGSIb3DQEBCwUAMFQxCzAJBgNV +BAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBX +aWRnaXRzIFB0eSBMdGQxDTALBgNVBAMMBGF1dGgwHhcNMTYwMTI5MDcyMTE3WhcN +MTcwMTI4MDcyMTE3WjBUMQswCQYDVQQGEwJBVTETMBEGA1UECAwKU29tZS1TdGF0 +ZTEhMB8GA1UECgwYSW50ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMQ0wCwYDVQQDDARh +dXRoMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAz/MC2CkIKsTUcC4s +uGbmBh7w3yvzU9AiJbzCbqGz7ejSBoujUSEi8ke3mb6OqB0zd4tBJaW5cy9B6iZh +fO3e6O7alcTthavn2rJV6yk4DKQ4j4/lsVEd4oE8tvg2eGT9NGOI8Gj2Lb8EorDj +9mHjOq/t7EhE4+V6JyK/v1N5kGJFPRoBUCGz5iZ8j2/lmktHwWevOs3iCr2N2Pnp +0gijo7LNUBck29E5psEFHEwQohF1ddBUoM1d/N4IY/havfpyqN3MKKBzWMFPmv+o +KSNRhlkdO+CezxngSHeAzSLXKUdcefARpoGlR2m7BFvvUXTDZ4de0BZN1rdnk0uS +p5eFEwIDAQABo1AwTjAdBgNVHQ4EFgQUcCD00y15Rdvwe8VnwoZee+J+6ucwHwYD +VR0jBBgwFoAUcCD00y15Rdvwe8VnwoZee+J+6ucwDAYDVR0TBAUwAwEB/zANBgkq +hkiG9w0BAQsFAAOCAQEAvmlCA49FGGOZS5CWl/NzH3es3N1Gr8MihdAK0vYLxbOM +8qA2PirEjJ6sWSeB0ZthVpk/dcod68r4dpFh7hpypvaEerFbpr+eWa9nf/KVJ/ft +ClLw+iWZpjEjmtSbSg/XIfraWfvwQp9XNMcmIeHvovHd4HyyU1Ulx6aE31wnZ6SJ +UKhTPgft0DRsmvFMc683jjeUg/Ik/XknnCiSyfVvwv7UEUs7sH85mE0p4giJxhEv +7MdGlQkob+58BpzsErjoj+RpZSljna98NpwBZUfbxkYE2KzU0oqPC0zQ8KawPtw1 +OB9O45KN2mJ9dPIAbezQHolrTQ7V+49/nhTghS/T3Q== +-----END CERTIFICATE----- diff --git a/cmd/clairclt/contrib/config/clair.yml b/cmd/clairclt/contrib/config/clair.yml new file mode 100644 index 00000000..c274b10b --- /dev/null +++ b/cmd/clairclt/contrib/config/clair.yml @@ -0,0 +1,77 @@ +# Copyright 2015 clair authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# The values specified here are the default values that Clair uses if no configuration file is specified or if the keys are not defined. +clair: + database: + # PostgreSQL Connection string + # http://www.postgresql.org/docs/9.4/static/libpq-connect.html + source: postgresql://postgres:root@postgres:5432?sslmode=disable + + # Number of elements kept in the cache + # Values unlikely to change (e.g. namespaces) are cached in order to save prevent needless roundtrips to the database. + cacheSize: 16384 + + api: + # API server port + port: 6060 + + # Health server port + # This is an unencrypted endpoint useful for load balancers to check to healthiness of the clair server. + healthport: 6061 + + # Deadline before an API request will respond with a 503 + timeout: 900s + + # 32-bit URL-safe base64 key used to encrypt pagination tokens + # If one is not provided, it will be generated. + # Multiple clair instances in the same cluster need the same value. + paginationKey: + + # Optional PKI configuration + # If you want to easily generate client certificates and CAs, try the following projects: + # https://github.com/coreos/etcd-ca + # https://github.com/cloudflare/cfssl + servername: + cafile: + keyfile: + certfile: + + updater: + # Frequency the database will be updated with vulnerabilities from the default data sources + # The value 0 disables the updater entirely. + interval: 0 + + notifier: + # Number of attempts before the notification is marked as failed to be sent + attempts: 3 + + # Duration before a failed notification is retried + renotifyInterval: 2h + + http: + # Optional endpoint that will receive notifications via POST requests + endpoint: + + # Optional PKI configuration + # If you want to easily generate client certificates and CAs, try the following projects: + # https://github.com/cloudflare/cfssl + # https://github.com/coreos/etcd-ca + servername: + cafile: + keyfile: + certfile: + + # Optional HTTP Proxy: must be a valid URL (including the scheme). + proxy: diff --git a/cmd/clairclt/contrib/docker-compose.yml b/cmd/clairclt/contrib/docker-compose.yml new file mode 100644 index 00000000..29f56fff --- /dev/null +++ b/cmd/clairclt/contrib/docker-compose.yml @@ -0,0 +1,54 @@ +version: '2' + +services: + auth: + image: cesanta/docker_auth:stable + ports: + - "5001:5001" + volumes: + - ./auth_server/config:/config:ro + - ./auth_server/ssl:/ssl + command: --v=2 --alsologtostderr /config/auth_config.yml + container_name: "auth" + + registry: + image: registry:2.2.1 + ports: + - 5000:5000 + volumes: + - ./auth_server/ssl:/ssl + - registry-data:/var/lib/registry + container_name: "registry" + environment: + - REGISTRY_STORAGE_FILESYSTEM_ROOTDIRECTORY=/var/lib/registry + - REGISTRY_AUTH=token + - REGISTRY_AUTH_TOKEN_REALM=https://auth:5001/auth + - REGISTRY_AUTH_TOKEN_SERVICE="registry" + - REGISTRY_AUTH_TOKEN_ISSUER="auth_service" + - REGISTRY_AUTH_TOKEN_ROOTCERTBUNDLE=/ssl/server.pem + + clair: + image: quay.io/coreos/clair + volumes: + - /tmp:/tmp + - ./config:/config + - clair-data:/var/local + ports: + - 6060:6060 + - 6061:6061 + container_name: "clair" + command: --log-level=debug --config=/config/clair.yml + + postgres: + image: postgres + container_name: "postgres" + environment: + - POSTGRES_PASSWORD=root + +volumes: + clair-data: + driver: local + hyperclair-data: + driver: local + registry-data: + driver: local diff --git a/cmd/clairclt/docker/analyse.go b/cmd/clairclt/docker/analyse.go new file mode 100644 index 00000000..13e7020c --- /dev/null +++ b/cmd/clairclt/docker/analyse.go @@ -0,0 +1,32 @@ +package docker + +import ( + "github.com/Sirupsen/logrus" + "github.com/coreos/clair/api/v1" + "github.com/coreos/clair/cmd/clairclt/clair" + "github.com/coreos/clair/cmd/clairclt/xstrings" +) + +//Analyse return Clair Image analysis +func Analyse(image Image) clair.ImageAnalysis { + c := len(image.FsLayers) + res := []v1.LayerEnvelope{} + + for i := range image.FsLayers { + l := image.FsLayers[c-i-1].BlobSum + lShort := xstrings.Substr(l, 0, 12) + + if a, err := clair.Analyse(l); err != nil { + logrus.Infof("analysing layer [%v] %d/%d: %v", lShort, i+1, c, err) + } else { + logrus.Infof("analysing layer [%v] %d/%d", lShort, i+1, c) + res = append(res, a) + } + } + return clair.ImageAnalysis{ + Registry: xstrings.TrimPrefixSuffix(image.Registry, "http://", "/v2"), + ImageName: image.Name, + Tag: image.Tag, + Layers: res, + } +} diff --git a/cmd/clairclt/docker/auth.go b/cmd/clairclt/docker/auth.go new file mode 100644 index 00000000..089b6631 --- /dev/null +++ b/cmd/clairclt/docker/auth.go @@ -0,0 +1,90 @@ +package docker + +import ( + "encoding/json" + "errors" + "fmt" + "io/ioutil" + "net/http" + "strings" + + "github.com/coreos/clair/cmd/clairclt/config" + "github.com/coreos/clair/cmd/clairclt/docker/httpclient" +) + +var ErrUnauthorized = errors.New("unauthorized access") + +type token struct { + Value string `json:"token"` +} + +func (tok token) String() string { + return tok.Value +} + +//BearerAuthParams parse Bearer Token on Www-Authenticate header +func BearerAuthParams(r *http.Response) map[string]string { + s := strings.Fields(r.Header.Get("Www-Authenticate")) + if len(s) != 2 || s[0] != "Bearer" { + return nil + } + result := map[string]string{} + + for _, kv := range strings.Split(s[1], ",") { + parts := strings.Split(kv, "=") + if len(parts) != 2 { + continue + } + result[strings.Trim(parts[0], "\" ")] = strings.Trim(parts[1], "\" ") + } + return result +} + +func AuthenticateResponse(dockerResponse *http.Response, request *http.Request) error { + bearerToken := BearerAuthParams(dockerResponse) + url := bearerToken["realm"] + "?service=" + bearerToken["service"] + if bearerToken["scope"] != "" { + url += "&scope=" + bearerToken["scope"] + } + req, err := http.NewRequest("GET", url, nil) + + if err != nil { + return err + } + l, err := config.GetLogin(request.URL.Host) + if err != nil { + return err + } + req.SetBasicAuth(l.Username, l.Password) + + response, err := httpclient.Get().Do(req) + + if err != nil { + return err + } + + if response.StatusCode == http.StatusUnauthorized { + return ErrUnauthorized + } + + if response.StatusCode != http.StatusOK { + return fmt.Errorf("authentication server response: %v - %v", response.StatusCode, response.Status) + } + + defer response.Body.Close() + body, err := ioutil.ReadAll(response.Body) + + if err != nil { + return err + } + + var tok token + err = json.Unmarshal(body, &tok) + + if err != nil { + return err + } + request.Header.Set("Authorization", "Bearer "+tok.String()) + + return nil +} diff --git a/cmd/clairclt/docker/httpclient/httpclient.go b/cmd/clairclt/docker/httpclient/httpclient.go new file mode 100644 index 00000000..2d9f9906 --- /dev/null +++ b/cmd/clairclt/docker/httpclient/httpclient.go @@ -0,0 +1,24 @@ +package httpclient + +import ( + "crypto/tls" + "net/http" + + "github.com/spf13/viper" +) + +var client *http.Client + +//Get create a http.Client with Transport configuration +func Get() *http.Client { + + if client == nil { + tr := &http.Transport{ + TLSClientConfig: &tls.Config{InsecureSkipVerify: viper.GetBool("auth.insecureSkipVerify")}, + DisableCompression: true, + } + client = &http.Client{Transport: tr} + } + + return client +} diff --git a/cmd/clairclt/docker/image.go b/cmd/clairclt/docker/image.go new file mode 100644 index 00000000..6dbc09d7 --- /dev/null +++ b/cmd/clairclt/docker/image.go @@ -0,0 +1,110 @@ +package docker + +import ( + "encoding/json" + "errors" + "fmt" + "regexp" + "strings" + + "github.com/spf13/viper" +) + +var ErrDisallowed = errors.New("analysing official images is not allowed") + +//Image represent Image Manifest from Docker image, including the registry URL +type Image struct { + Name string + Tag string + Registry string + FsLayers []Layer +} + +//Layer represent the digest of a image layer +type Layer struct { + BlobSum string + History string +} + +const dockerImageRegex = "^(?:([^/]+)/)?(?:([^/]+)/)?([^@:/]+)(?:[@:](.+))?" +const DockerHub = "registry-1.docker.io" +const hubURI = "https://" + DockerHub + "/v2" + +var IsLocal = false + +func TmpLocal() string { + return viper.GetString("hyperclair.tempFolder") +} + +// Parse is used to parse a docker image command +// +//Example: +//"register.com:5080/wemanity-belgium/alpine" +//"register.com:5080/wemanity-belgium/alpine:latest" +//"register.com:5080/alpine" +//"register.com/wemanity-belgium/alpine" +//"register.com/alpine" +//"register.com/wemanity-belgium/alpine:latest" +//"alpine" +//"wemanity-belgium/alpine" +//"wemanity-belgium/alpine:latest" +func Parse(image string) (Image, error) { + imageRegex := regexp.MustCompile(dockerImageRegex) + + if imageRegex.MatchString(image) == false { + return Image{}, fmt.Errorf("cannot parse image name: %v", image) + } + groups := imageRegex.FindStringSubmatch(image) + + registry, repository, name, tag := groups[1], groups[2], groups[3], groups[4] + + if tag == "" { + tag = "latest" + } + + if repository == "" && !strings.ContainsAny(registry, ":.") { + repository, registry = registry, hubURI //Regex problem, if no registry in url, regex parse repository as registry, so need to invert it + + } else { + //FIXME We need to move to https. + //Maybe using a `insecure-registry` flag in configuration + if strings.Contains(registry, "docker") { + registry = "https://" + registry + "/v2" + + } else { + registry = "http://" + registry + "/v2" + } + } + + if repository != "" { + name = repository + "/" + name + } + + if strings.Contains(registry, "docker.io") && repository == "" { + return Image{}, ErrDisallowed + } + + return Image{ + Registry: registry, + Name: name, + Tag: tag, + }, nil +} + +// BlobsURI run Blobs URI as //blobs/ +// eg: "http://registry:5000/v2/jgsqware/ubuntu-git/blobs/sha256:13be4a52fdee2f6c44948b99b5b65ec703b1ca76c1ab5d2d90ae9bf18347082e" +func (image Image) BlobsURI(digest string) string { + return strings.Join([]string{image.Registry, image.Name, "blobs", digest}, "/") +} + +func (image Image) String() string { + return image.Registry + "/" + image.Name + ":" + image.Tag +} + +func (image Image) AsJSON() (string, error) { + b, err := json.Marshal(image) + if err != nil { + return "", fmt.Errorf("cannot marshal image: %v", err) + } + return string(b), nil +} diff --git a/cmd/clairclt/docker/image_test.go b/cmd/clairclt/docker/image_test.go new file mode 100644 index 00000000..12c25597 --- /dev/null +++ b/cmd/clairclt/docker/image_test.go @@ -0,0 +1,74 @@ +package docker + +import "testing" + +var imageNameTests = []struct { + in string + out string +}{ + {"jgsqware/ubuntu-git", hubURI + "/jgsqware/ubuntu-git:latest"}, + {"wemanity-belgium/registry-backup", hubURI + "/wemanity-belgium/registry-backup:latest"}, + {"wemanity-belgium/alpine:latest", hubURI + "/wemanity-belgium/alpine:latest"}, + {"register.com/alpine", "http://register.com/v2/alpine:latest"}, + {"register.com/wemanity-belgium/alpine", "http://register.com/v2/wemanity-belgium/alpine:latest"}, + {"register.com/wemanity-belgium/alpine:latest", "http://register.com/v2/wemanity-belgium/alpine:latest"}, + {"register.com:5080/alpine", "http://register.com:5080/v2/alpine:latest"}, + {"register.com:5080/wemanity-belgium/alpine", "http://register.com:5080/v2/wemanity-belgium/alpine:latest"}, + {"register.com:5080/wemanity-belgium/alpine:latest", "http://register.com:5080/v2/wemanity-belgium/alpine:latest"}, + {"registry:5000/google/cadvisor", "http://registry:5000/v2/google/cadvisor:latest"}, +} + +var invalidImageNameTests = []struct { + in string + out string +}{ + {"alpine", hubURI + "/alpine:latest"}, + {"docker.io/golang", hubURI + "/golang:latest"}, +} + +func TestParse(t *testing.T) { + for _, imageName := range imageNameTests { + image, err := Parse(imageName.in) + if err != nil { + t.Errorf("Parse(\"%s\") should be valid: %v", imageName.in, err) + } + if image.String() != imageName.out { + t.Errorf("Parse(\"%s\") => %v, want %v", imageName.in, image, imageName.out) + + } + } +} + +func TestParseDisallowed(t *testing.T) { + for _, imageName := range invalidImageNameTests { + _, err := Parse(imageName.in) + if err != ErrDisallowed { + t.Errorf("Parse(\"%s\") should failed with err \"%v\": %v", imageName.in, ErrDisallowed, err) + } + } +} + +func TestMBlobstURI(t *testing.T) { + image, err := Parse("localhost:5000/alpine") + + if err != nil { + t.Error(err) + } + + result := image.BlobsURI("sha256:13be4a52fdee2f6c44948b99b5b65ec703b1ca76c1ab5d2d90ae9bf18347082e") + if result != "http://localhost:5000/v2/alpine/blobs/sha256:13be4a52fdee2f6c44948b99b5b65ec703b1ca76c1ab5d2d90ae9bf18347082e" { + t.Errorf("Is %s, should be http://localhost:5000/v2/alpine/blobs/sha256:13be4a52fdee2f6c44948b99b5b65ec703b1ca76c1ab5d2d90ae9bf18347082e", result) + } +} + +func TestUniqueLayer(t *testing.T) { + image := Image{ + FsLayers: []Layer{Layer{BlobSum: "test1"}, Layer{BlobSum: "test1"}, Layer{BlobSum: "test2"}}, + } + + image.uniqueLayers() + + if len(image.FsLayers) > 2 { + t.Errorf("Layers must be unique: %v", image.FsLayers) + } +} diff --git a/cmd/clairclt/docker/local.go b/cmd/clairclt/docker/local.go new file mode 100644 index 00000000..391eeff6 --- /dev/null +++ b/cmd/clairclt/docker/local.go @@ -0,0 +1,171 @@ +package docker + +import ( + "bufio" + "bytes" + "encoding/json" + "errors" + "fmt" + "os" + "os/exec" + "strings" + + "github.com/Sirupsen/logrus" +) + +//Prepare populate image.FSLayers with the layer from manifest coming from `docker save` command. Layer.History will be populated with `docker history` command +func Prepare(im *Image) error { + imageName := im.Name + ":" + im.Tag + logrus.Debugf("preparing %v", imageName) + + path, err := save(imageName) + // defer os.RemoveAll(path) + if err != nil { + return fmt.Errorf("could not save image: %s", err) + } + + // Retrieve history. + logrus.Infoln("Getting image's history") + manifestLayerIDs, err := historyFromManifest(path) + + historyLayerIDs, err := historyFromCommand(imageName) + + if err != nil || (len(manifestLayerIDs) == 0 && len(historyLayerIDs) == 0) { + return fmt.Errorf("Could not get image's history: %s", err) + } + + for i, l := range manifestLayerIDs { + im.FsLayers = append(im.FsLayers, Layer{BlobSum: l, History: historyLayerIDs[i]}) + } + + return nil +} + +//FromHistory populate image.FSLayers with the layer from `docker history` command +func FromHistory(im *Image) error { + imageName := im.Name + ":" + im.Tag + layerIDs, err := historyFromCommand(imageName) + + if err != nil || len(layerIDs) == 0 { + return fmt.Errorf("Could not get image's history: %s", err) + } + + for _, l := range layerIDs { + im.FsLayers = append(im.FsLayers, Layer{BlobSum: l}) + } + + return nil +} + +func cleanLocal() error { + logrus.Debugln("cleaning temporary local repository") + err := os.RemoveAll(TmpLocal()) + + if err != nil { + return fmt.Errorf("cleaning temporary local repository: %v", err) + } + + return nil +} + +func save(imageName string) (string, error) { + path := TmpLocal() + "/" + strings.Split(imageName, ":")[0] + "/blobs" + + if _, err := os.Stat(path); os.IsExist(err) { + err := os.RemoveAll(path) + if err != nil { + return "", err + } + } + + err := os.MkdirAll(path, 0755) + if err != nil { + return "", err + } + + var stderr bytes.Buffer + logrus.Debugln("docker image to save: ", imageName) + logrus.Debugln("saving in: ", path) + save := exec.Command("docker", "save", imageName) + save.Stderr = &stderr + extract := exec.Command("tar", "xf", "-", "-C"+path) + extract.Stderr = &stderr + pipe, err := extract.StdinPipe() + if err != nil { + return "", err + } + save.Stdout = pipe + + err = extract.Start() + if err != nil { + return "", errors.New(stderr.String()) + } + err = save.Run() + if err != nil { + return "", errors.New(stderr.String()) + } + err = pipe.Close() + if err != nil { + return "", err + } + err = extract.Wait() + if err != nil { + return "", errors.New(stderr.String()) + } + return path, nil +} + +func historyFromManifest(path string) ([]string, error) { + mf, err := os.Open(path + "/manifest.json") + if err != nil { + return nil, err + } + defer mf.Close() + + // https://github.com/docker/docker/blob/master/image/tarexport/tarexport.go#L17 + type manifestItem struct { + Config string + RepoTags []string + Layers []string + } + + var manifest []manifestItem + if err = json.NewDecoder(mf).Decode(&manifest); err != nil { + return nil, err + } else if len(manifest) != 1 { + return nil, err + } + var layers []string + for _, layer := range manifest[0].Layers { + layers = append(layers, strings.TrimSuffix(layer, "/layer.tar")) + } + return layers, nil +} + +func historyFromCommand(imageName string) ([]string, error) { + var stderr bytes.Buffer + cmd := exec.Command("docker", "history", "-q", "--no-trunc", imageName) + cmd.Stderr = &stderr + stdout, err := cmd.StdoutPipe() + if err != nil { + return []string{}, err + } + + err = cmd.Start() + if err != nil { + return []string{}, errors.New(stderr.String()) + } + + var layers []string + scanner := bufio.NewScanner(stdout) + for scanner.Scan() { + layers = append(layers, scanner.Text()) + } + + for i := len(layers)/2 - 1; i >= 0; i-- { + opp := len(layers) - 1 - i + layers[i], layers[opp] = layers[opp], layers[i] + } + + return layers, nil +} diff --git a/cmd/clairclt/docker/login.go b/cmd/clairclt/docker/login.go new file mode 100644 index 00000000..59997e9f --- /dev/null +++ b/cmd/clairclt/docker/login.go @@ -0,0 +1,46 @@ +package docker + +import ( + "fmt" + "net/http" + "strings" + + "github.com/Sirupsen/logrus" + "github.com/coreos/clair/cmd/clairclt/docker/httpclient" +) + +//Pull Image from Registry or Hub depending on image name +func Login(registry string) (bool, error) { + + logrus.Info("log in: ", registry) + + if strings.Contains(registry, "docker") { + registry = "https://" + registry + "/v2" + + } else { + registry = "http://" + registry + "/v2" + } + + client := httpclient.Get() + request, err := http.NewRequest("GET", registry, nil) + response, err := client.Do(request) + if err != nil { + return false, fmt.Errorf("log in %v: %v", registry, err) + } + authorized := response.StatusCode != http.StatusUnauthorized + if !authorized { + logrus.Info("Unauthorized access") + err := AuthenticateResponse(response, request) + + if err != nil { + if err == ErrUnauthorized { + authorized = false + } + return false, err + } else { + authorized = true + } + } + + return authorized, nil +} diff --git a/cmd/clairclt/docker/pull.go b/cmd/clairclt/docker/pull.go new file mode 100644 index 00000000..ae41330c --- /dev/null +++ b/cmd/clairclt/docker/pull.go @@ -0,0 +1,90 @@ +package docker + +import ( + "encoding/json" + "errors" + "fmt" + "io/ioutil" + "net/http" + + "github.com/Sirupsen/logrus" + "github.com/coreos/clair/cmd/clairclt/docker/httpclient" +) + +var ErrNotFound = errors.New("image not found") + +//Pull Image from Registry or Hub depending on image name +func Pull(imageName string) (Image, error) { + image, err := Parse(imageName) + if err != nil { + return Image{}, err + } + + logrus.Info("pulling image: ", image) + + mURI := fmt.Sprintf("%v/%v/manifests/%v", image.Registry, image.Name, image.Tag) + client := httpclient.Get() + request, err := http.NewRequest("GET", mURI, nil) + response, err := client.Do(request) + if err != nil { + return Image{}, fmt.Errorf("retrieving manifest: %v", err) + } + + if response.StatusCode == http.StatusUnauthorized { + logrus.Info("Pull is Unauthorized") + err := AuthenticateResponse(response, request) + + if err != nil { + return Image{}, fmt.Errorf("authenticating: %v", err) + } + response, err = client.Do(request) + if err != nil { + return Image{}, fmt.Errorf("retrieving manifest: %v", err) + } + } + + body, err := ioutil.ReadAll(response.Body) + if err != nil { + return Image{}, fmt.Errorf("reading manifest body: %v", err) + } + if response.StatusCode != 200 { + switch response.StatusCode { + case http.StatusUnauthorized: + return Image{}, ErrUnauthorized + case http.StatusNotFound: + return Image{}, ErrNotFound + default: + return Image{}, fmt.Errorf("%d - %s", response.StatusCode, string(body)) + } + } + if err := image.parseManifest(body); err != nil { + return Image{}, fmt.Errorf("parsing manifest: %v", err) + } + + return image, nil +} + +func (image *Image) parseManifest(body []byte) error { + + err := json.Unmarshal(body, &image) + + if err != nil { + return fmt.Errorf("unmarshalling manifest body: %v", err) + } + + image.uniqueLayers() + return nil +} + +func (image *Image) uniqueLayers() { + encountered := map[Layer]bool{} + result := []Layer{} + + for index := range image.FsLayers { + if encountered[image.FsLayers[index]] != true { + encountered[image.FsLayers[index]] = true + result = append(result, image.FsLayers[index]) + } + } + image.FsLayers = result +} diff --git a/cmd/clairclt/docker/push.go b/cmd/clairclt/docker/push.go new file mode 100644 index 00000000..087f0f9b --- /dev/null +++ b/cmd/clairclt/docker/push.go @@ -0,0 +1,87 @@ +package docker + +import ( + "fmt" + "strings" + + "github.com/Sirupsen/logrus" + "github.com/coreos/clair/api/v1" + "github.com/coreos/clair/cmd/clairclt/clair" + "github.com/coreos/clair/cmd/clairclt/config" + "github.com/coreos/clair/cmd/clairclt/xstrings" +) + +var registryMapping map[string]string + +//Push image to Clair for analysis +func Push(image Image) error { + layerCount := len(image.FsLayers) + + parentID := "" + + if layerCount == 0 { + logrus.Warningln("there is no layer to push") + } + localIP, err := config.LocalServerIP() + if err != nil { + return err + } + hURL := fmt.Sprintf("http://%v/v2", localIP) + if IsLocal { + hURL = strings.Replace(hURL, "/v2", "/local", -1) + logrus.Infof("using %v as local url", hURL) + } + + for index, layer := range image.FsLayers { + lUID := xstrings.Substr(layer.BlobSum, 0, 12) + logrus.Infof("Pushing Layer %d/%d [%v]", index+1, layerCount, lUID) + + insertRegistryMapping(layer.BlobSum, image.Registry) + payload := v1.LayerEnvelope{Layer: &v1.Layer{ + Name: layer.BlobSum, + Path: image.BlobsURI(layer.BlobSum), + ParentName: parentID, + Format: "Docker", + }} + + //FIXME Update to TLS + if IsLocal { + payload.Layer.Name = layer.History + payload.Layer.Path += "/layer.tar" + } + payload.Layer.Path = strings.Replace(payload.Layer.Path, image.Registry, hURL, 1) + if err := clair.Push(payload); err != nil { + logrus.Infof("adding layer %d/%d [%v]: %v", index+1, layerCount, lUID, err) + if err != clair.ErrOSNotSupported { + return err + } + parentID = "" + } else { + parentID = payload.Layer.Name + } + } + if IsLocal { + if err := cleanLocal(); err != nil { + return err + } + } + return nil +} + +func insertRegistryMapping(layerDigest string, registryURI string) { + logrus.Debugf("Saving %s[%s]", layerDigest, registryURI) + registryMapping[layerDigest] = registryURI +} + +//GetRegistryMapping return the registryURI corresponding to the layerID passed as parameter +func GetRegistryMapping(layerDigest string) (string, error) { + registryURI, present := registryMapping[layerDigest] + if !present { + return "", fmt.Errorf("%v mapping not found", layerDigest) + } + return registryURI, nil +} + +func init() { + registryMapping = map[string]string{} +} diff --git a/cmd/clairclt/docker/push_test.go b/cmd/clairclt/docker/push_test.go new file mode 100644 index 00000000..bc734d1c --- /dev/null +++ b/cmd/clairclt/docker/push_test.go @@ -0,0 +1,28 @@ +package docker + +import "testing" + +func TestInsertRegistryMapping(t *testing.T) { + layerID := "sha256:13be4a52fdee2f6c44948b99b5b65ec703b1ca76c1ab5d2d90ae9bf18347082e" + registryURI := "registry:5000" + insertRegistryMapping(layerID, registryURI) + + if r := registryMapping[layerID]; r != registryURI { + t.Errorf("insertRegistryMapping(%q,%q) => %q, want %q", layerID, registryURI, r, registryURI) + } +} + +func TestGetRegistryMapping(t *testing.T) { + layerID := "sha256:13be4a52fdee2f6c44948b99b5b65ec703b1ca76c1ab5d2d90ae9bf18347082e" + registryURI := "registry:5000" + insertRegistryMapping(layerID, registryURI) + + if r, err := GetRegistryMapping(layerID); r != registryURI { + + if err != nil { + t.Errorf("GetRegistryMapping(%q) failed => %v", layerID, err) + } else { + t.Errorf("GetRegistryMapping(%q) => %q, want %q", layerID, registryURI, r) + } + } +} diff --git a/cmd/clairclt/hyperclair.yml b/cmd/clairclt/hyperclair.yml new file mode 100644 index 00000000..b290f6cb --- /dev/null +++ b/cmd/clairclt/hyperclair.yml @@ -0,0 +1,10 @@ +clair: + port: 6060 + healthPort: 6061 + uri: http://clair + priority: Low + report: + path: ./reports + format: html +hyperclair: + interface: virtualbox \ No newline at end of file diff --git a/cmd/clairclt/hyperclair.yml.default b/cmd/clairclt/hyperclair.yml.default new file mode 100644 index 00000000..743c73e3 --- /dev/null +++ b/cmd/clairclt/hyperclair.yml.default @@ -0,0 +1,8 @@ +clair: + port: 6060 + healthPort: 6061 + uri: http://clair + priority: Low + report: + path: ./reports + format: html diff --git a/cmd/clairclt/main.go b/cmd/clairclt/main.go new file mode 100644 index 00000000..9b91f5af --- /dev/null +++ b/cmd/clairclt/main.go @@ -0,0 +1,21 @@ +// Copyright © 2016 NAME HERE +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package main + +import "github.com/coreos/clair/cmd/clairclt/cmd" + +func main() { + cmd.Execute() +} diff --git a/cmd/clairclt/reports/html/analysis-jgsqware-clair-latest.html b/cmd/clairclt/reports/html/analysis-jgsqware-clair-latest.html new file mode 100644 index 00000000..68bbc690 --- /dev/null +++ b/cmd/clairclt/reports/html/analysis-jgsqware-clair-latest.html @@ -0,0 +1,15538 @@ + + + + + + + + + Hyperclair Reports + + + + + +
+
+

+ Hyperclair reports +

+

+ Image: jgsqware/clair +

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameSeverityIntroduceByDescriptionLayer
CVE-2015-5600Highopenssh:1:6.7p1-5The kbdint_next_device function in auth2-chall.c in sshd in OpenSSH through 6.9 does not properly restrict the processing of keyboard-interactive devices within a single connection, which makes it easier for remote attackers to conduct brute-force attacks or cause a denial of service (CPU consumption) via a long and duplicative list in the ssh -oKbdInteractiveDevices option, as demonstrated by a modified client that provides a different password for each pam element on this list.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-5277Highglibc:2.19-18+deb8u1The get_contents function in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) before 2.20 might allow local users to cause a denial of service (heap corruption) or gain privileges via a long line in the NSS files database.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2016-2856Highglibc:2.19-18+deb8u1pt_chown in the glibc package before 2.19-18+deb8u4 on Debian jessie lacks a namespace check associated with file-descriptor passing, which allows local users to capture keystrokes and spoof data, and possibly gain privileges, via pts read and write operations, related to debian/sysdeps/linux.mk. NOTE: this is not considered a vulnerability in the upstream GNU C Library because the upstream documentation has a clear security recommendation against the --enable-pt_chown option.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-7182Highnss:2:3.17.2-1.1+deb8u2Heap-based buffer overflow in the ASN.1 decoder in Mozilla Network Security Services (NSS) before 3.19.2.1 and 3.20.x before 3.20.1, as used in Firefox before 42.0 and Firefox ESR 38.x before 38.4 and other products, allows remote attackers to cause a denial of service (application crash) or possibly execute arbitrary code via crafted OCTET STRING data.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-7181Highnss:2:3.17.2-1.1+deb8u2The sec_asn1d_parse_leaf function in Mozilla Network Security Services (NSS) before 3.19.2.1 and 3.20.x before 3.20.1, as used in Firefox before 42.0 and Firefox ESR 38.x before 38.4 and other products, improperly restricts access to an unspecified data structure, which allows remote attackers to cause a denial of service (application crash) or possibly execute arbitrary code via crafted OCTET STRING data, related to a "use-after-poison" issue.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-8391Highpcre3:2:8.35-3.3The pcre_compile function in pcre_compile.c in PCRE before 8.38 mishandles certain [: nesting, which allows remote attackers to cause a denial of service (CPU consumption) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-8395Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain references, which allows remote attackers to cause a denial of service or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8392.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-8386Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the interaction of lookbehind assertions and mutually recursive subpatterns, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-2328Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /((?(R)a|(?1)))+/ pattern and related patterns with certain recursion, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-8380Highpcre3:2:8.35-3.3The pcre_exec function in pcre_exec.c in PCRE before 8.38 mishandles a // pattern with a \01 string, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-8390Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the [: and \\ substrings in character classes, which allows remote attackers to cause a denial of service (uninitialized memory read) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-8381Highpcre3:2:8.35-3.3The compile_regex function in pcre_compile.c in PCRE before 8.38 and pcre2_compile.c in PCRE2 before 10.2x mishandles the /(?J:(?|(:(?|(?'R')(\k'R')|((?'R')))H'Rk'Rf)|s(?'R'))))/ and /(?J:(?|(:(?|(?'R')(\z(?|(?'R')(\k'R')|((?'R')))k'R')|((?'R')))H'Ak'Rf)|s(?'R')))/ patterns, and related patterns with certain group references, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-8394Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the (?() and (?(R) conditions, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-8387Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles (?123) subroutine calls and related subroutine calls, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-8392Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain instances of the (?| substring, which allows remote attackers to cause a denial of service (unintended recursion and buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8395.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2016-3191Highpcre3:2:8.35-3.3The compile_branch function in pcre_compile.c in PCRE 8.x before 8.39 and pcre2_compile.c in PCRE2 before 10.22 mishandles patterns containing an (*ACCEPT) substring in conjunction with nested parentheses, which allows remote attackers to execute arbitrary code or cause a denial of service (stack-based buffer overflow) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-3542.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-8389Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?:|a|){100}x/ pattern and related patterns, which allows remote attackers to cause a denial of service (infinite recursion) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-8383Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain repeated conditional groups, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-8385Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?|(\k'Pm')|(?'Pm'))/ pattern and related patterns with certain forward references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-2327Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /(((a\2)|(a*)\g<-1>))*/ pattern and related patterns with certain internal recursive back references, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-8384Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?J)(?'d'(?'d'\g{d}))/ pattern and related patterns with certain recursive back references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8392 and CVE-2015-8395.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-8388Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?=di(?<=(?1))|(?=(.))))/ pattern and related patterns with an unmatched closing parenthesis, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2016-1283Highpcre3:2:8.35-3.3The pcre_compile2 function in pcre_compile.c in PCRE 8.38 mishandles the /((?:F?+(?:^(?(R)a+\"){99}-))(?J)(?'R'(?'R'<((?'RR'(?'R'\){97)?J)?J)(?'R'(?'R'\){99|(:(?|(?'R')(\k'R')|((?'R')))H'R'R)(H'R))))))/ pattern and related patterns with named subgroups, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2014-9769Highpcre3:2:8.35-3.3pcre_jit_compile.c in PCRE 8.35 does not properly use table jumps to optimize nested alternatives, which allows remote attackers to cause a denial of service (stack memory corruption) or possibly have unspecified other impact via a crafted string, as demonstrated by packets encountered by Suricata during use of a regular expression in an Emerging Threats Open ruleset.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2016-0799Highopenssl:1.0.1k-3+deb8u2The fmtstr function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g improperly calculates string lengths, which allows remote attackers to cause a denial of service (overflow and out-of-bounds read) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-2842.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2016-0798Highopenssl:1.0.1k-3+deb8u2Memory leak in the SRP_VBASE_get_by_user implementation in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory consumption) by providing an invalid username in a connection attempt, related to apps/s_server.c and crypto/srp/srp_vfy.c.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2016-0705Highopenssl:1.0.1k-3+deb8u2Double free vulnerability in the dsa_priv_decode function in crypto/dsa/dsa_ameth.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory corruption) or possibly have unspecified other impact via a malformed DSA private key.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2016-2842Highopenssl:1.0.1k-3+deb8u2The doapr_outch function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not verify that a certain memory allocation succeeds, which allows remote attackers to cause a denial of service (out-of-bounds write or memory consumption) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-0799.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-8607Highperl:5.20.2-3+deb8u1The canonpath function in the File::Spec module in PathTools before 3.62, as used in Perl, does not properly preserve the taint attribute of data, which might allow context-dependent attackers to bypass the taint protection mechanism via a crafted string.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2016-0494Highicu:52.1-8+deb8u3Unspecified vulnerability in the Java SE and Java SE Embedded components in Oracle Java SE 6u105, 7u91, and 8u66 and Java SE Embedded 8u65 allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-4844Highicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u101, 7u85, and 8u60, and Java SE Embedded 8u51, allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2016-0728Highlinux:3.16.7-ckt20-1+deb8u2The join_session_keyring function in security/keys/process_keys.c in the Linux kernel before 4.4.1 mishandles object references in a certain error case, which allows local users to gain privileges or cause a denial of service (integer overflow and use-after-free) via crafted keyctl commands.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2013-7445Highlinux:3.16.7-ckt20-1+deb8u2The Direct Rendering Manager (DRM) subsystem in the Linux kernel through 4.x mishandles requests for Graphics Execution Manager (GEM) objects, which allows context-dependent attackers to cause a denial of service (memory consumption) via an application that processes graphics data, as demonstrated by JavaScript code that creates many CANVAS elements for rendering by Chrome or Firefox.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-2059Highlibidn:1.29-1The stringprep_utf8_to_ucs4 function in libin before 1.31, as used in jabberd2, allows context-dependent attackers to read system memory and possibly have other unspecified impact via invalid UTF-8 characters in a string, which triggers an out-of-bounds read.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-8805Highnettle:2.7.1-5The ecc_256_modq function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8803.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-8804Highnettle:2.7.1-5x86_64/ecc-384-modp.asm in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-384 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-8803Highnettle:2.7.1-5The ecc_256_modp function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8805.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-5600Highopenssh:1:6.7p1-5The kbdint_next_device function in auth2-chall.c in sshd in OpenSSH through 6.9 does not properly restrict the processing of keyboard-interactive devices within a single connection, which makes it easier for remote attackers to conduct brute-force attacks or cause a denial of service (CPU consumption) via a long and duplicative list in the ssh -oKbdInteractiveDevices option, as demonstrated by a modified client that provides a different password for each pam element on this list.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-5277Highglibc:2.19-18+deb8u1The get_contents function in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) before 2.20 might allow local users to cause a denial of service (heap corruption) or gain privileges via a long line in the NSS files database.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-2856Highglibc:2.19-18+deb8u1pt_chown in the glibc package before 2.19-18+deb8u4 on Debian jessie lacks a namespace check associated with file-descriptor passing, which allows local users to capture keystrokes and spoof data, and possibly gain privileges, via pts read and write operations, related to debian/sysdeps/linux.mk. NOTE: this is not considered a vulnerability in the upstream GNU C Library because the upstream documentation has a clear security recommendation against the --enable-pt_chown option.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-8805Highnettle:2.7.1-5The ecc_256_modq function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8803.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-8804Highnettle:2.7.1-5x86_64/ecc-384-modp.asm in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-384 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-8803Highnettle:2.7.1-5The ecc_256_modp function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8805.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-0494Highicu:52.1-8+deb8u3Unspecified vulnerability in the Java SE and Java SE Embedded components in Oracle Java SE 6u105, 7u91, and 8u66 and Java SE Embedded 8u65 allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-4844Highicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u101, 7u85, and 8u60, and Java SE Embedded 8u51, allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-8391Highpcre3:2:8.35-3.3The pcre_compile function in pcre_compile.c in PCRE before 8.38 mishandles certain [: nesting, which allows remote attackers to cause a denial of service (CPU consumption) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-8395Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain references, which allows remote attackers to cause a denial of service or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8392.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-8386Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the interaction of lookbehind assertions and mutually recursive subpatterns, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-2328Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /((?(R)a|(?1)))+/ pattern and related patterns with certain recursion, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-8380Highpcre3:2:8.35-3.3The pcre_exec function in pcre_exec.c in PCRE before 8.38 mishandles a // pattern with a \01 string, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-8390Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the [: and \\ substrings in character classes, which allows remote attackers to cause a denial of service (uninitialized memory read) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-8381Highpcre3:2:8.35-3.3The compile_regex function in pcre_compile.c in PCRE before 8.38 and pcre2_compile.c in PCRE2 before 10.2x mishandles the /(?J:(?|(:(?|(?'R')(\k'R')|((?'R')))H'Rk'Rf)|s(?'R'))))/ and /(?J:(?|(:(?|(?'R')(\z(?|(?'R')(\k'R')|((?'R')))k'R')|((?'R')))H'Ak'Rf)|s(?'R')))/ patterns, and related patterns with certain group references, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-8394Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the (?() and (?(R) conditions, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-8387Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles (?123) subroutine calls and related subroutine calls, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-8392Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain instances of the (?| substring, which allows remote attackers to cause a denial of service (unintended recursion and buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8395.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-3191Highpcre3:2:8.35-3.3The compile_branch function in pcre_compile.c in PCRE 8.x before 8.39 and pcre2_compile.c in PCRE2 before 10.22 mishandles patterns containing an (*ACCEPT) substring in conjunction with nested parentheses, which allows remote attackers to execute arbitrary code or cause a denial of service (stack-based buffer overflow) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-3542.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-8389Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?:|a|){100}x/ pattern and related patterns, which allows remote attackers to cause a denial of service (infinite recursion) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-8383Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain repeated conditional groups, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-8385Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?|(\k'Pm')|(?'Pm'))/ pattern and related patterns with certain forward references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-2327Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /(((a\2)|(a*)\g<-1>))*/ pattern and related patterns with certain internal recursive back references, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-8384Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?J)(?'d'(?'d'\g{d}))/ pattern and related patterns with certain recursive back references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8392 and CVE-2015-8395.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-8388Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?=di(?<=(?1))|(?=(.))))/ pattern and related patterns with an unmatched closing parenthesis, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-1283Highpcre3:2:8.35-3.3The pcre_compile2 function in pcre_compile.c in PCRE 8.38 mishandles the /((?:F?+(?:^(?(R)a+\"){99}-))(?J)(?'R'(?'R'<((?'RR'(?'R'\){97)?J)?J)(?'R'(?'R'\){99|(:(?|(?'R')(\k'R')|((?'R')))H'R'R)(H'R))))))/ pattern and related patterns with named subgroups, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2014-9769Highpcre3:2:8.35-3.3pcre_jit_compile.c in PCRE 8.35 does not properly use table jumps to optimize nested alternatives, which allows remote attackers to cause a denial of service (stack memory corruption) or possibly have unspecified other impact via a crafted string, as demonstrated by packets encountered by Suricata during use of a regular expression in an Emerging Threats Open ruleset.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-8607Highperl:5.20.2-3+deb8u1The canonpath function in the File::Spec module in PathTools before 3.62, as used in Perl, does not properly preserve the taint attribute of data, which might allow context-dependent attackers to bypass the taint protection mechanism via a crafted string.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-7182Highnss:2:3.17.2-1.1+deb8u2Heap-based buffer overflow in the ASN.1 decoder in Mozilla Network Security Services (NSS) before 3.19.2.1 and 3.20.x before 3.20.1, as used in Firefox before 42.0 and Firefox ESR 38.x before 38.4 and other products, allows remote attackers to cause a denial of service (application crash) or possibly execute arbitrary code via crafted OCTET STRING data.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-7181Highnss:2:3.17.2-1.1+deb8u2The sec_asn1d_parse_leaf function in Mozilla Network Security Services (NSS) before 3.19.2.1 and 3.20.x before 3.20.1, as used in Firefox before 42.0 and Firefox ESR 38.x before 38.4 and other products, improperly restricts access to an unspecified data structure, which allows remote attackers to cause a denial of service (application crash) or possibly execute arbitrary code via crafted OCTET STRING data, related to a "use-after-poison" issue.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-0728Highlinux:3.16.7-ckt20-1+deb8u2The join_session_keyring function in security/keys/process_keys.c in the Linux kernel before 4.4.1 mishandles object references in a certain error case, which allows local users to gain privileges or cause a denial of service (integer overflow and use-after-free) via crafted keyctl commands.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2013-7445Highlinux:3.16.7-ckt20-1+deb8u2The Direct Rendering Manager (DRM) subsystem in the Linux kernel through 4.x mishandles requests for Graphics Execution Manager (GEM) objects, which allows context-dependent attackers to cause a denial of service (memory consumption) via an application that processes graphics data, as demonstrated by JavaScript code that creates many CANVAS elements for rendering by Chrome or Firefox.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-2059Highlibidn:1.29-1The stringprep_utf8_to_ucs4 function in libin before 1.31, as used in jabberd2, allows context-dependent attackers to read system memory and possibly have other unspecified impact via invalid UTF-8 characters in a string, which triggers an out-of-bounds read.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-0799Highopenssl:1.0.1k-3+deb8u2The fmtstr function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g improperly calculates string lengths, which allows remote attackers to cause a denial of service (overflow and out-of-bounds read) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-2842.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-0798Highopenssl:1.0.1k-3+deb8u2Memory leak in the SRP_VBASE_get_by_user implementation in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory consumption) by providing an invalid username in a connection attempt, related to apps/s_server.c and crypto/srp/srp_vfy.c.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-0705Highopenssl:1.0.1k-3+deb8u2Double free vulnerability in the dsa_priv_decode function in crypto/dsa/dsa_ameth.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory corruption) or possibly have unspecified other impact via a malformed DSA private key.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-2842Highopenssl:1.0.1k-3+deb8u2The doapr_outch function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not verify that a certain memory allocation succeeds, which allows remote attackers to cause a denial of service (out-of-bounds write or memory consumption) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-0799.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-0494Highicu:52.1-8+deb8u3Unspecified vulnerability in the Java SE and Java SE Embedded components in Oracle Java SE 6u105, 7u91, and 8u66 and Java SE Embedded 8u65 allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-4844Highicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u101, 7u85, and 8u60, and Java SE Embedded 8u51, allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-5600Highopenssh:1:6.7p1-5The kbdint_next_device function in auth2-chall.c in sshd in OpenSSH through 6.9 does not properly restrict the processing of keyboard-interactive devices within a single connection, which makes it easier for remote attackers to conduct brute-force attacks or cause a denial of service (CPU consumption) via a long and duplicative list in the ssh -oKbdInteractiveDevices option, as demonstrated by a modified client that provides a different password for each pam element on this list.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-8805Highnettle:2.7.1-5The ecc_256_modq function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8803.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-8804Highnettle:2.7.1-5x86_64/ecc-384-modp.asm in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-384 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-8803Highnettle:2.7.1-5The ecc_256_modp function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8805.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2016-0728Highlinux:3.16.7-ckt20-1+deb8u2The join_session_keyring function in security/keys/process_keys.c in the Linux kernel before 4.4.1 mishandles object references in a certain error case, which allows local users to gain privileges or cause a denial of service (integer overflow and use-after-free) via crafted keyctl commands.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2013-7445Highlinux:3.16.7-ckt20-1+deb8u2The Direct Rendering Manager (DRM) subsystem in the Linux kernel through 4.x mishandles requests for Graphics Execution Manager (GEM) objects, which allows context-dependent attackers to cause a denial of service (memory consumption) via an application that processes graphics data, as demonstrated by JavaScript code that creates many CANVAS elements for rendering by Chrome or Firefox.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-5277Highglibc:2.19-18+deb8u1The get_contents function in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) before 2.20 might allow local users to cause a denial of service (heap corruption) or gain privileges via a long line in the NSS files database.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2016-2856Highglibc:2.19-18+deb8u1pt_chown in the glibc package before 2.19-18+deb8u4 on Debian jessie lacks a namespace check associated with file-descriptor passing, which allows local users to capture keystrokes and spoof data, and possibly gain privileges, via pts read and write operations, related to debian/sysdeps/linux.mk. NOTE: this is not considered a vulnerability in the upstream GNU C Library because the upstream documentation has a clear security recommendation against the --enable-pt_chown option.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-2059Highlibidn:1.29-1The stringprep_utf8_to_ucs4 function in libin before 1.31, as used in jabberd2, allows context-dependent attackers to read system memory and possibly have other unspecified impact via invalid UTF-8 characters in a string, which triggers an out-of-bounds read.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-7182Highnss:2:3.17.2-1.1+deb8u2Heap-based buffer overflow in the ASN.1 decoder in Mozilla Network Security Services (NSS) before 3.19.2.1 and 3.20.x before 3.20.1, as used in Firefox before 42.0 and Firefox ESR 38.x before 38.4 and other products, allows remote attackers to cause a denial of service (application crash) or possibly execute arbitrary code via crafted OCTET STRING data.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-7181Highnss:2:3.17.2-1.1+deb8u2The sec_asn1d_parse_leaf function in Mozilla Network Security Services (NSS) before 3.19.2.1 and 3.20.x before 3.20.1, as used in Firefox before 42.0 and Firefox ESR 38.x before 38.4 and other products, improperly restricts access to an unspecified data structure, which allows remote attackers to cause a denial of service (application crash) or possibly execute arbitrary code via crafted OCTET STRING data, related to a "use-after-poison" issue.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2016-0799Highopenssl:1.0.1k-3+deb8u2The fmtstr function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g improperly calculates string lengths, which allows remote attackers to cause a denial of service (overflow and out-of-bounds read) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-2842.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2016-0798Highopenssl:1.0.1k-3+deb8u2Memory leak in the SRP_VBASE_get_by_user implementation in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory consumption) by providing an invalid username in a connection attempt, related to apps/s_server.c and crypto/srp/srp_vfy.c.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2016-0705Highopenssl:1.0.1k-3+deb8u2Double free vulnerability in the dsa_priv_decode function in crypto/dsa/dsa_ameth.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory corruption) or possibly have unspecified other impact via a malformed DSA private key.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2016-2842Highopenssl:1.0.1k-3+deb8u2The doapr_outch function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not verify that a certain memory allocation succeeds, which allows remote attackers to cause a denial of service (out-of-bounds write or memory consumption) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-0799.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-8607Highperl:5.20.2-3+deb8u1The canonpath function in the File::Spec module in PathTools before 3.62, as used in Perl, does not properly preserve the taint attribute of data, which might allow context-dependent attackers to bypass the taint protection mechanism via a crafted string.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-8391Highpcre3:2:8.35-3.3The pcre_compile function in pcre_compile.c in PCRE before 8.38 mishandles certain [: nesting, which allows remote attackers to cause a denial of service (CPU consumption) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-8395Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain references, which allows remote attackers to cause a denial of service or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8392.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-8386Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the interaction of lookbehind assertions and mutually recursive subpatterns, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-2328Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /((?(R)a|(?1)))+/ pattern and related patterns with certain recursion, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-8380Highpcre3:2:8.35-3.3The pcre_exec function in pcre_exec.c in PCRE before 8.38 mishandles a // pattern with a \01 string, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-8390Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the [: and \\ substrings in character classes, which allows remote attackers to cause a denial of service (uninitialized memory read) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-8381Highpcre3:2:8.35-3.3The compile_regex function in pcre_compile.c in PCRE before 8.38 and pcre2_compile.c in PCRE2 before 10.2x mishandles the /(?J:(?|(:(?|(?'R')(\k'R')|((?'R')))H'Rk'Rf)|s(?'R'))))/ and /(?J:(?|(:(?|(?'R')(\z(?|(?'R')(\k'R')|((?'R')))k'R')|((?'R')))H'Ak'Rf)|s(?'R')))/ patterns, and related patterns with certain group references, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-8394Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the (?() and (?(R) conditions, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-8387Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles (?123) subroutine calls and related subroutine calls, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-8392Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain instances of the (?| substring, which allows remote attackers to cause a denial of service (unintended recursion and buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8395.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2016-3191Highpcre3:2:8.35-3.3The compile_branch function in pcre_compile.c in PCRE 8.x before 8.39 and pcre2_compile.c in PCRE2 before 10.22 mishandles patterns containing an (*ACCEPT) substring in conjunction with nested parentheses, which allows remote attackers to execute arbitrary code or cause a denial of service (stack-based buffer overflow) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-3542.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-8389Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?:|a|){100}x/ pattern and related patterns, which allows remote attackers to cause a denial of service (infinite recursion) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-8383Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain repeated conditional groups, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-8385Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?|(\k'Pm')|(?'Pm'))/ pattern and related patterns with certain forward references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-2327Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /(((a\2)|(a*)\g<-1>))*/ pattern and related patterns with certain internal recursive back references, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-8384Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?J)(?'d'(?'d'\g{d}))/ pattern and related patterns with certain recursive back references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8392 and CVE-2015-8395.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-8388Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?=di(?<=(?1))|(?=(.))))/ pattern and related patterns with an unmatched closing parenthesis, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2016-1283Highpcre3:2:8.35-3.3The pcre_compile2 function in pcre_compile.c in PCRE 8.38 mishandles the /((?:F?+(?:^(?(R)a+\"){99}-))(?J)(?'R'(?'R'<((?'RR'(?'R'\){97)?J)?J)(?'R'(?'R'\){99|(:(?|(?'R')(\k'R')|((?'R')))H'R'R)(H'R))))))/ pattern and related patterns with named subgroups, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2014-9769Highpcre3:2:8.35-3.3pcre_jit_compile.c in PCRE 8.35 does not properly use table jumps to optimize nested alternatives, which allows remote attackers to cause a denial of service (stack memory corruption) or possibly have unspecified other impact via a crafted string, as demonstrated by packets encountered by Suricata during use of a regular expression in an Emerging Threats Open ruleset.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-7182Highnss:2:3.17.2-1.1+deb8u2Heap-based buffer overflow in the ASN.1 decoder in Mozilla Network Security Services (NSS) before 3.19.2.1 and 3.20.x before 3.20.1, as used in Firefox before 42.0 and Firefox ESR 38.x before 38.4 and other products, allows remote attackers to cause a denial of service (application crash) or possibly execute arbitrary code via crafted OCTET STRING data.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-7181Highnss:2:3.17.2-1.1+deb8u2The sec_asn1d_parse_leaf function in Mozilla Network Security Services (NSS) before 3.19.2.1 and 3.20.x before 3.20.1, as used in Firefox before 42.0 and Firefox ESR 38.x before 38.4 and other products, improperly restricts access to an unspecified data structure, which allows remote attackers to cause a denial of service (application crash) or possibly execute arbitrary code via crafted OCTET STRING data, related to a "use-after-poison" issue.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-5277Highglibc:2.19-18+deb8u1The get_contents function in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) before 2.20 might allow local users to cause a denial of service (heap corruption) or gain privileges via a long line in the NSS files database.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2016-2856Highglibc:2.19-18+deb8u1pt_chown in the glibc package before 2.19-18+deb8u4 on Debian jessie lacks a namespace check associated with file-descriptor passing, which allows local users to capture keystrokes and spoof data, and possibly gain privileges, via pts read and write operations, related to debian/sysdeps/linux.mk. NOTE: this is not considered a vulnerability in the upstream GNU C Library because the upstream documentation has a clear security recommendation against the --enable-pt_chown option.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-8391Highpcre3:2:8.35-3.3The pcre_compile function in pcre_compile.c in PCRE before 8.38 mishandles certain [: nesting, which allows remote attackers to cause a denial of service (CPU consumption) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-8395Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain references, which allows remote attackers to cause a denial of service or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8392.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-8386Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the interaction of lookbehind assertions and mutually recursive subpatterns, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-2328Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /((?(R)a|(?1)))+/ pattern and related patterns with certain recursion, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-8380Highpcre3:2:8.35-3.3The pcre_exec function in pcre_exec.c in PCRE before 8.38 mishandles a // pattern with a \01 string, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-8390Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the [: and \\ substrings in character classes, which allows remote attackers to cause a denial of service (uninitialized memory read) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-8381Highpcre3:2:8.35-3.3The compile_regex function in pcre_compile.c in PCRE before 8.38 and pcre2_compile.c in PCRE2 before 10.2x mishandles the /(?J:(?|(:(?|(?'R')(\k'R')|((?'R')))H'Rk'Rf)|s(?'R'))))/ and /(?J:(?|(:(?|(?'R')(\z(?|(?'R')(\k'R')|((?'R')))k'R')|((?'R')))H'Ak'Rf)|s(?'R')))/ patterns, and related patterns with certain group references, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-8394Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the (?() and (?(R) conditions, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-8387Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles (?123) subroutine calls and related subroutine calls, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-8392Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain instances of the (?| substring, which allows remote attackers to cause a denial of service (unintended recursion and buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8395.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2016-3191Highpcre3:2:8.35-3.3The compile_branch function in pcre_compile.c in PCRE 8.x before 8.39 and pcre2_compile.c in PCRE2 before 10.22 mishandles patterns containing an (*ACCEPT) substring in conjunction with nested parentheses, which allows remote attackers to execute arbitrary code or cause a denial of service (stack-based buffer overflow) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-3542.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-8389Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?:|a|){100}x/ pattern and related patterns, which allows remote attackers to cause a denial of service (infinite recursion) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-8383Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain repeated conditional groups, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-8385Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?|(\k'Pm')|(?'Pm'))/ pattern and related patterns with certain forward references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-2327Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /(((a\2)|(a*)\g<-1>))*/ pattern and related patterns with certain internal recursive back references, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-8384Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?J)(?'d'(?'d'\g{d}))/ pattern and related patterns with certain recursive back references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8392 and CVE-2015-8395.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-8388Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?=di(?<=(?1))|(?=(.))))/ pattern and related patterns with an unmatched closing parenthesis, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2016-1283Highpcre3:2:8.35-3.3The pcre_compile2 function in pcre_compile.c in PCRE 8.38 mishandles the /((?:F?+(?:^(?(R)a+\"){99}-))(?J)(?'R'(?'R'<((?'RR'(?'R'\){97)?J)?J)(?'R'(?'R'\){99|(:(?|(?'R')(\k'R')|((?'R')))H'R'R)(H'R))))))/ pattern and related patterns with named subgroups, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2014-9769Highpcre3:2:8.35-3.3pcre_jit_compile.c in PCRE 8.35 does not properly use table jumps to optimize nested alternatives, which allows remote attackers to cause a denial of service (stack memory corruption) or possibly have unspecified other impact via a crafted string, as demonstrated by packets encountered by Suricata during use of a regular expression in an Emerging Threats Open ruleset.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2016-0799Highopenssl:1.0.1k-3+deb8u2The fmtstr function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g improperly calculates string lengths, which allows remote attackers to cause a denial of service (overflow and out-of-bounds read) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-2842.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2016-0798Highopenssl:1.0.1k-3+deb8u2Memory leak in the SRP_VBASE_get_by_user implementation in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory consumption) by providing an invalid username in a connection attempt, related to apps/s_server.c and crypto/srp/srp_vfy.c.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2016-0705Highopenssl:1.0.1k-3+deb8u2Double free vulnerability in the dsa_priv_decode function in crypto/dsa/dsa_ameth.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory corruption) or possibly have unspecified other impact via a malformed DSA private key.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2016-2842Highopenssl:1.0.1k-3+deb8u2The doapr_outch function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not verify that a certain memory allocation succeeds, which allows remote attackers to cause a denial of service (out-of-bounds write or memory consumption) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-0799.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-8607Highperl:5.20.2-3+deb8u1The canonpath function in the File::Spec module in PathTools before 3.62, as used in Perl, does not properly preserve the taint attribute of data, which might allow context-dependent attackers to bypass the taint protection mechanism via a crafted string.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-8805Highnettle:2.7.1-5The ecc_256_modq function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8803.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-8804Highnettle:2.7.1-5x86_64/ecc-384-modp.asm in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-384 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-8803Highnettle:2.7.1-5The ecc_256_modp function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8805.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-5600Highopenssh:1:6.7p1-5The kbdint_next_device function in auth2-chall.c in sshd in OpenSSH through 6.9 does not properly restrict the processing of keyboard-interactive devices within a single connection, which makes it easier for remote attackers to conduct brute-force attacks or cause a denial of service (CPU consumption) via a long and duplicative list in the ssh -oKbdInteractiveDevices option, as demonstrated by a modified client that provides a different password for each pam element on this list.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-2059Highlibidn:1.29-1The stringprep_utf8_to_ucs4 function in libin before 1.31, as used in jabberd2, allows context-dependent attackers to read system memory and possibly have other unspecified impact via invalid UTF-8 characters in a string, which triggers an out-of-bounds read.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2016-0494Highicu:52.1-8+deb8u3Unspecified vulnerability in the Java SE and Java SE Embedded components in Oracle Java SE 6u105, 7u91, and 8u66 and Java SE Embedded 8u65 allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-4844Highicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u101, 7u85, and 8u60, and Java SE Embedded 8u51, allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2016-0728Highlinux:3.16.7-ckt20-1+deb8u2The join_session_keyring function in security/keys/process_keys.c in the Linux kernel before 4.4.1 mishandles object references in a certain error case, which allows local users to gain privileges or cause a denial of service (integer overflow and use-after-free) via crafted keyctl commands.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2013-7445Highlinux:3.16.7-ckt20-1+deb8u2The Direct Rendering Manager (DRM) subsystem in the Linux kernel through 4.x mishandles requests for Graphics Execution Manager (GEM) objects, which allows context-dependent attackers to cause a denial of service (memory consumption) via an application that processes graphics data, as demonstrated by JavaScript code that creates many CANVAS elements for rendering by Chrome or Firefox.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-5600Highopenssh:1:6.7p1-5The kbdint_next_device function in auth2-chall.c in sshd in OpenSSH through 6.9 does not properly restrict the processing of keyboard-interactive devices within a single connection, which makes it easier for remote attackers to conduct brute-force attacks or cause a denial of service (CPU consumption) via a long and duplicative list in the ssh -oKbdInteractiveDevices option, as demonstrated by a modified client that provides a different password for each pam element on this list.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-0799Highopenssl:1.0.1k-3+deb8u2The fmtstr function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g improperly calculates string lengths, which allows remote attackers to cause a denial of service (overflow and out-of-bounds read) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-2842.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-0798Highopenssl:1.0.1k-3+deb8u2Memory leak in the SRP_VBASE_get_by_user implementation in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory consumption) by providing an invalid username in a connection attempt, related to apps/s_server.c and crypto/srp/srp_vfy.c.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-0705Highopenssl:1.0.1k-3+deb8u2Double free vulnerability in the dsa_priv_decode function in crypto/dsa/dsa_ameth.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory corruption) or possibly have unspecified other impact via a malformed DSA private key.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-2842Highopenssl:1.0.1k-3+deb8u2The doapr_outch function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not verify that a certain memory allocation succeeds, which allows remote attackers to cause a denial of service (out-of-bounds write or memory consumption) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-0799.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-8391Highpcre3:2:8.35-3.3The pcre_compile function in pcre_compile.c in PCRE before 8.38 mishandles certain [: nesting, which allows remote attackers to cause a denial of service (CPU consumption) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-8395Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain references, which allows remote attackers to cause a denial of service or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8392.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-8386Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the interaction of lookbehind assertions and mutually recursive subpatterns, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-2328Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /((?(R)a|(?1)))+/ pattern and related patterns with certain recursion, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-8380Highpcre3:2:8.35-3.3The pcre_exec function in pcre_exec.c in PCRE before 8.38 mishandles a // pattern with a \01 string, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-8390Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the [: and \\ substrings in character classes, which allows remote attackers to cause a denial of service (uninitialized memory read) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-8381Highpcre3:2:8.35-3.3The compile_regex function in pcre_compile.c in PCRE before 8.38 and pcre2_compile.c in PCRE2 before 10.2x mishandles the /(?J:(?|(:(?|(?'R')(\k'R')|((?'R')))H'Rk'Rf)|s(?'R'))))/ and /(?J:(?|(:(?|(?'R')(\z(?|(?'R')(\k'R')|((?'R')))k'R')|((?'R')))H'Ak'Rf)|s(?'R')))/ patterns, and related patterns with certain group references, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-8394Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the (?() and (?(R) conditions, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-8387Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles (?123) subroutine calls and related subroutine calls, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-8392Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain instances of the (?| substring, which allows remote attackers to cause a denial of service (unintended recursion and buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8395.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-3191Highpcre3:2:8.35-3.3The compile_branch function in pcre_compile.c in PCRE 8.x before 8.39 and pcre2_compile.c in PCRE2 before 10.22 mishandles patterns containing an (*ACCEPT) substring in conjunction with nested parentheses, which allows remote attackers to execute arbitrary code or cause a denial of service (stack-based buffer overflow) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-3542.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-8389Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?:|a|){100}x/ pattern and related patterns, which allows remote attackers to cause a denial of service (infinite recursion) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-8383Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain repeated conditional groups, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-8385Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?|(\k'Pm')|(?'Pm'))/ pattern and related patterns with certain forward references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-2327Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /(((a\2)|(a*)\g<-1>))*/ pattern and related patterns with certain internal recursive back references, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-8384Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?J)(?'d'(?'d'\g{d}))/ pattern and related patterns with certain recursive back references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8392 and CVE-2015-8395.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-8388Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?=di(?<=(?1))|(?=(.))))/ pattern and related patterns with an unmatched closing parenthesis, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-1283Highpcre3:2:8.35-3.3The pcre_compile2 function in pcre_compile.c in PCRE 8.38 mishandles the /((?:F?+(?:^(?(R)a+\"){99}-))(?J)(?'R'(?'R'<((?'RR'(?'R'\){97)?J)?J)(?'R'(?'R'\){99|(:(?|(?'R')(\k'R')|((?'R')))H'R'R)(H'R))))))/ pattern and related patterns with named subgroups, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2014-9769Highpcre3:2:8.35-3.3pcre_jit_compile.c in PCRE 8.35 does not properly use table jumps to optimize nested alternatives, which allows remote attackers to cause a denial of service (stack memory corruption) or possibly have unspecified other impact via a crafted string, as demonstrated by packets encountered by Suricata during use of a regular expression in an Emerging Threats Open ruleset.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-5277Highglibc:2.19-18+deb8u1The get_contents function in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) before 2.20 might allow local users to cause a denial of service (heap corruption) or gain privileges via a long line in the NSS files database.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-2856Highglibc:2.19-18+deb8u1pt_chown in the glibc package before 2.19-18+deb8u4 on Debian jessie lacks a namespace check associated with file-descriptor passing, which allows local users to capture keystrokes and spoof data, and possibly gain privileges, via pts read and write operations, related to debian/sysdeps/linux.mk. NOTE: this is not considered a vulnerability in the upstream GNU C Library because the upstream documentation has a clear security recommendation against the --enable-pt_chown option.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-2059Highlibidn:1.29-1The stringprep_utf8_to_ucs4 function in libin before 1.31, as used in jabberd2, allows context-dependent attackers to read system memory and possibly have other unspecified impact via invalid UTF-8 characters in a string, which triggers an out-of-bounds read.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-7182Highnss:2:3.17.2-1.1+deb8u2Heap-based buffer overflow in the ASN.1 decoder in Mozilla Network Security Services (NSS) before 3.19.2.1 and 3.20.x before 3.20.1, as used in Firefox before 42.0 and Firefox ESR 38.x before 38.4 and other products, allows remote attackers to cause a denial of service (application crash) or possibly execute arbitrary code via crafted OCTET STRING data.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-7181Highnss:2:3.17.2-1.1+deb8u2The sec_asn1d_parse_leaf function in Mozilla Network Security Services (NSS) before 3.19.2.1 and 3.20.x before 3.20.1, as used in Firefox before 42.0 and Firefox ESR 38.x before 38.4 and other products, improperly restricts access to an unspecified data structure, which allows remote attackers to cause a denial of service (application crash) or possibly execute arbitrary code via crafted OCTET STRING data, related to a "use-after-poison" issue.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-8607Highperl:5.20.2-3+deb8u1The canonpath function in the File::Spec module in PathTools before 3.62, as used in Perl, does not properly preserve the taint attribute of data, which might allow context-dependent attackers to bypass the taint protection mechanism via a crafted string.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-8805Highnettle:2.7.1-5The ecc_256_modq function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8803.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-8804Highnettle:2.7.1-5x86_64/ecc-384-modp.asm in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-384 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-8803Highnettle:2.7.1-5The ecc_256_modp function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8805.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-0728Highlinux:3.16.7-ckt20-1+deb8u2The join_session_keyring function in security/keys/process_keys.c in the Linux kernel before 4.4.1 mishandles object references in a certain error case, which allows local users to gain privileges or cause a denial of service (integer overflow and use-after-free) via crafted keyctl commands.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2013-7445Highlinux:3.16.7-ckt20-1+deb8u2The Direct Rendering Manager (DRM) subsystem in the Linux kernel through 4.x mishandles requests for Graphics Execution Manager (GEM) objects, which allows context-dependent attackers to cause a denial of service (memory consumption) via an application that processes graphics data, as demonstrated by JavaScript code that creates many CANVAS elements for rendering by Chrome or Firefox.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-0494Highicu:52.1-8+deb8u3Unspecified vulnerability in the Java SE and Java SE Embedded components in Oracle Java SE 6u105, 7u91, and 8u66 and Java SE Embedded 8u65 allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-4844Highicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u101, 7u85, and 8u60, and Java SE Embedded 8u51, allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-8805Highnettle:2.7.1-5The ecc_256_modq function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8803.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-8804Highnettle:2.7.1-5x86_64/ecc-384-modp.asm in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-384 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-8803Highnettle:2.7.1-5The ecc_256_modp function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8805.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-2059Highlibidn:1.29-1The stringprep_utf8_to_ucs4 function in libin before 1.31, as used in jabberd2, allows context-dependent attackers to read system memory and possibly have other unspecified impact via invalid UTF-8 characters in a string, which triggers an out-of-bounds read.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2016-0799Highopenssl:1.0.1k-3+deb8u2The fmtstr function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g improperly calculates string lengths, which allows remote attackers to cause a denial of service (overflow and out-of-bounds read) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-2842.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2016-0798Highopenssl:1.0.1k-3+deb8u2Memory leak in the SRP_VBASE_get_by_user implementation in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory consumption) by providing an invalid username in a connection attempt, related to apps/s_server.c and crypto/srp/srp_vfy.c.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2016-0705Highopenssl:1.0.1k-3+deb8u2Double free vulnerability in the dsa_priv_decode function in crypto/dsa/dsa_ameth.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory corruption) or possibly have unspecified other impact via a malformed DSA private key.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2016-2842Highopenssl:1.0.1k-3+deb8u2The doapr_outch function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not verify that a certain memory allocation succeeds, which allows remote attackers to cause a denial of service (out-of-bounds write or memory consumption) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-0799.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-8391Highpcre3:2:8.35-3.3The pcre_compile function in pcre_compile.c in PCRE before 8.38 mishandles certain [: nesting, which allows remote attackers to cause a denial of service (CPU consumption) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-8395Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain references, which allows remote attackers to cause a denial of service or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8392.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-8386Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the interaction of lookbehind assertions and mutually recursive subpatterns, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-2328Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /((?(R)a|(?1)))+/ pattern and related patterns with certain recursion, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-8380Highpcre3:2:8.35-3.3The pcre_exec function in pcre_exec.c in PCRE before 8.38 mishandles a // pattern with a \01 string, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-8390Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the [: and \\ substrings in character classes, which allows remote attackers to cause a denial of service (uninitialized memory read) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-8381Highpcre3:2:8.35-3.3The compile_regex function in pcre_compile.c in PCRE before 8.38 and pcre2_compile.c in PCRE2 before 10.2x mishandles the /(?J:(?|(:(?|(?'R')(\k'R')|((?'R')))H'Rk'Rf)|s(?'R'))))/ and /(?J:(?|(:(?|(?'R')(\z(?|(?'R')(\k'R')|((?'R')))k'R')|((?'R')))H'Ak'Rf)|s(?'R')))/ patterns, and related patterns with certain group references, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-8394Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the (?() and (?(R) conditions, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-8387Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles (?123) subroutine calls and related subroutine calls, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-8392Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain instances of the (?| substring, which allows remote attackers to cause a denial of service (unintended recursion and buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8395.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2016-3191Highpcre3:2:8.35-3.3The compile_branch function in pcre_compile.c in PCRE 8.x before 8.39 and pcre2_compile.c in PCRE2 before 10.22 mishandles patterns containing an (*ACCEPT) substring in conjunction with nested parentheses, which allows remote attackers to execute arbitrary code or cause a denial of service (stack-based buffer overflow) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-3542.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-8389Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?:|a|){100}x/ pattern and related patterns, which allows remote attackers to cause a denial of service (infinite recursion) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-8383Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain repeated conditional groups, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-8385Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?|(\k'Pm')|(?'Pm'))/ pattern and related patterns with certain forward references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-2327Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /(((a\2)|(a*)\g<-1>))*/ pattern and related patterns with certain internal recursive back references, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-8384Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?J)(?'d'(?'d'\g{d}))/ pattern and related patterns with certain recursive back references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8392 and CVE-2015-8395.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-8388Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?=di(?<=(?1))|(?=(.))))/ pattern and related patterns with an unmatched closing parenthesis, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2016-1283Highpcre3:2:8.35-3.3The pcre_compile2 function in pcre_compile.c in PCRE 8.38 mishandles the /((?:F?+(?:^(?(R)a+\"){99}-))(?J)(?'R'(?'R'<((?'RR'(?'R'\){97)?J)?J)(?'R'(?'R'\){99|(:(?|(?'R')(\k'R')|((?'R')))H'R'R)(H'R))))))/ pattern and related patterns with named subgroups, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2014-9769Highpcre3:2:8.35-3.3pcre_jit_compile.c in PCRE 8.35 does not properly use table jumps to optimize nested alternatives, which allows remote attackers to cause a denial of service (stack memory corruption) or possibly have unspecified other impact via a crafted string, as demonstrated by packets encountered by Suricata during use of a regular expression in an Emerging Threats Open ruleset.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-5600Highopenssh:1:6.7p1-5The kbdint_next_device function in auth2-chall.c in sshd in OpenSSH through 6.9 does not properly restrict the processing of keyboard-interactive devices within a single connection, which makes it easier for remote attackers to conduct brute-force attacks or cause a denial of service (CPU consumption) via a long and duplicative list in the ssh -oKbdInteractiveDevices option, as demonstrated by a modified client that provides a different password for each pam element on this list.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-7182Highnss:2:3.17.2-1.1+deb8u2Heap-based buffer overflow in the ASN.1 decoder in Mozilla Network Security Services (NSS) before 3.19.2.1 and 3.20.x before 3.20.1, as used in Firefox before 42.0 and Firefox ESR 38.x before 38.4 and other products, allows remote attackers to cause a denial of service (application crash) or possibly execute arbitrary code via crafted OCTET STRING data.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-7181Highnss:2:3.17.2-1.1+deb8u2The sec_asn1d_parse_leaf function in Mozilla Network Security Services (NSS) before 3.19.2.1 and 3.20.x before 3.20.1, as used in Firefox before 42.0 and Firefox ESR 38.x before 38.4 and other products, improperly restricts access to an unspecified data structure, which allows remote attackers to cause a denial of service (application crash) or possibly execute arbitrary code via crafted OCTET STRING data, related to a "use-after-poison" issue.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-8607Highperl:5.20.2-3+deb8u1The canonpath function in the File::Spec module in PathTools before 3.62, as used in Perl, does not properly preserve the taint attribute of data, which might allow context-dependent attackers to bypass the taint protection mechanism via a crafted string.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2016-0494Highicu:52.1-8+deb8u3Unspecified vulnerability in the Java SE and Java SE Embedded components in Oracle Java SE 6u105, 7u91, and 8u66 and Java SE Embedded 8u65 allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-4844Highicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u101, 7u85, and 8u60, and Java SE Embedded 8u51, allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2016-0728Highlinux:3.16.7-ckt20-1+deb8u2The join_session_keyring function in security/keys/process_keys.c in the Linux kernel before 4.4.1 mishandles object references in a certain error case, which allows local users to gain privileges or cause a denial of service (integer overflow and use-after-free) via crafted keyctl commands.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2013-7445Highlinux:3.16.7-ckt20-1+deb8u2The Direct Rendering Manager (DRM) subsystem in the Linux kernel through 4.x mishandles requests for Graphics Execution Manager (GEM) objects, which allows context-dependent attackers to cause a denial of service (memory consumption) via an application that processes graphics data, as demonstrated by JavaScript code that creates many CANVAS elements for rendering by Chrome or Firefox.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-5277Highglibc:2.19-18+deb8u1The get_contents function in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) before 2.20 might allow local users to cause a denial of service (heap corruption) or gain privileges via a long line in the NSS files database.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2016-2856Highglibc:2.19-18+deb8u1pt_chown in the glibc package before 2.19-18+deb8u4 on Debian jessie lacks a namespace check associated with file-descriptor passing, which allows local users to capture keystrokes and spoof data, and possibly gain privileges, via pts read and write operations, related to debian/sysdeps/linux.mk. NOTE: this is not considered a vulnerability in the upstream GNU C Library because the upstream documentation has a clear security recommendation against the --enable-pt_chown option.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2016-0728Highlinux:3.16.7-ckt20-1+deb8u2The join_session_keyring function in security/keys/process_keys.c in the Linux kernel before 4.4.1 mishandles object references in a certain error case, which allows local users to gain privileges or cause a denial of service (integer overflow and use-after-free) via crafted keyctl commands.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2013-7445Highlinux:3.16.7-ckt20-1+deb8u2The Direct Rendering Manager (DRM) subsystem in the Linux kernel through 4.x mishandles requests for Graphics Execution Manager (GEM) objects, which allows context-dependent attackers to cause a denial of service (memory consumption) via an application that processes graphics data, as demonstrated by JavaScript code that creates many CANVAS elements for rendering by Chrome or Firefox.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-8805Highnettle:2.7.1-5The ecc_256_modq function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8803.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-8804Highnettle:2.7.1-5x86_64/ecc-384-modp.asm in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-384 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-8803Highnettle:2.7.1-5The ecc_256_modp function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8805.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2016-0799Highopenssl:1.0.1k-3+deb8u2The fmtstr function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g improperly calculates string lengths, which allows remote attackers to cause a denial of service (overflow and out-of-bounds read) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-2842.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2016-0798Highopenssl:1.0.1k-3+deb8u2Memory leak in the SRP_VBASE_get_by_user implementation in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory consumption) by providing an invalid username in a connection attempt, related to apps/s_server.c and crypto/srp/srp_vfy.c.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2016-0705Highopenssl:1.0.1k-3+deb8u2Double free vulnerability in the dsa_priv_decode function in crypto/dsa/dsa_ameth.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory corruption) or possibly have unspecified other impact via a malformed DSA private key.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2016-2842Highopenssl:1.0.1k-3+deb8u2The doapr_outch function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not verify that a certain memory allocation succeeds, which allows remote attackers to cause a denial of service (out-of-bounds write or memory consumption) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-0799.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-2059Highlibidn:1.29-1The stringprep_utf8_to_ucs4 function in libin before 1.31, as used in jabberd2, allows context-dependent attackers to read system memory and possibly have other unspecified impact via invalid UTF-8 characters in a string, which triggers an out-of-bounds read.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-5277Highglibc:2.19-18+deb8u1The get_contents function in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) before 2.20 might allow local users to cause a denial of service (heap corruption) or gain privileges via a long line in the NSS files database.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2016-2856Highglibc:2.19-18+deb8u1pt_chown in the glibc package before 2.19-18+deb8u4 on Debian jessie lacks a namespace check associated with file-descriptor passing, which allows local users to capture keystrokes and spoof data, and possibly gain privileges, via pts read and write operations, related to debian/sysdeps/linux.mk. NOTE: this is not considered a vulnerability in the upstream GNU C Library because the upstream documentation has a clear security recommendation against the --enable-pt_chown option.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-8607Highperl:5.20.2-3+deb8u1The canonpath function in the File::Spec module in PathTools before 3.62, as used in Perl, does not properly preserve the taint attribute of data, which might allow context-dependent attackers to bypass the taint protection mechanism via a crafted string.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2016-0494Highicu:52.1-8+deb8u3Unspecified vulnerability in the Java SE and Java SE Embedded components in Oracle Java SE 6u105, 7u91, and 8u66 and Java SE Embedded 8u65 allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-4844Highicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u101, 7u85, and 8u60, and Java SE Embedded 8u51, allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-8391Highpcre3:2:8.35-3.3The pcre_compile function in pcre_compile.c in PCRE before 8.38 mishandles certain [: nesting, which allows remote attackers to cause a denial of service (CPU consumption) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-8395Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain references, which allows remote attackers to cause a denial of service or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8392.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-8386Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the interaction of lookbehind assertions and mutually recursive subpatterns, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-2328Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /((?(R)a|(?1)))+/ pattern and related patterns with certain recursion, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-8380Highpcre3:2:8.35-3.3The pcre_exec function in pcre_exec.c in PCRE before 8.38 mishandles a // pattern with a \01 string, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-8390Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the [: and \\ substrings in character classes, which allows remote attackers to cause a denial of service (uninitialized memory read) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-8381Highpcre3:2:8.35-3.3The compile_regex function in pcre_compile.c in PCRE before 8.38 and pcre2_compile.c in PCRE2 before 10.2x mishandles the /(?J:(?|(:(?|(?'R')(\k'R')|((?'R')))H'Rk'Rf)|s(?'R'))))/ and /(?J:(?|(:(?|(?'R')(\z(?|(?'R')(\k'R')|((?'R')))k'R')|((?'R')))H'Ak'Rf)|s(?'R')))/ patterns, and related patterns with certain group references, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-8394Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the (?() and (?(R) conditions, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-8387Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles (?123) subroutine calls and related subroutine calls, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-8392Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain instances of the (?| substring, which allows remote attackers to cause a denial of service (unintended recursion and buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8395.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2016-3191Highpcre3:2:8.35-3.3The compile_branch function in pcre_compile.c in PCRE 8.x before 8.39 and pcre2_compile.c in PCRE2 before 10.22 mishandles patterns containing an (*ACCEPT) substring in conjunction with nested parentheses, which allows remote attackers to execute arbitrary code or cause a denial of service (stack-based buffer overflow) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-3542.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-8389Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?:|a|){100}x/ pattern and related patterns, which allows remote attackers to cause a denial of service (infinite recursion) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-8383Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain repeated conditional groups, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-8385Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?|(\k'Pm')|(?'Pm'))/ pattern and related patterns with certain forward references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-2327Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /(((a\2)|(a*)\g<-1>))*/ pattern and related patterns with certain internal recursive back references, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-8384Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?J)(?'d'(?'d'\g{d}))/ pattern and related patterns with certain recursive back references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8392 and CVE-2015-8395.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-8388Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?=di(?<=(?1))|(?=(.))))/ pattern and related patterns with an unmatched closing parenthesis, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2016-1283Highpcre3:2:8.35-3.3The pcre_compile2 function in pcre_compile.c in PCRE 8.38 mishandles the /((?:F?+(?:^(?(R)a+\"){99}-))(?J)(?'R'(?'R'<((?'RR'(?'R'\){97)?J)?J)(?'R'(?'R'\){99|(:(?|(?'R')(\k'R')|((?'R')))H'R'R)(H'R))))))/ pattern and related patterns with named subgroups, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2014-9769Highpcre3:2:8.35-3.3pcre_jit_compile.c in PCRE 8.35 does not properly use table jumps to optimize nested alternatives, which allows remote attackers to cause a denial of service (stack memory corruption) or possibly have unspecified other impact via a crafted string, as demonstrated by packets encountered by Suricata during use of a regular expression in an Emerging Threats Open ruleset.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-5600Highopenssh:1:6.7p1-5The kbdint_next_device function in auth2-chall.c in sshd in OpenSSH through 6.9 does not properly restrict the processing of keyboard-interactive devices within a single connection, which makes it easier for remote attackers to conduct brute-force attacks or cause a denial of service (CPU consumption) via a long and duplicative list in the ssh -oKbdInteractiveDevices option, as demonstrated by a modified client that provides a different password for each pam element on this list.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-7182Highnss:2:3.17.2-1.1+deb8u2Heap-based buffer overflow in the ASN.1 decoder in Mozilla Network Security Services (NSS) before 3.19.2.1 and 3.20.x before 3.20.1, as used in Firefox before 42.0 and Firefox ESR 38.x before 38.4 and other products, allows remote attackers to cause a denial of service (application crash) or possibly execute arbitrary code via crafted OCTET STRING data.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-7181Highnss:2:3.17.2-1.1+deb8u2The sec_asn1d_parse_leaf function in Mozilla Network Security Services (NSS) before 3.19.2.1 and 3.20.x before 3.20.1, as used in Firefox before 42.0 and Firefox ESR 38.x before 38.4 and other products, improperly restricts access to an unspecified data structure, which allows remote attackers to cause a denial of service (application crash) or possibly execute arbitrary code via crafted OCTET STRING data, related to a "use-after-poison" issue.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2016-0494Highicu:52.1-8+deb8u3Unspecified vulnerability in the Java SE and Java SE Embedded components in Oracle Java SE 6u105, 7u91, and 8u66 and Java SE Embedded 8u65 allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-4844Highicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u101, 7u85, and 8u60, and Java SE Embedded 8u51, allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-8805Highnettle:2.7.1-5The ecc_256_modq function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8803.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-8804Highnettle:2.7.1-5x86_64/ecc-384-modp.asm in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-384 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-8803Highnettle:2.7.1-5The ecc_256_modp function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8805.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-5600Highopenssh:1:6.7p1-5The kbdint_next_device function in auth2-chall.c in sshd in OpenSSH through 6.9 does not properly restrict the processing of keyboard-interactive devices within a single connection, which makes it easier for remote attackers to conduct brute-force attacks or cause a denial of service (CPU consumption) via a long and duplicative list in the ssh -oKbdInteractiveDevices option, as demonstrated by a modified client that provides a different password for each pam element on this list.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2016-0799Highopenssl:1.0.1k-3+deb8u2The fmtstr function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g improperly calculates string lengths, which allows remote attackers to cause a denial of service (overflow and out-of-bounds read) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-2842.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2016-0798Highopenssl:1.0.1k-3+deb8u2Memory leak in the SRP_VBASE_get_by_user implementation in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory consumption) by providing an invalid username in a connection attempt, related to apps/s_server.c and crypto/srp/srp_vfy.c.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2016-0705Highopenssl:1.0.1k-3+deb8u2Double free vulnerability in the dsa_priv_decode function in crypto/dsa/dsa_ameth.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory corruption) or possibly have unspecified other impact via a malformed DSA private key.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2016-2842Highopenssl:1.0.1k-3+deb8u2The doapr_outch function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not verify that a certain memory allocation succeeds, which allows remote attackers to cause a denial of service (out-of-bounds write or memory consumption) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-0799.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-8607Highperl:5.20.2-3+deb8u1The canonpath function in the File::Spec module in PathTools before 3.62, as used in Perl, does not properly preserve the taint attribute of data, which might allow context-dependent attackers to bypass the taint protection mechanism via a crafted string.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-5277Highglibc:2.19-18+deb8u1The get_contents function in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) before 2.20 might allow local users to cause a denial of service (heap corruption) or gain privileges via a long line in the NSS files database.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2016-2856Highglibc:2.19-18+deb8u1pt_chown in the glibc package before 2.19-18+deb8u4 on Debian jessie lacks a namespace check associated with file-descriptor passing, which allows local users to capture keystrokes and spoof data, and possibly gain privileges, via pts read and write operations, related to debian/sysdeps/linux.mk. NOTE: this is not considered a vulnerability in the upstream GNU C Library because the upstream documentation has a clear security recommendation against the --enable-pt_chown option.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2016-0728Highlinux:3.16.7-ckt20-1+deb8u2The join_session_keyring function in security/keys/process_keys.c in the Linux kernel before 4.4.1 mishandles object references in a certain error case, which allows local users to gain privileges or cause a denial of service (integer overflow and use-after-free) via crafted keyctl commands.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2013-7445Highlinux:3.16.7-ckt20-1+deb8u2The Direct Rendering Manager (DRM) subsystem in the Linux kernel through 4.x mishandles requests for Graphics Execution Manager (GEM) objects, which allows context-dependent attackers to cause a denial of service (memory consumption) via an application that processes graphics data, as demonstrated by JavaScript code that creates many CANVAS elements for rendering by Chrome or Firefox.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-7182Highnss:2:3.17.2-1.1+deb8u2Heap-based buffer overflow in the ASN.1 decoder in Mozilla Network Security Services (NSS) before 3.19.2.1 and 3.20.x before 3.20.1, as used in Firefox before 42.0 and Firefox ESR 38.x before 38.4 and other products, allows remote attackers to cause a denial of service (application crash) or possibly execute arbitrary code via crafted OCTET STRING data.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-7181Highnss:2:3.17.2-1.1+deb8u2The sec_asn1d_parse_leaf function in Mozilla Network Security Services (NSS) before 3.19.2.1 and 3.20.x before 3.20.1, as used in Firefox before 42.0 and Firefox ESR 38.x before 38.4 and other products, improperly restricts access to an unspecified data structure, which allows remote attackers to cause a denial of service (application crash) or possibly execute arbitrary code via crafted OCTET STRING data, related to a "use-after-poison" issue.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-8391Highpcre3:2:8.35-3.3The pcre_compile function in pcre_compile.c in PCRE before 8.38 mishandles certain [: nesting, which allows remote attackers to cause a denial of service (CPU consumption) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-8395Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain references, which allows remote attackers to cause a denial of service or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8392.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-8386Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the interaction of lookbehind assertions and mutually recursive subpatterns, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-2328Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /((?(R)a|(?1)))+/ pattern and related patterns with certain recursion, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-8380Highpcre3:2:8.35-3.3The pcre_exec function in pcre_exec.c in PCRE before 8.38 mishandles a // pattern with a \01 string, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-8390Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the [: and \\ substrings in character classes, which allows remote attackers to cause a denial of service (uninitialized memory read) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-8381Highpcre3:2:8.35-3.3The compile_regex function in pcre_compile.c in PCRE before 8.38 and pcre2_compile.c in PCRE2 before 10.2x mishandles the /(?J:(?|(:(?|(?'R')(\k'R')|((?'R')))H'Rk'Rf)|s(?'R'))))/ and /(?J:(?|(:(?|(?'R')(\z(?|(?'R')(\k'R')|((?'R')))k'R')|((?'R')))H'Ak'Rf)|s(?'R')))/ patterns, and related patterns with certain group references, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-8394Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the (?() and (?(R) conditions, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-8387Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles (?123) subroutine calls and related subroutine calls, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-8392Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain instances of the (?| substring, which allows remote attackers to cause a denial of service (unintended recursion and buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8395.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2016-3191Highpcre3:2:8.35-3.3The compile_branch function in pcre_compile.c in PCRE 8.x before 8.39 and pcre2_compile.c in PCRE2 before 10.22 mishandles patterns containing an (*ACCEPT) substring in conjunction with nested parentheses, which allows remote attackers to execute arbitrary code or cause a denial of service (stack-based buffer overflow) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-3542.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-8389Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?:|a|){100}x/ pattern and related patterns, which allows remote attackers to cause a denial of service (infinite recursion) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-8383Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain repeated conditional groups, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-8385Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?|(\k'Pm')|(?'Pm'))/ pattern and related patterns with certain forward references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-2327Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /(((a\2)|(a*)\g<-1>))*/ pattern and related patterns with certain internal recursive back references, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-8384Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?J)(?'d'(?'d'\g{d}))/ pattern and related patterns with certain recursive back references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8392 and CVE-2015-8395.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-8388Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?=di(?<=(?1))|(?=(.))))/ pattern and related patterns with an unmatched closing parenthesis, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2016-1283Highpcre3:2:8.35-3.3The pcre_compile2 function in pcre_compile.c in PCRE 8.38 mishandles the /((?:F?+(?:^(?(R)a+\"){99}-))(?J)(?'R'(?'R'<((?'RR'(?'R'\){97)?J)?J)(?'R'(?'R'\){99|(:(?|(?'R')(\k'R')|((?'R')))H'R'R)(H'R))))))/ pattern and related patterns with named subgroups, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2014-9769Highpcre3:2:8.35-3.3pcre_jit_compile.c in PCRE 8.35 does not properly use table jumps to optimize nested alternatives, which allows remote attackers to cause a denial of service (stack memory corruption) or possibly have unspecified other impact via a crafted string, as demonstrated by packets encountered by Suricata during use of a regular expression in an Emerging Threats Open ruleset.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-2059Highlibidn:1.29-1The stringprep_utf8_to_ucs4 function in libin before 1.31, as used in jabberd2, allows context-dependent attackers to read system memory and possibly have other unspecified impact via invalid UTF-8 characters in a string, which triggers an out-of-bounds read.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2016-0728Highlinux:3.16.7-ckt20-1+deb8u2The join_session_keyring function in security/keys/process_keys.c in the Linux kernel before 4.4.1 mishandles object references in a certain error case, which allows local users to gain privileges or cause a denial of service (integer overflow and use-after-free) via crafted keyctl commands.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2013-7445Highlinux:3.16.7-ckt20-1+deb8u2The Direct Rendering Manager (DRM) subsystem in the Linux kernel through 4.x mishandles requests for Graphics Execution Manager (GEM) objects, which allows context-dependent attackers to cause a denial of service (memory consumption) via an application that processes graphics data, as demonstrated by JavaScript code that creates many CANVAS elements for rendering by Chrome or Firefox.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-5600Highopenssh:1:6.7p1-5The kbdint_next_device function in auth2-chall.c in sshd in OpenSSH through 6.9 does not properly restrict the processing of keyboard-interactive devices within a single connection, which makes it easier for remote attackers to conduct brute-force attacks or cause a denial of service (CPU consumption) via a long and duplicative list in the ssh -oKbdInteractiveDevices option, as demonstrated by a modified client that provides a different password for each pam element on this list.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2016-0494Highicu:52.1-8+deb8u3Unspecified vulnerability in the Java SE and Java SE Embedded components in Oracle Java SE 6u105, 7u91, and 8u66 and Java SE Embedded 8u65 allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-4844Highicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u101, 7u85, and 8u60, and Java SE Embedded 8u51, allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-8805Highnettle:2.7.1-5The ecc_256_modq function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8803.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-8804Highnettle:2.7.1-5x86_64/ecc-384-modp.asm in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-384 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-8803Highnettle:2.7.1-5The ecc_256_modp function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8805.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-7182Highnss:2:3.17.2-1.1+deb8u2Heap-based buffer overflow in the ASN.1 decoder in Mozilla Network Security Services (NSS) before 3.19.2.1 and 3.20.x before 3.20.1, as used in Firefox before 42.0 and Firefox ESR 38.x before 38.4 and other products, allows remote attackers to cause a denial of service (application crash) or possibly execute arbitrary code via crafted OCTET STRING data.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-7181Highnss:2:3.17.2-1.1+deb8u2The sec_asn1d_parse_leaf function in Mozilla Network Security Services (NSS) before 3.19.2.1 and 3.20.x before 3.20.1, as used in Firefox before 42.0 and Firefox ESR 38.x before 38.4 and other products, improperly restricts access to an unspecified data structure, which allows remote attackers to cause a denial of service (application crash) or possibly execute arbitrary code via crafted OCTET STRING data, related to a "use-after-poison" issue.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-5277Highglibc:2.19-18+deb8u1The get_contents function in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) before 2.20 might allow local users to cause a denial of service (heap corruption) or gain privileges via a long line in the NSS files database.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2016-2856Highglibc:2.19-18+deb8u1pt_chown in the glibc package before 2.19-18+deb8u4 on Debian jessie lacks a namespace check associated with file-descriptor passing, which allows local users to capture keystrokes and spoof data, and possibly gain privileges, via pts read and write operations, related to debian/sysdeps/linux.mk. NOTE: this is not considered a vulnerability in the upstream GNU C Library because the upstream documentation has a clear security recommendation against the --enable-pt_chown option.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-2059Highlibidn:1.29-1The stringprep_utf8_to_ucs4 function in libin before 1.31, as used in jabberd2, allows context-dependent attackers to read system memory and possibly have other unspecified impact via invalid UTF-8 characters in a string, which triggers an out-of-bounds read.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-8607Highperl:5.20.2-3+deb8u1The canonpath function in the File::Spec module in PathTools before 3.62, as used in Perl, does not properly preserve the taint attribute of data, which might allow context-dependent attackers to bypass the taint protection mechanism via a crafted string.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-8391Highpcre3:2:8.35-3.3The pcre_compile function in pcre_compile.c in PCRE before 8.38 mishandles certain [: nesting, which allows remote attackers to cause a denial of service (CPU consumption) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-8395Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain references, which allows remote attackers to cause a denial of service or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8392.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-8386Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the interaction of lookbehind assertions and mutually recursive subpatterns, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-2328Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /((?(R)a|(?1)))+/ pattern and related patterns with certain recursion, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-8380Highpcre3:2:8.35-3.3The pcre_exec function in pcre_exec.c in PCRE before 8.38 mishandles a // pattern with a \01 string, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-8390Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the [: and \\ substrings in character classes, which allows remote attackers to cause a denial of service (uninitialized memory read) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-8381Highpcre3:2:8.35-3.3The compile_regex function in pcre_compile.c in PCRE before 8.38 and pcre2_compile.c in PCRE2 before 10.2x mishandles the /(?J:(?|(:(?|(?'R')(\k'R')|((?'R')))H'Rk'Rf)|s(?'R'))))/ and /(?J:(?|(:(?|(?'R')(\z(?|(?'R')(\k'R')|((?'R')))k'R')|((?'R')))H'Ak'Rf)|s(?'R')))/ patterns, and related patterns with certain group references, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-8394Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the (?() and (?(R) conditions, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-8387Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles (?123) subroutine calls and related subroutine calls, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-8392Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain instances of the (?| substring, which allows remote attackers to cause a denial of service (unintended recursion and buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8395.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2016-3191Highpcre3:2:8.35-3.3The compile_branch function in pcre_compile.c in PCRE 8.x before 8.39 and pcre2_compile.c in PCRE2 before 10.22 mishandles patterns containing an (*ACCEPT) substring in conjunction with nested parentheses, which allows remote attackers to execute arbitrary code or cause a denial of service (stack-based buffer overflow) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-3542.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-8389Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?:|a|){100}x/ pattern and related patterns, which allows remote attackers to cause a denial of service (infinite recursion) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-8383Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain repeated conditional groups, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-8385Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?|(\k'Pm')|(?'Pm'))/ pattern and related patterns with certain forward references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-2327Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /(((a\2)|(a*)\g<-1>))*/ pattern and related patterns with certain internal recursive back references, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-8384Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?J)(?'d'(?'d'\g{d}))/ pattern and related patterns with certain recursive back references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8392 and CVE-2015-8395.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-8388Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?=di(?<=(?1))|(?=(.))))/ pattern and related patterns with an unmatched closing parenthesis, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2016-1283Highpcre3:2:8.35-3.3The pcre_compile2 function in pcre_compile.c in PCRE 8.38 mishandles the /((?:F?+(?:^(?(R)a+\"){99}-))(?J)(?'R'(?'R'<((?'RR'(?'R'\){97)?J)?J)(?'R'(?'R'\){99|(:(?|(?'R')(\k'R')|((?'R')))H'R'R)(H'R))))))/ pattern and related patterns with named subgroups, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2014-9769Highpcre3:2:8.35-3.3pcre_jit_compile.c in PCRE 8.35 does not properly use table jumps to optimize nested alternatives, which allows remote attackers to cause a denial of service (stack memory corruption) or possibly have unspecified other impact via a crafted string, as demonstrated by packets encountered by Suricata during use of a regular expression in an Emerging Threats Open ruleset.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2016-0799Highopenssl:1.0.1k-3+deb8u2The fmtstr function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g improperly calculates string lengths, which allows remote attackers to cause a denial of service (overflow and out-of-bounds read) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-2842.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2016-0798Highopenssl:1.0.1k-3+deb8u2Memory leak in the SRP_VBASE_get_by_user implementation in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory consumption) by providing an invalid username in a connection attempt, related to apps/s_server.c and crypto/srp/srp_vfy.c.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2016-0705Highopenssl:1.0.1k-3+deb8u2Double free vulnerability in the dsa_priv_decode function in crypto/dsa/dsa_ameth.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory corruption) or possibly have unspecified other impact via a malformed DSA private key.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2016-2842Highopenssl:1.0.1k-3+deb8u2The doapr_outch function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not verify that a certain memory allocation succeeds, which allows remote attackers to cause a denial of service (out-of-bounds write or memory consumption) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-0799.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2016-0494Highicu:52.1-8+deb8u3Unspecified vulnerability in the Java SE and Java SE Embedded components in Oracle Java SE 6u105, 7u91, and 8u66 and Java SE Embedded 8u65 allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-4844Highicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u101, 7u85, and 8u60, and Java SE Embedded 8u51, allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-7182Highnss:2:3.17.2-1.1+deb8u2Heap-based buffer overflow in the ASN.1 decoder in Mozilla Network Security Services (NSS) before 3.19.2.1 and 3.20.x before 3.20.1, as used in Firefox before 42.0 and Firefox ESR 38.x before 38.4 and other products, allows remote attackers to cause a denial of service (application crash) or possibly execute arbitrary code via crafted OCTET STRING data.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-7181Highnss:2:3.17.2-1.1+deb8u2The sec_asn1d_parse_leaf function in Mozilla Network Security Services (NSS) before 3.19.2.1 and 3.20.x before 3.20.1, as used in Firefox before 42.0 and Firefox ESR 38.x before 38.4 and other products, improperly restricts access to an unspecified data structure, which allows remote attackers to cause a denial of service (application crash) or possibly execute arbitrary code via crafted OCTET STRING data, related to a "use-after-poison" issue.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-8391Highpcre3:2:8.35-3.3The pcre_compile function in pcre_compile.c in PCRE before 8.38 mishandles certain [: nesting, which allows remote attackers to cause a denial of service (CPU consumption) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-8395Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain references, which allows remote attackers to cause a denial of service or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8392.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-8386Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the interaction of lookbehind assertions and mutually recursive subpatterns, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-2328Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /((?(R)a|(?1)))+/ pattern and related patterns with certain recursion, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-8380Highpcre3:2:8.35-3.3The pcre_exec function in pcre_exec.c in PCRE before 8.38 mishandles a // pattern with a \01 string, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-8390Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the [: and \\ substrings in character classes, which allows remote attackers to cause a denial of service (uninitialized memory read) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-8381Highpcre3:2:8.35-3.3The compile_regex function in pcre_compile.c in PCRE before 8.38 and pcre2_compile.c in PCRE2 before 10.2x mishandles the /(?J:(?|(:(?|(?'R')(\k'R')|((?'R')))H'Rk'Rf)|s(?'R'))))/ and /(?J:(?|(:(?|(?'R')(\z(?|(?'R')(\k'R')|((?'R')))k'R')|((?'R')))H'Ak'Rf)|s(?'R')))/ patterns, and related patterns with certain group references, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-8394Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the (?() and (?(R) conditions, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-8387Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles (?123) subroutine calls and related subroutine calls, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-8392Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain instances of the (?| substring, which allows remote attackers to cause a denial of service (unintended recursion and buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8395.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2016-3191Highpcre3:2:8.35-3.3The compile_branch function in pcre_compile.c in PCRE 8.x before 8.39 and pcre2_compile.c in PCRE2 before 10.22 mishandles patterns containing an (*ACCEPT) substring in conjunction with nested parentheses, which allows remote attackers to execute arbitrary code or cause a denial of service (stack-based buffer overflow) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-3542.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-8389Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?:|a|){100}x/ pattern and related patterns, which allows remote attackers to cause a denial of service (infinite recursion) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-8383Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain repeated conditional groups, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-8385Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?|(\k'Pm')|(?'Pm'))/ pattern and related patterns with certain forward references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-2327Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /(((a\2)|(a*)\g<-1>))*/ pattern and related patterns with certain internal recursive back references, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-8384Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?J)(?'d'(?'d'\g{d}))/ pattern and related patterns with certain recursive back references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8392 and CVE-2015-8395.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-8388Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?=di(?<=(?1))|(?=(.))))/ pattern and related patterns with an unmatched closing parenthesis, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2016-1283Highpcre3:2:8.35-3.3The pcre_compile2 function in pcre_compile.c in PCRE 8.38 mishandles the /((?:F?+(?:^(?(R)a+\"){99}-))(?J)(?'R'(?'R'<((?'RR'(?'R'\){97)?J)?J)(?'R'(?'R'\){99|(:(?|(?'R')(\k'R')|((?'R')))H'R'R)(H'R))))))/ pattern and related patterns with named subgroups, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2014-9769Highpcre3:2:8.35-3.3pcre_jit_compile.c in PCRE 8.35 does not properly use table jumps to optimize nested alternatives, which allows remote attackers to cause a denial of service (stack memory corruption) or possibly have unspecified other impact via a crafted string, as demonstrated by packets encountered by Suricata during use of a regular expression in an Emerging Threats Open ruleset.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-8805Highnettle:2.7.1-5The ecc_256_modq function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8803.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-8804Highnettle:2.7.1-5x86_64/ecc-384-modp.asm in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-384 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-8803Highnettle:2.7.1-5The ecc_256_modp function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8805.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2016-0728Highlinux:3.16.7-ckt20-1+deb8u2The join_session_keyring function in security/keys/process_keys.c in the Linux kernel before 4.4.1 mishandles object references in a certain error case, which allows local users to gain privileges or cause a denial of service (integer overflow and use-after-free) via crafted keyctl commands.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2013-7445Highlinux:3.16.7-ckt20-1+deb8u2The Direct Rendering Manager (DRM) subsystem in the Linux kernel through 4.x mishandles requests for Graphics Execution Manager (GEM) objects, which allows context-dependent attackers to cause a denial of service (memory consumption) via an application that processes graphics data, as demonstrated by JavaScript code that creates many CANVAS elements for rendering by Chrome or Firefox.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-8607Highperl:5.20.2-3+deb8u1The canonpath function in the File::Spec module in PathTools before 3.62, as used in Perl, does not properly preserve the taint attribute of data, which might allow context-dependent attackers to bypass the taint protection mechanism via a crafted string.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-2059Highlibidn:1.29-1The stringprep_utf8_to_ucs4 function in libin before 1.31, as used in jabberd2, allows context-dependent attackers to read system memory and possibly have other unspecified impact via invalid UTF-8 characters in a string, which triggers an out-of-bounds read.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-5277Highglibc:2.19-18+deb8u1The get_contents function in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) before 2.20 might allow local users to cause a denial of service (heap corruption) or gain privileges via a long line in the NSS files database.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2016-2856Highglibc:2.19-18+deb8u1pt_chown in the glibc package before 2.19-18+deb8u4 on Debian jessie lacks a namespace check associated with file-descriptor passing, which allows local users to capture keystrokes and spoof data, and possibly gain privileges, via pts read and write operations, related to debian/sysdeps/linux.mk. NOTE: this is not considered a vulnerability in the upstream GNU C Library because the upstream documentation has a clear security recommendation against the --enable-pt_chown option.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-5600Highopenssh:1:6.7p1-5The kbdint_next_device function in auth2-chall.c in sshd in OpenSSH through 6.9 does not properly restrict the processing of keyboard-interactive devices within a single connection, which makes it easier for remote attackers to conduct brute-force attacks or cause a denial of service (CPU consumption) via a long and duplicative list in the ssh -oKbdInteractiveDevices option, as demonstrated by a modified client that provides a different password for each pam element on this list.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2016-0799Highopenssl:1.0.1k-3+deb8u2The fmtstr function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g improperly calculates string lengths, which allows remote attackers to cause a denial of service (overflow and out-of-bounds read) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-2842.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2016-0798Highopenssl:1.0.1k-3+deb8u2Memory leak in the SRP_VBASE_get_by_user implementation in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory consumption) by providing an invalid username in a connection attempt, related to apps/s_server.c and crypto/srp/srp_vfy.c.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2016-0705Highopenssl:1.0.1k-3+deb8u2Double free vulnerability in the dsa_priv_decode function in crypto/dsa/dsa_ameth.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory corruption) or possibly have unspecified other impact via a malformed DSA private key.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2016-2842Highopenssl:1.0.1k-3+deb8u2The doapr_outch function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not verify that a certain memory allocation succeeds, which allows remote attackers to cause a denial of service (out-of-bounds write or memory consumption) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-0799.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-7182Highnss:2:3.17.2-1.1+deb8u2Heap-based buffer overflow in the ASN.1 decoder in Mozilla Network Security Services (NSS) before 3.19.2.1 and 3.20.x before 3.20.1, as used in Firefox before 42.0 and Firefox ESR 38.x before 38.4 and other products, allows remote attackers to cause a denial of service (application crash) or possibly execute arbitrary code via crafted OCTET STRING data.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-7181Highnss:2:3.17.2-1.1+deb8u2The sec_asn1d_parse_leaf function in Mozilla Network Security Services (NSS) before 3.19.2.1 and 3.20.x before 3.20.1, as used in Firefox before 42.0 and Firefox ESR 38.x before 38.4 and other products, improperly restricts access to an unspecified data structure, which allows remote attackers to cause a denial of service (application crash) or possibly execute arbitrary code via crafted OCTET STRING data, related to a "use-after-poison" issue.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-5277Highglibc:2.19-18+deb8u1The get_contents function in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) before 2.20 might allow local users to cause a denial of service (heap corruption) or gain privileges via a long line in the NSS files database.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2016-2856Highglibc:2.19-18+deb8u1pt_chown in the glibc package before 2.19-18+deb8u4 on Debian jessie lacks a namespace check associated with file-descriptor passing, which allows local users to capture keystrokes and spoof data, and possibly gain privileges, via pts read and write operations, related to debian/sysdeps/linux.mk. NOTE: this is not considered a vulnerability in the upstream GNU C Library because the upstream documentation has a clear security recommendation against the --enable-pt_chown option.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-2059Highlibidn:1.29-1The stringprep_utf8_to_ucs4 function in libin before 1.31, as used in jabberd2, allows context-dependent attackers to read system memory and possibly have other unspecified impact via invalid UTF-8 characters in a string, which triggers an out-of-bounds read.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2016-0799Highopenssl:1.0.1k-3+deb8u2The fmtstr function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g improperly calculates string lengths, which allows remote attackers to cause a denial of service (overflow and out-of-bounds read) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-2842.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2016-0798Highopenssl:1.0.1k-3+deb8u2Memory leak in the SRP_VBASE_get_by_user implementation in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory consumption) by providing an invalid username in a connection attempt, related to apps/s_server.c and crypto/srp/srp_vfy.c.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2016-0705Highopenssl:1.0.1k-3+deb8u2Double free vulnerability in the dsa_priv_decode function in crypto/dsa/dsa_ameth.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory corruption) or possibly have unspecified other impact via a malformed DSA private key.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2016-2842Highopenssl:1.0.1k-3+deb8u2The doapr_outch function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not verify that a certain memory allocation succeeds, which allows remote attackers to cause a denial of service (out-of-bounds write or memory consumption) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-0799.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-8607Highperl:5.20.2-3+deb8u1The canonpath function in the File::Spec module in PathTools before 3.62, as used in Perl, does not properly preserve the taint attribute of data, which might allow context-dependent attackers to bypass the taint protection mechanism via a crafted string.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-8805Highnettle:2.7.1-5The ecc_256_modq function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8803.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-8804Highnettle:2.7.1-5x86_64/ecc-384-modp.asm in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-384 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-8803Highnettle:2.7.1-5The ecc_256_modp function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8805.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-5600Highopenssh:1:6.7p1-5The kbdint_next_device function in auth2-chall.c in sshd in OpenSSH through 6.9 does not properly restrict the processing of keyboard-interactive devices within a single connection, which makes it easier for remote attackers to conduct brute-force attacks or cause a denial of service (CPU consumption) via a long and duplicative list in the ssh -oKbdInteractiveDevices option, as demonstrated by a modified client that provides a different password for each pam element on this list.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-8391Highpcre3:2:8.35-3.3The pcre_compile function in pcre_compile.c in PCRE before 8.38 mishandles certain [: nesting, which allows remote attackers to cause a denial of service (CPU consumption) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-8395Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain references, which allows remote attackers to cause a denial of service or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8392.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-8386Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the interaction of lookbehind assertions and mutually recursive subpatterns, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-2328Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /((?(R)a|(?1)))+/ pattern and related patterns with certain recursion, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-8380Highpcre3:2:8.35-3.3The pcre_exec function in pcre_exec.c in PCRE before 8.38 mishandles a // pattern with a \01 string, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-8390Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the [: and \\ substrings in character classes, which allows remote attackers to cause a denial of service (uninitialized memory read) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-8381Highpcre3:2:8.35-3.3The compile_regex function in pcre_compile.c in PCRE before 8.38 and pcre2_compile.c in PCRE2 before 10.2x mishandles the /(?J:(?|(:(?|(?'R')(\k'R')|((?'R')))H'Rk'Rf)|s(?'R'))))/ and /(?J:(?|(:(?|(?'R')(\z(?|(?'R')(\k'R')|((?'R')))k'R')|((?'R')))H'Ak'Rf)|s(?'R')))/ patterns, and related patterns with certain group references, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-8394Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the (?() and (?(R) conditions, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-8387Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles (?123) subroutine calls and related subroutine calls, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-8392Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain instances of the (?| substring, which allows remote attackers to cause a denial of service (unintended recursion and buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8395.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2016-3191Highpcre3:2:8.35-3.3The compile_branch function in pcre_compile.c in PCRE 8.x before 8.39 and pcre2_compile.c in PCRE2 before 10.22 mishandles patterns containing an (*ACCEPT) substring in conjunction with nested parentheses, which allows remote attackers to execute arbitrary code or cause a denial of service (stack-based buffer overflow) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-3542.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-8389Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?:|a|){100}x/ pattern and related patterns, which allows remote attackers to cause a denial of service (infinite recursion) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-8383Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain repeated conditional groups, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-8385Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?|(\k'Pm')|(?'Pm'))/ pattern and related patterns with certain forward references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-2327Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /(((a\2)|(a*)\g<-1>))*/ pattern and related patterns with certain internal recursive back references, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-8384Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?J)(?'d'(?'d'\g{d}))/ pattern and related patterns with certain recursive back references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8392 and CVE-2015-8395.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-8388Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?=di(?<=(?1))|(?=(.))))/ pattern and related patterns with an unmatched closing parenthesis, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2016-1283Highpcre3:2:8.35-3.3The pcre_compile2 function in pcre_compile.c in PCRE 8.38 mishandles the /((?:F?+(?:^(?(R)a+\"){99}-))(?J)(?'R'(?'R'<((?'RR'(?'R'\){97)?J)?J)(?'R'(?'R'\){99|(:(?|(?'R')(\k'R')|((?'R')))H'R'R)(H'R))))))/ pattern and related patterns with named subgroups, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2014-9769Highpcre3:2:8.35-3.3pcre_jit_compile.c in PCRE 8.35 does not properly use table jumps to optimize nested alternatives, which allows remote attackers to cause a denial of service (stack memory corruption) or possibly have unspecified other impact via a crafted string, as demonstrated by packets encountered by Suricata during use of a regular expression in an Emerging Threats Open ruleset.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2016-0494Highicu:52.1-8+deb8u3Unspecified vulnerability in the Java SE and Java SE Embedded components in Oracle Java SE 6u105, 7u91, and 8u66 and Java SE Embedded 8u65 allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-4844Highicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u101, 7u85, and 8u60, and Java SE Embedded 8u51, allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2016-0728Highlinux:3.16.7-ckt20-1+deb8u2The join_session_keyring function in security/keys/process_keys.c in the Linux kernel before 4.4.1 mishandles object references in a certain error case, which allows local users to gain privileges or cause a denial of service (integer overflow and use-after-free) via crafted keyctl commands.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2013-7445Highlinux:3.16.7-ckt20-1+deb8u2The Direct Rendering Manager (DRM) subsystem in the Linux kernel through 4.x mishandles requests for Graphics Execution Manager (GEM) objects, which allows context-dependent attackers to cause a denial of service (memory consumption) via an application that processes graphics data, as demonstrated by JavaScript code that creates many CANVAS elements for rendering by Chrome or Firefox.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-5277Highglibc:2.19-18+deb8u1The get_contents function in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) before 2.20 might allow local users to cause a denial of service (heap corruption) or gain privileges via a long line in the NSS files database.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2016-2856Highglibc:2.19-18+deb8u1pt_chown in the glibc package before 2.19-18+deb8u4 on Debian jessie lacks a namespace check associated with file-descriptor passing, which allows local users to capture keystrokes and spoof data, and possibly gain privileges, via pts read and write operations, related to debian/sysdeps/linux.mk. NOTE: this is not considered a vulnerability in the upstream GNU C Library because the upstream documentation has a clear security recommendation against the --enable-pt_chown option.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-5600Highopenssh:1:6.7p1-5The kbdint_next_device function in auth2-chall.c in sshd in OpenSSH through 6.9 does not properly restrict the processing of keyboard-interactive devices within a single connection, which makes it easier for remote attackers to conduct brute-force attacks or cause a denial of service (CPU consumption) via a long and duplicative list in the ssh -oKbdInteractiveDevices option, as demonstrated by a modified client that provides a different password for each pam element on this list.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2016-0494Highicu:52.1-8+deb8u3Unspecified vulnerability in the Java SE and Java SE Embedded components in Oracle Java SE 6u105, 7u91, and 8u66 and Java SE Embedded 8u65 allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-4844Highicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u101, 7u85, and 8u60, and Java SE Embedded 8u51, allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2016-0728Highlinux:3.16.7-ckt20-1+deb8u2The join_session_keyring function in security/keys/process_keys.c in the Linux kernel before 4.4.1 mishandles object references in a certain error case, which allows local users to gain privileges or cause a denial of service (integer overflow and use-after-free) via crafted keyctl commands.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2013-7445Highlinux:3.16.7-ckt20-1+deb8u2The Direct Rendering Manager (DRM) subsystem in the Linux kernel through 4.x mishandles requests for Graphics Execution Manager (GEM) objects, which allows context-dependent attackers to cause a denial of service (memory consumption) via an application that processes graphics data, as demonstrated by JavaScript code that creates many CANVAS elements for rendering by Chrome or Firefox.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2016-0799Highopenssl:1.0.1k-3+deb8u2The fmtstr function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g improperly calculates string lengths, which allows remote attackers to cause a denial of service (overflow and out-of-bounds read) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-2842.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2016-0798Highopenssl:1.0.1k-3+deb8u2Memory leak in the SRP_VBASE_get_by_user implementation in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory consumption) by providing an invalid username in a connection attempt, related to apps/s_server.c and crypto/srp/srp_vfy.c.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2016-0705Highopenssl:1.0.1k-3+deb8u2Double free vulnerability in the dsa_priv_decode function in crypto/dsa/dsa_ameth.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory corruption) or possibly have unspecified other impact via a malformed DSA private key.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2016-2842Highopenssl:1.0.1k-3+deb8u2The doapr_outch function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not verify that a certain memory allocation succeeds, which allows remote attackers to cause a denial of service (out-of-bounds write or memory consumption) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-0799.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-8805Highnettle:2.7.1-5The ecc_256_modq function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8803.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-8804Highnettle:2.7.1-5x86_64/ecc-384-modp.asm in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-384 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-8803Highnettle:2.7.1-5The ecc_256_modp function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8805.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-2059Highlibidn:1.29-1The stringprep_utf8_to_ucs4 function in libin before 1.31, as used in jabberd2, allows context-dependent attackers to read system memory and possibly have other unspecified impact via invalid UTF-8 characters in a string, which triggers an out-of-bounds read.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-8607Highperl:5.20.2-3+deb8u1The canonpath function in the File::Spec module in PathTools before 3.62, as used in Perl, does not properly preserve the taint attribute of data, which might allow context-dependent attackers to bypass the taint protection mechanism via a crafted string.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-8391Highpcre3:2:8.35-3.3The pcre_compile function in pcre_compile.c in PCRE before 8.38 mishandles certain [: nesting, which allows remote attackers to cause a denial of service (CPU consumption) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-8395Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain references, which allows remote attackers to cause a denial of service or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8392.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-8386Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the interaction of lookbehind assertions and mutually recursive subpatterns, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-2328Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /((?(R)a|(?1)))+/ pattern and related patterns with certain recursion, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-8380Highpcre3:2:8.35-3.3The pcre_exec function in pcre_exec.c in PCRE before 8.38 mishandles a // pattern with a \01 string, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-8390Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the [: and \\ substrings in character classes, which allows remote attackers to cause a denial of service (uninitialized memory read) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-8381Highpcre3:2:8.35-3.3The compile_regex function in pcre_compile.c in PCRE before 8.38 and pcre2_compile.c in PCRE2 before 10.2x mishandles the /(?J:(?|(:(?|(?'R')(\k'R')|((?'R')))H'Rk'Rf)|s(?'R'))))/ and /(?J:(?|(:(?|(?'R')(\z(?|(?'R')(\k'R')|((?'R')))k'R')|((?'R')))H'Ak'Rf)|s(?'R')))/ patterns, and related patterns with certain group references, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-8394Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the (?() and (?(R) conditions, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-8387Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles (?123) subroutine calls and related subroutine calls, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-8392Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain instances of the (?| substring, which allows remote attackers to cause a denial of service (unintended recursion and buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8395.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2016-3191Highpcre3:2:8.35-3.3The compile_branch function in pcre_compile.c in PCRE 8.x before 8.39 and pcre2_compile.c in PCRE2 before 10.22 mishandles patterns containing an (*ACCEPT) substring in conjunction with nested parentheses, which allows remote attackers to execute arbitrary code or cause a denial of service (stack-based buffer overflow) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-3542.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-8389Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?:|a|){100}x/ pattern and related patterns, which allows remote attackers to cause a denial of service (infinite recursion) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-8383Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain repeated conditional groups, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-8385Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?|(\k'Pm')|(?'Pm'))/ pattern and related patterns with certain forward references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-2327Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /(((a\2)|(a*)\g<-1>))*/ pattern and related patterns with certain internal recursive back references, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-8384Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?J)(?'d'(?'d'\g{d}))/ pattern and related patterns with certain recursive back references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8392 and CVE-2015-8395.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-8388Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?=di(?<=(?1))|(?=(.))))/ pattern and related patterns with an unmatched closing parenthesis, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2016-1283Highpcre3:2:8.35-3.3The pcre_compile2 function in pcre_compile.c in PCRE 8.38 mishandles the /((?:F?+(?:^(?(R)a+\"){99}-))(?J)(?'R'(?'R'<((?'RR'(?'R'\){97)?J)?J)(?'R'(?'R'\){99|(:(?|(?'R')(\k'R')|((?'R')))H'R'R)(H'R))))))/ pattern and related patterns with named subgroups, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2014-9769Highpcre3:2:8.35-3.3pcre_jit_compile.c in PCRE 8.35 does not properly use table jumps to optimize nested alternatives, which allows remote attackers to cause a denial of service (stack memory corruption) or possibly have unspecified other impact via a crafted string, as demonstrated by packets encountered by Suricata during use of a regular expression in an Emerging Threats Open ruleset.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-8391Highpcre3:2:8.35-3.3The pcre_compile function in pcre_compile.c in PCRE before 8.38 mishandles certain [: nesting, which allows remote attackers to cause a denial of service (CPU consumption) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-8395Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain references, which allows remote attackers to cause a denial of service or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8392.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-8386Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the interaction of lookbehind assertions and mutually recursive subpatterns, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-2328Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /((?(R)a|(?1)))+/ pattern and related patterns with certain recursion, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-8380Highpcre3:2:8.35-3.3The pcre_exec function in pcre_exec.c in PCRE before 8.38 mishandles a // pattern with a \01 string, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-8390Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the [: and \\ substrings in character classes, which allows remote attackers to cause a denial of service (uninitialized memory read) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-8381Highpcre3:2:8.35-3.3The compile_regex function in pcre_compile.c in PCRE before 8.38 and pcre2_compile.c in PCRE2 before 10.2x mishandles the /(?J:(?|(:(?|(?'R')(\k'R')|((?'R')))H'Rk'Rf)|s(?'R'))))/ and /(?J:(?|(:(?|(?'R')(\z(?|(?'R')(\k'R')|((?'R')))k'R')|((?'R')))H'Ak'Rf)|s(?'R')))/ patterns, and related patterns with certain group references, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-8394Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the (?() and (?(R) conditions, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-8387Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles (?123) subroutine calls and related subroutine calls, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-8392Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain instances of the (?| substring, which allows remote attackers to cause a denial of service (unintended recursion and buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8395.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2016-3191Highpcre3:2:8.35-3.3The compile_branch function in pcre_compile.c in PCRE 8.x before 8.39 and pcre2_compile.c in PCRE2 before 10.22 mishandles patterns containing an (*ACCEPT) substring in conjunction with nested parentheses, which allows remote attackers to execute arbitrary code or cause a denial of service (stack-based buffer overflow) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-3542.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-8389Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?:|a|){100}x/ pattern and related patterns, which allows remote attackers to cause a denial of service (infinite recursion) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-8383Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain repeated conditional groups, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-8385Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?|(\k'Pm')|(?'Pm'))/ pattern and related patterns with certain forward references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-2327Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /(((a\2)|(a*)\g<-1>))*/ pattern and related patterns with certain internal recursive back references, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-8384Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?J)(?'d'(?'d'\g{d}))/ pattern and related patterns with certain recursive back references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8392 and CVE-2015-8395.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-8388Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?=di(?<=(?1))|(?=(.))))/ pattern and related patterns with an unmatched closing parenthesis, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2016-1283Highpcre3:2:8.35-3.3The pcre_compile2 function in pcre_compile.c in PCRE 8.38 mishandles the /((?:F?+(?:^(?(R)a+\"){99}-))(?J)(?'R'(?'R'<((?'RR'(?'R'\){97)?J)?J)(?'R'(?'R'\){99|(:(?|(?'R')(\k'R')|((?'R')))H'R'R)(H'R))))))/ pattern and related patterns with named subgroups, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2014-9769Highpcre3:2:8.35-3.3pcre_jit_compile.c in PCRE 8.35 does not properly use table jumps to optimize nested alternatives, which allows remote attackers to cause a denial of service (stack memory corruption) or possibly have unspecified other impact via a crafted string, as demonstrated by packets encountered by Suricata during use of a regular expression in an Emerging Threats Open ruleset.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-5600Highopenssh:1:6.7p1-5The kbdint_next_device function in auth2-chall.c in sshd in OpenSSH through 6.9 does not properly restrict the processing of keyboard-interactive devices within a single connection, which makes it easier for remote attackers to conduct brute-force attacks or cause a denial of service (CPU consumption) via a long and duplicative list in the ssh -oKbdInteractiveDevices option, as demonstrated by a modified client that provides a different password for each pam element on this list.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2016-0728Highlinux:3.16.7-ckt20-1+deb8u2The join_session_keyring function in security/keys/process_keys.c in the Linux kernel before 4.4.1 mishandles object references in a certain error case, which allows local users to gain privileges or cause a denial of service (integer overflow and use-after-free) via crafted keyctl commands.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2013-7445Highlinux:3.16.7-ckt20-1+deb8u2The Direct Rendering Manager (DRM) subsystem in the Linux kernel through 4.x mishandles requests for Graphics Execution Manager (GEM) objects, which allows context-dependent attackers to cause a denial of service (memory consumption) via an application that processes graphics data, as demonstrated by JavaScript code that creates many CANVAS elements for rendering by Chrome or Firefox.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-2059Highlibidn:1.29-1The stringprep_utf8_to_ucs4 function in libin before 1.31, as used in jabberd2, allows context-dependent attackers to read system memory and possibly have other unspecified impact via invalid UTF-8 characters in a string, which triggers an out-of-bounds read.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-5277Highglibc:2.19-18+deb8u1The get_contents function in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) before 2.20 might allow local users to cause a denial of service (heap corruption) or gain privileges via a long line in the NSS files database.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2016-2856Highglibc:2.19-18+deb8u1pt_chown in the glibc package before 2.19-18+deb8u4 on Debian jessie lacks a namespace check associated with file-descriptor passing, which allows local users to capture keystrokes and spoof data, and possibly gain privileges, via pts read and write operations, related to debian/sysdeps/linux.mk. NOTE: this is not considered a vulnerability in the upstream GNU C Library because the upstream documentation has a clear security recommendation against the --enable-pt_chown option.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-8805Highnettle:2.7.1-5The ecc_256_modq function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8803.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-8804Highnettle:2.7.1-5x86_64/ecc-384-modp.asm in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-384 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-8803Highnettle:2.7.1-5The ecc_256_modp function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8805.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2016-0799Highopenssl:1.0.1k-3+deb8u2The fmtstr function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g improperly calculates string lengths, which allows remote attackers to cause a denial of service (overflow and out-of-bounds read) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-2842.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2016-0798Highopenssl:1.0.1k-3+deb8u2Memory leak in the SRP_VBASE_get_by_user implementation in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory consumption) by providing an invalid username in a connection attempt, related to apps/s_server.c and crypto/srp/srp_vfy.c.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2016-0705Highopenssl:1.0.1k-3+deb8u2Double free vulnerability in the dsa_priv_decode function in crypto/dsa/dsa_ameth.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory corruption) or possibly have unspecified other impact via a malformed DSA private key.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2016-2842Highopenssl:1.0.1k-3+deb8u2The doapr_outch function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not verify that a certain memory allocation succeeds, which allows remote attackers to cause a denial of service (out-of-bounds write or memory consumption) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-0799.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-8607Highperl:5.20.2-3+deb8u1The canonpath function in the File::Spec module in PathTools before 3.62, as used in Perl, does not properly preserve the taint attribute of data, which might allow context-dependent attackers to bypass the taint protection mechanism via a crafted string.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2016-0494Highicu:52.1-8+deb8u3Unspecified vulnerability in the Java SE and Java SE Embedded components in Oracle Java SE 6u105, 7u91, and 8u66 and Java SE Embedded 8u65 allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-4844Highicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u101, 7u85, and 8u60, and Java SE Embedded 8u51, allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2016-0494Highicu:52.1-8+deb8u3Unspecified vulnerability in the Java SE and Java SE Embedded components in Oracle Java SE 6u105, 7u91, and 8u66 and Java SE Embedded 8u65 allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-4844Highicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u101, 7u85, and 8u60, and Java SE Embedded 8u51, allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-2059Highlibidn:1.29-1The stringprep_utf8_to_ucs4 function in libin before 1.31, as used in jabberd2, allows context-dependent attackers to read system memory and possibly have other unspecified impact via invalid UTF-8 characters in a string, which triggers an out-of-bounds read.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-5600Highopenssh:1:6.7p1-5The kbdint_next_device function in auth2-chall.c in sshd in OpenSSH through 6.9 does not properly restrict the processing of keyboard-interactive devices within a single connection, which makes it easier for remote attackers to conduct brute-force attacks or cause a denial of service (CPU consumption) via a long and duplicative list in the ssh -oKbdInteractiveDevices option, as demonstrated by a modified client that provides a different password for each pam element on this list.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-8607Highperl:5.20.2-3+deb8u1The canonpath function in the File::Spec module in PathTools before 3.62, as used in Perl, does not properly preserve the taint attribute of data, which might allow context-dependent attackers to bypass the taint protection mechanism via a crafted string.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-5277Highglibc:2.19-18+deb8u1The get_contents function in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) before 2.20 might allow local users to cause a denial of service (heap corruption) or gain privileges via a long line in the NSS files database.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2016-2856Highglibc:2.19-18+deb8u1pt_chown in the glibc package before 2.19-18+deb8u4 on Debian jessie lacks a namespace check associated with file-descriptor passing, which allows local users to capture keystrokes and spoof data, and possibly gain privileges, via pts read and write operations, related to debian/sysdeps/linux.mk. NOTE: this is not considered a vulnerability in the upstream GNU C Library because the upstream documentation has a clear security recommendation against the --enable-pt_chown option.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2016-0728Highlinux:3.16.7-ckt20-1+deb8u2The join_session_keyring function in security/keys/process_keys.c in the Linux kernel before 4.4.1 mishandles object references in a certain error case, which allows local users to gain privileges or cause a denial of service (integer overflow and use-after-free) via crafted keyctl commands.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2013-7445Highlinux:3.16.7-ckt20-1+deb8u2The Direct Rendering Manager (DRM) subsystem in the Linux kernel through 4.x mishandles requests for Graphics Execution Manager (GEM) objects, which allows context-dependent attackers to cause a denial of service (memory consumption) via an application that processes graphics data, as demonstrated by JavaScript code that creates many CANVAS elements for rendering by Chrome or Firefox.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2016-0799Highopenssl:1.0.1k-3+deb8u2The fmtstr function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g improperly calculates string lengths, which allows remote attackers to cause a denial of service (overflow and out-of-bounds read) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-2842.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2016-0798Highopenssl:1.0.1k-3+deb8u2Memory leak in the SRP_VBASE_get_by_user implementation in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory consumption) by providing an invalid username in a connection attempt, related to apps/s_server.c and crypto/srp/srp_vfy.c.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2016-0705Highopenssl:1.0.1k-3+deb8u2Double free vulnerability in the dsa_priv_decode function in crypto/dsa/dsa_ameth.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory corruption) or possibly have unspecified other impact via a malformed DSA private key.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2016-2842Highopenssl:1.0.1k-3+deb8u2The doapr_outch function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not verify that a certain memory allocation succeeds, which allows remote attackers to cause a denial of service (out-of-bounds write or memory consumption) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-0799.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-8805Highnettle:2.7.1-5The ecc_256_modq function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8803.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-8804Highnettle:2.7.1-5x86_64/ecc-384-modp.asm in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-384 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-8803Highnettle:2.7.1-5The ecc_256_modp function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8805.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-8391Highpcre3:2:8.35-3.3The pcre_compile function in pcre_compile.c in PCRE before 8.38 mishandles certain [: nesting, which allows remote attackers to cause a denial of service (CPU consumption) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-8395Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain references, which allows remote attackers to cause a denial of service or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8392.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-8386Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the interaction of lookbehind assertions and mutually recursive subpatterns, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-2328Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /((?(R)a|(?1)))+/ pattern and related patterns with certain recursion, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-8380Highpcre3:2:8.35-3.3The pcre_exec function in pcre_exec.c in PCRE before 8.38 mishandles a // pattern with a \01 string, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-8390Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the [: and \\ substrings in character classes, which allows remote attackers to cause a denial of service (uninitialized memory read) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-8381Highpcre3:2:8.35-3.3The compile_regex function in pcre_compile.c in PCRE before 8.38 and pcre2_compile.c in PCRE2 before 10.2x mishandles the /(?J:(?|(:(?|(?'R')(\k'R')|((?'R')))H'Rk'Rf)|s(?'R'))))/ and /(?J:(?|(:(?|(?'R')(\z(?|(?'R')(\k'R')|((?'R')))k'R')|((?'R')))H'Ak'Rf)|s(?'R')))/ patterns, and related patterns with certain group references, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-8394Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the (?() and (?(R) conditions, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-8387Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles (?123) subroutine calls and related subroutine calls, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-8392Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain instances of the (?| substring, which allows remote attackers to cause a denial of service (unintended recursion and buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8395.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2016-3191Highpcre3:2:8.35-3.3The compile_branch function in pcre_compile.c in PCRE 8.x before 8.39 and pcre2_compile.c in PCRE2 before 10.22 mishandles patterns containing an (*ACCEPT) substring in conjunction with nested parentheses, which allows remote attackers to execute arbitrary code or cause a denial of service (stack-based buffer overflow) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-3542.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-8389Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?:|a|){100}x/ pattern and related patterns, which allows remote attackers to cause a denial of service (infinite recursion) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-8383Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain repeated conditional groups, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-8385Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?|(\k'Pm')|(?'Pm'))/ pattern and related patterns with certain forward references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-2327Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /(((a\2)|(a*)\g<-1>))*/ pattern and related patterns with certain internal recursive back references, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-8384Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?J)(?'d'(?'d'\g{d}))/ pattern and related patterns with certain recursive back references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8392 and CVE-2015-8395.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-8388Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?=di(?<=(?1))|(?=(.))))/ pattern and related patterns with an unmatched closing parenthesis, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2016-1283Highpcre3:2:8.35-3.3The pcre_compile2 function in pcre_compile.c in PCRE 8.38 mishandles the /((?:F?+(?:^(?(R)a+\"){99}-))(?J)(?'R'(?'R'<((?'RR'(?'R'\){97)?J)?J)(?'R'(?'R'\){99|(:(?|(?'R')(\k'R')|((?'R')))H'R'R)(H'R))))))/ pattern and related patterns with named subgroups, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2014-9769Highpcre3:2:8.35-3.3pcre_jit_compile.c in PCRE 8.35 does not properly use table jumps to optimize nested alternatives, which allows remote attackers to cause a denial of service (stack memory corruption) or possibly have unspecified other impact via a crafted string, as demonstrated by packets encountered by Suricata during use of a regular expression in an Emerging Threats Open ruleset.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-8391Highpcre3:2:8.35-3.3The pcre_compile function in pcre_compile.c in PCRE before 8.38 mishandles certain [: nesting, which allows remote attackers to cause a denial of service (CPU consumption) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-8395Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain references, which allows remote attackers to cause a denial of service or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8392.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-8386Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the interaction of lookbehind assertions and mutually recursive subpatterns, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-2328Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /((?(R)a|(?1)))+/ pattern and related patterns with certain recursion, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-8380Highpcre3:2:8.35-3.3The pcre_exec function in pcre_exec.c in PCRE before 8.38 mishandles a // pattern with a \01 string, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-8390Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the [: and \\ substrings in character classes, which allows remote attackers to cause a denial of service (uninitialized memory read) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-8381Highpcre3:2:8.35-3.3The compile_regex function in pcre_compile.c in PCRE before 8.38 and pcre2_compile.c in PCRE2 before 10.2x mishandles the /(?J:(?|(:(?|(?'R')(\k'R')|((?'R')))H'Rk'Rf)|s(?'R'))))/ and /(?J:(?|(:(?|(?'R')(\z(?|(?'R')(\k'R')|((?'R')))k'R')|((?'R')))H'Ak'Rf)|s(?'R')))/ patterns, and related patterns with certain group references, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-8394Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the (?() and (?(R) conditions, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-8387Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles (?123) subroutine calls and related subroutine calls, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-8392Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain instances of the (?| substring, which allows remote attackers to cause a denial of service (unintended recursion and buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8395.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2016-3191Highpcre3:2:8.35-3.3The compile_branch function in pcre_compile.c in PCRE 8.x before 8.39 and pcre2_compile.c in PCRE2 before 10.22 mishandles patterns containing an (*ACCEPT) substring in conjunction with nested parentheses, which allows remote attackers to execute arbitrary code or cause a denial of service (stack-based buffer overflow) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-3542.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-8389Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?:|a|){100}x/ pattern and related patterns, which allows remote attackers to cause a denial of service (infinite recursion) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-8383Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain repeated conditional groups, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-8385Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?|(\k'Pm')|(?'Pm'))/ pattern and related patterns with certain forward references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-2327Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /(((a\2)|(a*)\g<-1>))*/ pattern and related patterns with certain internal recursive back references, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-8384Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?J)(?'d'(?'d'\g{d}))/ pattern and related patterns with certain recursive back references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8392 and CVE-2015-8395.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-8388Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?=di(?<=(?1))|(?=(.))))/ pattern and related patterns with an unmatched closing parenthesis, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2016-1283Highpcre3:2:8.35-3.3The pcre_compile2 function in pcre_compile.c in PCRE 8.38 mishandles the /((?:F?+(?:^(?(R)a+\"){99}-))(?J)(?'R'(?'R'<((?'RR'(?'R'\){97)?J)?J)(?'R'(?'R'\){99|(:(?|(?'R')(\k'R')|((?'R')))H'R'R)(H'R))))))/ pattern and related patterns with named subgroups, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2014-9769Highpcre3:2:8.35-3.3pcre_jit_compile.c in PCRE 8.35 does not properly use table jumps to optimize nested alternatives, which allows remote attackers to cause a denial of service (stack memory corruption) or possibly have unspecified other impact via a crafted string, as demonstrated by packets encountered by Suricata during use of a regular expression in an Emerging Threats Open ruleset.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-5600Highopenssh:1:6.7p1-5The kbdint_next_device function in auth2-chall.c in sshd in OpenSSH through 6.9 does not properly restrict the processing of keyboard-interactive devices within a single connection, which makes it easier for remote attackers to conduct brute-force attacks or cause a denial of service (CPU consumption) via a long and duplicative list in the ssh -oKbdInteractiveDevices option, as demonstrated by a modified client that provides a different password for each pam element on this list.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-2059Highlibidn:1.29-1The stringprep_utf8_to_ucs4 function in libin before 1.31, as used in jabberd2, allows context-dependent attackers to read system memory and possibly have other unspecified impact via invalid UTF-8 characters in a string, which triggers an out-of-bounds read.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-8607Highperl:5.20.2-3+deb8u1The canonpath function in the File::Spec module in PathTools before 3.62, as used in Perl, does not properly preserve the taint attribute of data, which might allow context-dependent attackers to bypass the taint protection mechanism via a crafted string.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2016-0728Highlinux:3.16.7-ckt20-1+deb8u2The join_session_keyring function in security/keys/process_keys.c in the Linux kernel before 4.4.1 mishandles object references in a certain error case, which allows local users to gain privileges or cause a denial of service (integer overflow and use-after-free) via crafted keyctl commands.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2013-7445Highlinux:3.16.7-ckt20-1+deb8u2The Direct Rendering Manager (DRM) subsystem in the Linux kernel through 4.x mishandles requests for Graphics Execution Manager (GEM) objects, which allows context-dependent attackers to cause a denial of service (memory consumption) via an application that processes graphics data, as demonstrated by JavaScript code that creates many CANVAS elements for rendering by Chrome or Firefox.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-8805Highnettle:2.7.1-5The ecc_256_modq function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8803.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-8804Highnettle:2.7.1-5x86_64/ecc-384-modp.asm in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-384 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-8803Highnettle:2.7.1-5The ecc_256_modp function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8805.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-5277Highglibc:2.19-18+deb8u1The get_contents function in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) before 2.20 might allow local users to cause a denial of service (heap corruption) or gain privileges via a long line in the NSS files database.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2016-2856Highglibc:2.19-18+deb8u1pt_chown in the glibc package before 2.19-18+deb8u4 on Debian jessie lacks a namespace check associated with file-descriptor passing, which allows local users to capture keystrokes and spoof data, and possibly gain privileges, via pts read and write operations, related to debian/sysdeps/linux.mk. NOTE: this is not considered a vulnerability in the upstream GNU C Library because the upstream documentation has a clear security recommendation against the --enable-pt_chown option.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2016-0494Highicu:52.1-8+deb8u3Unspecified vulnerability in the Java SE and Java SE Embedded components in Oracle Java SE 6u105, 7u91, and 8u66 and Java SE Embedded 8u65 allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-4844Highicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u101, 7u85, and 8u60, and Java SE Embedded 8u51, allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2016-0799Highopenssl:1.0.1k-3+deb8u2The fmtstr function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g improperly calculates string lengths, which allows remote attackers to cause a denial of service (overflow and out-of-bounds read) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-2842.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2016-0798Highopenssl:1.0.1k-3+deb8u2Memory leak in the SRP_VBASE_get_by_user implementation in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory consumption) by providing an invalid username in a connection attempt, related to apps/s_server.c and crypto/srp/srp_vfy.c.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2016-0705Highopenssl:1.0.1k-3+deb8u2Double free vulnerability in the dsa_priv_decode function in crypto/dsa/dsa_ameth.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory corruption) or possibly have unspecified other impact via a malformed DSA private key.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2016-2842Highopenssl:1.0.1k-3+deb8u2The doapr_outch function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not verify that a certain memory allocation succeeds, which allows remote attackers to cause a denial of service (out-of-bounds write or memory consumption) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-0799.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-5600Highopenssh:1:6.7p1-5The kbdint_next_device function in auth2-chall.c in sshd in OpenSSH through 6.9 does not properly restrict the processing of keyboard-interactive devices within a single connection, which makes it easier for remote attackers to conduct brute-force attacks or cause a denial of service (CPU consumption) via a long and duplicative list in the ssh -oKbdInteractiveDevices option, as demonstrated by a modified client that provides a different password for each pam element on this list.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2016-0494Highicu:52.1-8+deb8u3Unspecified vulnerability in the Java SE and Java SE Embedded components in Oracle Java SE 6u105, 7u91, and 8u66 and Java SE Embedded 8u65 allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-4844Highicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u101, 7u85, and 8u60, and Java SE Embedded 8u51, allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2016-0799Highopenssl:1.0.1k-3+deb8u2The fmtstr function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g improperly calculates string lengths, which allows remote attackers to cause a denial of service (overflow and out-of-bounds read) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-2842.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2016-0798Highopenssl:1.0.1k-3+deb8u2Memory leak in the SRP_VBASE_get_by_user implementation in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory consumption) by providing an invalid username in a connection attempt, related to apps/s_server.c and crypto/srp/srp_vfy.c.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2016-0705Highopenssl:1.0.1k-3+deb8u2Double free vulnerability in the dsa_priv_decode function in crypto/dsa/dsa_ameth.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory corruption) or possibly have unspecified other impact via a malformed DSA private key.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2016-2842Highopenssl:1.0.1k-3+deb8u2The doapr_outch function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not verify that a certain memory allocation succeeds, which allows remote attackers to cause a denial of service (out-of-bounds write or memory consumption) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-0799.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-5277Highglibc:2.19-18+deb8u1The get_contents function in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) before 2.20 might allow local users to cause a denial of service (heap corruption) or gain privileges via a long line in the NSS files database.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2016-2856Highglibc:2.19-18+deb8u1pt_chown in the glibc package before 2.19-18+deb8u4 on Debian jessie lacks a namespace check associated with file-descriptor passing, which allows local users to capture keystrokes and spoof data, and possibly gain privileges, via pts read and write operations, related to debian/sysdeps/linux.mk. NOTE: this is not considered a vulnerability in the upstream GNU C Library because the upstream documentation has a clear security recommendation against the --enable-pt_chown option.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-2059Highlibidn:1.29-1The stringprep_utf8_to_ucs4 function in libin before 1.31, as used in jabberd2, allows context-dependent attackers to read system memory and possibly have other unspecified impact via invalid UTF-8 characters in a string, which triggers an out-of-bounds read.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2016-0728Highlinux:3.16.7-ckt20-1+deb8u2The join_session_keyring function in security/keys/process_keys.c in the Linux kernel before 4.4.1 mishandles object references in a certain error case, which allows local users to gain privileges or cause a denial of service (integer overflow and use-after-free) via crafted keyctl commands.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2013-7445Highlinux:3.16.7-ckt20-1+deb8u2The Direct Rendering Manager (DRM) subsystem in the Linux kernel through 4.x mishandles requests for Graphics Execution Manager (GEM) objects, which allows context-dependent attackers to cause a denial of service (memory consumption) via an application that processes graphics data, as demonstrated by JavaScript code that creates many CANVAS elements for rendering by Chrome or Firefox.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-8607Highperl:5.20.2-3+deb8u1The canonpath function in the File::Spec module in PathTools before 3.62, as used in Perl, does not properly preserve the taint attribute of data, which might allow context-dependent attackers to bypass the taint protection mechanism via a crafted string.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-8391Highpcre3:2:8.35-3.3The pcre_compile function in pcre_compile.c in PCRE before 8.38 mishandles certain [: nesting, which allows remote attackers to cause a denial of service (CPU consumption) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-8395Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain references, which allows remote attackers to cause a denial of service or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8392.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-8386Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the interaction of lookbehind assertions and mutually recursive subpatterns, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-2328Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /((?(R)a|(?1)))+/ pattern and related patterns with certain recursion, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-8380Highpcre3:2:8.35-3.3The pcre_exec function in pcre_exec.c in PCRE before 8.38 mishandles a // pattern with a \01 string, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-8390Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the [: and \\ substrings in character classes, which allows remote attackers to cause a denial of service (uninitialized memory read) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-8381Highpcre3:2:8.35-3.3The compile_regex function in pcre_compile.c in PCRE before 8.38 and pcre2_compile.c in PCRE2 before 10.2x mishandles the /(?J:(?|(:(?|(?'R')(\k'R')|((?'R')))H'Rk'Rf)|s(?'R'))))/ and /(?J:(?|(:(?|(?'R')(\z(?|(?'R')(\k'R')|((?'R')))k'R')|((?'R')))H'Ak'Rf)|s(?'R')))/ patterns, and related patterns with certain group references, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-8394Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the (?() and (?(R) conditions, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-8387Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles (?123) subroutine calls and related subroutine calls, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-8392Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain instances of the (?| substring, which allows remote attackers to cause a denial of service (unintended recursion and buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8395.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2016-3191Highpcre3:2:8.35-3.3The compile_branch function in pcre_compile.c in PCRE 8.x before 8.39 and pcre2_compile.c in PCRE2 before 10.22 mishandles patterns containing an (*ACCEPT) substring in conjunction with nested parentheses, which allows remote attackers to execute arbitrary code or cause a denial of service (stack-based buffer overflow) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-3542.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-8389Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?:|a|){100}x/ pattern and related patterns, which allows remote attackers to cause a denial of service (infinite recursion) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-8383Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain repeated conditional groups, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-8385Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?|(\k'Pm')|(?'Pm'))/ pattern and related patterns with certain forward references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-2327Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /(((a\2)|(a*)\g<-1>))*/ pattern and related patterns with certain internal recursive back references, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-8384Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?J)(?'d'(?'d'\g{d}))/ pattern and related patterns with certain recursive back references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8392 and CVE-2015-8395.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-8388Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?=di(?<=(?1))|(?=(.))))/ pattern and related patterns with an unmatched closing parenthesis, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2016-1283Highpcre3:2:8.35-3.3The pcre_compile2 function in pcre_compile.c in PCRE 8.38 mishandles the /((?:F?+(?:^(?(R)a+\"){99}-))(?J)(?'R'(?'R'<((?'RR'(?'R'\){97)?J)?J)(?'R'(?'R'\){99|(:(?|(?'R')(\k'R')|((?'R')))H'R'R)(H'R))))))/ pattern and related patterns with named subgroups, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2014-9769Highpcre3:2:8.35-3.3pcre_jit_compile.c in PCRE 8.35 does not properly use table jumps to optimize nested alternatives, which allows remote attackers to cause a denial of service (stack memory corruption) or possibly have unspecified other impact via a crafted string, as demonstrated by packets encountered by Suricata during use of a regular expression in an Emerging Threats Open ruleset.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-8805Highnettle:2.7.1-5The ecc_256_modq function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8803.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-8804Highnettle:2.7.1-5x86_64/ecc-384-modp.asm in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-384 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-8803Highnettle:2.7.1-5The ecc_256_modp function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8805.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2016-0494Highicu:52.1-8+deb8u3Unspecified vulnerability in the Java SE and Java SE Embedded components in Oracle Java SE 6u105, 7u91, and 8u66 and Java SE Embedded 8u65 allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-4844Highicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u101, 7u85, and 8u60, and Java SE Embedded 8u51, allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-8805Highnettle:2.7.1-5The ecc_256_modq function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8803.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-8804Highnettle:2.7.1-5x86_64/ecc-384-modp.asm in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-384 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-8803Highnettle:2.7.1-5The ecc_256_modp function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8805.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-2059Highlibidn:1.29-1The stringprep_utf8_to_ucs4 function in libin before 1.31, as used in jabberd2, allows context-dependent attackers to read system memory and possibly have other unspecified impact via invalid UTF-8 characters in a string, which triggers an out-of-bounds read.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2016-0728Highlinux:3.16.7-ckt20-1+deb8u2The join_session_keyring function in security/keys/process_keys.c in the Linux kernel before 4.4.1 mishandles object references in a certain error case, which allows local users to gain privileges or cause a denial of service (integer overflow and use-after-free) via crafted keyctl commands.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2013-7445Highlinux:3.16.7-ckt20-1+deb8u2The Direct Rendering Manager (DRM) subsystem in the Linux kernel through 4.x mishandles requests for Graphics Execution Manager (GEM) objects, which allows context-dependent attackers to cause a denial of service (memory consumption) via an application that processes graphics data, as demonstrated by JavaScript code that creates many CANVAS elements for rendering by Chrome or Firefox.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-8607Highperl:5.20.2-3+deb8u1The canonpath function in the File::Spec module in PathTools before 3.62, as used in Perl, does not properly preserve the taint attribute of data, which might allow context-dependent attackers to bypass the taint protection mechanism via a crafted string.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-5277Highglibc:2.19-18+deb8u1The get_contents function in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) before 2.20 might allow local users to cause a denial of service (heap corruption) or gain privileges via a long line in the NSS files database.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2016-2856Highglibc:2.19-18+deb8u1pt_chown in the glibc package before 2.19-18+deb8u4 on Debian jessie lacks a namespace check associated with file-descriptor passing, which allows local users to capture keystrokes and spoof data, and possibly gain privileges, via pts read and write operations, related to debian/sysdeps/linux.mk. NOTE: this is not considered a vulnerability in the upstream GNU C Library because the upstream documentation has a clear security recommendation against the --enable-pt_chown option.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2016-0799Highopenssl:1.0.1k-3+deb8u2The fmtstr function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g improperly calculates string lengths, which allows remote attackers to cause a denial of service (overflow and out-of-bounds read) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-2842.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2016-0798Highopenssl:1.0.1k-3+deb8u2Memory leak in the SRP_VBASE_get_by_user implementation in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory consumption) by providing an invalid username in a connection attempt, related to apps/s_server.c and crypto/srp/srp_vfy.c.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2016-0705Highopenssl:1.0.1k-3+deb8u2Double free vulnerability in the dsa_priv_decode function in crypto/dsa/dsa_ameth.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory corruption) or possibly have unspecified other impact via a malformed DSA private key.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2016-2842Highopenssl:1.0.1k-3+deb8u2The doapr_outch function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not verify that a certain memory allocation succeeds, which allows remote attackers to cause a denial of service (out-of-bounds write or memory consumption) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-0799.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-8391Highpcre3:2:8.35-3.3The pcre_compile function in pcre_compile.c in PCRE before 8.38 mishandles certain [: nesting, which allows remote attackers to cause a denial of service (CPU consumption) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-8395Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain references, which allows remote attackers to cause a denial of service or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8392.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-8386Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the interaction of lookbehind assertions and mutually recursive subpatterns, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-2328Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /((?(R)a|(?1)))+/ pattern and related patterns with certain recursion, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-8380Highpcre3:2:8.35-3.3The pcre_exec function in pcre_exec.c in PCRE before 8.38 mishandles a // pattern with a \01 string, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-8390Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the [: and \\ substrings in character classes, which allows remote attackers to cause a denial of service (uninitialized memory read) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-8381Highpcre3:2:8.35-3.3The compile_regex function in pcre_compile.c in PCRE before 8.38 and pcre2_compile.c in PCRE2 before 10.2x mishandles the /(?J:(?|(:(?|(?'R')(\k'R')|((?'R')))H'Rk'Rf)|s(?'R'))))/ and /(?J:(?|(:(?|(?'R')(\z(?|(?'R')(\k'R')|((?'R')))k'R')|((?'R')))H'Ak'Rf)|s(?'R')))/ patterns, and related patterns with certain group references, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-8394Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the (?() and (?(R) conditions, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-8387Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles (?123) subroutine calls and related subroutine calls, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-8392Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain instances of the (?| substring, which allows remote attackers to cause a denial of service (unintended recursion and buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8395.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2016-3191Highpcre3:2:8.35-3.3The compile_branch function in pcre_compile.c in PCRE 8.x before 8.39 and pcre2_compile.c in PCRE2 before 10.22 mishandles patterns containing an (*ACCEPT) substring in conjunction with nested parentheses, which allows remote attackers to execute arbitrary code or cause a denial of service (stack-based buffer overflow) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-3542.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-8389Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?:|a|){100}x/ pattern and related patterns, which allows remote attackers to cause a denial of service (infinite recursion) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-8383Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain repeated conditional groups, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-8385Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?|(\k'Pm')|(?'Pm'))/ pattern and related patterns with certain forward references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-2327Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /(((a\2)|(a*)\g<-1>))*/ pattern and related patterns with certain internal recursive back references, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-8384Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?J)(?'d'(?'d'\g{d}))/ pattern and related patterns with certain recursive back references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8392 and CVE-2015-8395.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-8388Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?=di(?<=(?1))|(?=(.))))/ pattern and related patterns with an unmatched closing parenthesis, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2016-1283Highpcre3:2:8.35-3.3The pcre_compile2 function in pcre_compile.c in PCRE 8.38 mishandles the /((?:F?+(?:^(?(R)a+\"){99}-))(?J)(?'R'(?'R'<((?'RR'(?'R'\){97)?J)?J)(?'R'(?'R'\){99|(:(?|(?'R')(\k'R')|((?'R')))H'R'R)(H'R))))))/ pattern and related patterns with named subgroups, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2014-9769Highpcre3:2:8.35-3.3pcre_jit_compile.c in PCRE 8.35 does not properly use table jumps to optimize nested alternatives, which allows remote attackers to cause a denial of service (stack memory corruption) or possibly have unspecified other impact via a crafted string, as demonstrated by packets encountered by Suricata during use of a regular expression in an Emerging Threats Open ruleset.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-5600Highopenssh:1:6.7p1-5The kbdint_next_device function in auth2-chall.c in sshd in OpenSSH through 6.9 does not properly restrict the processing of keyboard-interactive devices within a single connection, which makes it easier for remote attackers to conduct brute-force attacks or cause a denial of service (CPU consumption) via a long and duplicative list in the ssh -oKbdInteractiveDevices option, as demonstrated by a modified client that provides a different password for each pam element on this list.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2016-0494Highicu:52.1-8+deb8u3Unspecified vulnerability in the Java SE and Java SE Embedded components in Oracle Java SE 6u105, 7u91, and 8u66 and Java SE Embedded 8u65 allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-4844Highicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u101, 7u85, and 8u60, and Java SE Embedded 8u51, allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-8805Highnettle:2.7.1-5The ecc_256_modq function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8803.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-8804Highnettle:2.7.1-5x86_64/ecc-384-modp.asm in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-384 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-8803Highnettle:2.7.1-5The ecc_256_modp function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8805.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-5600Highopenssh:1:6.7p1-5The kbdint_next_device function in auth2-chall.c in sshd in OpenSSH through 6.9 does not properly restrict the processing of keyboard-interactive devices within a single connection, which makes it easier for remote attackers to conduct brute-force attacks or cause a denial of service (CPU consumption) via a long and duplicative list in the ssh -oKbdInteractiveDevices option, as demonstrated by a modified client that provides a different password for each pam element on this list.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2016-0728Highlinux:3.16.7-ckt20-1+deb8u2The join_session_keyring function in security/keys/process_keys.c in the Linux kernel before 4.4.1 mishandles object references in a certain error case, which allows local users to gain privileges or cause a denial of service (integer overflow and use-after-free) via crafted keyctl commands.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2013-7445Highlinux:3.16.7-ckt20-1+deb8u2The Direct Rendering Manager (DRM) subsystem in the Linux kernel through 4.x mishandles requests for Graphics Execution Manager (GEM) objects, which allows context-dependent attackers to cause a denial of service (memory consumption) via an application that processes graphics data, as demonstrated by JavaScript code that creates many CANVAS elements for rendering by Chrome or Firefox.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-8391Highpcre3:2:8.35-3.3The pcre_compile function in pcre_compile.c in PCRE before 8.38 mishandles certain [: nesting, which allows remote attackers to cause a denial of service (CPU consumption) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-8395Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain references, which allows remote attackers to cause a denial of service or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8392.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-8386Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the interaction of lookbehind assertions and mutually recursive subpatterns, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-2328Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /((?(R)a|(?1)))+/ pattern and related patterns with certain recursion, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-8380Highpcre3:2:8.35-3.3The pcre_exec function in pcre_exec.c in PCRE before 8.38 mishandles a // pattern with a \01 string, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-8390Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the [: and \\ substrings in character classes, which allows remote attackers to cause a denial of service (uninitialized memory read) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-8381Highpcre3:2:8.35-3.3The compile_regex function in pcre_compile.c in PCRE before 8.38 and pcre2_compile.c in PCRE2 before 10.2x mishandles the /(?J:(?|(:(?|(?'R')(\k'R')|((?'R')))H'Rk'Rf)|s(?'R'))))/ and /(?J:(?|(:(?|(?'R')(\z(?|(?'R')(\k'R')|((?'R')))k'R')|((?'R')))H'Ak'Rf)|s(?'R')))/ patterns, and related patterns with certain group references, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-8394Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the (?() and (?(R) conditions, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-8387Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles (?123) subroutine calls and related subroutine calls, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-8392Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain instances of the (?| substring, which allows remote attackers to cause a denial of service (unintended recursion and buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8395.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2016-3191Highpcre3:2:8.35-3.3The compile_branch function in pcre_compile.c in PCRE 8.x before 8.39 and pcre2_compile.c in PCRE2 before 10.22 mishandles patterns containing an (*ACCEPT) substring in conjunction with nested parentheses, which allows remote attackers to execute arbitrary code or cause a denial of service (stack-based buffer overflow) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-3542.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-8389Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?:|a|){100}x/ pattern and related patterns, which allows remote attackers to cause a denial of service (infinite recursion) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-8383Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain repeated conditional groups, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-8385Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?|(\k'Pm')|(?'Pm'))/ pattern and related patterns with certain forward references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-2327Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /(((a\2)|(a*)\g<-1>))*/ pattern and related patterns with certain internal recursive back references, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-8384Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?J)(?'d'(?'d'\g{d}))/ pattern and related patterns with certain recursive back references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8392 and CVE-2015-8395.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-8388Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?=di(?<=(?1))|(?=(.))))/ pattern and related patterns with an unmatched closing parenthesis, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2016-1283Highpcre3:2:8.35-3.3The pcre_compile2 function in pcre_compile.c in PCRE 8.38 mishandles the /((?:F?+(?:^(?(R)a+\"){99}-))(?J)(?'R'(?'R'<((?'RR'(?'R'\){97)?J)?J)(?'R'(?'R'\){99|(:(?|(?'R')(\k'R')|((?'R')))H'R'R)(H'R))))))/ pattern and related patterns with named subgroups, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2014-9769Highpcre3:2:8.35-3.3pcre_jit_compile.c in PCRE 8.35 does not properly use table jumps to optimize nested alternatives, which allows remote attackers to cause a denial of service (stack memory corruption) or possibly have unspecified other impact via a crafted string, as demonstrated by packets encountered by Suricata during use of a regular expression in an Emerging Threats Open ruleset.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2016-0799Highopenssl:1.0.1k-3+deb8u2The fmtstr function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g improperly calculates string lengths, which allows remote attackers to cause a denial of service (overflow and out-of-bounds read) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-2842.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2016-0798Highopenssl:1.0.1k-3+deb8u2Memory leak in the SRP_VBASE_get_by_user implementation in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory consumption) by providing an invalid username in a connection attempt, related to apps/s_server.c and crypto/srp/srp_vfy.c.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2016-0705Highopenssl:1.0.1k-3+deb8u2Double free vulnerability in the dsa_priv_decode function in crypto/dsa/dsa_ameth.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory corruption) or possibly have unspecified other impact via a malformed DSA private key.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2016-2842Highopenssl:1.0.1k-3+deb8u2The doapr_outch function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not verify that a certain memory allocation succeeds, which allows remote attackers to cause a denial of service (out-of-bounds write or memory consumption) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-0799.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-5277Highglibc:2.19-18+deb8u1The get_contents function in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) before 2.20 might allow local users to cause a denial of service (heap corruption) or gain privileges via a long line in the NSS files database.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2016-2856Highglibc:2.19-18+deb8u1pt_chown in the glibc package before 2.19-18+deb8u4 on Debian jessie lacks a namespace check associated with file-descriptor passing, which allows local users to capture keystrokes and spoof data, and possibly gain privileges, via pts read and write operations, related to debian/sysdeps/linux.mk. NOTE: this is not considered a vulnerability in the upstream GNU C Library because the upstream documentation has a clear security recommendation against the --enable-pt_chown option.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-2059Highlibidn:1.29-1The stringprep_utf8_to_ucs4 function in libin before 1.31, as used in jabberd2, allows context-dependent attackers to read system memory and possibly have other unspecified impact via invalid UTF-8 characters in a string, which triggers an out-of-bounds read.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-8607Highperl:5.20.2-3+deb8u1The canonpath function in the File::Spec module in PathTools before 3.62, as used in Perl, does not properly preserve the taint attribute of data, which might allow context-dependent attackers to bypass the taint protection mechanism via a crafted string.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-5600Highopenssh:1:6.7p1-5The kbdint_next_device function in auth2-chall.c in sshd in OpenSSH through 6.9 does not properly restrict the processing of keyboard-interactive devices within a single connection, which makes it easier for remote attackers to conduct brute-force attacks or cause a denial of service (CPU consumption) via a long and duplicative list in the ssh -oKbdInteractiveDevices option, as demonstrated by a modified client that provides a different password for each pam element on this list.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-5277Highglibc:2.19-18+deb8u1The get_contents function in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) before 2.20 might allow local users to cause a denial of service (heap corruption) or gain privileges via a long line in the NSS files database.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2016-2856Highglibc:2.19-18+deb8u1pt_chown in the glibc package before 2.19-18+deb8u4 on Debian jessie lacks a namespace check associated with file-descriptor passing, which allows local users to capture keystrokes and spoof data, and possibly gain privileges, via pts read and write operations, related to debian/sysdeps/linux.mk. NOTE: this is not considered a vulnerability in the upstream GNU C Library because the upstream documentation has a clear security recommendation against the --enable-pt_chown option.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-8607Highperl:5.20.2-3+deb8u1The canonpath function in the File::Spec module in PathTools before 3.62, as used in Perl, does not properly preserve the taint attribute of data, which might allow context-dependent attackers to bypass the taint protection mechanism via a crafted string.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2016-0728Highlinux:3.16.7-ckt20-1+deb8u2The join_session_keyring function in security/keys/process_keys.c in the Linux kernel before 4.4.1 mishandles object references in a certain error case, which allows local users to gain privileges or cause a denial of service (integer overflow and use-after-free) via crafted keyctl commands.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2013-7445Highlinux:3.16.7-ckt20-1+deb8u2The Direct Rendering Manager (DRM) subsystem in the Linux kernel through 4.x mishandles requests for Graphics Execution Manager (GEM) objects, which allows context-dependent attackers to cause a denial of service (memory consumption) via an application that processes graphics data, as demonstrated by JavaScript code that creates many CANVAS elements for rendering by Chrome or Firefox.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-8805Highnettle:2.7.1-5The ecc_256_modq function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8803.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-8804Highnettle:2.7.1-5x86_64/ecc-384-modp.asm in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-384 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-8803Highnettle:2.7.1-5The ecc_256_modp function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8805.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2016-0494Highicu:52.1-8+deb8u3Unspecified vulnerability in the Java SE and Java SE Embedded components in Oracle Java SE 6u105, 7u91, and 8u66 and Java SE Embedded 8u65 allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-4844Highicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u101, 7u85, and 8u60, and Java SE Embedded 8u51, allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-2059Highlibidn:1.29-1The stringprep_utf8_to_ucs4 function in libin before 1.31, as used in jabberd2, allows context-dependent attackers to read system memory and possibly have other unspecified impact via invalid UTF-8 characters in a string, which triggers an out-of-bounds read.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-8391Highpcre3:2:8.35-3.3The pcre_compile function in pcre_compile.c in PCRE before 8.38 mishandles certain [: nesting, which allows remote attackers to cause a denial of service (CPU consumption) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-8395Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain references, which allows remote attackers to cause a denial of service or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8392.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-8386Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the interaction of lookbehind assertions and mutually recursive subpatterns, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-2328Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /((?(R)a|(?1)))+/ pattern and related patterns with certain recursion, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-8380Highpcre3:2:8.35-3.3The pcre_exec function in pcre_exec.c in PCRE before 8.38 mishandles a // pattern with a \01 string, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-8390Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the [: and \\ substrings in character classes, which allows remote attackers to cause a denial of service (uninitialized memory read) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-8381Highpcre3:2:8.35-3.3The compile_regex function in pcre_compile.c in PCRE before 8.38 and pcre2_compile.c in PCRE2 before 10.2x mishandles the /(?J:(?|(:(?|(?'R')(\k'R')|((?'R')))H'Rk'Rf)|s(?'R'))))/ and /(?J:(?|(:(?|(?'R')(\z(?|(?'R')(\k'R')|((?'R')))k'R')|((?'R')))H'Ak'Rf)|s(?'R')))/ patterns, and related patterns with certain group references, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-8394Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the (?() and (?(R) conditions, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-8387Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles (?123) subroutine calls and related subroutine calls, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-8392Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain instances of the (?| substring, which allows remote attackers to cause a denial of service (unintended recursion and buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8395.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2016-3191Highpcre3:2:8.35-3.3The compile_branch function in pcre_compile.c in PCRE 8.x before 8.39 and pcre2_compile.c in PCRE2 before 10.22 mishandles patterns containing an (*ACCEPT) substring in conjunction with nested parentheses, which allows remote attackers to execute arbitrary code or cause a denial of service (stack-based buffer overflow) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-3542.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-8389Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?:|a|){100}x/ pattern and related patterns, which allows remote attackers to cause a denial of service (infinite recursion) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-8383Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain repeated conditional groups, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-8385Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?|(\k'Pm')|(?'Pm'))/ pattern and related patterns with certain forward references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-2327Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /(((a\2)|(a*)\g<-1>))*/ pattern and related patterns with certain internal recursive back references, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-8384Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?J)(?'d'(?'d'\g{d}))/ pattern and related patterns with certain recursive back references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8392 and CVE-2015-8395.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-8388Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?=di(?<=(?1))|(?=(.))))/ pattern and related patterns with an unmatched closing parenthesis, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2016-1283Highpcre3:2:8.35-3.3The pcre_compile2 function in pcre_compile.c in PCRE 8.38 mishandles the /((?:F?+(?:^(?(R)a+\"){99}-))(?J)(?'R'(?'R'<((?'RR'(?'R'\){97)?J)?J)(?'R'(?'R'\){99|(:(?|(?'R')(\k'R')|((?'R')))H'R'R)(H'R))))))/ pattern and related patterns with named subgroups, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2014-9769Highpcre3:2:8.35-3.3pcre_jit_compile.c in PCRE 8.35 does not properly use table jumps to optimize nested alternatives, which allows remote attackers to cause a denial of service (stack memory corruption) or possibly have unspecified other impact via a crafted string, as demonstrated by packets encountered by Suricata during use of a regular expression in an Emerging Threats Open ruleset.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2016-0799Highopenssl:1.0.1k-3+deb8u2The fmtstr function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g improperly calculates string lengths, which allows remote attackers to cause a denial of service (overflow and out-of-bounds read) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-2842.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2016-0798Highopenssl:1.0.1k-3+deb8u2Memory leak in the SRP_VBASE_get_by_user implementation in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory consumption) by providing an invalid username in a connection attempt, related to apps/s_server.c and crypto/srp/srp_vfy.c.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2016-0705Highopenssl:1.0.1k-3+deb8u2Double free vulnerability in the dsa_priv_decode function in crypto/dsa/dsa_ameth.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory corruption) or possibly have unspecified other impact via a malformed DSA private key.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2016-2842Highopenssl:1.0.1k-3+deb8u2The doapr_outch function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not verify that a certain memory allocation succeeds, which allows remote attackers to cause a denial of service (out-of-bounds write or memory consumption) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-0799.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2016-0494Highicu:52.1-8+deb8u3Unspecified vulnerability in the Java SE and Java SE Embedded components in Oracle Java SE 6u105, 7u91, and 8u66 and Java SE Embedded 8u65 allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-4844Highicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u101, 7u85, and 8u60, and Java SE Embedded 8u51, allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-8805Highnettle:2.7.1-5The ecc_256_modq function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8803.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-8804Highnettle:2.7.1-5x86_64/ecc-384-modp.asm in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-384 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-8803Highnettle:2.7.1-5The ecc_256_modp function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8805.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-5600Highopenssh:1:6.7p1-5The kbdint_next_device function in auth2-chall.c in sshd in OpenSSH through 6.9 does not properly restrict the processing of keyboard-interactive devices within a single connection, which makes it easier for remote attackers to conduct brute-force attacks or cause a denial of service (CPU consumption) via a long and duplicative list in the ssh -oKbdInteractiveDevices option, as demonstrated by a modified client that provides a different password for each pam element on this list.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-8391Highpcre3:2:8.35-3.3The pcre_compile function in pcre_compile.c in PCRE before 8.38 mishandles certain [: nesting, which allows remote attackers to cause a denial of service (CPU consumption) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-8395Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain references, which allows remote attackers to cause a denial of service or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8392.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-8386Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the interaction of lookbehind assertions and mutually recursive subpatterns, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-2328Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /((?(R)a|(?1)))+/ pattern and related patterns with certain recursion, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-8380Highpcre3:2:8.35-3.3The pcre_exec function in pcre_exec.c in PCRE before 8.38 mishandles a // pattern with a \01 string, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-8390Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the [: and \\ substrings in character classes, which allows remote attackers to cause a denial of service (uninitialized memory read) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-8381Highpcre3:2:8.35-3.3The compile_regex function in pcre_compile.c in PCRE before 8.38 and pcre2_compile.c in PCRE2 before 10.2x mishandles the /(?J:(?|(:(?|(?'R')(\k'R')|((?'R')))H'Rk'Rf)|s(?'R'))))/ and /(?J:(?|(:(?|(?'R')(\z(?|(?'R')(\k'R')|((?'R')))k'R')|((?'R')))H'Ak'Rf)|s(?'R')))/ patterns, and related patterns with certain group references, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-8394Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the (?() and (?(R) conditions, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-8387Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles (?123) subroutine calls and related subroutine calls, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-8392Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain instances of the (?| substring, which allows remote attackers to cause a denial of service (unintended recursion and buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8395.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2016-3191Highpcre3:2:8.35-3.3The compile_branch function in pcre_compile.c in PCRE 8.x before 8.39 and pcre2_compile.c in PCRE2 before 10.22 mishandles patterns containing an (*ACCEPT) substring in conjunction with nested parentheses, which allows remote attackers to execute arbitrary code or cause a denial of service (stack-based buffer overflow) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-3542.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-8389Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?:|a|){100}x/ pattern and related patterns, which allows remote attackers to cause a denial of service (infinite recursion) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-8383Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain repeated conditional groups, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-8385Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?|(\k'Pm')|(?'Pm'))/ pattern and related patterns with certain forward references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-2327Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /(((a\2)|(a*)\g<-1>))*/ pattern and related patterns with certain internal recursive back references, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-8384Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?J)(?'d'(?'d'\g{d}))/ pattern and related patterns with certain recursive back references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8392 and CVE-2015-8395.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-8388Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?=di(?<=(?1))|(?=(.))))/ pattern and related patterns with an unmatched closing parenthesis, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2016-1283Highpcre3:2:8.35-3.3The pcre_compile2 function in pcre_compile.c in PCRE 8.38 mishandles the /((?:F?+(?:^(?(R)a+\"){99}-))(?J)(?'R'(?'R'<((?'RR'(?'R'\){97)?J)?J)(?'R'(?'R'\){99|(:(?|(?'R')(\k'R')|((?'R')))H'R'R)(H'R))))))/ pattern and related patterns with named subgroups, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2014-9769Highpcre3:2:8.35-3.3pcre_jit_compile.c in PCRE 8.35 does not properly use table jumps to optimize nested alternatives, which allows remote attackers to cause a denial of service (stack memory corruption) or possibly have unspecified other impact via a crafted string, as demonstrated by packets encountered by Suricata during use of a regular expression in an Emerging Threats Open ruleset.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-2059Highlibidn:1.29-1The stringprep_utf8_to_ucs4 function in libin before 1.31, as used in jabberd2, allows context-dependent attackers to read system memory and possibly have other unspecified impact via invalid UTF-8 characters in a string, which triggers an out-of-bounds read.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2016-0728Highlinux:3.16.7-ckt20-1+deb8u2The join_session_keyring function in security/keys/process_keys.c in the Linux kernel before 4.4.1 mishandles object references in a certain error case, which allows local users to gain privileges or cause a denial of service (integer overflow and use-after-free) via crafted keyctl commands.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2013-7445Highlinux:3.16.7-ckt20-1+deb8u2The Direct Rendering Manager (DRM) subsystem in the Linux kernel through 4.x mishandles requests for Graphics Execution Manager (GEM) objects, which allows context-dependent attackers to cause a denial of service (memory consumption) via an application that processes graphics data, as demonstrated by JavaScript code that creates many CANVAS elements for rendering by Chrome or Firefox.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-5277Highglibc:2.19-18+deb8u1The get_contents function in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) before 2.20 might allow local users to cause a denial of service (heap corruption) or gain privileges via a long line in the NSS files database.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2016-2856Highglibc:2.19-18+deb8u1pt_chown in the glibc package before 2.19-18+deb8u4 on Debian jessie lacks a namespace check associated with file-descriptor passing, which allows local users to capture keystrokes and spoof data, and possibly gain privileges, via pts read and write operations, related to debian/sysdeps/linux.mk. NOTE: this is not considered a vulnerability in the upstream GNU C Library because the upstream documentation has a clear security recommendation against the --enable-pt_chown option.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-8607Highperl:5.20.2-3+deb8u1The canonpath function in the File::Spec module in PathTools before 3.62, as used in Perl, does not properly preserve the taint attribute of data, which might allow context-dependent attackers to bypass the taint protection mechanism via a crafted string.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2016-0799Highopenssl:1.0.1k-3+deb8u2The fmtstr function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g improperly calculates string lengths, which allows remote attackers to cause a denial of service (overflow and out-of-bounds read) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-2842.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2016-0798Highopenssl:1.0.1k-3+deb8u2Memory leak in the SRP_VBASE_get_by_user implementation in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory consumption) by providing an invalid username in a connection attempt, related to apps/s_server.c and crypto/srp/srp_vfy.c.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2016-0705Highopenssl:1.0.1k-3+deb8u2Double free vulnerability in the dsa_priv_decode function in crypto/dsa/dsa_ameth.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory corruption) or possibly have unspecified other impact via a malformed DSA private key.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2016-2842Highopenssl:1.0.1k-3+deb8u2The doapr_outch function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not verify that a certain memory allocation succeeds, which allows remote attackers to cause a denial of service (out-of-bounds write or memory consumption) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-0799.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2016-0799Highopenssl:1.0.1k-3+deb8u2The fmtstr function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g improperly calculates string lengths, which allows remote attackers to cause a denial of service (overflow and out-of-bounds read) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-2842.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2016-0798Highopenssl:1.0.1k-3+deb8u2Memory leak in the SRP_VBASE_get_by_user implementation in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory consumption) by providing an invalid username in a connection attempt, related to apps/s_server.c and crypto/srp/srp_vfy.c.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2016-0705Highopenssl:1.0.1k-3+deb8u2Double free vulnerability in the dsa_priv_decode function in crypto/dsa/dsa_ameth.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory corruption) or possibly have unspecified other impact via a malformed DSA private key.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2016-2842Highopenssl:1.0.1k-3+deb8u2The doapr_outch function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not verify that a certain memory allocation succeeds, which allows remote attackers to cause a denial of service (out-of-bounds write or memory consumption) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-0799.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-2059Highlibidn:1.29-1The stringprep_utf8_to_ucs4 function in libin before 1.31, as used in jabberd2, allows context-dependent attackers to read system memory and possibly have other unspecified impact via invalid UTF-8 characters in a string, which triggers an out-of-bounds read.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-8391Highpcre3:2:8.35-3.3The pcre_compile function in pcre_compile.c in PCRE before 8.38 mishandles certain [: nesting, which allows remote attackers to cause a denial of service (CPU consumption) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-8395Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain references, which allows remote attackers to cause a denial of service or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8392.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-8386Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the interaction of lookbehind assertions and mutually recursive subpatterns, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-2328Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /((?(R)a|(?1)))+/ pattern and related patterns with certain recursion, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-8380Highpcre3:2:8.35-3.3The pcre_exec function in pcre_exec.c in PCRE before 8.38 mishandles a // pattern with a \01 string, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-8390Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the [: and \\ substrings in character classes, which allows remote attackers to cause a denial of service (uninitialized memory read) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-8381Highpcre3:2:8.35-3.3The compile_regex function in pcre_compile.c in PCRE before 8.38 and pcre2_compile.c in PCRE2 before 10.2x mishandles the /(?J:(?|(:(?|(?'R')(\k'R')|((?'R')))H'Rk'Rf)|s(?'R'))))/ and /(?J:(?|(:(?|(?'R')(\z(?|(?'R')(\k'R')|((?'R')))k'R')|((?'R')))H'Ak'Rf)|s(?'R')))/ patterns, and related patterns with certain group references, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-8394Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the (?() and (?(R) conditions, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-8387Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles (?123) subroutine calls and related subroutine calls, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-8392Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain instances of the (?| substring, which allows remote attackers to cause a denial of service (unintended recursion and buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8395.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2016-3191Highpcre3:2:8.35-3.3The compile_branch function in pcre_compile.c in PCRE 8.x before 8.39 and pcre2_compile.c in PCRE2 before 10.22 mishandles patterns containing an (*ACCEPT) substring in conjunction with nested parentheses, which allows remote attackers to execute arbitrary code or cause a denial of service (stack-based buffer overflow) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-3542.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-8389Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?:|a|){100}x/ pattern and related patterns, which allows remote attackers to cause a denial of service (infinite recursion) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-8383Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain repeated conditional groups, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-8385Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?|(\k'Pm')|(?'Pm'))/ pattern and related patterns with certain forward references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-2327Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /(((a\2)|(a*)\g<-1>))*/ pattern and related patterns with certain internal recursive back references, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-8384Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?J)(?'d'(?'d'\g{d}))/ pattern and related patterns with certain recursive back references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8392 and CVE-2015-8395.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-8388Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?=di(?<=(?1))|(?=(.))))/ pattern and related patterns with an unmatched closing parenthesis, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2016-1283Highpcre3:2:8.35-3.3The pcre_compile2 function in pcre_compile.c in PCRE 8.38 mishandles the /((?:F?+(?:^(?(R)a+\"){99}-))(?J)(?'R'(?'R'<((?'RR'(?'R'\){97)?J)?J)(?'R'(?'R'\){99|(:(?|(?'R')(\k'R')|((?'R')))H'R'R)(H'R))))))/ pattern and related patterns with named subgroups, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2014-9769Highpcre3:2:8.35-3.3pcre_jit_compile.c in PCRE 8.35 does not properly use table jumps to optimize nested alternatives, which allows remote attackers to cause a denial of service (stack memory corruption) or possibly have unspecified other impact via a crafted string, as demonstrated by packets encountered by Suricata during use of a regular expression in an Emerging Threats Open ruleset.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2016-0494Highicu:52.1-8+deb8u3Unspecified vulnerability in the Java SE and Java SE Embedded components in Oracle Java SE 6u105, 7u91, and 8u66 and Java SE Embedded 8u65 allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-4844Highicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u101, 7u85, and 8u60, and Java SE Embedded 8u51, allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-5600Highopenssh:1:6.7p1-5The kbdint_next_device function in auth2-chall.c in sshd in OpenSSH through 6.9 does not properly restrict the processing of keyboard-interactive devices within a single connection, which makes it easier for remote attackers to conduct brute-force attacks or cause a denial of service (CPU consumption) via a long and duplicative list in the ssh -oKbdInteractiveDevices option, as demonstrated by a modified client that provides a different password for each pam element on this list.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-5277Highglibc:2.19-18+deb8u1The get_contents function in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) before 2.20 might allow local users to cause a denial of service (heap corruption) or gain privileges via a long line in the NSS files database.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2016-2856Highglibc:2.19-18+deb8u1pt_chown in the glibc package before 2.19-18+deb8u4 on Debian jessie lacks a namespace check associated with file-descriptor passing, which allows local users to capture keystrokes and spoof data, and possibly gain privileges, via pts read and write operations, related to debian/sysdeps/linux.mk. NOTE: this is not considered a vulnerability in the upstream GNU C Library because the upstream documentation has a clear security recommendation against the --enable-pt_chown option.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-8607Highperl:5.20.2-3+deb8u1The canonpath function in the File::Spec module in PathTools before 3.62, as used in Perl, does not properly preserve the taint attribute of data, which might allow context-dependent attackers to bypass the taint protection mechanism via a crafted string.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-8805Highnettle:2.7.1-5The ecc_256_modq function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8803.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-8804Highnettle:2.7.1-5x86_64/ecc-384-modp.asm in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-384 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-8803Highnettle:2.7.1-5The ecc_256_modp function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8805.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2016-0728Highlinux:3.16.7-ckt20-1+deb8u2The join_session_keyring function in security/keys/process_keys.c in the Linux kernel before 4.4.1 mishandles object references in a certain error case, which allows local users to gain privileges or cause a denial of service (integer overflow and use-after-free) via crafted keyctl commands.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2013-7445Highlinux:3.16.7-ckt20-1+deb8u2The Direct Rendering Manager (DRM) subsystem in the Linux kernel through 4.x mishandles requests for Graphics Execution Manager (GEM) objects, which allows context-dependent attackers to cause a denial of service (memory consumption) via an application that processes graphics data, as demonstrated by JavaScript code that creates many CANVAS elements for rendering by Chrome or Firefox.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-2059Highlibidn:1.29-1The stringprep_utf8_to_ucs4 function in libin before 1.31, as used in jabberd2, allows context-dependent attackers to read system memory and possibly have other unspecified impact via invalid UTF-8 characters in a string, which triggers an out-of-bounds read.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-8391Highpcre3:2:8.35-3.3The pcre_compile function in pcre_compile.c in PCRE before 8.38 mishandles certain [: nesting, which allows remote attackers to cause a denial of service (CPU consumption) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-8395Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain references, which allows remote attackers to cause a denial of service or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8392.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-8386Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the interaction of lookbehind assertions and mutually recursive subpatterns, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-2328Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /((?(R)a|(?1)))+/ pattern and related patterns with certain recursion, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-8380Highpcre3:2:8.35-3.3The pcre_exec function in pcre_exec.c in PCRE before 8.38 mishandles a // pattern with a \01 string, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-8390Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the [: and \\ substrings in character classes, which allows remote attackers to cause a denial of service (uninitialized memory read) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-8381Highpcre3:2:8.35-3.3The compile_regex function in pcre_compile.c in PCRE before 8.38 and pcre2_compile.c in PCRE2 before 10.2x mishandles the /(?J:(?|(:(?|(?'R')(\k'R')|((?'R')))H'Rk'Rf)|s(?'R'))))/ and /(?J:(?|(:(?|(?'R')(\z(?|(?'R')(\k'R')|((?'R')))k'R')|((?'R')))H'Ak'Rf)|s(?'R')))/ patterns, and related patterns with certain group references, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-8394Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the (?() and (?(R) conditions, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-8387Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles (?123) subroutine calls and related subroutine calls, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-8392Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain instances of the (?| substring, which allows remote attackers to cause a denial of service (unintended recursion and buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8395.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2016-3191Highpcre3:2:8.35-3.3The compile_branch function in pcre_compile.c in PCRE 8.x before 8.39 and pcre2_compile.c in PCRE2 before 10.22 mishandles patterns containing an (*ACCEPT) substring in conjunction with nested parentheses, which allows remote attackers to execute arbitrary code or cause a denial of service (stack-based buffer overflow) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-3542.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-8389Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?:|a|){100}x/ pattern and related patterns, which allows remote attackers to cause a denial of service (infinite recursion) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-8383Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain repeated conditional groups, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-8385Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?|(\k'Pm')|(?'Pm'))/ pattern and related patterns with certain forward references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-2327Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /(((a\2)|(a*)\g<-1>))*/ pattern and related patterns with certain internal recursive back references, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-8384Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?J)(?'d'(?'d'\g{d}))/ pattern and related patterns with certain recursive back references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8392 and CVE-2015-8395.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-8388Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?=di(?<=(?1))|(?=(.))))/ pattern and related patterns with an unmatched closing parenthesis, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2016-1283Highpcre3:2:8.35-3.3The pcre_compile2 function in pcre_compile.c in PCRE 8.38 mishandles the /((?:F?+(?:^(?(R)a+\"){99}-))(?J)(?'R'(?'R'<((?'RR'(?'R'\){97)?J)?J)(?'R'(?'R'\){99|(:(?|(?'R')(\k'R')|((?'R')))H'R'R)(H'R))))))/ pattern and related patterns with named subgroups, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2014-9769Highpcre3:2:8.35-3.3pcre_jit_compile.c in PCRE 8.35 does not properly use table jumps to optimize nested alternatives, which allows remote attackers to cause a denial of service (stack memory corruption) or possibly have unspecified other impact via a crafted string, as demonstrated by packets encountered by Suricata during use of a regular expression in an Emerging Threats Open ruleset.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-5277Highglibc:2.19-18+deb8u1The get_contents function in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) before 2.20 might allow local users to cause a denial of service (heap corruption) or gain privileges via a long line in the NSS files database.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2016-2856Highglibc:2.19-18+deb8u1pt_chown in the glibc package before 2.19-18+deb8u4 on Debian jessie lacks a namespace check associated with file-descriptor passing, which allows local users to capture keystrokes and spoof data, and possibly gain privileges, via pts read and write operations, related to debian/sysdeps/linux.mk. NOTE: this is not considered a vulnerability in the upstream GNU C Library because the upstream documentation has a clear security recommendation against the --enable-pt_chown option.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-8607Highperl:5.20.2-3+deb8u1The canonpath function in the File::Spec module in PathTools before 3.62, as used in Perl, does not properly preserve the taint attribute of data, which might allow context-dependent attackers to bypass the taint protection mechanism via a crafted string.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-5600Highopenssh:1:6.7p1-5The kbdint_next_device function in auth2-chall.c in sshd in OpenSSH through 6.9 does not properly restrict the processing of keyboard-interactive devices within a single connection, which makes it easier for remote attackers to conduct brute-force attacks or cause a denial of service (CPU consumption) via a long and duplicative list in the ssh -oKbdInteractiveDevices option, as demonstrated by a modified client that provides a different password for each pam element on this list.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2016-0728Highlinux:3.16.7-ckt20-1+deb8u2The join_session_keyring function in security/keys/process_keys.c in the Linux kernel before 4.4.1 mishandles object references in a certain error case, which allows local users to gain privileges or cause a denial of service (integer overflow and use-after-free) via crafted keyctl commands.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2013-7445Highlinux:3.16.7-ckt20-1+deb8u2The Direct Rendering Manager (DRM) subsystem in the Linux kernel through 4.x mishandles requests for Graphics Execution Manager (GEM) objects, which allows context-dependent attackers to cause a denial of service (memory consumption) via an application that processes graphics data, as demonstrated by JavaScript code that creates many CANVAS elements for rendering by Chrome or Firefox.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2016-0494Highicu:52.1-8+deb8u3Unspecified vulnerability in the Java SE and Java SE Embedded components in Oracle Java SE 6u105, 7u91, and 8u66 and Java SE Embedded 8u65 allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-4844Highicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u101, 7u85, and 8u60, and Java SE Embedded 8u51, allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2016-0799Highopenssl:1.0.1k-3+deb8u2The fmtstr function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g improperly calculates string lengths, which allows remote attackers to cause a denial of service (overflow and out-of-bounds read) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-2842.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2016-0798Highopenssl:1.0.1k-3+deb8u2Memory leak in the SRP_VBASE_get_by_user implementation in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory consumption) by providing an invalid username in a connection attempt, related to apps/s_server.c and crypto/srp/srp_vfy.c.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2016-0705Highopenssl:1.0.1k-3+deb8u2Double free vulnerability in the dsa_priv_decode function in crypto/dsa/dsa_ameth.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory corruption) or possibly have unspecified other impact via a malformed DSA private key.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2016-2842Highopenssl:1.0.1k-3+deb8u2The doapr_outch function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not verify that a certain memory allocation succeeds, which allows remote attackers to cause a denial of service (out-of-bounds write or memory consumption) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-0799.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-8805Highnettle:2.7.1-5The ecc_256_modq function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8803.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-8804Highnettle:2.7.1-5x86_64/ecc-384-modp.asm in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-384 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-8803Highnettle:2.7.1-5The ecc_256_modp function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8805.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-2059Highlibidn:1.29-1The stringprep_utf8_to_ucs4 function in libin before 1.31, as used in jabberd2, allows context-dependent attackers to read system memory and possibly have other unspecified impact via invalid UTF-8 characters in a string, which triggers an out-of-bounds read.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-8391Highpcre3:2:8.35-3.3The pcre_compile function in pcre_compile.c in PCRE before 8.38 mishandles certain [: nesting, which allows remote attackers to cause a denial of service (CPU consumption) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-8395Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain references, which allows remote attackers to cause a denial of service or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8392.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-8386Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the interaction of lookbehind assertions and mutually recursive subpatterns, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-2328Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /((?(R)a|(?1)))+/ pattern and related patterns with certain recursion, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-8380Highpcre3:2:8.35-3.3The pcre_exec function in pcre_exec.c in PCRE before 8.38 mishandles a // pattern with a \01 string, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-8390Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the [: and \\ substrings in character classes, which allows remote attackers to cause a denial of service (uninitialized memory read) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-8381Highpcre3:2:8.35-3.3The compile_regex function in pcre_compile.c in PCRE before 8.38 and pcre2_compile.c in PCRE2 before 10.2x mishandles the /(?J:(?|(:(?|(?'R')(\k'R')|((?'R')))H'Rk'Rf)|s(?'R'))))/ and /(?J:(?|(:(?|(?'R')(\z(?|(?'R')(\k'R')|((?'R')))k'R')|((?'R')))H'Ak'Rf)|s(?'R')))/ patterns, and related patterns with certain group references, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-8394Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the (?() and (?(R) conditions, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-8387Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles (?123) subroutine calls and related subroutine calls, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-8392Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain instances of the (?| substring, which allows remote attackers to cause a denial of service (unintended recursion and buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8395.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2016-3191Highpcre3:2:8.35-3.3The compile_branch function in pcre_compile.c in PCRE 8.x before 8.39 and pcre2_compile.c in PCRE2 before 10.22 mishandles patterns containing an (*ACCEPT) substring in conjunction with nested parentheses, which allows remote attackers to execute arbitrary code or cause a denial of service (stack-based buffer overflow) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-3542.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-8389Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?:|a|){100}x/ pattern and related patterns, which allows remote attackers to cause a denial of service (infinite recursion) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-8383Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain repeated conditional groups, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-8385Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?|(\k'Pm')|(?'Pm'))/ pattern and related patterns with certain forward references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-2327Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /(((a\2)|(a*)\g<-1>))*/ pattern and related patterns with certain internal recursive back references, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-8384Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?J)(?'d'(?'d'\g{d}))/ pattern and related patterns with certain recursive back references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8392 and CVE-2015-8395.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-8388Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?=di(?<=(?1))|(?=(.))))/ pattern and related patterns with an unmatched closing parenthesis, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2016-1283Highpcre3:2:8.35-3.3The pcre_compile2 function in pcre_compile.c in PCRE 8.38 mishandles the /((?:F?+(?:^(?(R)a+\"){99}-))(?J)(?'R'(?'R'<((?'RR'(?'R'\){97)?J)?J)(?'R'(?'R'\){99|(:(?|(?'R')(\k'R')|((?'R')))H'R'R)(H'R))))))/ pattern and related patterns with named subgroups, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2014-9769Highpcre3:2:8.35-3.3pcre_jit_compile.c in PCRE 8.35 does not properly use table jumps to optimize nested alternatives, which allows remote attackers to cause a denial of service (stack memory corruption) or possibly have unspecified other impact via a crafted string, as demonstrated by packets encountered by Suricata during use of a regular expression in an Emerging Threats Open ruleset.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2016-0799Highopenssl:1.0.1k-3+deb8u2The fmtstr function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g improperly calculates string lengths, which allows remote attackers to cause a denial of service (overflow and out-of-bounds read) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-2842.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2016-0798Highopenssl:1.0.1k-3+deb8u2Memory leak in the SRP_VBASE_get_by_user implementation in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory consumption) by providing an invalid username in a connection attempt, related to apps/s_server.c and crypto/srp/srp_vfy.c.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2016-0705Highopenssl:1.0.1k-3+deb8u2Double free vulnerability in the dsa_priv_decode function in crypto/dsa/dsa_ameth.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory corruption) or possibly have unspecified other impact via a malformed DSA private key.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2016-2842Highopenssl:1.0.1k-3+deb8u2The doapr_outch function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not verify that a certain memory allocation succeeds, which allows remote attackers to cause a denial of service (out-of-bounds write or memory consumption) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-0799.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-5277Highglibc:2.19-18+deb8u1The get_contents function in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) before 2.20 might allow local users to cause a denial of service (heap corruption) or gain privileges via a long line in the NSS files database.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2016-2856Highglibc:2.19-18+deb8u1pt_chown in the glibc package before 2.19-18+deb8u4 on Debian jessie lacks a namespace check associated with file-descriptor passing, which allows local users to capture keystrokes and spoof data, and possibly gain privileges, via pts read and write operations, related to debian/sysdeps/linux.mk. NOTE: this is not considered a vulnerability in the upstream GNU C Library because the upstream documentation has a clear security recommendation against the --enable-pt_chown option.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2016-0494Highicu:52.1-8+deb8u3Unspecified vulnerability in the Java SE and Java SE Embedded components in Oracle Java SE 6u105, 7u91, and 8u66 and Java SE Embedded 8u65 allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-4844Highicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u101, 7u85, and 8u60, and Java SE Embedded 8u51, allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-8805Highnettle:2.7.1-5The ecc_256_modq function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8803.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-8804Highnettle:2.7.1-5x86_64/ecc-384-modp.asm in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-384 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-8803Highnettle:2.7.1-5The ecc_256_modp function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8805.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-5600Highopenssh:1:6.7p1-5The kbdint_next_device function in auth2-chall.c in sshd in OpenSSH through 6.9 does not properly restrict the processing of keyboard-interactive devices within a single connection, which makes it easier for remote attackers to conduct brute-force attacks or cause a denial of service (CPU consumption) via a long and duplicative list in the ssh -oKbdInteractiveDevices option, as demonstrated by a modified client that provides a different password for each pam element on this list.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-8607Highperl:5.20.2-3+deb8u1The canonpath function in the File::Spec module in PathTools before 3.62, as used in Perl, does not properly preserve the taint attribute of data, which might allow context-dependent attackers to bypass the taint protection mechanism via a crafted string.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2016-0494Highicu:52.1-8+deb8u3Unspecified vulnerability in the Java SE and Java SE Embedded components in Oracle Java SE 6u105, 7u91, and 8u66 and Java SE Embedded 8u65 allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-4844Highicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u101, 7u85, and 8u60, and Java SE Embedded 8u51, allows remote attackers to affect confidentiality, integrity, and availability via unknown vectors related to 2D.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-8391Highpcre3:2:8.35-3.3The pcre_compile function in pcre_compile.c in PCRE before 8.38 mishandles certain [: nesting, which allows remote attackers to cause a denial of service (CPU consumption) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-8395Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain references, which allows remote attackers to cause a denial of service or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8392.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-8386Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the interaction of lookbehind assertions and mutually recursive subpatterns, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-2328Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /((?(R)a|(?1)))+/ pattern and related patterns with certain recursion, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-8380Highpcre3:2:8.35-3.3The pcre_exec function in pcre_exec.c in PCRE before 8.38 mishandles a // pattern with a \01 string, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-8390Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the [: and \\ substrings in character classes, which allows remote attackers to cause a denial of service (uninitialized memory read) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-8381Highpcre3:2:8.35-3.3The compile_regex function in pcre_compile.c in PCRE before 8.38 and pcre2_compile.c in PCRE2 before 10.2x mishandles the /(?J:(?|(:(?|(?'R')(\k'R')|((?'R')))H'Rk'Rf)|s(?'R'))))/ and /(?J:(?|(:(?|(?'R')(\z(?|(?'R')(\k'R')|((?'R')))k'R')|((?'R')))H'Ak'Rf)|s(?'R')))/ patterns, and related patterns with certain group references, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-8394Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the (?() and (?(R) conditions, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-8387Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles (?123) subroutine calls and related subroutine calls, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-8392Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain instances of the (?| substring, which allows remote attackers to cause a denial of service (unintended recursion and buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8395.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2016-3191Highpcre3:2:8.35-3.3The compile_branch function in pcre_compile.c in PCRE 8.x before 8.39 and pcre2_compile.c in PCRE2 before 10.22 mishandles patterns containing an (*ACCEPT) substring in conjunction with nested parentheses, which allows remote attackers to execute arbitrary code or cause a denial of service (stack-based buffer overflow) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-3542.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-8389Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?:|a|){100}x/ pattern and related patterns, which allows remote attackers to cause a denial of service (infinite recursion) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-8383Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain repeated conditional groups, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-8385Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?|(\k'Pm')|(?'Pm'))/ pattern and related patterns with certain forward references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-2327Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /(((a\2)|(a*)\g<-1>))*/ pattern and related patterns with certain internal recursive back references, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-8384Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?J)(?'d'(?'d'\g{d}))/ pattern and related patterns with certain recursive back references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8392 and CVE-2015-8395.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-8388Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?=di(?<=(?1))|(?=(.))))/ pattern and related patterns with an unmatched closing parenthesis, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2016-1283Highpcre3:2:8.35-3.3The pcre_compile2 function in pcre_compile.c in PCRE 8.38 mishandles the /((?:F?+(?:^(?(R)a+\"){99}-))(?J)(?'R'(?'R'<((?'RR'(?'R'\){97)?J)?J)(?'R'(?'R'\){99|(:(?|(?'R')(\k'R')|((?'R')))H'R'R)(H'R))))))/ pattern and related patterns with named subgroups, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2014-9769Highpcre3:2:8.35-3.3pcre_jit_compile.c in PCRE 8.35 does not properly use table jumps to optimize nested alternatives, which allows remote attackers to cause a denial of service (stack memory corruption) or possibly have unspecified other impact via a crafted string, as demonstrated by packets encountered by Suricata during use of a regular expression in an Emerging Threats Open ruleset.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-8607Highperl:5.20.2-3+deb8u1The canonpath function in the File::Spec module in PathTools before 3.62, as used in Perl, does not properly preserve the taint attribute of data, which might allow context-dependent attackers to bypass the taint protection mechanism via a crafted string.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-2059Highlibidn:1.29-1The stringprep_utf8_to_ucs4 function in libin before 1.31, as used in jabberd2, allows context-dependent attackers to read system memory and possibly have other unspecified impact via invalid UTF-8 characters in a string, which triggers an out-of-bounds read.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2016-0799Highopenssl:1.0.1k-3+deb8u2The fmtstr function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g improperly calculates string lengths, which allows remote attackers to cause a denial of service (overflow and out-of-bounds read) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-2842.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2016-0798Highopenssl:1.0.1k-3+deb8u2Memory leak in the SRP_VBASE_get_by_user implementation in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory consumption) by providing an invalid username in a connection attempt, related to apps/s_server.c and crypto/srp/srp_vfy.c.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2016-0705Highopenssl:1.0.1k-3+deb8u2Double free vulnerability in the dsa_priv_decode function in crypto/dsa/dsa_ameth.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory corruption) or possibly have unspecified other impact via a malformed DSA private key.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2016-2842Highopenssl:1.0.1k-3+deb8u2The doapr_outch function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not verify that a certain memory allocation succeeds, which allows remote attackers to cause a denial of service (out-of-bounds write or memory consumption) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-0799.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-5277Highglibc:2.19-18+deb8u1The get_contents function in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) before 2.20 might allow local users to cause a denial of service (heap corruption) or gain privileges via a long line in the NSS files database.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2016-2856Highglibc:2.19-18+deb8u1pt_chown in the glibc package before 2.19-18+deb8u4 on Debian jessie lacks a namespace check associated with file-descriptor passing, which allows local users to capture keystrokes and spoof data, and possibly gain privileges, via pts read and write operations, related to debian/sysdeps/linux.mk. NOTE: this is not considered a vulnerability in the upstream GNU C Library because the upstream documentation has a clear security recommendation against the --enable-pt_chown option.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-8805Highnettle:2.7.1-5The ecc_256_modq function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8803.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-8804Highnettle:2.7.1-5x86_64/ecc-384-modp.asm in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-384 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-8803Highnettle:2.7.1-5The ecc_256_modp function in ecc-256.c in Nettle before 3.2 does not properly handle carry propagation and produces incorrect output in its implementation of the P-256 NIST elliptic curve, which allows attackers to have unspecified impact via unknown vectors, a different vulnerability than CVE-2015-8805.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-8391Highpcre3:2:8.35-3.3The pcre_compile function in pcre_compile.c in PCRE before 8.38 mishandles certain [: nesting, which allows remote attackers to cause a denial of service (CPU consumption) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:c648cd6a73969d01003f84dcb558aa19f153fdbb63f6e7bc096cf204c1d46280
CVE-2015-8395Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain references, which allows remote attackers to cause a denial of service or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8392.sha256:c648cd6a73969d01003f84dcb558aa19f153fdbb63f6e7bc096cf204c1d46280
CVE-2015-8386Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the interaction of lookbehind assertions and mutually recursive subpatterns, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:c648cd6a73969d01003f84dcb558aa19f153fdbb63f6e7bc096cf204c1d46280
CVE-2015-2328Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /((?(R)a|(?1)))+/ pattern and related patterns with certain recursion, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:c648cd6a73969d01003f84dcb558aa19f153fdbb63f6e7bc096cf204c1d46280
CVE-2015-8380Highpcre3:2:8.35-3.3The pcre_exec function in pcre_exec.c in PCRE before 8.38 mishandles a // pattern with a \01 string, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:c648cd6a73969d01003f84dcb558aa19f153fdbb63f6e7bc096cf204c1d46280
CVE-2015-8390Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the [: and \\ substrings in character classes, which allows remote attackers to cause a denial of service (uninitialized memory read) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:c648cd6a73969d01003f84dcb558aa19f153fdbb63f6e7bc096cf204c1d46280
CVE-2015-8381Highpcre3:2:8.35-3.3The compile_regex function in pcre_compile.c in PCRE before 8.38 and pcre2_compile.c in PCRE2 before 10.2x mishandles the /(?J:(?|(:(?|(?'R')(\k'R')|((?'R')))H'Rk'Rf)|s(?'R'))))/ and /(?J:(?|(:(?|(?'R')(\z(?|(?'R')(\k'R')|((?'R')))k'R')|((?'R')))H'Ak'Rf)|s(?'R')))/ patterns, and related patterns with certain group references, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:c648cd6a73969d01003f84dcb558aa19f153fdbb63f6e7bc096cf204c1d46280
CVE-2015-8394Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the (?() and (?(R) conditions, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:c648cd6a73969d01003f84dcb558aa19f153fdbb63f6e7bc096cf204c1d46280
CVE-2015-8387Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles (?123) subroutine calls and related subroutine calls, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:c648cd6a73969d01003f84dcb558aa19f153fdbb63f6e7bc096cf204c1d46280
CVE-2015-8392Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain instances of the (?| substring, which allows remote attackers to cause a denial of service (unintended recursion and buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8395.sha256:c648cd6a73969d01003f84dcb558aa19f153fdbb63f6e7bc096cf204c1d46280
CVE-2016-3191Highpcre3:2:8.35-3.3The compile_branch function in pcre_compile.c in PCRE 8.x before 8.39 and pcre2_compile.c in PCRE2 before 10.22 mishandles patterns containing an (*ACCEPT) substring in conjunction with nested parentheses, which allows remote attackers to execute arbitrary code or cause a denial of service (stack-based buffer overflow) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-3542.sha256:c648cd6a73969d01003f84dcb558aa19f153fdbb63f6e7bc096cf204c1d46280
CVE-2015-8389Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?:|a|){100}x/ pattern and related patterns, which allows remote attackers to cause a denial of service (infinite recursion) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:c648cd6a73969d01003f84dcb558aa19f153fdbb63f6e7bc096cf204c1d46280
CVE-2015-8383Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain repeated conditional groups, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:c648cd6a73969d01003f84dcb558aa19f153fdbb63f6e7bc096cf204c1d46280
CVE-2015-8385Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?|(\k'Pm')|(?'Pm'))/ pattern and related patterns with certain forward references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:c648cd6a73969d01003f84dcb558aa19f153fdbb63f6e7bc096cf204c1d46280
CVE-2015-2327Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /(((a\2)|(a*)\g<-1>))*/ pattern and related patterns with certain internal recursive back references, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:c648cd6a73969d01003f84dcb558aa19f153fdbb63f6e7bc096cf204c1d46280
CVE-2015-8384Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?J)(?'d'(?'d'\g{d}))/ pattern and related patterns with certain recursive back references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8392 and CVE-2015-8395.sha256:c648cd6a73969d01003f84dcb558aa19f153fdbb63f6e7bc096cf204c1d46280
CVE-2015-8388Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?=di(?<=(?1))|(?=(.))))/ pattern and related patterns with an unmatched closing parenthesis, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:c648cd6a73969d01003f84dcb558aa19f153fdbb63f6e7bc096cf204c1d46280
CVE-2016-1283Highpcre3:2:8.35-3.3The pcre_compile2 function in pcre_compile.c in PCRE 8.38 mishandles the /((?:F?+(?:^(?(R)a+\"){99}-))(?J)(?'R'(?'R'<((?'RR'(?'R'\){97)?J)?J)(?'R'(?'R'\){99|(:(?|(?'R')(\k'R')|((?'R')))H'R'R)(H'R))))))/ pattern and related patterns with named subgroups, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:c648cd6a73969d01003f84dcb558aa19f153fdbb63f6e7bc096cf204c1d46280
CVE-2014-9769Highpcre3:2:8.35-3.3pcre_jit_compile.c in PCRE 8.35 does not properly use table jumps to optimize nested alternatives, which allows remote attackers to cause a denial of service (stack memory corruption) or possibly have unspecified other impact via a crafted string, as demonstrated by packets encountered by Suricata during use of a regular expression in an Emerging Threats Open ruleset.sha256:c648cd6a73969d01003f84dcb558aa19f153fdbb63f6e7bc096cf204c1d46280
CVE-2015-5277Highglibc:2.19-18+deb8u1The get_contents function in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) before 2.20 might allow local users to cause a denial of service (heap corruption) or gain privileges via a long line in the NSS files database.sha256:c648cd6a73969d01003f84dcb558aa19f153fdbb63f6e7bc096cf204c1d46280
CVE-2016-2856Highglibc:2.19-18+deb8u1pt_chown in the glibc package before 2.19-18+deb8u4 on Debian jessie lacks a namespace check associated with file-descriptor passing, which allows local users to capture keystrokes and spoof data, and possibly gain privileges, via pts read and write operations, related to debian/sysdeps/linux.mk. NOTE: this is not considered a vulnerability in the upstream GNU C Library because the upstream documentation has a clear security recommendation against the --enable-pt_chown option.sha256:c648cd6a73969d01003f84dcb558aa19f153fdbb63f6e7bc096cf204c1d46280
CVE-2015-8607Highperl:5.20.2-3+deb8u1The canonpath function in the File::Spec module in PathTools before 3.62, as used in Perl, does not properly preserve the taint attribute of data, which might allow context-dependent attackers to bypass the taint protection mechanism via a crafted string.sha256:c648cd6a73969d01003f84dcb558aa19f153fdbb63f6e7bc096cf204c1d46280
CVE-2015-8607Highperl:5.20.2-3+deb8u1The canonpath function in the File::Spec module in PathTools before 3.62, as used in Perl, does not properly preserve the taint attribute of data, which might allow context-dependent attackers to bypass the taint protection mechanism via a crafted string.sha256:440e9f8ae5cb10857c9b901fe6ed10eb9aa67b997981d16bc4d52f3713908f4e
CVE-2015-5277Highglibc:2.19-18+deb8u1The get_contents function in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) before 2.20 might allow local users to cause a denial of service (heap corruption) or gain privileges via a long line in the NSS files database.sha256:440e9f8ae5cb10857c9b901fe6ed10eb9aa67b997981d16bc4d52f3713908f4e
CVE-2016-2856Highglibc:2.19-18+deb8u1pt_chown in the glibc package before 2.19-18+deb8u4 on Debian jessie lacks a namespace check associated with file-descriptor passing, which allows local users to capture keystrokes and spoof data, and possibly gain privileges, via pts read and write operations, related to debian/sysdeps/linux.mk. NOTE: this is not considered a vulnerability in the upstream GNU C Library because the upstream documentation has a clear security recommendation against the --enable-pt_chown option.sha256:440e9f8ae5cb10857c9b901fe6ed10eb9aa67b997981d16bc4d52f3713908f4e
CVE-2015-8391Highpcre3:2:8.35-3.3The pcre_compile function in pcre_compile.c in PCRE before 8.38 mishandles certain [: nesting, which allows remote attackers to cause a denial of service (CPU consumption) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:440e9f8ae5cb10857c9b901fe6ed10eb9aa67b997981d16bc4d52f3713908f4e
CVE-2015-8395Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain references, which allows remote attackers to cause a denial of service or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8392.sha256:440e9f8ae5cb10857c9b901fe6ed10eb9aa67b997981d16bc4d52f3713908f4e
CVE-2015-8386Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the interaction of lookbehind assertions and mutually recursive subpatterns, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:440e9f8ae5cb10857c9b901fe6ed10eb9aa67b997981d16bc4d52f3713908f4e
CVE-2015-2328Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /((?(R)a|(?1)))+/ pattern and related patterns with certain recursion, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:440e9f8ae5cb10857c9b901fe6ed10eb9aa67b997981d16bc4d52f3713908f4e
CVE-2015-8380Highpcre3:2:8.35-3.3The pcre_exec function in pcre_exec.c in PCRE before 8.38 mishandles a // pattern with a \01 string, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:440e9f8ae5cb10857c9b901fe6ed10eb9aa67b997981d16bc4d52f3713908f4e
CVE-2015-8390Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the [: and \\ substrings in character classes, which allows remote attackers to cause a denial of service (uninitialized memory read) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:440e9f8ae5cb10857c9b901fe6ed10eb9aa67b997981d16bc4d52f3713908f4e
CVE-2015-8381Highpcre3:2:8.35-3.3The compile_regex function in pcre_compile.c in PCRE before 8.38 and pcre2_compile.c in PCRE2 before 10.2x mishandles the /(?J:(?|(:(?|(?'R')(\k'R')|((?'R')))H'Rk'Rf)|s(?'R'))))/ and /(?J:(?|(:(?|(?'R')(\z(?|(?'R')(\k'R')|((?'R')))k'R')|((?'R')))H'Ak'Rf)|s(?'R')))/ patterns, and related patterns with certain group references, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:440e9f8ae5cb10857c9b901fe6ed10eb9aa67b997981d16bc4d52f3713908f4e
CVE-2015-8394Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the (?() and (?(R) conditions, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:440e9f8ae5cb10857c9b901fe6ed10eb9aa67b997981d16bc4d52f3713908f4e
CVE-2015-8387Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles (?123) subroutine calls and related subroutine calls, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:440e9f8ae5cb10857c9b901fe6ed10eb9aa67b997981d16bc4d52f3713908f4e
CVE-2015-8392Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain instances of the (?| substring, which allows remote attackers to cause a denial of service (unintended recursion and buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8384 and CVE-2015-8395.sha256:440e9f8ae5cb10857c9b901fe6ed10eb9aa67b997981d16bc4d52f3713908f4e
CVE-2016-3191Highpcre3:2:8.35-3.3The compile_branch function in pcre_compile.c in PCRE 8.x before 8.39 and pcre2_compile.c in PCRE2 before 10.22 mishandles patterns containing an (*ACCEPT) substring in conjunction with nested parentheses, which allows remote attackers to execute arbitrary code or cause a denial of service (stack-based buffer overflow) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-3542.sha256:440e9f8ae5cb10857c9b901fe6ed10eb9aa67b997981d16bc4d52f3713908f4e
CVE-2015-8389Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?:|a|){100}x/ pattern and related patterns, which allows remote attackers to cause a denial of service (infinite recursion) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:440e9f8ae5cb10857c9b901fe6ed10eb9aa67b997981d16bc4d52f3713908f4e
CVE-2015-8383Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles certain repeated conditional groups, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:440e9f8ae5cb10857c9b901fe6ed10eb9aa67b997981d16bc4d52f3713908f4e
CVE-2015-8385Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?|(\k'Pm')|(?'Pm'))/ pattern and related patterns with certain forward references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:440e9f8ae5cb10857c9b901fe6ed10eb9aa67b997981d16bc4d52f3713908f4e
CVE-2015-2327Highpcre3:2:8.35-3.3PCRE before 8.36 mishandles the /(((a\2)|(a*)\g<-1>))*/ pattern and related patterns with certain internal recursive back references, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:440e9f8ae5cb10857c9b901fe6ed10eb9aa67b997981d16bc4d52f3713908f4e
CVE-2015-8384Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?J)(?'d'(?'d'\g{d}))/ pattern and related patterns with certain recursive back references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, a related issue to CVE-2015-8392 and CVE-2015-8395.sha256:440e9f8ae5cb10857c9b901fe6ed10eb9aa67b997981d16bc4d52f3713908f4e
CVE-2015-8388Highpcre3:2:8.35-3.3PCRE before 8.38 mishandles the /(?=di(?<=(?1))|(?=(.))))/ pattern and related patterns with an unmatched closing parenthesis, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:440e9f8ae5cb10857c9b901fe6ed10eb9aa67b997981d16bc4d52f3713908f4e
CVE-2016-1283Highpcre3:2:8.35-3.3The pcre_compile2 function in pcre_compile.c in PCRE 8.38 mishandles the /((?:F?+(?:^(?(R)a+\"){99}-))(?J)(?'R'(?'R'<((?'RR'(?'R'\){97)?J)?J)(?'R'(?'R'\){99|(:(?|(?'R')(\k'R')|((?'R')))H'R'R)(H'R))))))/ pattern and related patterns with named subgroups, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:440e9f8ae5cb10857c9b901fe6ed10eb9aa67b997981d16bc4d52f3713908f4e
CVE-2014-9769Highpcre3:2:8.35-3.3pcre_jit_compile.c in PCRE 8.35 does not properly use table jumps to optimize nested alternatives, which allows remote attackers to cause a denial of service (stack memory corruption) or possibly have unspecified other impact via a crafted string, as demonstrated by packets encountered by Suricata during use of a regular expression in an Emerging Threats Open ruleset.sha256:440e9f8ae5cb10857c9b901fe6ed10eb9aa67b997981d16bc4d52f3713908f4e
CVE-2016-0777Mediumopenssh:1:6.7p1-5The resend_bytes function in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2 allows remote servers to obtain sensitive information from process memory by requesting transmission of an entire buffer, as demonstrated by reading a private key.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2016-0778Mediumopenssh:1:6.7p1-5The (1) roaming_read and (2) roaming_write functions in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2, when certain proxy and forward options are enabled, do not properly maintain connection file descriptors, which allows remote servers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact by requesting many forwardings.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2016-3115Mediumopenssh:1:6.7p1-5Multiple CRLF injection vulnerabilities in session.c in sshd in OpenSSH before 7.2p2 allow remote authenticated users to bypass intended shell-command restrictions via crafted X11 forwarding data, related to the (1) do_authenticated1 and (2) session_x11_req functions.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-5352Mediumopenssh:1:6.7p1-5The x11_open_helper function in channels.c in ssh in OpenSSH before 6.9, when ForwardX11Trusted mode is not used, lacks a check of the refusal deadline for X connections, which makes it easier for remote attackers to bypass intended access restrictions via a connection outside of the permitted time window.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-6564Mediumopenssh:1:6.7p1-5Use-after-free vulnerability in the mm_answer_pam_free_ctx function in monitor.c in sshd in OpenSSH before 7.0 on non-OpenBSD platforms might allow local users to gain privileges by leveraging control of the sshd uid to send an unexpectedly early MONITOR_REQ_PAM_FREE_CTX request.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2014-8121Mediumglibc:2.19-18+deb8u1DB_LOOKUP in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) 2.21 and earlier does not properly check if a file is open, which allows remote attackers to cause a denial of service (infinite loop) by performing a look-up while the database is iterated over the database, which triggers the file pointer to be reset.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-7547Mediumglibc:2.19-18+deb8u1Multiple stack-based buffer overflows in the (1) send_dg and (2) send_vc functions in the libresolv library in the GNU C Library (aka glibc or libc6) before 2.23 allow remote attackers to cause a denial of service (crash) or possibly execute arbitrary code via a crafted DNS response that triggers a call to the getaddrinfo function with the AF_UNSPEC or AF_INET6 address family, related to performing "dual A/AAAA DNS queries" and the libnss_dns.so.2 NSS module.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2011-3389Mediumgnutls28:3.3.8-6+deb8u3The SSL protocol, as used in certain configurations in Microsoft Windows and Microsoft Internet Explorer, Mozilla Firefox, Google Chrome, Opera, and other products, encrypts data by using CBC mode with chained initialization vectors, which allows man-in-the-middle attackers to obtain plaintext HTTP headers via a blockwise chosen-boundary attack (BCBA) on an HTTPS session, in conjunction with JavaScript code that uses (1) the HTML5 WebSocket API, (2) the Java URLConnection API, or (3) the Silverlight WebClient API, aka a "BEAST" attack.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2016-1978Mediumnss:2:3.17.2-1.1+deb8u2Use-after-free vulnerability in the ssl3_HandleECDHServerKeyExchange function in Mozilla Network Security Services (NSS) before 3.21, as used in Mozilla Firefox before 44.0, allows remote attackers to cause a denial of service or possibly have unspecified other impact by making an SSL (1) DHE or (2) ECDHE handshake at a time of high memory consumption.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2016-1979Mediumnss:2:3.17.2-1.1+deb8u2Use-after-free vulnerability in the PK11_ImportDERPrivateKeyInfoAndReturnKey function in Mozilla Network Security Services (NSS) before 3.21.1, as used in Mozilla Firefox before 45.0, allows remote attackers to cause a denial of service or possibly have unspecified other impact via crafted key data with DER encoding.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-4000Mediumnss:2:3.17.2-1.1+deb8u2The TLS protocol 1.2 and earlier, when a DHE_EXPORT ciphersuite is enabled on a server but not on a client, does not properly convey a DHE_EXPORT choice, which allows man-in-the-middle attackers to conduct cipher-downgrade attacks by rewriting a ClientHello with DHE replaced by DHE_EXPORT and then rewriting a ServerHello with DHE_EXPORT replaced by DHE, aka the "Logjam" issue.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-7575Mediumnss:2:3.17.2-1.1+deb8u2Mozilla Network Security Services (NSS) before 3.20.2, as used in Mozilla Firefox before 43.0.2 and Firefox ESR 38.x before 38.5.2, does not reject MD5 signatures in Server Key Exchange messages in TLS 1.2 Handshake Protocol traffic, which makes it easier for man-in-the-middle attackers to spoof servers by triggering a collision.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2016-1950Mediumnss:2:3.17.2-1.1+deb8u2Heap-based buffer overflow in Mozilla Network Security Services (NSS) before 3.19.2.3 and 3.20.x and 3.21.x before 3.21.1, as used in Mozilla Firefox before 45.0 and Firefox ESR 38.x before 38.7, allows remote attackers to execute arbitrary code via crafted ASN.1 data in an X.509 certificate.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2016-1938Mediumnss:2:3.17.2-1.1+deb8u2The s_mp_div function in lib/freebl/mpi/mpi.c in Mozilla Network Security Services (NSS) before 3.21, as used in Mozilla Firefox before 44.0, improperly divides numbers, which might make it easier for remote attackers to defeat cryptographic protection mechanisms by leveraging use of the (1) mp_div or (2) mp_exptmod function.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-8382Mediumpcre3:2:8.35-3.3The match function in pcre_exec.c in PCRE before 8.37 mishandles the /(?:((abcd))|(((?:(?:(?:(?:abc|(?:abcdef))))b)abcdefghi)abc)|((*ACCEPT)))/ pattern and related patterns involving (*ACCEPT), which allows remote attackers to obtain sensitive information from process memory or cause a denial of service (partially initialized memory and application crash) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-2547.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-8393Mediumpcre3:2:8.35-3.3pcregrep in PCRE before 8.38 mishandles the -q option for binary files, which might allow remote attackers to obtain sensitive information via a crafted file, as demonstrated by a CGI script that sends stdout data to a client.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2016-0797Mediumopenssl:1.0.1k-3+deb8u2Multiple integer overflows in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allow remote attackers to cause a denial of service (heap memory corruption or NULL pointer dereference) or possibly have unspecified other impact via a long digit string that is mishandled by the (1) BN_dec2bn or (2) BN_hex2bn function, related to crypto/bn/bn.h and crypto/bn/bn_print.c.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-2632Mediumicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u95, 7u80, and 8u45 allows remote attackers to affect confidentiality via unknown vectors related to 2D.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2016-0755Mediumcurl:7.38.0-4+deb8u2The ConnectionExists function in lib/url.c in libcurl before 7.47.0 does not properly re-use NTLM-authenticated proxy connections, which might allow remote attackers to authenticate as other users via a request, a similar issue to CVE-2014-0015.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-5276Mediumgcc-4.9:4.9.2-10The std::random_device class in libstdc++ in the GNU Compiler Collection (aka GCC) before 4.9.4 does not properly handle short reads from blocking sources, which makes it easier for context-dependent attackers to predict the random values via unspecified vectors.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-8767Mediumlinux:3.16.7-ckt20-1+deb8u2net/sctp/sm_sideeffect.c in the Linux kernel before 4.3 does not properly manage the relationship between a lock and a socket, which allows local users to cause a denial of service (deadlock) via a crafted sctp_accept call.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-7566Mediumlinux:3.16.7-ckt20-1+deb8u2The clie_5_attach function in drivers/usb/serial/visor.c in the Linux kernel through 4.4.1 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact by inserting a USB device that lacks a bulk-out endpoint.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2013-4312Mediumlinux:3.16.7-ckt20-1+deb8u2The Linux kernel before 4.4.1 allows local users to bypass file-descriptor limits and cause a denial of service (memory consumption) by sending each descriptor over a UNIX socket before closing it, related to net/unix/af_unix.c and net/unix/garbage.c.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-8785Mediumlinux:3.16.7-ckt20-1+deb8u2The fuse_fill_write_pages function in fs/fuse/file.c in the Linux kernel before 4.4 allows local users to cause a denial of service (infinite loop) via a writev system call that triggers a zero length for the first segment of an iov.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2016-0723Mediumlinux:3.16.7-ckt20-1+deb8u2Race condition in the tty_ioctl function in drivers/tty/tty_io.c in the Linux kernel through 4.4.1 allows local users to obtain sensitive information from kernel memory or cause a denial of service (use-after-free and system crash) by making a TIOCGETD ioctl call during processing of a TIOCSETD ioctl call.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2016-0821Mediumlinux:3.16.7-ckt20-1+deb8u2The LIST_POISON feature in include/linux/poison.h in the Linux kernel before 4.3, as used in Android 6.0.1 before 2016-03-01, does not properly consider the relationship to the mmap_min_addr value, which makes it easier for attackers to bypass a poison-pointer protection mechanism by triggering the use of an uninitialized list entry, aka Android internal bug 26186802, a different vulnerability than CVE-2015-3636.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-8631Mediumkrb5:1.12.1+dfsg-19+deb8u1Multiple memory leaks in kadmin/server/server_stubs.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (memory consumption) via a request specifying a NULL principal name.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-2694Mediumkrb5:1.12.1+dfsg-19+deb8u1The kdcpreauth modules in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.2 do not properly track whether a client's request has been validated, which allows remote attackers to bypass an intended preauthentication requirement by providing (1) zero bytes of data or (2) an arbitrary realm name, related to plugins/preauth/otp/main.c and plugins/preauth/pkinit/pkinit_srv.c.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-8630Mediumkrb5:1.12.1+dfsg-19+deb8u1The (1) kadm5_create_principal_3 and (2) kadm5_modify_principal functions in lib/kadm5/srv/svr_principal.c in kadmind in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) by specifying KADM5_POLICY with a NULL policy name.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-3238Mediumpam:1.1.8-3.1The _unix_run_helper_binary function in the pam_unix module in Linux-PAM (aka pam) before 1.2.1, when unable to directly access passwords, allows local users to enumerate usernames or cause a denial of service (hang) via a large password.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-3238Mediumpam:1.1.8-3.1The _unix_run_helper_binary function in the pam_unix module in Linux-PAM (aka pam) before 1.2.1, when unable to directly access passwords, allows local users to enumerate usernames or cause a denial of service (hang) via a large password.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-5276Mediumgcc-4.9:4.9.2-10The std::random_device class in libstdc++ in the GNU Compiler Collection (aka GCC) before 4.9.4 does not properly handle short reads from blocking sources, which makes it easier for context-dependent attackers to predict the random values via unspecified vectors.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-0777Mediumopenssh:1:6.7p1-5The resend_bytes function in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2 allows remote servers to obtain sensitive information from process memory by requesting transmission of an entire buffer, as demonstrated by reading a private key.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-0778Mediumopenssh:1:6.7p1-5The (1) roaming_read and (2) roaming_write functions in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2, when certain proxy and forward options are enabled, do not properly maintain connection file descriptors, which allows remote servers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact by requesting many forwardings.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-3115Mediumopenssh:1:6.7p1-5Multiple CRLF injection vulnerabilities in session.c in sshd in OpenSSH before 7.2p2 allow remote authenticated users to bypass intended shell-command restrictions via crafted X11 forwarding data, related to the (1) do_authenticated1 and (2) session_x11_req functions.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-5352Mediumopenssh:1:6.7p1-5The x11_open_helper function in channels.c in ssh in OpenSSH before 6.9, when ForwardX11Trusted mode is not used, lacks a check of the refusal deadline for X connections, which makes it easier for remote attackers to bypass intended access restrictions via a connection outside of the permitted time window.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-6564Mediumopenssh:1:6.7p1-5Use-after-free vulnerability in the mm_answer_pam_free_ctx function in monitor.c in sshd in OpenSSH before 7.0 on non-OpenBSD platforms might allow local users to gain privileges by leveraging control of the sshd uid to send an unexpectedly early MONITOR_REQ_PAM_FREE_CTX request.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2011-3389Mediumgnutls28:3.3.8-6+deb8u3The SSL protocol, as used in certain configurations in Microsoft Windows and Microsoft Internet Explorer, Mozilla Firefox, Google Chrome, Opera, and other products, encrypts data by using CBC mode with chained initialization vectors, which allows man-in-the-middle attackers to obtain plaintext HTTP headers via a blockwise chosen-boundary attack (BCBA) on an HTTPS session, in conjunction with JavaScript code that uses (1) the HTML5 WebSocket API, (2) the Java URLConnection API, or (3) the Silverlight WebClient API, aka a "BEAST" attack.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2014-8121Mediumglibc:2.19-18+deb8u1DB_LOOKUP in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) 2.21 and earlier does not properly check if a file is open, which allows remote attackers to cause a denial of service (infinite loop) by performing a look-up while the database is iterated over the database, which triggers the file pointer to be reset.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-7547Mediumglibc:2.19-18+deb8u1Multiple stack-based buffer overflows in the (1) send_dg and (2) send_vc functions in the libresolv library in the GNU C Library (aka glibc or libc6) before 2.23 allow remote attackers to cause a denial of service (crash) or possibly execute arbitrary code via a crafted DNS response that triggers a call to the getaddrinfo function with the AF_UNSPEC or AF_INET6 address family, related to performing "dual A/AAAA DNS queries" and the libnss_dns.so.2 NSS module.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-2632Mediumicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u95, 7u80, and 8u45 allows remote attackers to affect confidentiality via unknown vectors related to 2D.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-8382Mediumpcre3:2:8.35-3.3The match function in pcre_exec.c in PCRE before 8.37 mishandles the /(?:((abcd))|(((?:(?:(?:(?:abc|(?:abcdef))))b)abcdefghi)abc)|((*ACCEPT)))/ pattern and related patterns involving (*ACCEPT), which allows remote attackers to obtain sensitive information from process memory or cause a denial of service (partially initialized memory and application crash) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-2547.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-8393Mediumpcre3:2:8.35-3.3pcregrep in PCRE before 8.38 mishandles the -q option for binary files, which might allow remote attackers to obtain sensitive information via a crafted file, as demonstrated by a CGI script that sends stdout data to a client.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-0755Mediumcurl:7.38.0-4+deb8u2The ConnectionExists function in lib/url.c in libcurl before 7.47.0 does not properly re-use NTLM-authenticated proxy connections, which might allow remote attackers to authenticate as other users via a request, a similar issue to CVE-2014-0015.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-1978Mediumnss:2:3.17.2-1.1+deb8u2Use-after-free vulnerability in the ssl3_HandleECDHServerKeyExchange function in Mozilla Network Security Services (NSS) before 3.21, as used in Mozilla Firefox before 44.0, allows remote attackers to cause a denial of service or possibly have unspecified other impact by making an SSL (1) DHE or (2) ECDHE handshake at a time of high memory consumption.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-1979Mediumnss:2:3.17.2-1.1+deb8u2Use-after-free vulnerability in the PK11_ImportDERPrivateKeyInfoAndReturnKey function in Mozilla Network Security Services (NSS) before 3.21.1, as used in Mozilla Firefox before 45.0, allows remote attackers to cause a denial of service or possibly have unspecified other impact via crafted key data with DER encoding.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-4000Mediumnss:2:3.17.2-1.1+deb8u2The TLS protocol 1.2 and earlier, when a DHE_EXPORT ciphersuite is enabled on a server but not on a client, does not properly convey a DHE_EXPORT choice, which allows man-in-the-middle attackers to conduct cipher-downgrade attacks by rewriting a ClientHello with DHE replaced by DHE_EXPORT and then rewriting a ServerHello with DHE_EXPORT replaced by DHE, aka the "Logjam" issue.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-7575Mediumnss:2:3.17.2-1.1+deb8u2Mozilla Network Security Services (NSS) before 3.20.2, as used in Mozilla Firefox before 43.0.2 and Firefox ESR 38.x before 38.5.2, does not reject MD5 signatures in Server Key Exchange messages in TLS 1.2 Handshake Protocol traffic, which makes it easier for man-in-the-middle attackers to spoof servers by triggering a collision.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-1950Mediumnss:2:3.17.2-1.1+deb8u2Heap-based buffer overflow in Mozilla Network Security Services (NSS) before 3.19.2.3 and 3.20.x and 3.21.x before 3.21.1, as used in Mozilla Firefox before 45.0 and Firefox ESR 38.x before 38.7, allows remote attackers to execute arbitrary code via crafted ASN.1 data in an X.509 certificate.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-1938Mediumnss:2:3.17.2-1.1+deb8u2The s_mp_div function in lib/freebl/mpi/mpi.c in Mozilla Network Security Services (NSS) before 3.21, as used in Mozilla Firefox before 44.0, improperly divides numbers, which might make it easier for remote attackers to defeat cryptographic protection mechanisms by leveraging use of the (1) mp_div or (2) mp_exptmod function.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-8767Mediumlinux:3.16.7-ckt20-1+deb8u2net/sctp/sm_sideeffect.c in the Linux kernel before 4.3 does not properly manage the relationship between a lock and a socket, which allows local users to cause a denial of service (deadlock) via a crafted sctp_accept call.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-7566Mediumlinux:3.16.7-ckt20-1+deb8u2The clie_5_attach function in drivers/usb/serial/visor.c in the Linux kernel through 4.4.1 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact by inserting a USB device that lacks a bulk-out endpoint.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2013-4312Mediumlinux:3.16.7-ckt20-1+deb8u2The Linux kernel before 4.4.1 allows local users to bypass file-descriptor limits and cause a denial of service (memory consumption) by sending each descriptor over a UNIX socket before closing it, related to net/unix/af_unix.c and net/unix/garbage.c.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-8785Mediumlinux:3.16.7-ckt20-1+deb8u2The fuse_fill_write_pages function in fs/fuse/file.c in the Linux kernel before 4.4 allows local users to cause a denial of service (infinite loop) via a writev system call that triggers a zero length for the first segment of an iov.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-0723Mediumlinux:3.16.7-ckt20-1+deb8u2Race condition in the tty_ioctl function in drivers/tty/tty_io.c in the Linux kernel through 4.4.1 allows local users to obtain sensitive information from kernel memory or cause a denial of service (use-after-free and system crash) by making a TIOCGETD ioctl call during processing of a TIOCSETD ioctl call.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-0821Mediumlinux:3.16.7-ckt20-1+deb8u2The LIST_POISON feature in include/linux/poison.h in the Linux kernel before 4.3, as used in Android 6.0.1 before 2016-03-01, does not properly consider the relationship to the mmap_min_addr value, which makes it easier for attackers to bypass a poison-pointer protection mechanism by triggering the use of an uninitialized list entry, aka Android internal bug 26186802, a different vulnerability than CVE-2015-3636.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-8631Mediumkrb5:1.12.1+dfsg-19+deb8u1Multiple memory leaks in kadmin/server/server_stubs.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (memory consumption) via a request specifying a NULL principal name.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-2694Mediumkrb5:1.12.1+dfsg-19+deb8u1The kdcpreauth modules in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.2 do not properly track whether a client's request has been validated, which allows remote attackers to bypass an intended preauthentication requirement by providing (1) zero bytes of data or (2) an arbitrary realm name, related to plugins/preauth/otp/main.c and plugins/preauth/pkinit/pkinit_srv.c.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-8630Mediumkrb5:1.12.1+dfsg-19+deb8u1The (1) kadm5_create_principal_3 and (2) kadm5_modify_principal functions in lib/kadm5/srv/svr_principal.c in kadmind in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) by specifying KADM5_POLICY with a NULL policy name.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-0797Mediumopenssl:1.0.1k-3+deb8u2Multiple integer overflows in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allow remote attackers to cause a denial of service (heap memory corruption or NULL pointer dereference) or possibly have unspecified other impact via a long digit string that is mishandled by the (1) BN_dec2bn or (2) BN_hex2bn function, related to crypto/bn/bn.h and crypto/bn/bn_print.c.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-5276Mediumgcc-4.9:4.9.2-10The std::random_device class in libstdc++ in the GNU Compiler Collection (aka GCC) before 4.9.4 does not properly handle short reads from blocking sources, which makes it easier for context-dependent attackers to predict the random values via unspecified vectors.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-2632Mediumicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u95, 7u80, and 8u45 allows remote attackers to affect confidentiality via unknown vectors related to 2D.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2016-0777Mediumopenssh:1:6.7p1-5The resend_bytes function in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2 allows remote servers to obtain sensitive information from process memory by requesting transmission of an entire buffer, as demonstrated by reading a private key.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2016-0778Mediumopenssh:1:6.7p1-5The (1) roaming_read and (2) roaming_write functions in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2, when certain proxy and forward options are enabled, do not properly maintain connection file descriptors, which allows remote servers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact by requesting many forwardings.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2016-3115Mediumopenssh:1:6.7p1-5Multiple CRLF injection vulnerabilities in session.c in sshd in OpenSSH before 7.2p2 allow remote authenticated users to bypass intended shell-command restrictions via crafted X11 forwarding data, related to the (1) do_authenticated1 and (2) session_x11_req functions.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-5352Mediumopenssh:1:6.7p1-5The x11_open_helper function in channels.c in ssh in OpenSSH before 6.9, when ForwardX11Trusted mode is not used, lacks a check of the refusal deadline for X connections, which makes it easier for remote attackers to bypass intended access restrictions via a connection outside of the permitted time window.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-6564Mediumopenssh:1:6.7p1-5Use-after-free vulnerability in the mm_answer_pam_free_ctx function in monitor.c in sshd in OpenSSH before 7.0 on non-OpenBSD platforms might allow local users to gain privileges by leveraging control of the sshd uid to send an unexpectedly early MONITOR_REQ_PAM_FREE_CTX request.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-8631Mediumkrb5:1.12.1+dfsg-19+deb8u1Multiple memory leaks in kadmin/server/server_stubs.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (memory consumption) via a request specifying a NULL principal name.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-2694Mediumkrb5:1.12.1+dfsg-19+deb8u1The kdcpreauth modules in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.2 do not properly track whether a client's request has been validated, which allows remote attackers to bypass an intended preauthentication requirement by providing (1) zero bytes of data or (2) an arbitrary realm name, related to plugins/preauth/otp/main.c and plugins/preauth/pkinit/pkinit_srv.c.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-8630Mediumkrb5:1.12.1+dfsg-19+deb8u1The (1) kadm5_create_principal_3 and (2) kadm5_modify_principal functions in lib/kadm5/srv/svr_principal.c in kadmind in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) by specifying KADM5_POLICY with a NULL policy name.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-8767Mediumlinux:3.16.7-ckt20-1+deb8u2net/sctp/sm_sideeffect.c in the Linux kernel before 4.3 does not properly manage the relationship between a lock and a socket, which allows local users to cause a denial of service (deadlock) via a crafted sctp_accept call.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-7566Mediumlinux:3.16.7-ckt20-1+deb8u2The clie_5_attach function in drivers/usb/serial/visor.c in the Linux kernel through 4.4.1 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact by inserting a USB device that lacks a bulk-out endpoint.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2013-4312Mediumlinux:3.16.7-ckt20-1+deb8u2The Linux kernel before 4.4.1 allows local users to bypass file-descriptor limits and cause a denial of service (memory consumption) by sending each descriptor over a UNIX socket before closing it, related to net/unix/af_unix.c and net/unix/garbage.c.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-8785Mediumlinux:3.16.7-ckt20-1+deb8u2The fuse_fill_write_pages function in fs/fuse/file.c in the Linux kernel before 4.4 allows local users to cause a denial of service (infinite loop) via a writev system call that triggers a zero length for the first segment of an iov.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2016-0723Mediumlinux:3.16.7-ckt20-1+deb8u2Race condition in the tty_ioctl function in drivers/tty/tty_io.c in the Linux kernel through 4.4.1 allows local users to obtain sensitive information from kernel memory or cause a denial of service (use-after-free and system crash) by making a TIOCGETD ioctl call during processing of a TIOCSETD ioctl call.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2016-0821Mediumlinux:3.16.7-ckt20-1+deb8u2The LIST_POISON feature in include/linux/poison.h in the Linux kernel before 4.3, as used in Android 6.0.1 before 2016-03-01, does not properly consider the relationship to the mmap_min_addr value, which makes it easier for attackers to bypass a poison-pointer protection mechanism by triggering the use of an uninitialized list entry, aka Android internal bug 26186802, a different vulnerability than CVE-2015-3636.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2014-8121Mediumglibc:2.19-18+deb8u1DB_LOOKUP in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) 2.21 and earlier does not properly check if a file is open, which allows remote attackers to cause a denial of service (infinite loop) by performing a look-up while the database is iterated over the database, which triggers the file pointer to be reset.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-7547Mediumglibc:2.19-18+deb8u1Multiple stack-based buffer overflows in the (1) send_dg and (2) send_vc functions in the libresolv library in the GNU C Library (aka glibc or libc6) before 2.23 allow remote attackers to cause a denial of service (crash) or possibly execute arbitrary code via a crafted DNS response that triggers a call to the getaddrinfo function with the AF_UNSPEC or AF_INET6 address family, related to performing "dual A/AAAA DNS queries" and the libnss_dns.so.2 NSS module.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2016-0755Mediumcurl:7.38.0-4+deb8u2The ConnectionExists function in lib/url.c in libcurl before 7.47.0 does not properly re-use NTLM-authenticated proxy connections, which might allow remote attackers to authenticate as other users via a request, a similar issue to CVE-2014-0015.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2016-1978Mediumnss:2:3.17.2-1.1+deb8u2Use-after-free vulnerability in the ssl3_HandleECDHServerKeyExchange function in Mozilla Network Security Services (NSS) before 3.21, as used in Mozilla Firefox before 44.0, allows remote attackers to cause a denial of service or possibly have unspecified other impact by making an SSL (1) DHE or (2) ECDHE handshake at a time of high memory consumption.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2016-1979Mediumnss:2:3.17.2-1.1+deb8u2Use-after-free vulnerability in the PK11_ImportDERPrivateKeyInfoAndReturnKey function in Mozilla Network Security Services (NSS) before 3.21.1, as used in Mozilla Firefox before 45.0, allows remote attackers to cause a denial of service or possibly have unspecified other impact via crafted key data with DER encoding.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-4000Mediumnss:2:3.17.2-1.1+deb8u2The TLS protocol 1.2 and earlier, when a DHE_EXPORT ciphersuite is enabled on a server but not on a client, does not properly convey a DHE_EXPORT choice, which allows man-in-the-middle attackers to conduct cipher-downgrade attacks by rewriting a ClientHello with DHE replaced by DHE_EXPORT and then rewriting a ServerHello with DHE_EXPORT replaced by DHE, aka the "Logjam" issue.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-7575Mediumnss:2:3.17.2-1.1+deb8u2Mozilla Network Security Services (NSS) before 3.20.2, as used in Mozilla Firefox before 43.0.2 and Firefox ESR 38.x before 38.5.2, does not reject MD5 signatures in Server Key Exchange messages in TLS 1.2 Handshake Protocol traffic, which makes it easier for man-in-the-middle attackers to spoof servers by triggering a collision.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2016-1950Mediumnss:2:3.17.2-1.1+deb8u2Heap-based buffer overflow in Mozilla Network Security Services (NSS) before 3.19.2.3 and 3.20.x and 3.21.x before 3.21.1, as used in Mozilla Firefox before 45.0 and Firefox ESR 38.x before 38.7, allows remote attackers to execute arbitrary code via crafted ASN.1 data in an X.509 certificate.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2016-1938Mediumnss:2:3.17.2-1.1+deb8u2The s_mp_div function in lib/freebl/mpi/mpi.c in Mozilla Network Security Services (NSS) before 3.21, as used in Mozilla Firefox before 44.0, improperly divides numbers, which might make it easier for remote attackers to defeat cryptographic protection mechanisms by leveraging use of the (1) mp_div or (2) mp_exptmod function.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-3238Mediumpam:1.1.8-3.1The _unix_run_helper_binary function in the pam_unix module in Linux-PAM (aka pam) before 1.2.1, when unable to directly access passwords, allows local users to enumerate usernames or cause a denial of service (hang) via a large password.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2016-0797Mediumopenssl:1.0.1k-3+deb8u2Multiple integer overflows in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allow remote attackers to cause a denial of service (heap memory corruption or NULL pointer dereference) or possibly have unspecified other impact via a long digit string that is mishandled by the (1) BN_dec2bn or (2) BN_hex2bn function, related to crypto/bn/bn.h and crypto/bn/bn_print.c.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-8382Mediumpcre3:2:8.35-3.3The match function in pcre_exec.c in PCRE before 8.37 mishandles the /(?:((abcd))|(((?:(?:(?:(?:abc|(?:abcdef))))b)abcdefghi)abc)|((*ACCEPT)))/ pattern and related patterns involving (*ACCEPT), which allows remote attackers to obtain sensitive information from process memory or cause a denial of service (partially initialized memory and application crash) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-2547.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-8393Mediumpcre3:2:8.35-3.3pcregrep in PCRE before 8.38 mishandles the -q option for binary files, which might allow remote attackers to obtain sensitive information via a crafted file, as demonstrated by a CGI script that sends stdout data to a client.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2011-3389Mediumgnutls28:3.3.8-6+deb8u3The SSL protocol, as used in certain configurations in Microsoft Windows and Microsoft Internet Explorer, Mozilla Firefox, Google Chrome, Opera, and other products, encrypts data by using CBC mode with chained initialization vectors, which allows man-in-the-middle attackers to obtain plaintext HTTP headers via a blockwise chosen-boundary attack (BCBA) on an HTTPS session, in conjunction with JavaScript code that uses (1) the HTML5 WebSocket API, (2) the Java URLConnection API, or (3) the Silverlight WebClient API, aka a "BEAST" attack.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-3238Mediumpam:1.1.8-3.1The _unix_run_helper_binary function in the pam_unix module in Linux-PAM (aka pam) before 1.2.1, when unable to directly access passwords, allows local users to enumerate usernames or cause a denial of service (hang) via a large password.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2016-1978Mediumnss:2:3.17.2-1.1+deb8u2Use-after-free vulnerability in the ssl3_HandleECDHServerKeyExchange function in Mozilla Network Security Services (NSS) before 3.21, as used in Mozilla Firefox before 44.0, allows remote attackers to cause a denial of service or possibly have unspecified other impact by making an SSL (1) DHE or (2) ECDHE handshake at a time of high memory consumption.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2016-1979Mediumnss:2:3.17.2-1.1+deb8u2Use-after-free vulnerability in the PK11_ImportDERPrivateKeyInfoAndReturnKey function in Mozilla Network Security Services (NSS) before 3.21.1, as used in Mozilla Firefox before 45.0, allows remote attackers to cause a denial of service or possibly have unspecified other impact via crafted key data with DER encoding.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-4000Mediumnss:2:3.17.2-1.1+deb8u2The TLS protocol 1.2 and earlier, when a DHE_EXPORT ciphersuite is enabled on a server but not on a client, does not properly convey a DHE_EXPORT choice, which allows man-in-the-middle attackers to conduct cipher-downgrade attacks by rewriting a ClientHello with DHE replaced by DHE_EXPORT and then rewriting a ServerHello with DHE_EXPORT replaced by DHE, aka the "Logjam" issue.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-7575Mediumnss:2:3.17.2-1.1+deb8u2Mozilla Network Security Services (NSS) before 3.20.2, as used in Mozilla Firefox before 43.0.2 and Firefox ESR 38.x before 38.5.2, does not reject MD5 signatures in Server Key Exchange messages in TLS 1.2 Handshake Protocol traffic, which makes it easier for man-in-the-middle attackers to spoof servers by triggering a collision.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2016-1950Mediumnss:2:3.17.2-1.1+deb8u2Heap-based buffer overflow in Mozilla Network Security Services (NSS) before 3.19.2.3 and 3.20.x and 3.21.x before 3.21.1, as used in Mozilla Firefox before 45.0 and Firefox ESR 38.x before 38.7, allows remote attackers to execute arbitrary code via crafted ASN.1 data in an X.509 certificate.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2016-1938Mediumnss:2:3.17.2-1.1+deb8u2The s_mp_div function in lib/freebl/mpi/mpi.c in Mozilla Network Security Services (NSS) before 3.21, as used in Mozilla Firefox before 44.0, improperly divides numbers, which might make it easier for remote attackers to defeat cryptographic protection mechanisms by leveraging use of the (1) mp_div or (2) mp_exptmod function.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2011-3389Mediumgnutls28:3.3.8-6+deb8u3The SSL protocol, as used in certain configurations in Microsoft Windows and Microsoft Internet Explorer, Mozilla Firefox, Google Chrome, Opera, and other products, encrypts data by using CBC mode with chained initialization vectors, which allows man-in-the-middle attackers to obtain plaintext HTTP headers via a blockwise chosen-boundary attack (BCBA) on an HTTPS session, in conjunction with JavaScript code that uses (1) the HTML5 WebSocket API, (2) the Java URLConnection API, or (3) the Silverlight WebClient API, aka a "BEAST" attack.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-5276Mediumgcc-4.9:4.9.2-10The std::random_device class in libstdc++ in the GNU Compiler Collection (aka GCC) before 4.9.4 does not properly handle short reads from blocking sources, which makes it easier for context-dependent attackers to predict the random values via unspecified vectors.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2014-8121Mediumglibc:2.19-18+deb8u1DB_LOOKUP in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) 2.21 and earlier does not properly check if a file is open, which allows remote attackers to cause a denial of service (infinite loop) by performing a look-up while the database is iterated over the database, which triggers the file pointer to be reset.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-7547Mediumglibc:2.19-18+deb8u1Multiple stack-based buffer overflows in the (1) send_dg and (2) send_vc functions in the libresolv library in the GNU C Library (aka glibc or libc6) before 2.23 allow remote attackers to cause a denial of service (crash) or possibly execute arbitrary code via a crafted DNS response that triggers a call to the getaddrinfo function with the AF_UNSPEC or AF_INET6 address family, related to performing "dual A/AAAA DNS queries" and the libnss_dns.so.2 NSS module.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-8631Mediumkrb5:1.12.1+dfsg-19+deb8u1Multiple memory leaks in kadmin/server/server_stubs.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (memory consumption) via a request specifying a NULL principal name.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-2694Mediumkrb5:1.12.1+dfsg-19+deb8u1The kdcpreauth modules in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.2 do not properly track whether a client's request has been validated, which allows remote attackers to bypass an intended preauthentication requirement by providing (1) zero bytes of data or (2) an arbitrary realm name, related to plugins/preauth/otp/main.c and plugins/preauth/pkinit/pkinit_srv.c.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-8630Mediumkrb5:1.12.1+dfsg-19+deb8u1The (1) kadm5_create_principal_3 and (2) kadm5_modify_principal functions in lib/kadm5/srv/svr_principal.c in kadmind in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) by specifying KADM5_POLICY with a NULL policy name.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-8382Mediumpcre3:2:8.35-3.3The match function in pcre_exec.c in PCRE before 8.37 mishandles the /(?:((abcd))|(((?:(?:(?:(?:abc|(?:abcdef))))b)abcdefghi)abc)|((*ACCEPT)))/ pattern and related patterns involving (*ACCEPT), which allows remote attackers to obtain sensitive information from process memory or cause a denial of service (partially initialized memory and application crash) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-2547.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-8393Mediumpcre3:2:8.35-3.3pcregrep in PCRE before 8.38 mishandles the -q option for binary files, which might allow remote attackers to obtain sensitive information via a crafted file, as demonstrated by a CGI script that sends stdout data to a client.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2016-0797Mediumopenssl:1.0.1k-3+deb8u2Multiple integer overflows in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allow remote attackers to cause a denial of service (heap memory corruption or NULL pointer dereference) or possibly have unspecified other impact via a long digit string that is mishandled by the (1) BN_dec2bn or (2) BN_hex2bn function, related to crypto/bn/bn.h and crypto/bn/bn_print.c.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2016-0777Mediumopenssh:1:6.7p1-5The resend_bytes function in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2 allows remote servers to obtain sensitive information from process memory by requesting transmission of an entire buffer, as demonstrated by reading a private key.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2016-0778Mediumopenssh:1:6.7p1-5The (1) roaming_read and (2) roaming_write functions in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2, when certain proxy and forward options are enabled, do not properly maintain connection file descriptors, which allows remote servers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact by requesting many forwardings.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2016-3115Mediumopenssh:1:6.7p1-5Multiple CRLF injection vulnerabilities in session.c in sshd in OpenSSH before 7.2p2 allow remote authenticated users to bypass intended shell-command restrictions via crafted X11 forwarding data, related to the (1) do_authenticated1 and (2) session_x11_req functions.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-5352Mediumopenssh:1:6.7p1-5The x11_open_helper function in channels.c in ssh in OpenSSH before 6.9, when ForwardX11Trusted mode is not used, lacks a check of the refusal deadline for X connections, which makes it easier for remote attackers to bypass intended access restrictions via a connection outside of the permitted time window.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-6564Mediumopenssh:1:6.7p1-5Use-after-free vulnerability in the mm_answer_pam_free_ctx function in monitor.c in sshd in OpenSSH before 7.0 on non-OpenBSD platforms might allow local users to gain privileges by leveraging control of the sshd uid to send an unexpectedly early MONITOR_REQ_PAM_FREE_CTX request.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2016-0755Mediumcurl:7.38.0-4+deb8u2The ConnectionExists function in lib/url.c in libcurl before 7.47.0 does not properly re-use NTLM-authenticated proxy connections, which might allow remote attackers to authenticate as other users via a request, a similar issue to CVE-2014-0015.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-2632Mediumicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u95, 7u80, and 8u45 allows remote attackers to affect confidentiality via unknown vectors related to 2D.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-8767Mediumlinux:3.16.7-ckt20-1+deb8u2net/sctp/sm_sideeffect.c in the Linux kernel before 4.3 does not properly manage the relationship between a lock and a socket, which allows local users to cause a denial of service (deadlock) via a crafted sctp_accept call.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-7566Mediumlinux:3.16.7-ckt20-1+deb8u2The clie_5_attach function in drivers/usb/serial/visor.c in the Linux kernel through 4.4.1 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact by inserting a USB device that lacks a bulk-out endpoint.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2013-4312Mediumlinux:3.16.7-ckt20-1+deb8u2The Linux kernel before 4.4.1 allows local users to bypass file-descriptor limits and cause a denial of service (memory consumption) by sending each descriptor over a UNIX socket before closing it, related to net/unix/af_unix.c and net/unix/garbage.c.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-8785Mediumlinux:3.16.7-ckt20-1+deb8u2The fuse_fill_write_pages function in fs/fuse/file.c in the Linux kernel before 4.4 allows local users to cause a denial of service (infinite loop) via a writev system call that triggers a zero length for the first segment of an iov.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2016-0723Mediumlinux:3.16.7-ckt20-1+deb8u2Race condition in the tty_ioctl function in drivers/tty/tty_io.c in the Linux kernel through 4.4.1 allows local users to obtain sensitive information from kernel memory or cause a denial of service (use-after-free and system crash) by making a TIOCGETD ioctl call during processing of a TIOCSETD ioctl call.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2016-0821Mediumlinux:3.16.7-ckt20-1+deb8u2The LIST_POISON feature in include/linux/poison.h in the Linux kernel before 4.3, as used in Android 6.0.1 before 2016-03-01, does not properly consider the relationship to the mmap_min_addr value, which makes it easier for attackers to bypass a poison-pointer protection mechanism by triggering the use of an uninitialized list entry, aka Android internal bug 26186802, a different vulnerability than CVE-2015-3636.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-3238Mediumpam:1.1.8-3.1The _unix_run_helper_binary function in the pam_unix module in Linux-PAM (aka pam) before 1.2.1, when unable to directly access passwords, allows local users to enumerate usernames or cause a denial of service (hang) via a large password.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-5276Mediumgcc-4.9:4.9.2-10The std::random_device class in libstdc++ in the GNU Compiler Collection (aka GCC) before 4.9.4 does not properly handle short reads from blocking sources, which makes it easier for context-dependent attackers to predict the random values via unspecified vectors.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-8631Mediumkrb5:1.12.1+dfsg-19+deb8u1Multiple memory leaks in kadmin/server/server_stubs.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (memory consumption) via a request specifying a NULL principal name.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-2694Mediumkrb5:1.12.1+dfsg-19+deb8u1The kdcpreauth modules in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.2 do not properly track whether a client's request has been validated, which allows remote attackers to bypass an intended preauthentication requirement by providing (1) zero bytes of data or (2) an arbitrary realm name, related to plugins/preauth/otp/main.c and plugins/preauth/pkinit/pkinit_srv.c.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-8630Mediumkrb5:1.12.1+dfsg-19+deb8u1The (1) kadm5_create_principal_3 and (2) kadm5_modify_principal functions in lib/kadm5/srv/svr_principal.c in kadmind in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) by specifying KADM5_POLICY with a NULL policy name.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2011-3389Mediumgnutls28:3.3.8-6+deb8u3The SSL protocol, as used in certain configurations in Microsoft Windows and Microsoft Internet Explorer, Mozilla Firefox, Google Chrome, Opera, and other products, encrypts data by using CBC mode with chained initialization vectors, which allows man-in-the-middle attackers to obtain plaintext HTTP headers via a blockwise chosen-boundary attack (BCBA) on an HTTPS session, in conjunction with JavaScript code that uses (1) the HTML5 WebSocket API, (2) the Java URLConnection API, or (3) the Silverlight WebClient API, aka a "BEAST" attack.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-0755Mediumcurl:7.38.0-4+deb8u2The ConnectionExists function in lib/url.c in libcurl before 7.47.0 does not properly re-use NTLM-authenticated proxy connections, which might allow remote attackers to authenticate as other users via a request, a similar issue to CVE-2014-0015.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-0777Mediumopenssh:1:6.7p1-5The resend_bytes function in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2 allows remote servers to obtain sensitive information from process memory by requesting transmission of an entire buffer, as demonstrated by reading a private key.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-0778Mediumopenssh:1:6.7p1-5The (1) roaming_read and (2) roaming_write functions in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2, when certain proxy and forward options are enabled, do not properly maintain connection file descriptors, which allows remote servers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact by requesting many forwardings.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-3115Mediumopenssh:1:6.7p1-5Multiple CRLF injection vulnerabilities in session.c in sshd in OpenSSH before 7.2p2 allow remote authenticated users to bypass intended shell-command restrictions via crafted X11 forwarding data, related to the (1) do_authenticated1 and (2) session_x11_req functions.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-5352Mediumopenssh:1:6.7p1-5The x11_open_helper function in channels.c in ssh in OpenSSH before 6.9, when ForwardX11Trusted mode is not used, lacks a check of the refusal deadline for X connections, which makes it easier for remote attackers to bypass intended access restrictions via a connection outside of the permitted time window.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-6564Mediumopenssh:1:6.7p1-5Use-after-free vulnerability in the mm_answer_pam_free_ctx function in monitor.c in sshd in OpenSSH before 7.0 on non-OpenBSD platforms might allow local users to gain privileges by leveraging control of the sshd uid to send an unexpectedly early MONITOR_REQ_PAM_FREE_CTX request.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-0797Mediumopenssl:1.0.1k-3+deb8u2Multiple integer overflows in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allow remote attackers to cause a denial of service (heap memory corruption or NULL pointer dereference) or possibly have unspecified other impact via a long digit string that is mishandled by the (1) BN_dec2bn or (2) BN_hex2bn function, related to crypto/bn/bn.h and crypto/bn/bn_print.c.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-8382Mediumpcre3:2:8.35-3.3The match function in pcre_exec.c in PCRE before 8.37 mishandles the /(?:((abcd))|(((?:(?:(?:(?:abc|(?:abcdef))))b)abcdefghi)abc)|((*ACCEPT)))/ pattern and related patterns involving (*ACCEPT), which allows remote attackers to obtain sensitive information from process memory or cause a denial of service (partially initialized memory and application crash) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-2547.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-8393Mediumpcre3:2:8.35-3.3pcregrep in PCRE before 8.38 mishandles the -q option for binary files, which might allow remote attackers to obtain sensitive information via a crafted file, as demonstrated by a CGI script that sends stdout data to a client.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2014-8121Mediumglibc:2.19-18+deb8u1DB_LOOKUP in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) 2.21 and earlier does not properly check if a file is open, which allows remote attackers to cause a denial of service (infinite loop) by performing a look-up while the database is iterated over the database, which triggers the file pointer to be reset.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-7547Mediumglibc:2.19-18+deb8u1Multiple stack-based buffer overflows in the (1) send_dg and (2) send_vc functions in the libresolv library in the GNU C Library (aka glibc or libc6) before 2.23 allow remote attackers to cause a denial of service (crash) or possibly execute arbitrary code via a crafted DNS response that triggers a call to the getaddrinfo function with the AF_UNSPEC or AF_INET6 address family, related to performing "dual A/AAAA DNS queries" and the libnss_dns.so.2 NSS module.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-1978Mediumnss:2:3.17.2-1.1+deb8u2Use-after-free vulnerability in the ssl3_HandleECDHServerKeyExchange function in Mozilla Network Security Services (NSS) before 3.21, as used in Mozilla Firefox before 44.0, allows remote attackers to cause a denial of service or possibly have unspecified other impact by making an SSL (1) DHE or (2) ECDHE handshake at a time of high memory consumption.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-1979Mediumnss:2:3.17.2-1.1+deb8u2Use-after-free vulnerability in the PK11_ImportDERPrivateKeyInfoAndReturnKey function in Mozilla Network Security Services (NSS) before 3.21.1, as used in Mozilla Firefox before 45.0, allows remote attackers to cause a denial of service or possibly have unspecified other impact via crafted key data with DER encoding.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-4000Mediumnss:2:3.17.2-1.1+deb8u2The TLS protocol 1.2 and earlier, when a DHE_EXPORT ciphersuite is enabled on a server but not on a client, does not properly convey a DHE_EXPORT choice, which allows man-in-the-middle attackers to conduct cipher-downgrade attacks by rewriting a ClientHello with DHE replaced by DHE_EXPORT and then rewriting a ServerHello with DHE_EXPORT replaced by DHE, aka the "Logjam" issue.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-7575Mediumnss:2:3.17.2-1.1+deb8u2Mozilla Network Security Services (NSS) before 3.20.2, as used in Mozilla Firefox before 43.0.2 and Firefox ESR 38.x before 38.5.2, does not reject MD5 signatures in Server Key Exchange messages in TLS 1.2 Handshake Protocol traffic, which makes it easier for man-in-the-middle attackers to spoof servers by triggering a collision.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-1950Mediumnss:2:3.17.2-1.1+deb8u2Heap-based buffer overflow in Mozilla Network Security Services (NSS) before 3.19.2.3 and 3.20.x and 3.21.x before 3.21.1, as used in Mozilla Firefox before 45.0 and Firefox ESR 38.x before 38.7, allows remote attackers to execute arbitrary code via crafted ASN.1 data in an X.509 certificate.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-1938Mediumnss:2:3.17.2-1.1+deb8u2The s_mp_div function in lib/freebl/mpi/mpi.c in Mozilla Network Security Services (NSS) before 3.21, as used in Mozilla Firefox before 44.0, improperly divides numbers, which might make it easier for remote attackers to defeat cryptographic protection mechanisms by leveraging use of the (1) mp_div or (2) mp_exptmod function.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-8767Mediumlinux:3.16.7-ckt20-1+deb8u2net/sctp/sm_sideeffect.c in the Linux kernel before 4.3 does not properly manage the relationship between a lock and a socket, which allows local users to cause a denial of service (deadlock) via a crafted sctp_accept call.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-7566Mediumlinux:3.16.7-ckt20-1+deb8u2The clie_5_attach function in drivers/usb/serial/visor.c in the Linux kernel through 4.4.1 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact by inserting a USB device that lacks a bulk-out endpoint.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2013-4312Mediumlinux:3.16.7-ckt20-1+deb8u2The Linux kernel before 4.4.1 allows local users to bypass file-descriptor limits and cause a denial of service (memory consumption) by sending each descriptor over a UNIX socket before closing it, related to net/unix/af_unix.c and net/unix/garbage.c.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-8785Mediumlinux:3.16.7-ckt20-1+deb8u2The fuse_fill_write_pages function in fs/fuse/file.c in the Linux kernel before 4.4 allows local users to cause a denial of service (infinite loop) via a writev system call that triggers a zero length for the first segment of an iov.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-0723Mediumlinux:3.16.7-ckt20-1+deb8u2Race condition in the tty_ioctl function in drivers/tty/tty_io.c in the Linux kernel through 4.4.1 allows local users to obtain sensitive information from kernel memory or cause a denial of service (use-after-free and system crash) by making a TIOCGETD ioctl call during processing of a TIOCSETD ioctl call.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-0821Mediumlinux:3.16.7-ckt20-1+deb8u2The LIST_POISON feature in include/linux/poison.h in the Linux kernel before 4.3, as used in Android 6.0.1 before 2016-03-01, does not properly consider the relationship to the mmap_min_addr value, which makes it easier for attackers to bypass a poison-pointer protection mechanism by triggering the use of an uninitialized list entry, aka Android internal bug 26186802, a different vulnerability than CVE-2015-3636.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-2632Mediumicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u95, 7u80, and 8u45 allows remote attackers to affect confidentiality via unknown vectors related to 2D.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-3238Mediumpam:1.1.8-3.1The _unix_run_helper_binary function in the pam_unix module in Linux-PAM (aka pam) before 1.2.1, when unable to directly access passwords, allows local users to enumerate usernames or cause a denial of service (hang) via a large password.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2011-3389Mediumgnutls28:3.3.8-6+deb8u3The SSL protocol, as used in certain configurations in Microsoft Windows and Microsoft Internet Explorer, Mozilla Firefox, Google Chrome, Opera, and other products, encrypts data by using CBC mode with chained initialization vectors, which allows man-in-the-middle attackers to obtain plaintext HTTP headers via a blockwise chosen-boundary attack (BCBA) on an HTTPS session, in conjunction with JavaScript code that uses (1) the HTML5 WebSocket API, (2) the Java URLConnection API, or (3) the Silverlight WebClient API, aka a "BEAST" attack.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2016-0797Mediumopenssl:1.0.1k-3+deb8u2Multiple integer overflows in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allow remote attackers to cause a denial of service (heap memory corruption or NULL pointer dereference) or possibly have unspecified other impact via a long digit string that is mishandled by the (1) BN_dec2bn or (2) BN_hex2bn function, related to crypto/bn/bn.h and crypto/bn/bn_print.c.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-5276Mediumgcc-4.9:4.9.2-10The std::random_device class in libstdc++ in the GNU Compiler Collection (aka GCC) before 4.9.4 does not properly handle short reads from blocking sources, which makes it easier for context-dependent attackers to predict the random values via unspecified vectors.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-8382Mediumpcre3:2:8.35-3.3The match function in pcre_exec.c in PCRE before 8.37 mishandles the /(?:((abcd))|(((?:(?:(?:(?:abc|(?:abcdef))))b)abcdefghi)abc)|((*ACCEPT)))/ pattern and related patterns involving (*ACCEPT), which allows remote attackers to obtain sensitive information from process memory or cause a denial of service (partially initialized memory and application crash) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-2547.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-8393Mediumpcre3:2:8.35-3.3pcregrep in PCRE before 8.38 mishandles the -q option for binary files, which might allow remote attackers to obtain sensitive information via a crafted file, as demonstrated by a CGI script that sends stdout data to a client.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2016-0777Mediumopenssh:1:6.7p1-5The resend_bytes function in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2 allows remote servers to obtain sensitive information from process memory by requesting transmission of an entire buffer, as demonstrated by reading a private key.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2016-0778Mediumopenssh:1:6.7p1-5The (1) roaming_read and (2) roaming_write functions in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2, when certain proxy and forward options are enabled, do not properly maintain connection file descriptors, which allows remote servers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact by requesting many forwardings.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2016-3115Mediumopenssh:1:6.7p1-5Multiple CRLF injection vulnerabilities in session.c in sshd in OpenSSH before 7.2p2 allow remote authenticated users to bypass intended shell-command restrictions via crafted X11 forwarding data, related to the (1) do_authenticated1 and (2) session_x11_req functions.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-5352Mediumopenssh:1:6.7p1-5The x11_open_helper function in channels.c in ssh in OpenSSH before 6.9, when ForwardX11Trusted mode is not used, lacks a check of the refusal deadline for X connections, which makes it easier for remote attackers to bypass intended access restrictions via a connection outside of the permitted time window.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-6564Mediumopenssh:1:6.7p1-5Use-after-free vulnerability in the mm_answer_pam_free_ctx function in monitor.c in sshd in OpenSSH before 7.0 on non-OpenBSD platforms might allow local users to gain privileges by leveraging control of the sshd uid to send an unexpectedly early MONITOR_REQ_PAM_FREE_CTX request.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2016-1978Mediumnss:2:3.17.2-1.1+deb8u2Use-after-free vulnerability in the ssl3_HandleECDHServerKeyExchange function in Mozilla Network Security Services (NSS) before 3.21, as used in Mozilla Firefox before 44.0, allows remote attackers to cause a denial of service or possibly have unspecified other impact by making an SSL (1) DHE or (2) ECDHE handshake at a time of high memory consumption.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2016-1979Mediumnss:2:3.17.2-1.1+deb8u2Use-after-free vulnerability in the PK11_ImportDERPrivateKeyInfoAndReturnKey function in Mozilla Network Security Services (NSS) before 3.21.1, as used in Mozilla Firefox before 45.0, allows remote attackers to cause a denial of service or possibly have unspecified other impact via crafted key data with DER encoding.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-4000Mediumnss:2:3.17.2-1.1+deb8u2The TLS protocol 1.2 and earlier, when a DHE_EXPORT ciphersuite is enabled on a server but not on a client, does not properly convey a DHE_EXPORT choice, which allows man-in-the-middle attackers to conduct cipher-downgrade attacks by rewriting a ClientHello with DHE replaced by DHE_EXPORT and then rewriting a ServerHello with DHE_EXPORT replaced by DHE, aka the "Logjam" issue.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-7575Mediumnss:2:3.17.2-1.1+deb8u2Mozilla Network Security Services (NSS) before 3.20.2, as used in Mozilla Firefox before 43.0.2 and Firefox ESR 38.x before 38.5.2, does not reject MD5 signatures in Server Key Exchange messages in TLS 1.2 Handshake Protocol traffic, which makes it easier for man-in-the-middle attackers to spoof servers by triggering a collision.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2016-1950Mediumnss:2:3.17.2-1.1+deb8u2Heap-based buffer overflow in Mozilla Network Security Services (NSS) before 3.19.2.3 and 3.20.x and 3.21.x before 3.21.1, as used in Mozilla Firefox before 45.0 and Firefox ESR 38.x before 38.7, allows remote attackers to execute arbitrary code via crafted ASN.1 data in an X.509 certificate.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2016-1938Mediumnss:2:3.17.2-1.1+deb8u2The s_mp_div function in lib/freebl/mpi/mpi.c in Mozilla Network Security Services (NSS) before 3.21, as used in Mozilla Firefox before 44.0, improperly divides numbers, which might make it easier for remote attackers to defeat cryptographic protection mechanisms by leveraging use of the (1) mp_div or (2) mp_exptmod function.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-2632Mediumicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u95, 7u80, and 8u45 allows remote attackers to affect confidentiality via unknown vectors related to 2D.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-8631Mediumkrb5:1.12.1+dfsg-19+deb8u1Multiple memory leaks in kadmin/server/server_stubs.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (memory consumption) via a request specifying a NULL principal name.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-2694Mediumkrb5:1.12.1+dfsg-19+deb8u1The kdcpreauth modules in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.2 do not properly track whether a client's request has been validated, which allows remote attackers to bypass an intended preauthentication requirement by providing (1) zero bytes of data or (2) an arbitrary realm name, related to plugins/preauth/otp/main.c and plugins/preauth/pkinit/pkinit_srv.c.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-8630Mediumkrb5:1.12.1+dfsg-19+deb8u1The (1) kadm5_create_principal_3 and (2) kadm5_modify_principal functions in lib/kadm5/srv/svr_principal.c in kadmind in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) by specifying KADM5_POLICY with a NULL policy name.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-8767Mediumlinux:3.16.7-ckt20-1+deb8u2net/sctp/sm_sideeffect.c in the Linux kernel before 4.3 does not properly manage the relationship between a lock and a socket, which allows local users to cause a denial of service (deadlock) via a crafted sctp_accept call.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-7566Mediumlinux:3.16.7-ckt20-1+deb8u2The clie_5_attach function in drivers/usb/serial/visor.c in the Linux kernel through 4.4.1 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact by inserting a USB device that lacks a bulk-out endpoint.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2013-4312Mediumlinux:3.16.7-ckt20-1+deb8u2The Linux kernel before 4.4.1 allows local users to bypass file-descriptor limits and cause a denial of service (memory consumption) by sending each descriptor over a UNIX socket before closing it, related to net/unix/af_unix.c and net/unix/garbage.c.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-8785Mediumlinux:3.16.7-ckt20-1+deb8u2The fuse_fill_write_pages function in fs/fuse/file.c in the Linux kernel before 4.4 allows local users to cause a denial of service (infinite loop) via a writev system call that triggers a zero length for the first segment of an iov.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2016-0723Mediumlinux:3.16.7-ckt20-1+deb8u2Race condition in the tty_ioctl function in drivers/tty/tty_io.c in the Linux kernel through 4.4.1 allows local users to obtain sensitive information from kernel memory or cause a denial of service (use-after-free and system crash) by making a TIOCGETD ioctl call during processing of a TIOCSETD ioctl call.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2016-0821Mediumlinux:3.16.7-ckt20-1+deb8u2The LIST_POISON feature in include/linux/poison.h in the Linux kernel before 4.3, as used in Android 6.0.1 before 2016-03-01, does not properly consider the relationship to the mmap_min_addr value, which makes it easier for attackers to bypass a poison-pointer protection mechanism by triggering the use of an uninitialized list entry, aka Android internal bug 26186802, a different vulnerability than CVE-2015-3636.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2014-8121Mediumglibc:2.19-18+deb8u1DB_LOOKUP in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) 2.21 and earlier does not properly check if a file is open, which allows remote attackers to cause a denial of service (infinite loop) by performing a look-up while the database is iterated over the database, which triggers the file pointer to be reset.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-7547Mediumglibc:2.19-18+deb8u1Multiple stack-based buffer overflows in the (1) send_dg and (2) send_vc functions in the libresolv library in the GNU C Library (aka glibc or libc6) before 2.23 allow remote attackers to cause a denial of service (crash) or possibly execute arbitrary code via a crafted DNS response that triggers a call to the getaddrinfo function with the AF_UNSPEC or AF_INET6 address family, related to performing "dual A/AAAA DNS queries" and the libnss_dns.so.2 NSS module.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2016-0755Mediumcurl:7.38.0-4+deb8u2The ConnectionExists function in lib/url.c in libcurl before 7.47.0 does not properly re-use NTLM-authenticated proxy connections, which might allow remote attackers to authenticate as other users via a request, a similar issue to CVE-2014-0015.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-3238Mediumpam:1.1.8-3.1The _unix_run_helper_binary function in the pam_unix module in Linux-PAM (aka pam) before 1.2.1, when unable to directly access passwords, allows local users to enumerate usernames or cause a denial of service (hang) via a large password.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-8767Mediumlinux:3.16.7-ckt20-1+deb8u2net/sctp/sm_sideeffect.c in the Linux kernel before 4.3 does not properly manage the relationship between a lock and a socket, which allows local users to cause a denial of service (deadlock) via a crafted sctp_accept call.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-7566Mediumlinux:3.16.7-ckt20-1+deb8u2The clie_5_attach function in drivers/usb/serial/visor.c in the Linux kernel through 4.4.1 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact by inserting a USB device that lacks a bulk-out endpoint.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2013-4312Mediumlinux:3.16.7-ckt20-1+deb8u2The Linux kernel before 4.4.1 allows local users to bypass file-descriptor limits and cause a denial of service (memory consumption) by sending each descriptor over a UNIX socket before closing it, related to net/unix/af_unix.c and net/unix/garbage.c.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-8785Mediumlinux:3.16.7-ckt20-1+deb8u2The fuse_fill_write_pages function in fs/fuse/file.c in the Linux kernel before 4.4 allows local users to cause a denial of service (infinite loop) via a writev system call that triggers a zero length for the first segment of an iov.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2016-0723Mediumlinux:3.16.7-ckt20-1+deb8u2Race condition in the tty_ioctl function in drivers/tty/tty_io.c in the Linux kernel through 4.4.1 allows local users to obtain sensitive information from kernel memory or cause a denial of service (use-after-free and system crash) by making a TIOCGETD ioctl call during processing of a TIOCSETD ioctl call.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2016-0821Mediumlinux:3.16.7-ckt20-1+deb8u2The LIST_POISON feature in include/linux/poison.h in the Linux kernel before 4.3, as used in Android 6.0.1 before 2016-03-01, does not properly consider the relationship to the mmap_min_addr value, which makes it easier for attackers to bypass a poison-pointer protection mechanism by triggering the use of an uninitialized list entry, aka Android internal bug 26186802, a different vulnerability than CVE-2015-3636.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-5276Mediumgcc-4.9:4.9.2-10The std::random_device class in libstdc++ in the GNU Compiler Collection (aka GCC) before 4.9.4 does not properly handle short reads from blocking sources, which makes it easier for context-dependent attackers to predict the random values via unspecified vectors.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2016-0797Mediumopenssl:1.0.1k-3+deb8u2Multiple integer overflows in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allow remote attackers to cause a denial of service (heap memory corruption or NULL pointer dereference) or possibly have unspecified other impact via a long digit string that is mishandled by the (1) BN_dec2bn or (2) BN_hex2bn function, related to crypto/bn/bn.h and crypto/bn/bn_print.c.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2014-8121Mediumglibc:2.19-18+deb8u1DB_LOOKUP in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) 2.21 and earlier does not properly check if a file is open, which allows remote attackers to cause a denial of service (infinite loop) by performing a look-up while the database is iterated over the database, which triggers the file pointer to be reset.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-7547Mediumglibc:2.19-18+deb8u1Multiple stack-based buffer overflows in the (1) send_dg and (2) send_vc functions in the libresolv library in the GNU C Library (aka glibc or libc6) before 2.23 allow remote attackers to cause a denial of service (crash) or possibly execute arbitrary code via a crafted DNS response that triggers a call to the getaddrinfo function with the AF_UNSPEC or AF_INET6 address family, related to performing "dual A/AAAA DNS queries" and the libnss_dns.so.2 NSS module.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-2632Mediumicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u95, 7u80, and 8u45 allows remote attackers to affect confidentiality via unknown vectors related to 2D.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-8382Mediumpcre3:2:8.35-3.3The match function in pcre_exec.c in PCRE before 8.37 mishandles the /(?:((abcd))|(((?:(?:(?:(?:abc|(?:abcdef))))b)abcdefghi)abc)|((*ACCEPT)))/ pattern and related patterns involving (*ACCEPT), which allows remote attackers to obtain sensitive information from process memory or cause a denial of service (partially initialized memory and application crash) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-2547.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-8393Mediumpcre3:2:8.35-3.3pcregrep in PCRE before 8.38 mishandles the -q option for binary files, which might allow remote attackers to obtain sensitive information via a crafted file, as demonstrated by a CGI script that sends stdout data to a client.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2016-0777Mediumopenssh:1:6.7p1-5The resend_bytes function in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2 allows remote servers to obtain sensitive information from process memory by requesting transmission of an entire buffer, as demonstrated by reading a private key.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2016-0778Mediumopenssh:1:6.7p1-5The (1) roaming_read and (2) roaming_write functions in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2, when certain proxy and forward options are enabled, do not properly maintain connection file descriptors, which allows remote servers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact by requesting many forwardings.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2016-3115Mediumopenssh:1:6.7p1-5Multiple CRLF injection vulnerabilities in session.c in sshd in OpenSSH before 7.2p2 allow remote authenticated users to bypass intended shell-command restrictions via crafted X11 forwarding data, related to the (1) do_authenticated1 and (2) session_x11_req functions.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-5352Mediumopenssh:1:6.7p1-5The x11_open_helper function in channels.c in ssh in OpenSSH before 6.9, when ForwardX11Trusted mode is not used, lacks a check of the refusal deadline for X connections, which makes it easier for remote attackers to bypass intended access restrictions via a connection outside of the permitted time window.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-6564Mediumopenssh:1:6.7p1-5Use-after-free vulnerability in the mm_answer_pam_free_ctx function in monitor.c in sshd in OpenSSH before 7.0 on non-OpenBSD platforms might allow local users to gain privileges by leveraging control of the sshd uid to send an unexpectedly early MONITOR_REQ_PAM_FREE_CTX request.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-8631Mediumkrb5:1.12.1+dfsg-19+deb8u1Multiple memory leaks in kadmin/server/server_stubs.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (memory consumption) via a request specifying a NULL principal name.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-2694Mediumkrb5:1.12.1+dfsg-19+deb8u1The kdcpreauth modules in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.2 do not properly track whether a client's request has been validated, which allows remote attackers to bypass an intended preauthentication requirement by providing (1) zero bytes of data or (2) an arbitrary realm name, related to plugins/preauth/otp/main.c and plugins/preauth/pkinit/pkinit_srv.c.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-8630Mediumkrb5:1.12.1+dfsg-19+deb8u1The (1) kadm5_create_principal_3 and (2) kadm5_modify_principal functions in lib/kadm5/srv/svr_principal.c in kadmind in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) by specifying KADM5_POLICY with a NULL policy name.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2011-3389Mediumgnutls28:3.3.8-6+deb8u3The SSL protocol, as used in certain configurations in Microsoft Windows and Microsoft Internet Explorer, Mozilla Firefox, Google Chrome, Opera, and other products, encrypts data by using CBC mode with chained initialization vectors, which allows man-in-the-middle attackers to obtain plaintext HTTP headers via a blockwise chosen-boundary attack (BCBA) on an HTTPS session, in conjunction with JavaScript code that uses (1) the HTML5 WebSocket API, (2) the Java URLConnection API, or (3) the Silverlight WebClient API, aka a "BEAST" attack.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2016-1978Mediumnss:2:3.17.2-1.1+deb8u2Use-after-free vulnerability in the ssl3_HandleECDHServerKeyExchange function in Mozilla Network Security Services (NSS) before 3.21, as used in Mozilla Firefox before 44.0, allows remote attackers to cause a denial of service or possibly have unspecified other impact by making an SSL (1) DHE or (2) ECDHE handshake at a time of high memory consumption.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2016-1979Mediumnss:2:3.17.2-1.1+deb8u2Use-after-free vulnerability in the PK11_ImportDERPrivateKeyInfoAndReturnKey function in Mozilla Network Security Services (NSS) before 3.21.1, as used in Mozilla Firefox before 45.0, allows remote attackers to cause a denial of service or possibly have unspecified other impact via crafted key data with DER encoding.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-4000Mediumnss:2:3.17.2-1.1+deb8u2The TLS protocol 1.2 and earlier, when a DHE_EXPORT ciphersuite is enabled on a server but not on a client, does not properly convey a DHE_EXPORT choice, which allows man-in-the-middle attackers to conduct cipher-downgrade attacks by rewriting a ClientHello with DHE replaced by DHE_EXPORT and then rewriting a ServerHello with DHE_EXPORT replaced by DHE, aka the "Logjam" issue.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-7575Mediumnss:2:3.17.2-1.1+deb8u2Mozilla Network Security Services (NSS) before 3.20.2, as used in Mozilla Firefox before 43.0.2 and Firefox ESR 38.x before 38.5.2, does not reject MD5 signatures in Server Key Exchange messages in TLS 1.2 Handshake Protocol traffic, which makes it easier for man-in-the-middle attackers to spoof servers by triggering a collision.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2016-1950Mediumnss:2:3.17.2-1.1+deb8u2Heap-based buffer overflow in Mozilla Network Security Services (NSS) before 3.19.2.3 and 3.20.x and 3.21.x before 3.21.1, as used in Mozilla Firefox before 45.0 and Firefox ESR 38.x before 38.7, allows remote attackers to execute arbitrary code via crafted ASN.1 data in an X.509 certificate.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2016-1938Mediumnss:2:3.17.2-1.1+deb8u2The s_mp_div function in lib/freebl/mpi/mpi.c in Mozilla Network Security Services (NSS) before 3.21, as used in Mozilla Firefox before 44.0, improperly divides numbers, which might make it easier for remote attackers to defeat cryptographic protection mechanisms by leveraging use of the (1) mp_div or (2) mp_exptmod function.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2016-0755Mediumcurl:7.38.0-4+deb8u2The ConnectionExists function in lib/url.c in libcurl before 7.47.0 does not properly re-use NTLM-authenticated proxy connections, which might allow remote attackers to authenticate as other users via a request, a similar issue to CVE-2014-0015.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-2632Mediumicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u95, 7u80, and 8u45 allows remote attackers to affect confidentiality via unknown vectors related to 2D.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2016-0777Mediumopenssh:1:6.7p1-5The resend_bytes function in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2 allows remote servers to obtain sensitive information from process memory by requesting transmission of an entire buffer, as demonstrated by reading a private key.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2016-0778Mediumopenssh:1:6.7p1-5The (1) roaming_read and (2) roaming_write functions in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2, when certain proxy and forward options are enabled, do not properly maintain connection file descriptors, which allows remote servers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact by requesting many forwardings.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2016-3115Mediumopenssh:1:6.7p1-5Multiple CRLF injection vulnerabilities in session.c in sshd in OpenSSH before 7.2p2 allow remote authenticated users to bypass intended shell-command restrictions via crafted X11 forwarding data, related to the (1) do_authenticated1 and (2) session_x11_req functions.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-5352Mediumopenssh:1:6.7p1-5The x11_open_helper function in channels.c in ssh in OpenSSH before 6.9, when ForwardX11Trusted mode is not used, lacks a check of the refusal deadline for X connections, which makes it easier for remote attackers to bypass intended access restrictions via a connection outside of the permitted time window.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-6564Mediumopenssh:1:6.7p1-5Use-after-free vulnerability in the mm_answer_pam_free_ctx function in monitor.c in sshd in OpenSSH before 7.0 on non-OpenBSD platforms might allow local users to gain privileges by leveraging control of the sshd uid to send an unexpectedly early MONITOR_REQ_PAM_FREE_CTX request.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-3238Mediumpam:1.1.8-3.1The _unix_run_helper_binary function in the pam_unix module in Linux-PAM (aka pam) before 1.2.1, when unable to directly access passwords, allows local users to enumerate usernames or cause a denial of service (hang) via a large password.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2016-0797Mediumopenssl:1.0.1k-3+deb8u2Multiple integer overflows in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allow remote attackers to cause a denial of service (heap memory corruption or NULL pointer dereference) or possibly have unspecified other impact via a long digit string that is mishandled by the (1) BN_dec2bn or (2) BN_hex2bn function, related to crypto/bn/bn.h and crypto/bn/bn_print.c.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2014-8121Mediumglibc:2.19-18+deb8u1DB_LOOKUP in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) 2.21 and earlier does not properly check if a file is open, which allows remote attackers to cause a denial of service (infinite loop) by performing a look-up while the database is iterated over the database, which triggers the file pointer to be reset.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-7547Mediumglibc:2.19-18+deb8u1Multiple stack-based buffer overflows in the (1) send_dg and (2) send_vc functions in the libresolv library in the GNU C Library (aka glibc or libc6) before 2.23 allow remote attackers to cause a denial of service (crash) or possibly execute arbitrary code via a crafted DNS response that triggers a call to the getaddrinfo function with the AF_UNSPEC or AF_INET6 address family, related to performing "dual A/AAAA DNS queries" and the libnss_dns.so.2 NSS module.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2016-0755Mediumcurl:7.38.0-4+deb8u2The ConnectionExists function in lib/url.c in libcurl before 7.47.0 does not properly re-use NTLM-authenticated proxy connections, which might allow remote attackers to authenticate as other users via a request, a similar issue to CVE-2014-0015.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-8767Mediumlinux:3.16.7-ckt20-1+deb8u2net/sctp/sm_sideeffect.c in the Linux kernel before 4.3 does not properly manage the relationship between a lock and a socket, which allows local users to cause a denial of service (deadlock) via a crafted sctp_accept call.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-7566Mediumlinux:3.16.7-ckt20-1+deb8u2The clie_5_attach function in drivers/usb/serial/visor.c in the Linux kernel through 4.4.1 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact by inserting a USB device that lacks a bulk-out endpoint.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2013-4312Mediumlinux:3.16.7-ckt20-1+deb8u2The Linux kernel before 4.4.1 allows local users to bypass file-descriptor limits and cause a denial of service (memory consumption) by sending each descriptor over a UNIX socket before closing it, related to net/unix/af_unix.c and net/unix/garbage.c.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-8785Mediumlinux:3.16.7-ckt20-1+deb8u2The fuse_fill_write_pages function in fs/fuse/file.c in the Linux kernel before 4.4 allows local users to cause a denial of service (infinite loop) via a writev system call that triggers a zero length for the first segment of an iov.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2016-0723Mediumlinux:3.16.7-ckt20-1+deb8u2Race condition in the tty_ioctl function in drivers/tty/tty_io.c in the Linux kernel through 4.4.1 allows local users to obtain sensitive information from kernel memory or cause a denial of service (use-after-free and system crash) by making a TIOCGETD ioctl call during processing of a TIOCSETD ioctl call.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2016-0821Mediumlinux:3.16.7-ckt20-1+deb8u2The LIST_POISON feature in include/linux/poison.h in the Linux kernel before 4.3, as used in Android 6.0.1 before 2016-03-01, does not properly consider the relationship to the mmap_min_addr value, which makes it easier for attackers to bypass a poison-pointer protection mechanism by triggering the use of an uninitialized list entry, aka Android internal bug 26186802, a different vulnerability than CVE-2015-3636.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-5276Mediumgcc-4.9:4.9.2-10The std::random_device class in libstdc++ in the GNU Compiler Collection (aka GCC) before 4.9.4 does not properly handle short reads from blocking sources, which makes it easier for context-dependent attackers to predict the random values via unspecified vectors.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2016-1978Mediumnss:2:3.17.2-1.1+deb8u2Use-after-free vulnerability in the ssl3_HandleECDHServerKeyExchange function in Mozilla Network Security Services (NSS) before 3.21, as used in Mozilla Firefox before 44.0, allows remote attackers to cause a denial of service or possibly have unspecified other impact by making an SSL (1) DHE or (2) ECDHE handshake at a time of high memory consumption.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2016-1979Mediumnss:2:3.17.2-1.1+deb8u2Use-after-free vulnerability in the PK11_ImportDERPrivateKeyInfoAndReturnKey function in Mozilla Network Security Services (NSS) before 3.21.1, as used in Mozilla Firefox before 45.0, allows remote attackers to cause a denial of service or possibly have unspecified other impact via crafted key data with DER encoding.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-4000Mediumnss:2:3.17.2-1.1+deb8u2The TLS protocol 1.2 and earlier, when a DHE_EXPORT ciphersuite is enabled on a server but not on a client, does not properly convey a DHE_EXPORT choice, which allows man-in-the-middle attackers to conduct cipher-downgrade attacks by rewriting a ClientHello with DHE replaced by DHE_EXPORT and then rewriting a ServerHello with DHE_EXPORT replaced by DHE, aka the "Logjam" issue.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-7575Mediumnss:2:3.17.2-1.1+deb8u2Mozilla Network Security Services (NSS) before 3.20.2, as used in Mozilla Firefox before 43.0.2 and Firefox ESR 38.x before 38.5.2, does not reject MD5 signatures in Server Key Exchange messages in TLS 1.2 Handshake Protocol traffic, which makes it easier for man-in-the-middle attackers to spoof servers by triggering a collision.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2016-1950Mediumnss:2:3.17.2-1.1+deb8u2Heap-based buffer overflow in Mozilla Network Security Services (NSS) before 3.19.2.3 and 3.20.x and 3.21.x before 3.21.1, as used in Mozilla Firefox before 45.0 and Firefox ESR 38.x before 38.7, allows remote attackers to execute arbitrary code via crafted ASN.1 data in an X.509 certificate.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2016-1938Mediumnss:2:3.17.2-1.1+deb8u2The s_mp_div function in lib/freebl/mpi/mpi.c in Mozilla Network Security Services (NSS) before 3.21, as used in Mozilla Firefox before 44.0, improperly divides numbers, which might make it easier for remote attackers to defeat cryptographic protection mechanisms by leveraging use of the (1) mp_div or (2) mp_exptmod function.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-8382Mediumpcre3:2:8.35-3.3The match function in pcre_exec.c in PCRE before 8.37 mishandles the /(?:((abcd))|(((?:(?:(?:(?:abc|(?:abcdef))))b)abcdefghi)abc)|((*ACCEPT)))/ pattern and related patterns involving (*ACCEPT), which allows remote attackers to obtain sensitive information from process memory or cause a denial of service (partially initialized memory and application crash) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-2547.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-8393Mediumpcre3:2:8.35-3.3pcregrep in PCRE before 8.38 mishandles the -q option for binary files, which might allow remote attackers to obtain sensitive information via a crafted file, as demonstrated by a CGI script that sends stdout data to a client.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-8631Mediumkrb5:1.12.1+dfsg-19+deb8u1Multiple memory leaks in kadmin/server/server_stubs.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (memory consumption) via a request specifying a NULL principal name.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-2694Mediumkrb5:1.12.1+dfsg-19+deb8u1The kdcpreauth modules in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.2 do not properly track whether a client's request has been validated, which allows remote attackers to bypass an intended preauthentication requirement by providing (1) zero bytes of data or (2) an arbitrary realm name, related to plugins/preauth/otp/main.c and plugins/preauth/pkinit/pkinit_srv.c.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-8630Mediumkrb5:1.12.1+dfsg-19+deb8u1The (1) kadm5_create_principal_3 and (2) kadm5_modify_principal functions in lib/kadm5/srv/svr_principal.c in kadmind in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) by specifying KADM5_POLICY with a NULL policy name.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2011-3389Mediumgnutls28:3.3.8-6+deb8u3The SSL protocol, as used in certain configurations in Microsoft Windows and Microsoft Internet Explorer, Mozilla Firefox, Google Chrome, Opera, and other products, encrypts data by using CBC mode with chained initialization vectors, which allows man-in-the-middle attackers to obtain plaintext HTTP headers via a blockwise chosen-boundary attack (BCBA) on an HTTPS session, in conjunction with JavaScript code that uses (1) the HTML5 WebSocket API, (2) the Java URLConnection API, or (3) the Silverlight WebClient API, aka a "BEAST" attack.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-8767Mediumlinux:3.16.7-ckt20-1+deb8u2net/sctp/sm_sideeffect.c in the Linux kernel before 4.3 does not properly manage the relationship between a lock and a socket, which allows local users to cause a denial of service (deadlock) via a crafted sctp_accept call.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-7566Mediumlinux:3.16.7-ckt20-1+deb8u2The clie_5_attach function in drivers/usb/serial/visor.c in the Linux kernel through 4.4.1 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact by inserting a USB device that lacks a bulk-out endpoint.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2013-4312Mediumlinux:3.16.7-ckt20-1+deb8u2The Linux kernel before 4.4.1 allows local users to bypass file-descriptor limits and cause a denial of service (memory consumption) by sending each descriptor over a UNIX socket before closing it, related to net/unix/af_unix.c and net/unix/garbage.c.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-8785Mediumlinux:3.16.7-ckt20-1+deb8u2The fuse_fill_write_pages function in fs/fuse/file.c in the Linux kernel before 4.4 allows local users to cause a denial of service (infinite loop) via a writev system call that triggers a zero length for the first segment of an iov.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2016-0723Mediumlinux:3.16.7-ckt20-1+deb8u2Race condition in the tty_ioctl function in drivers/tty/tty_io.c in the Linux kernel through 4.4.1 allows local users to obtain sensitive information from kernel memory or cause a denial of service (use-after-free and system crash) by making a TIOCGETD ioctl call during processing of a TIOCSETD ioctl call.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2016-0821Mediumlinux:3.16.7-ckt20-1+deb8u2The LIST_POISON feature in include/linux/poison.h in the Linux kernel before 4.3, as used in Android 6.0.1 before 2016-03-01, does not properly consider the relationship to the mmap_min_addr value, which makes it easier for attackers to bypass a poison-pointer protection mechanism by triggering the use of an uninitialized list entry, aka Android internal bug 26186802, a different vulnerability than CVE-2015-3636.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-3238Mediumpam:1.1.8-3.1The _unix_run_helper_binary function in the pam_unix module in Linux-PAM (aka pam) before 1.2.1, when unable to directly access passwords, allows local users to enumerate usernames or cause a denial of service (hang) via a large password.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2016-0777Mediumopenssh:1:6.7p1-5The resend_bytes function in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2 allows remote servers to obtain sensitive information from process memory by requesting transmission of an entire buffer, as demonstrated by reading a private key.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2016-0778Mediumopenssh:1:6.7p1-5The (1) roaming_read and (2) roaming_write functions in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2, when certain proxy and forward options are enabled, do not properly maintain connection file descriptors, which allows remote servers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact by requesting many forwardings.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2016-3115Mediumopenssh:1:6.7p1-5Multiple CRLF injection vulnerabilities in session.c in sshd in OpenSSH before 7.2p2 allow remote authenticated users to bypass intended shell-command restrictions via crafted X11 forwarding data, related to the (1) do_authenticated1 and (2) session_x11_req functions.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-5352Mediumopenssh:1:6.7p1-5The x11_open_helper function in channels.c in ssh in OpenSSH before 6.9, when ForwardX11Trusted mode is not used, lacks a check of the refusal deadline for X connections, which makes it easier for remote attackers to bypass intended access restrictions via a connection outside of the permitted time window.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-6564Mediumopenssh:1:6.7p1-5Use-after-free vulnerability in the mm_answer_pam_free_ctx function in monitor.c in sshd in OpenSSH before 7.0 on non-OpenBSD platforms might allow local users to gain privileges by leveraging control of the sshd uid to send an unexpectedly early MONITOR_REQ_PAM_FREE_CTX request.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-2632Mediumicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u95, 7u80, and 8u45 allows remote attackers to affect confidentiality via unknown vectors related to 2D.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2016-1978Mediumnss:2:3.17.2-1.1+deb8u2Use-after-free vulnerability in the ssl3_HandleECDHServerKeyExchange function in Mozilla Network Security Services (NSS) before 3.21, as used in Mozilla Firefox before 44.0, allows remote attackers to cause a denial of service or possibly have unspecified other impact by making an SSL (1) DHE or (2) ECDHE handshake at a time of high memory consumption.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2016-1979Mediumnss:2:3.17.2-1.1+deb8u2Use-after-free vulnerability in the PK11_ImportDERPrivateKeyInfoAndReturnKey function in Mozilla Network Security Services (NSS) before 3.21.1, as used in Mozilla Firefox before 45.0, allows remote attackers to cause a denial of service or possibly have unspecified other impact via crafted key data with DER encoding.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-4000Mediumnss:2:3.17.2-1.1+deb8u2The TLS protocol 1.2 and earlier, when a DHE_EXPORT ciphersuite is enabled on a server but not on a client, does not properly convey a DHE_EXPORT choice, which allows man-in-the-middle attackers to conduct cipher-downgrade attacks by rewriting a ClientHello with DHE replaced by DHE_EXPORT and then rewriting a ServerHello with DHE_EXPORT replaced by DHE, aka the "Logjam" issue.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-7575Mediumnss:2:3.17.2-1.1+deb8u2Mozilla Network Security Services (NSS) before 3.20.2, as used in Mozilla Firefox before 43.0.2 and Firefox ESR 38.x before 38.5.2, does not reject MD5 signatures in Server Key Exchange messages in TLS 1.2 Handshake Protocol traffic, which makes it easier for man-in-the-middle attackers to spoof servers by triggering a collision.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2016-1950Mediumnss:2:3.17.2-1.1+deb8u2Heap-based buffer overflow in Mozilla Network Security Services (NSS) before 3.19.2.3 and 3.20.x and 3.21.x before 3.21.1, as used in Mozilla Firefox before 45.0 and Firefox ESR 38.x before 38.7, allows remote attackers to execute arbitrary code via crafted ASN.1 data in an X.509 certificate.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2016-1938Mediumnss:2:3.17.2-1.1+deb8u2The s_mp_div function in lib/freebl/mpi/mpi.c in Mozilla Network Security Services (NSS) before 3.21, as used in Mozilla Firefox before 44.0, improperly divides numbers, which might make it easier for remote attackers to defeat cryptographic protection mechanisms by leveraging use of the (1) mp_div or (2) mp_exptmod function.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2014-8121Mediumglibc:2.19-18+deb8u1DB_LOOKUP in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) 2.21 and earlier does not properly check if a file is open, which allows remote attackers to cause a denial of service (infinite loop) by performing a look-up while the database is iterated over the database, which triggers the file pointer to be reset.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-7547Mediumglibc:2.19-18+deb8u1Multiple stack-based buffer overflows in the (1) send_dg and (2) send_vc functions in the libresolv library in the GNU C Library (aka glibc or libc6) before 2.23 allow remote attackers to cause a denial of service (crash) or possibly execute arbitrary code via a crafted DNS response that triggers a call to the getaddrinfo function with the AF_UNSPEC or AF_INET6 address family, related to performing "dual A/AAAA DNS queries" and the libnss_dns.so.2 NSS module.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2011-3389Mediumgnutls28:3.3.8-6+deb8u3The SSL protocol, as used in certain configurations in Microsoft Windows and Microsoft Internet Explorer, Mozilla Firefox, Google Chrome, Opera, and other products, encrypts data by using CBC mode with chained initialization vectors, which allows man-in-the-middle attackers to obtain plaintext HTTP headers via a blockwise chosen-boundary attack (BCBA) on an HTTPS session, in conjunction with JavaScript code that uses (1) the HTML5 WebSocket API, (2) the Java URLConnection API, or (3) the Silverlight WebClient API, aka a "BEAST" attack.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2016-0755Mediumcurl:7.38.0-4+deb8u2The ConnectionExists function in lib/url.c in libcurl before 7.47.0 does not properly re-use NTLM-authenticated proxy connections, which might allow remote attackers to authenticate as other users via a request, a similar issue to CVE-2014-0015.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-8382Mediumpcre3:2:8.35-3.3The match function in pcre_exec.c in PCRE before 8.37 mishandles the /(?:((abcd))|(((?:(?:(?:(?:abc|(?:abcdef))))b)abcdefghi)abc)|((*ACCEPT)))/ pattern and related patterns involving (*ACCEPT), which allows remote attackers to obtain sensitive information from process memory or cause a denial of service (partially initialized memory and application crash) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-2547.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-8393Mediumpcre3:2:8.35-3.3pcregrep in PCRE before 8.38 mishandles the -q option for binary files, which might allow remote attackers to obtain sensitive information via a crafted file, as demonstrated by a CGI script that sends stdout data to a client.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-5276Mediumgcc-4.9:4.9.2-10The std::random_device class in libstdc++ in the GNU Compiler Collection (aka GCC) before 4.9.4 does not properly handle short reads from blocking sources, which makes it easier for context-dependent attackers to predict the random values via unspecified vectors.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-8631Mediumkrb5:1.12.1+dfsg-19+deb8u1Multiple memory leaks in kadmin/server/server_stubs.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (memory consumption) via a request specifying a NULL principal name.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-2694Mediumkrb5:1.12.1+dfsg-19+deb8u1The kdcpreauth modules in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.2 do not properly track whether a client's request has been validated, which allows remote attackers to bypass an intended preauthentication requirement by providing (1) zero bytes of data or (2) an arbitrary realm name, related to plugins/preauth/otp/main.c and plugins/preauth/pkinit/pkinit_srv.c.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-8630Mediumkrb5:1.12.1+dfsg-19+deb8u1The (1) kadm5_create_principal_3 and (2) kadm5_modify_principal functions in lib/kadm5/srv/svr_principal.c in kadmind in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) by specifying KADM5_POLICY with a NULL policy name.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2016-0797Mediumopenssl:1.0.1k-3+deb8u2Multiple integer overflows in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allow remote attackers to cause a denial of service (heap memory corruption or NULL pointer dereference) or possibly have unspecified other impact via a long digit string that is mishandled by the (1) BN_dec2bn or (2) BN_hex2bn function, related to crypto/bn/bn.h and crypto/bn/bn_print.c.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-2632Mediumicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u95, 7u80, and 8u45 allows remote attackers to affect confidentiality via unknown vectors related to 2D.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2011-3389Mediumgnutls28:3.3.8-6+deb8u3The SSL protocol, as used in certain configurations in Microsoft Windows and Microsoft Internet Explorer, Mozilla Firefox, Google Chrome, Opera, and other products, encrypts data by using CBC mode with chained initialization vectors, which allows man-in-the-middle attackers to obtain plaintext HTTP headers via a blockwise chosen-boundary attack (BCBA) on an HTTPS session, in conjunction with JavaScript code that uses (1) the HTML5 WebSocket API, (2) the Java URLConnection API, or (3) the Silverlight WebClient API, aka a "BEAST" attack.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2016-1978Mediumnss:2:3.17.2-1.1+deb8u2Use-after-free vulnerability in the ssl3_HandleECDHServerKeyExchange function in Mozilla Network Security Services (NSS) before 3.21, as used in Mozilla Firefox before 44.0, allows remote attackers to cause a denial of service or possibly have unspecified other impact by making an SSL (1) DHE or (2) ECDHE handshake at a time of high memory consumption.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2016-1979Mediumnss:2:3.17.2-1.1+deb8u2Use-after-free vulnerability in the PK11_ImportDERPrivateKeyInfoAndReturnKey function in Mozilla Network Security Services (NSS) before 3.21.1, as used in Mozilla Firefox before 45.0, allows remote attackers to cause a denial of service or possibly have unspecified other impact via crafted key data with DER encoding.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-4000Mediumnss:2:3.17.2-1.1+deb8u2The TLS protocol 1.2 and earlier, when a DHE_EXPORT ciphersuite is enabled on a server but not on a client, does not properly convey a DHE_EXPORT choice, which allows man-in-the-middle attackers to conduct cipher-downgrade attacks by rewriting a ClientHello with DHE replaced by DHE_EXPORT and then rewriting a ServerHello with DHE_EXPORT replaced by DHE, aka the "Logjam" issue.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-7575Mediumnss:2:3.17.2-1.1+deb8u2Mozilla Network Security Services (NSS) before 3.20.2, as used in Mozilla Firefox before 43.0.2 and Firefox ESR 38.x before 38.5.2, does not reject MD5 signatures in Server Key Exchange messages in TLS 1.2 Handshake Protocol traffic, which makes it easier for man-in-the-middle attackers to spoof servers by triggering a collision.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2016-1950Mediumnss:2:3.17.2-1.1+deb8u2Heap-based buffer overflow in Mozilla Network Security Services (NSS) before 3.19.2.3 and 3.20.x and 3.21.x before 3.21.1, as used in Mozilla Firefox before 45.0 and Firefox ESR 38.x before 38.7, allows remote attackers to execute arbitrary code via crafted ASN.1 data in an X.509 certificate.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2016-1938Mediumnss:2:3.17.2-1.1+deb8u2The s_mp_div function in lib/freebl/mpi/mpi.c in Mozilla Network Security Services (NSS) before 3.21, as used in Mozilla Firefox before 44.0, improperly divides numbers, which might make it easier for remote attackers to defeat cryptographic protection mechanisms by leveraging use of the (1) mp_div or (2) mp_exptmod function.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-8382Mediumpcre3:2:8.35-3.3The match function in pcre_exec.c in PCRE before 8.37 mishandles the /(?:((abcd))|(((?:(?:(?:(?:abc|(?:abcdef))))b)abcdefghi)abc)|((*ACCEPT)))/ pattern and related patterns involving (*ACCEPT), which allows remote attackers to obtain sensitive information from process memory or cause a denial of service (partially initialized memory and application crash) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-2547.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-8393Mediumpcre3:2:8.35-3.3pcregrep in PCRE before 8.38 mishandles the -q option for binary files, which might allow remote attackers to obtain sensitive information via a crafted file, as demonstrated by a CGI script that sends stdout data to a client.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-8767Mediumlinux:3.16.7-ckt20-1+deb8u2net/sctp/sm_sideeffect.c in the Linux kernel before 4.3 does not properly manage the relationship between a lock and a socket, which allows local users to cause a denial of service (deadlock) via a crafted sctp_accept call.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-7566Mediumlinux:3.16.7-ckt20-1+deb8u2The clie_5_attach function in drivers/usb/serial/visor.c in the Linux kernel through 4.4.1 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact by inserting a USB device that lacks a bulk-out endpoint.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2013-4312Mediumlinux:3.16.7-ckt20-1+deb8u2The Linux kernel before 4.4.1 allows local users to bypass file-descriptor limits and cause a denial of service (memory consumption) by sending each descriptor over a UNIX socket before closing it, related to net/unix/af_unix.c and net/unix/garbage.c.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-8785Mediumlinux:3.16.7-ckt20-1+deb8u2The fuse_fill_write_pages function in fs/fuse/file.c in the Linux kernel before 4.4 allows local users to cause a denial of service (infinite loop) via a writev system call that triggers a zero length for the first segment of an iov.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2016-0723Mediumlinux:3.16.7-ckt20-1+deb8u2Race condition in the tty_ioctl function in drivers/tty/tty_io.c in the Linux kernel through 4.4.1 allows local users to obtain sensitive information from kernel memory or cause a denial of service (use-after-free and system crash) by making a TIOCGETD ioctl call during processing of a TIOCSETD ioctl call.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2016-0821Mediumlinux:3.16.7-ckt20-1+deb8u2The LIST_POISON feature in include/linux/poison.h in the Linux kernel before 4.3, as used in Android 6.0.1 before 2016-03-01, does not properly consider the relationship to the mmap_min_addr value, which makes it easier for attackers to bypass a poison-pointer protection mechanism by triggering the use of an uninitialized list entry, aka Android internal bug 26186802, a different vulnerability than CVE-2015-3636.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-3238Mediumpam:1.1.8-3.1The _unix_run_helper_binary function in the pam_unix module in Linux-PAM (aka pam) before 1.2.1, when unable to directly access passwords, allows local users to enumerate usernames or cause a denial of service (hang) via a large password.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-5276Mediumgcc-4.9:4.9.2-10The std::random_device class in libstdc++ in the GNU Compiler Collection (aka GCC) before 4.9.4 does not properly handle short reads from blocking sources, which makes it easier for context-dependent attackers to predict the random values via unspecified vectors.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2016-0755Mediumcurl:7.38.0-4+deb8u2The ConnectionExists function in lib/url.c in libcurl before 7.47.0 does not properly re-use NTLM-authenticated proxy connections, which might allow remote attackers to authenticate as other users via a request, a similar issue to CVE-2014-0015.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-8631Mediumkrb5:1.12.1+dfsg-19+deb8u1Multiple memory leaks in kadmin/server/server_stubs.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (memory consumption) via a request specifying a NULL principal name.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-2694Mediumkrb5:1.12.1+dfsg-19+deb8u1The kdcpreauth modules in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.2 do not properly track whether a client's request has been validated, which allows remote attackers to bypass an intended preauthentication requirement by providing (1) zero bytes of data or (2) an arbitrary realm name, related to plugins/preauth/otp/main.c and plugins/preauth/pkinit/pkinit_srv.c.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-8630Mediumkrb5:1.12.1+dfsg-19+deb8u1The (1) kadm5_create_principal_3 and (2) kadm5_modify_principal functions in lib/kadm5/srv/svr_principal.c in kadmind in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) by specifying KADM5_POLICY with a NULL policy name.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2014-8121Mediumglibc:2.19-18+deb8u1DB_LOOKUP in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) 2.21 and earlier does not properly check if a file is open, which allows remote attackers to cause a denial of service (infinite loop) by performing a look-up while the database is iterated over the database, which triggers the file pointer to be reset.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-7547Mediumglibc:2.19-18+deb8u1Multiple stack-based buffer overflows in the (1) send_dg and (2) send_vc functions in the libresolv library in the GNU C Library (aka glibc or libc6) before 2.23 allow remote attackers to cause a denial of service (crash) or possibly execute arbitrary code via a crafted DNS response that triggers a call to the getaddrinfo function with the AF_UNSPEC or AF_INET6 address family, related to performing "dual A/AAAA DNS queries" and the libnss_dns.so.2 NSS module.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2016-0777Mediumopenssh:1:6.7p1-5The resend_bytes function in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2 allows remote servers to obtain sensitive information from process memory by requesting transmission of an entire buffer, as demonstrated by reading a private key.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2016-0778Mediumopenssh:1:6.7p1-5The (1) roaming_read and (2) roaming_write functions in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2, when certain proxy and forward options are enabled, do not properly maintain connection file descriptors, which allows remote servers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact by requesting many forwardings.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2016-3115Mediumopenssh:1:6.7p1-5Multiple CRLF injection vulnerabilities in session.c in sshd in OpenSSH before 7.2p2 allow remote authenticated users to bypass intended shell-command restrictions via crafted X11 forwarding data, related to the (1) do_authenticated1 and (2) session_x11_req functions.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-5352Mediumopenssh:1:6.7p1-5The x11_open_helper function in channels.c in ssh in OpenSSH before 6.9, when ForwardX11Trusted mode is not used, lacks a check of the refusal deadline for X connections, which makes it easier for remote attackers to bypass intended access restrictions via a connection outside of the permitted time window.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-6564Mediumopenssh:1:6.7p1-5Use-after-free vulnerability in the mm_answer_pam_free_ctx function in monitor.c in sshd in OpenSSH before 7.0 on non-OpenBSD platforms might allow local users to gain privileges by leveraging control of the sshd uid to send an unexpectedly early MONITOR_REQ_PAM_FREE_CTX request.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2016-0797Mediumopenssl:1.0.1k-3+deb8u2Multiple integer overflows in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allow remote attackers to cause a denial of service (heap memory corruption or NULL pointer dereference) or possibly have unspecified other impact via a long digit string that is mishandled by the (1) BN_dec2bn or (2) BN_hex2bn function, related to crypto/bn/bn.h and crypto/bn/bn_print.c.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2016-1978Mediumnss:2:3.17.2-1.1+deb8u2Use-after-free vulnerability in the ssl3_HandleECDHServerKeyExchange function in Mozilla Network Security Services (NSS) before 3.21, as used in Mozilla Firefox before 44.0, allows remote attackers to cause a denial of service or possibly have unspecified other impact by making an SSL (1) DHE or (2) ECDHE handshake at a time of high memory consumption.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2016-1979Mediumnss:2:3.17.2-1.1+deb8u2Use-after-free vulnerability in the PK11_ImportDERPrivateKeyInfoAndReturnKey function in Mozilla Network Security Services (NSS) before 3.21.1, as used in Mozilla Firefox before 45.0, allows remote attackers to cause a denial of service or possibly have unspecified other impact via crafted key data with DER encoding.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-4000Mediumnss:2:3.17.2-1.1+deb8u2The TLS protocol 1.2 and earlier, when a DHE_EXPORT ciphersuite is enabled on a server but not on a client, does not properly convey a DHE_EXPORT choice, which allows man-in-the-middle attackers to conduct cipher-downgrade attacks by rewriting a ClientHello with DHE replaced by DHE_EXPORT and then rewriting a ServerHello with DHE_EXPORT replaced by DHE, aka the "Logjam" issue.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-7575Mediumnss:2:3.17.2-1.1+deb8u2Mozilla Network Security Services (NSS) before 3.20.2, as used in Mozilla Firefox before 43.0.2 and Firefox ESR 38.x before 38.5.2, does not reject MD5 signatures in Server Key Exchange messages in TLS 1.2 Handshake Protocol traffic, which makes it easier for man-in-the-middle attackers to spoof servers by triggering a collision.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2016-1950Mediumnss:2:3.17.2-1.1+deb8u2Heap-based buffer overflow in Mozilla Network Security Services (NSS) before 3.19.2.3 and 3.20.x and 3.21.x before 3.21.1, as used in Mozilla Firefox before 45.0 and Firefox ESR 38.x before 38.7, allows remote attackers to execute arbitrary code via crafted ASN.1 data in an X.509 certificate.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2016-1938Mediumnss:2:3.17.2-1.1+deb8u2The s_mp_div function in lib/freebl/mpi/mpi.c in Mozilla Network Security Services (NSS) before 3.21, as used in Mozilla Firefox before 44.0, improperly divides numbers, which might make it easier for remote attackers to defeat cryptographic protection mechanisms by leveraging use of the (1) mp_div or (2) mp_exptmod function.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2014-8121Mediumglibc:2.19-18+deb8u1DB_LOOKUP in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) 2.21 and earlier does not properly check if a file is open, which allows remote attackers to cause a denial of service (infinite loop) by performing a look-up while the database is iterated over the database, which triggers the file pointer to be reset.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-7547Mediumglibc:2.19-18+deb8u1Multiple stack-based buffer overflows in the (1) send_dg and (2) send_vc functions in the libresolv library in the GNU C Library (aka glibc or libc6) before 2.23 allow remote attackers to cause a denial of service (crash) or possibly execute arbitrary code via a crafted DNS response that triggers a call to the getaddrinfo function with the AF_UNSPEC or AF_INET6 address family, related to performing "dual A/AAAA DNS queries" and the libnss_dns.so.2 NSS module.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2016-0797Mediumopenssl:1.0.1k-3+deb8u2Multiple integer overflows in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allow remote attackers to cause a denial of service (heap memory corruption or NULL pointer dereference) or possibly have unspecified other impact via a long digit string that is mishandled by the (1) BN_dec2bn or (2) BN_hex2bn function, related to crypto/bn/bn.h and crypto/bn/bn_print.c.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-8631Mediumkrb5:1.12.1+dfsg-19+deb8u1Multiple memory leaks in kadmin/server/server_stubs.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (memory consumption) via a request specifying a NULL principal name.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-2694Mediumkrb5:1.12.1+dfsg-19+deb8u1The kdcpreauth modules in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.2 do not properly track whether a client's request has been validated, which allows remote attackers to bypass an intended preauthentication requirement by providing (1) zero bytes of data or (2) an arbitrary realm name, related to plugins/preauth/otp/main.c and plugins/preauth/pkinit/pkinit_srv.c.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-8630Mediumkrb5:1.12.1+dfsg-19+deb8u1The (1) kadm5_create_principal_3 and (2) kadm5_modify_principal functions in lib/kadm5/srv/svr_principal.c in kadmind in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) by specifying KADM5_POLICY with a NULL policy name.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2016-0777Mediumopenssh:1:6.7p1-5The resend_bytes function in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2 allows remote servers to obtain sensitive information from process memory by requesting transmission of an entire buffer, as demonstrated by reading a private key.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2016-0778Mediumopenssh:1:6.7p1-5The (1) roaming_read and (2) roaming_write functions in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2, when certain proxy and forward options are enabled, do not properly maintain connection file descriptors, which allows remote servers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact by requesting many forwardings.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2016-3115Mediumopenssh:1:6.7p1-5Multiple CRLF injection vulnerabilities in session.c in sshd in OpenSSH before 7.2p2 allow remote authenticated users to bypass intended shell-command restrictions via crafted X11 forwarding data, related to the (1) do_authenticated1 and (2) session_x11_req functions.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-5352Mediumopenssh:1:6.7p1-5The x11_open_helper function in channels.c in ssh in OpenSSH before 6.9, when ForwardX11Trusted mode is not used, lacks a check of the refusal deadline for X connections, which makes it easier for remote attackers to bypass intended access restrictions via a connection outside of the permitted time window.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-6564Mediumopenssh:1:6.7p1-5Use-after-free vulnerability in the mm_answer_pam_free_ctx function in monitor.c in sshd in OpenSSH before 7.0 on non-OpenBSD platforms might allow local users to gain privileges by leveraging control of the sshd uid to send an unexpectedly early MONITOR_REQ_PAM_FREE_CTX request.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-5276Mediumgcc-4.9:4.9.2-10The std::random_device class in libstdc++ in the GNU Compiler Collection (aka GCC) before 4.9.4 does not properly handle short reads from blocking sources, which makes it easier for context-dependent attackers to predict the random values via unspecified vectors.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-8382Mediumpcre3:2:8.35-3.3The match function in pcre_exec.c in PCRE before 8.37 mishandles the /(?:((abcd))|(((?:(?:(?:(?:abc|(?:abcdef))))b)abcdefghi)abc)|((*ACCEPT)))/ pattern and related patterns involving (*ACCEPT), which allows remote attackers to obtain sensitive information from process memory or cause a denial of service (partially initialized memory and application crash) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-2547.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-8393Mediumpcre3:2:8.35-3.3pcregrep in PCRE before 8.38 mishandles the -q option for binary files, which might allow remote attackers to obtain sensitive information via a crafted file, as demonstrated by a CGI script that sends stdout data to a client.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-2632Mediumicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u95, 7u80, and 8u45 allows remote attackers to affect confidentiality via unknown vectors related to 2D.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2011-3389Mediumgnutls28:3.3.8-6+deb8u3The SSL protocol, as used in certain configurations in Microsoft Windows and Microsoft Internet Explorer, Mozilla Firefox, Google Chrome, Opera, and other products, encrypts data by using CBC mode with chained initialization vectors, which allows man-in-the-middle attackers to obtain plaintext HTTP headers via a blockwise chosen-boundary attack (BCBA) on an HTTPS session, in conjunction with JavaScript code that uses (1) the HTML5 WebSocket API, (2) the Java URLConnection API, or (3) the Silverlight WebClient API, aka a "BEAST" attack.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-8767Mediumlinux:3.16.7-ckt20-1+deb8u2net/sctp/sm_sideeffect.c in the Linux kernel before 4.3 does not properly manage the relationship between a lock and a socket, which allows local users to cause a denial of service (deadlock) via a crafted sctp_accept call.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-7566Mediumlinux:3.16.7-ckt20-1+deb8u2The clie_5_attach function in drivers/usb/serial/visor.c in the Linux kernel through 4.4.1 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact by inserting a USB device that lacks a bulk-out endpoint.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2013-4312Mediumlinux:3.16.7-ckt20-1+deb8u2The Linux kernel before 4.4.1 allows local users to bypass file-descriptor limits and cause a denial of service (memory consumption) by sending each descriptor over a UNIX socket before closing it, related to net/unix/af_unix.c and net/unix/garbage.c.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-8785Mediumlinux:3.16.7-ckt20-1+deb8u2The fuse_fill_write_pages function in fs/fuse/file.c in the Linux kernel before 4.4 allows local users to cause a denial of service (infinite loop) via a writev system call that triggers a zero length for the first segment of an iov.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2016-0723Mediumlinux:3.16.7-ckt20-1+deb8u2Race condition in the tty_ioctl function in drivers/tty/tty_io.c in the Linux kernel through 4.4.1 allows local users to obtain sensitive information from kernel memory or cause a denial of service (use-after-free and system crash) by making a TIOCGETD ioctl call during processing of a TIOCSETD ioctl call.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2016-0821Mediumlinux:3.16.7-ckt20-1+deb8u2The LIST_POISON feature in include/linux/poison.h in the Linux kernel before 4.3, as used in Android 6.0.1 before 2016-03-01, does not properly consider the relationship to the mmap_min_addr value, which makes it easier for attackers to bypass a poison-pointer protection mechanism by triggering the use of an uninitialized list entry, aka Android internal bug 26186802, a different vulnerability than CVE-2015-3636.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-3238Mediumpam:1.1.8-3.1The _unix_run_helper_binary function in the pam_unix module in Linux-PAM (aka pam) before 1.2.1, when unable to directly access passwords, allows local users to enumerate usernames or cause a denial of service (hang) via a large password.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2016-0755Mediumcurl:7.38.0-4+deb8u2The ConnectionExists function in lib/url.c in libcurl before 7.47.0 does not properly re-use NTLM-authenticated proxy connections, which might allow remote attackers to authenticate as other users via a request, a similar issue to CVE-2014-0015.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2014-8121Mediumglibc:2.19-18+deb8u1DB_LOOKUP in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) 2.21 and earlier does not properly check if a file is open, which allows remote attackers to cause a denial of service (infinite loop) by performing a look-up while the database is iterated over the database, which triggers the file pointer to be reset.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-7547Mediumglibc:2.19-18+deb8u1Multiple stack-based buffer overflows in the (1) send_dg and (2) send_vc functions in the libresolv library in the GNU C Library (aka glibc or libc6) before 2.23 allow remote attackers to cause a denial of service (crash) or possibly execute arbitrary code via a crafted DNS response that triggers a call to the getaddrinfo function with the AF_UNSPEC or AF_INET6 address family, related to performing "dual A/AAAA DNS queries" and the libnss_dns.so.2 NSS module.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2011-3389Mediumgnutls28:3.3.8-6+deb8u3The SSL protocol, as used in certain configurations in Microsoft Windows and Microsoft Internet Explorer, Mozilla Firefox, Google Chrome, Opera, and other products, encrypts data by using CBC mode with chained initialization vectors, which allows man-in-the-middle attackers to obtain plaintext HTTP headers via a blockwise chosen-boundary attack (BCBA) on an HTTPS session, in conjunction with JavaScript code that uses (1) the HTML5 WebSocket API, (2) the Java URLConnection API, or (3) the Silverlight WebClient API, aka a "BEAST" attack.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2016-0777Mediumopenssh:1:6.7p1-5The resend_bytes function in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2 allows remote servers to obtain sensitive information from process memory by requesting transmission of an entire buffer, as demonstrated by reading a private key.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2016-0778Mediumopenssh:1:6.7p1-5The (1) roaming_read and (2) roaming_write functions in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2, when certain proxy and forward options are enabled, do not properly maintain connection file descriptors, which allows remote servers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact by requesting many forwardings.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2016-3115Mediumopenssh:1:6.7p1-5Multiple CRLF injection vulnerabilities in session.c in sshd in OpenSSH before 7.2p2 allow remote authenticated users to bypass intended shell-command restrictions via crafted X11 forwarding data, related to the (1) do_authenticated1 and (2) session_x11_req functions.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-5352Mediumopenssh:1:6.7p1-5The x11_open_helper function in channels.c in ssh in OpenSSH before 6.9, when ForwardX11Trusted mode is not used, lacks a check of the refusal deadline for X connections, which makes it easier for remote attackers to bypass intended access restrictions via a connection outside of the permitted time window.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-6564Mediumopenssh:1:6.7p1-5Use-after-free vulnerability in the mm_answer_pam_free_ctx function in monitor.c in sshd in OpenSSH before 7.0 on non-OpenBSD platforms might allow local users to gain privileges by leveraging control of the sshd uid to send an unexpectedly early MONITOR_REQ_PAM_FREE_CTX request.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-2632Mediumicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u95, 7u80, and 8u45 allows remote attackers to affect confidentiality via unknown vectors related to 2D.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-8767Mediumlinux:3.16.7-ckt20-1+deb8u2net/sctp/sm_sideeffect.c in the Linux kernel before 4.3 does not properly manage the relationship between a lock and a socket, which allows local users to cause a denial of service (deadlock) via a crafted sctp_accept call.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-7566Mediumlinux:3.16.7-ckt20-1+deb8u2The clie_5_attach function in drivers/usb/serial/visor.c in the Linux kernel through 4.4.1 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact by inserting a USB device that lacks a bulk-out endpoint.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2013-4312Mediumlinux:3.16.7-ckt20-1+deb8u2The Linux kernel before 4.4.1 allows local users to bypass file-descriptor limits and cause a denial of service (memory consumption) by sending each descriptor over a UNIX socket before closing it, related to net/unix/af_unix.c and net/unix/garbage.c.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-8785Mediumlinux:3.16.7-ckt20-1+deb8u2The fuse_fill_write_pages function in fs/fuse/file.c in the Linux kernel before 4.4 allows local users to cause a denial of service (infinite loop) via a writev system call that triggers a zero length for the first segment of an iov.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2016-0723Mediumlinux:3.16.7-ckt20-1+deb8u2Race condition in the tty_ioctl function in drivers/tty/tty_io.c in the Linux kernel through 4.4.1 allows local users to obtain sensitive information from kernel memory or cause a denial of service (use-after-free and system crash) by making a TIOCGETD ioctl call during processing of a TIOCSETD ioctl call.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2016-0821Mediumlinux:3.16.7-ckt20-1+deb8u2The LIST_POISON feature in include/linux/poison.h in the Linux kernel before 4.3, as used in Android 6.0.1 before 2016-03-01, does not properly consider the relationship to the mmap_min_addr value, which makes it easier for attackers to bypass a poison-pointer protection mechanism by triggering the use of an uninitialized list entry, aka Android internal bug 26186802, a different vulnerability than CVE-2015-3636.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2016-0797Mediumopenssl:1.0.1k-3+deb8u2Multiple integer overflows in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allow remote attackers to cause a denial of service (heap memory corruption or NULL pointer dereference) or possibly have unspecified other impact via a long digit string that is mishandled by the (1) BN_dec2bn or (2) BN_hex2bn function, related to crypto/bn/bn.h and crypto/bn/bn_print.c.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-3238Mediumpam:1.1.8-3.1The _unix_run_helper_binary function in the pam_unix module in Linux-PAM (aka pam) before 1.2.1, when unable to directly access passwords, allows local users to enumerate usernames or cause a denial of service (hang) via a large password.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-5276Mediumgcc-4.9:4.9.2-10The std::random_device class in libstdc++ in the GNU Compiler Collection (aka GCC) before 4.9.4 does not properly handle short reads from blocking sources, which makes it easier for context-dependent attackers to predict the random values via unspecified vectors.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-8631Mediumkrb5:1.12.1+dfsg-19+deb8u1Multiple memory leaks in kadmin/server/server_stubs.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (memory consumption) via a request specifying a NULL principal name.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-2694Mediumkrb5:1.12.1+dfsg-19+deb8u1The kdcpreauth modules in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.2 do not properly track whether a client's request has been validated, which allows remote attackers to bypass an intended preauthentication requirement by providing (1) zero bytes of data or (2) an arbitrary realm name, related to plugins/preauth/otp/main.c and plugins/preauth/pkinit/pkinit_srv.c.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-8630Mediumkrb5:1.12.1+dfsg-19+deb8u1The (1) kadm5_create_principal_3 and (2) kadm5_modify_principal functions in lib/kadm5/srv/svr_principal.c in kadmind in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) by specifying KADM5_POLICY with a NULL policy name.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2016-0755Mediumcurl:7.38.0-4+deb8u2The ConnectionExists function in lib/url.c in libcurl before 7.47.0 does not properly re-use NTLM-authenticated proxy connections, which might allow remote attackers to authenticate as other users via a request, a similar issue to CVE-2014-0015.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-8382Mediumpcre3:2:8.35-3.3The match function in pcre_exec.c in PCRE before 8.37 mishandles the /(?:((abcd))|(((?:(?:(?:(?:abc|(?:abcdef))))b)abcdefghi)abc)|((*ACCEPT)))/ pattern and related patterns involving (*ACCEPT), which allows remote attackers to obtain sensitive information from process memory or cause a denial of service (partially initialized memory and application crash) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-2547.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-8393Mediumpcre3:2:8.35-3.3pcregrep in PCRE before 8.38 mishandles the -q option for binary files, which might allow remote attackers to obtain sensitive information via a crafted file, as demonstrated by a CGI script that sends stdout data to a client.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-8382Mediumpcre3:2:8.35-3.3The match function in pcre_exec.c in PCRE before 8.37 mishandles the /(?:((abcd))|(((?:(?:(?:(?:abc|(?:abcdef))))b)abcdefghi)abc)|((*ACCEPT)))/ pattern and related patterns involving (*ACCEPT), which allows remote attackers to obtain sensitive information from process memory or cause a denial of service (partially initialized memory and application crash) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-2547.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-8393Mediumpcre3:2:8.35-3.3pcregrep in PCRE before 8.38 mishandles the -q option for binary files, which might allow remote attackers to obtain sensitive information via a crafted file, as demonstrated by a CGI script that sends stdout data to a client.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2011-3389Mediumgnutls28:3.3.8-6+deb8u3The SSL protocol, as used in certain configurations in Microsoft Windows and Microsoft Internet Explorer, Mozilla Firefox, Google Chrome, Opera, and other products, encrypts data by using CBC mode with chained initialization vectors, which allows man-in-the-middle attackers to obtain plaintext HTTP headers via a blockwise chosen-boundary attack (BCBA) on an HTTPS session, in conjunction with JavaScript code that uses (1) the HTML5 WebSocket API, (2) the Java URLConnection API, or (3) the Silverlight WebClient API, aka a "BEAST" attack.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2016-0777Mediumopenssh:1:6.7p1-5The resend_bytes function in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2 allows remote servers to obtain sensitive information from process memory by requesting transmission of an entire buffer, as demonstrated by reading a private key.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2016-0778Mediumopenssh:1:6.7p1-5The (1) roaming_read and (2) roaming_write functions in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2, when certain proxy and forward options are enabled, do not properly maintain connection file descriptors, which allows remote servers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact by requesting many forwardings.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2016-3115Mediumopenssh:1:6.7p1-5Multiple CRLF injection vulnerabilities in session.c in sshd in OpenSSH before 7.2p2 allow remote authenticated users to bypass intended shell-command restrictions via crafted X11 forwarding data, related to the (1) do_authenticated1 and (2) session_x11_req functions.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-5352Mediumopenssh:1:6.7p1-5The x11_open_helper function in channels.c in ssh in OpenSSH before 6.9, when ForwardX11Trusted mode is not used, lacks a check of the refusal deadline for X connections, which makes it easier for remote attackers to bypass intended access restrictions via a connection outside of the permitted time window.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-6564Mediumopenssh:1:6.7p1-5Use-after-free vulnerability in the mm_answer_pam_free_ctx function in monitor.c in sshd in OpenSSH before 7.0 on non-OpenBSD platforms might allow local users to gain privileges by leveraging control of the sshd uid to send an unexpectedly early MONITOR_REQ_PAM_FREE_CTX request.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-8767Mediumlinux:3.16.7-ckt20-1+deb8u2net/sctp/sm_sideeffect.c in the Linux kernel before 4.3 does not properly manage the relationship between a lock and a socket, which allows local users to cause a denial of service (deadlock) via a crafted sctp_accept call.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-7566Mediumlinux:3.16.7-ckt20-1+deb8u2The clie_5_attach function in drivers/usb/serial/visor.c in the Linux kernel through 4.4.1 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact by inserting a USB device that lacks a bulk-out endpoint.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2013-4312Mediumlinux:3.16.7-ckt20-1+deb8u2The Linux kernel before 4.4.1 allows local users to bypass file-descriptor limits and cause a denial of service (memory consumption) by sending each descriptor over a UNIX socket before closing it, related to net/unix/af_unix.c and net/unix/garbage.c.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-8785Mediumlinux:3.16.7-ckt20-1+deb8u2The fuse_fill_write_pages function in fs/fuse/file.c in the Linux kernel before 4.4 allows local users to cause a denial of service (infinite loop) via a writev system call that triggers a zero length for the first segment of an iov.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2016-0723Mediumlinux:3.16.7-ckt20-1+deb8u2Race condition in the tty_ioctl function in drivers/tty/tty_io.c in the Linux kernel through 4.4.1 allows local users to obtain sensitive information from kernel memory or cause a denial of service (use-after-free and system crash) by making a TIOCGETD ioctl call during processing of a TIOCSETD ioctl call.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2016-0821Mediumlinux:3.16.7-ckt20-1+deb8u2The LIST_POISON feature in include/linux/poison.h in the Linux kernel before 4.3, as used in Android 6.0.1 before 2016-03-01, does not properly consider the relationship to the mmap_min_addr value, which makes it easier for attackers to bypass a poison-pointer protection mechanism by triggering the use of an uninitialized list entry, aka Android internal bug 26186802, a different vulnerability than CVE-2015-3636.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2014-8121Mediumglibc:2.19-18+deb8u1DB_LOOKUP in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) 2.21 and earlier does not properly check if a file is open, which allows remote attackers to cause a denial of service (infinite loop) by performing a look-up while the database is iterated over the database, which triggers the file pointer to be reset.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-7547Mediumglibc:2.19-18+deb8u1Multiple stack-based buffer overflows in the (1) send_dg and (2) send_vc functions in the libresolv library in the GNU C Library (aka glibc or libc6) before 2.23 allow remote attackers to cause a denial of service (crash) or possibly execute arbitrary code via a crafted DNS response that triggers a call to the getaddrinfo function with the AF_UNSPEC or AF_INET6 address family, related to performing "dual A/AAAA DNS queries" and the libnss_dns.so.2 NSS module.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-8631Mediumkrb5:1.12.1+dfsg-19+deb8u1Multiple memory leaks in kadmin/server/server_stubs.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (memory consumption) via a request specifying a NULL principal name.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-2694Mediumkrb5:1.12.1+dfsg-19+deb8u1The kdcpreauth modules in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.2 do not properly track whether a client's request has been validated, which allows remote attackers to bypass an intended preauthentication requirement by providing (1) zero bytes of data or (2) an arbitrary realm name, related to plugins/preauth/otp/main.c and plugins/preauth/pkinit/pkinit_srv.c.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-8630Mediumkrb5:1.12.1+dfsg-19+deb8u1The (1) kadm5_create_principal_3 and (2) kadm5_modify_principal functions in lib/kadm5/srv/svr_principal.c in kadmind in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) by specifying KADM5_POLICY with a NULL policy name.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-5276Mediumgcc-4.9:4.9.2-10The std::random_device class in libstdc++ in the GNU Compiler Collection (aka GCC) before 4.9.4 does not properly handle short reads from blocking sources, which makes it easier for context-dependent attackers to predict the random values via unspecified vectors.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-3238Mediumpam:1.1.8-3.1The _unix_run_helper_binary function in the pam_unix module in Linux-PAM (aka pam) before 1.2.1, when unable to directly access passwords, allows local users to enumerate usernames or cause a denial of service (hang) via a large password.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2016-0797Mediumopenssl:1.0.1k-3+deb8u2Multiple integer overflows in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allow remote attackers to cause a denial of service (heap memory corruption or NULL pointer dereference) or possibly have unspecified other impact via a long digit string that is mishandled by the (1) BN_dec2bn or (2) BN_hex2bn function, related to crypto/bn/bn.h and crypto/bn/bn_print.c.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2016-0755Mediumcurl:7.38.0-4+deb8u2The ConnectionExists function in lib/url.c in libcurl before 7.47.0 does not properly re-use NTLM-authenticated proxy connections, which might allow remote attackers to authenticate as other users via a request, a similar issue to CVE-2014-0015.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-2632Mediumicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u95, 7u80, and 8u45 allows remote attackers to affect confidentiality via unknown vectors related to 2D.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2016-0755Mediumcurl:7.38.0-4+deb8u2The ConnectionExists function in lib/url.c in libcurl before 7.47.0 does not properly re-use NTLM-authenticated proxy connections, which might allow remote attackers to authenticate as other users via a request, a similar issue to CVE-2014-0015.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-5276Mediumgcc-4.9:4.9.2-10The std::random_device class in libstdc++ in the GNU Compiler Collection (aka GCC) before 4.9.4 does not properly handle short reads from blocking sources, which makes it easier for context-dependent attackers to predict the random values via unspecified vectors.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-2632Mediumicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u95, 7u80, and 8u45 allows remote attackers to affect confidentiality via unknown vectors related to 2D.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2011-3389Mediumgnutls28:3.3.8-6+deb8u3The SSL protocol, as used in certain configurations in Microsoft Windows and Microsoft Internet Explorer, Mozilla Firefox, Google Chrome, Opera, and other products, encrypts data by using CBC mode with chained initialization vectors, which allows man-in-the-middle attackers to obtain plaintext HTTP headers via a blockwise chosen-boundary attack (BCBA) on an HTTPS session, in conjunction with JavaScript code that uses (1) the HTML5 WebSocket API, (2) the Java URLConnection API, or (3) the Silverlight WebClient API, aka a "BEAST" attack.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2016-0777Mediumopenssh:1:6.7p1-5The resend_bytes function in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2 allows remote servers to obtain sensitive information from process memory by requesting transmission of an entire buffer, as demonstrated by reading a private key.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2016-0778Mediumopenssh:1:6.7p1-5The (1) roaming_read and (2) roaming_write functions in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2, when certain proxy and forward options are enabled, do not properly maintain connection file descriptors, which allows remote servers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact by requesting many forwardings.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2016-3115Mediumopenssh:1:6.7p1-5Multiple CRLF injection vulnerabilities in session.c in sshd in OpenSSH before 7.2p2 allow remote authenticated users to bypass intended shell-command restrictions via crafted X11 forwarding data, related to the (1) do_authenticated1 and (2) session_x11_req functions.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-5352Mediumopenssh:1:6.7p1-5The x11_open_helper function in channels.c in ssh in OpenSSH before 6.9, when ForwardX11Trusted mode is not used, lacks a check of the refusal deadline for X connections, which makes it easier for remote attackers to bypass intended access restrictions via a connection outside of the permitted time window.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-6564Mediumopenssh:1:6.7p1-5Use-after-free vulnerability in the mm_answer_pam_free_ctx function in monitor.c in sshd in OpenSSH before 7.0 on non-OpenBSD platforms might allow local users to gain privileges by leveraging control of the sshd uid to send an unexpectedly early MONITOR_REQ_PAM_FREE_CTX request.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2014-8121Mediumglibc:2.19-18+deb8u1DB_LOOKUP in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) 2.21 and earlier does not properly check if a file is open, which allows remote attackers to cause a denial of service (infinite loop) by performing a look-up while the database is iterated over the database, which triggers the file pointer to be reset.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-7547Mediumglibc:2.19-18+deb8u1Multiple stack-based buffer overflows in the (1) send_dg and (2) send_vc functions in the libresolv library in the GNU C Library (aka glibc or libc6) before 2.23 allow remote attackers to cause a denial of service (crash) or possibly execute arbitrary code via a crafted DNS response that triggers a call to the getaddrinfo function with the AF_UNSPEC or AF_INET6 address family, related to performing "dual A/AAAA DNS queries" and the libnss_dns.so.2 NSS module.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-8767Mediumlinux:3.16.7-ckt20-1+deb8u2net/sctp/sm_sideeffect.c in the Linux kernel before 4.3 does not properly manage the relationship between a lock and a socket, which allows local users to cause a denial of service (deadlock) via a crafted sctp_accept call.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-7566Mediumlinux:3.16.7-ckt20-1+deb8u2The clie_5_attach function in drivers/usb/serial/visor.c in the Linux kernel through 4.4.1 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact by inserting a USB device that lacks a bulk-out endpoint.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2013-4312Mediumlinux:3.16.7-ckt20-1+deb8u2The Linux kernel before 4.4.1 allows local users to bypass file-descriptor limits and cause a denial of service (memory consumption) by sending each descriptor over a UNIX socket before closing it, related to net/unix/af_unix.c and net/unix/garbage.c.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-8785Mediumlinux:3.16.7-ckt20-1+deb8u2The fuse_fill_write_pages function in fs/fuse/file.c in the Linux kernel before 4.4 allows local users to cause a denial of service (infinite loop) via a writev system call that triggers a zero length for the first segment of an iov.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2016-0723Mediumlinux:3.16.7-ckt20-1+deb8u2Race condition in the tty_ioctl function in drivers/tty/tty_io.c in the Linux kernel through 4.4.1 allows local users to obtain sensitive information from kernel memory or cause a denial of service (use-after-free and system crash) by making a TIOCGETD ioctl call during processing of a TIOCSETD ioctl call.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2016-0821Mediumlinux:3.16.7-ckt20-1+deb8u2The LIST_POISON feature in include/linux/poison.h in the Linux kernel before 4.3, as used in Android 6.0.1 before 2016-03-01, does not properly consider the relationship to the mmap_min_addr value, which makes it easier for attackers to bypass a poison-pointer protection mechanism by triggering the use of an uninitialized list entry, aka Android internal bug 26186802, a different vulnerability than CVE-2015-3636.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2016-0797Mediumopenssl:1.0.1k-3+deb8u2Multiple integer overflows in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allow remote attackers to cause a denial of service (heap memory corruption or NULL pointer dereference) or possibly have unspecified other impact via a long digit string that is mishandled by the (1) BN_dec2bn or (2) BN_hex2bn function, related to crypto/bn/bn.h and crypto/bn/bn_print.c.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-3238Mediumpam:1.1.8-3.1The _unix_run_helper_binary function in the pam_unix module in Linux-PAM (aka pam) before 1.2.1, when unable to directly access passwords, allows local users to enumerate usernames or cause a denial of service (hang) via a large password.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-8631Mediumkrb5:1.12.1+dfsg-19+deb8u1Multiple memory leaks in kadmin/server/server_stubs.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (memory consumption) via a request specifying a NULL principal name.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-2694Mediumkrb5:1.12.1+dfsg-19+deb8u1The kdcpreauth modules in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.2 do not properly track whether a client's request has been validated, which allows remote attackers to bypass an intended preauthentication requirement by providing (1) zero bytes of data or (2) an arbitrary realm name, related to plugins/preauth/otp/main.c and plugins/preauth/pkinit/pkinit_srv.c.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-8630Mediumkrb5:1.12.1+dfsg-19+deb8u1The (1) kadm5_create_principal_3 and (2) kadm5_modify_principal functions in lib/kadm5/srv/svr_principal.c in kadmind in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) by specifying KADM5_POLICY with a NULL policy name.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-8382Mediumpcre3:2:8.35-3.3The match function in pcre_exec.c in PCRE before 8.37 mishandles the /(?:((abcd))|(((?:(?:(?:(?:abc|(?:abcdef))))b)abcdefghi)abc)|((*ACCEPT)))/ pattern and related patterns involving (*ACCEPT), which allows remote attackers to obtain sensitive information from process memory or cause a denial of service (partially initialized memory and application crash) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-2547.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-8393Mediumpcre3:2:8.35-3.3pcregrep in PCRE before 8.38 mishandles the -q option for binary files, which might allow remote attackers to obtain sensitive information via a crafted file, as demonstrated by a CGI script that sends stdout data to a client.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-3238Mediumpam:1.1.8-3.1The _unix_run_helper_binary function in the pam_unix module in Linux-PAM (aka pam) before 1.2.1, when unable to directly access passwords, allows local users to enumerate usernames or cause a denial of service (hang) via a large password.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-8382Mediumpcre3:2:8.35-3.3The match function in pcre_exec.c in PCRE before 8.37 mishandles the /(?:((abcd))|(((?:(?:(?:(?:abc|(?:abcdef))))b)abcdefghi)abc)|((*ACCEPT)))/ pattern and related patterns involving (*ACCEPT), which allows remote attackers to obtain sensitive information from process memory or cause a denial of service (partially initialized memory and application crash) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-2547.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-8393Mediumpcre3:2:8.35-3.3pcregrep in PCRE before 8.38 mishandles the -q option for binary files, which might allow remote attackers to obtain sensitive information via a crafted file, as demonstrated by a CGI script that sends stdout data to a client.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2016-0777Mediumopenssh:1:6.7p1-5The resend_bytes function in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2 allows remote servers to obtain sensitive information from process memory by requesting transmission of an entire buffer, as demonstrated by reading a private key.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2016-0778Mediumopenssh:1:6.7p1-5The (1) roaming_read and (2) roaming_write functions in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2, when certain proxy and forward options are enabled, do not properly maintain connection file descriptors, which allows remote servers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact by requesting many forwardings.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2016-3115Mediumopenssh:1:6.7p1-5Multiple CRLF injection vulnerabilities in session.c in sshd in OpenSSH before 7.2p2 allow remote authenticated users to bypass intended shell-command restrictions via crafted X11 forwarding data, related to the (1) do_authenticated1 and (2) session_x11_req functions.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-5352Mediumopenssh:1:6.7p1-5The x11_open_helper function in channels.c in ssh in OpenSSH before 6.9, when ForwardX11Trusted mode is not used, lacks a check of the refusal deadline for X connections, which makes it easier for remote attackers to bypass intended access restrictions via a connection outside of the permitted time window.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-6564Mediumopenssh:1:6.7p1-5Use-after-free vulnerability in the mm_answer_pam_free_ctx function in monitor.c in sshd in OpenSSH before 7.0 on non-OpenBSD platforms might allow local users to gain privileges by leveraging control of the sshd uid to send an unexpectedly early MONITOR_REQ_PAM_FREE_CTX request.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2016-0755Mediumcurl:7.38.0-4+deb8u2The ConnectionExists function in lib/url.c in libcurl before 7.47.0 does not properly re-use NTLM-authenticated proxy connections, which might allow remote attackers to authenticate as other users via a request, a similar issue to CVE-2014-0015.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-8631Mediumkrb5:1.12.1+dfsg-19+deb8u1Multiple memory leaks in kadmin/server/server_stubs.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (memory consumption) via a request specifying a NULL principal name.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-2694Mediumkrb5:1.12.1+dfsg-19+deb8u1The kdcpreauth modules in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.2 do not properly track whether a client's request has been validated, which allows remote attackers to bypass an intended preauthentication requirement by providing (1) zero bytes of data or (2) an arbitrary realm name, related to plugins/preauth/otp/main.c and plugins/preauth/pkinit/pkinit_srv.c.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-8630Mediumkrb5:1.12.1+dfsg-19+deb8u1The (1) kadm5_create_principal_3 and (2) kadm5_modify_principal functions in lib/kadm5/srv/svr_principal.c in kadmind in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) by specifying KADM5_POLICY with a NULL policy name.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2011-3389Mediumgnutls28:3.3.8-6+deb8u3The SSL protocol, as used in certain configurations in Microsoft Windows and Microsoft Internet Explorer, Mozilla Firefox, Google Chrome, Opera, and other products, encrypts data by using CBC mode with chained initialization vectors, which allows man-in-the-middle attackers to obtain plaintext HTTP headers via a blockwise chosen-boundary attack (BCBA) on an HTTPS session, in conjunction with JavaScript code that uses (1) the HTML5 WebSocket API, (2) the Java URLConnection API, or (3) the Silverlight WebClient API, aka a "BEAST" attack.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-8767Mediumlinux:3.16.7-ckt20-1+deb8u2net/sctp/sm_sideeffect.c in the Linux kernel before 4.3 does not properly manage the relationship between a lock and a socket, which allows local users to cause a denial of service (deadlock) via a crafted sctp_accept call.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-7566Mediumlinux:3.16.7-ckt20-1+deb8u2The clie_5_attach function in drivers/usb/serial/visor.c in the Linux kernel through 4.4.1 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact by inserting a USB device that lacks a bulk-out endpoint.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2013-4312Mediumlinux:3.16.7-ckt20-1+deb8u2The Linux kernel before 4.4.1 allows local users to bypass file-descriptor limits and cause a denial of service (memory consumption) by sending each descriptor over a UNIX socket before closing it, related to net/unix/af_unix.c and net/unix/garbage.c.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-8785Mediumlinux:3.16.7-ckt20-1+deb8u2The fuse_fill_write_pages function in fs/fuse/file.c in the Linux kernel before 4.4 allows local users to cause a denial of service (infinite loop) via a writev system call that triggers a zero length for the first segment of an iov.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2016-0723Mediumlinux:3.16.7-ckt20-1+deb8u2Race condition in the tty_ioctl function in drivers/tty/tty_io.c in the Linux kernel through 4.4.1 allows local users to obtain sensitive information from kernel memory or cause a denial of service (use-after-free and system crash) by making a TIOCGETD ioctl call during processing of a TIOCSETD ioctl call.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2016-0821Mediumlinux:3.16.7-ckt20-1+deb8u2The LIST_POISON feature in include/linux/poison.h in the Linux kernel before 4.3, as used in Android 6.0.1 before 2016-03-01, does not properly consider the relationship to the mmap_min_addr value, which makes it easier for attackers to bypass a poison-pointer protection mechanism by triggering the use of an uninitialized list entry, aka Android internal bug 26186802, a different vulnerability than CVE-2015-3636.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2014-8121Mediumglibc:2.19-18+deb8u1DB_LOOKUP in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) 2.21 and earlier does not properly check if a file is open, which allows remote attackers to cause a denial of service (infinite loop) by performing a look-up while the database is iterated over the database, which triggers the file pointer to be reset.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-7547Mediumglibc:2.19-18+deb8u1Multiple stack-based buffer overflows in the (1) send_dg and (2) send_vc functions in the libresolv library in the GNU C Library (aka glibc or libc6) before 2.23 allow remote attackers to cause a denial of service (crash) or possibly execute arbitrary code via a crafted DNS response that triggers a call to the getaddrinfo function with the AF_UNSPEC or AF_INET6 address family, related to performing "dual A/AAAA DNS queries" and the libnss_dns.so.2 NSS module.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-2632Mediumicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u95, 7u80, and 8u45 allows remote attackers to affect confidentiality via unknown vectors related to 2D.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2016-0797Mediumopenssl:1.0.1k-3+deb8u2Multiple integer overflows in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allow remote attackers to cause a denial of service (heap memory corruption or NULL pointer dereference) or possibly have unspecified other impact via a long digit string that is mishandled by the (1) BN_dec2bn or (2) BN_hex2bn function, related to crypto/bn/bn.h and crypto/bn/bn_print.c.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-5276Mediumgcc-4.9:4.9.2-10The std::random_device class in libstdc++ in the GNU Compiler Collection (aka GCC) before 4.9.4 does not properly handle short reads from blocking sources, which makes it easier for context-dependent attackers to predict the random values via unspecified vectors.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2011-3389Mediumgnutls28:3.3.8-6+deb8u3The SSL protocol, as used in certain configurations in Microsoft Windows and Microsoft Internet Explorer, Mozilla Firefox, Google Chrome, Opera, and other products, encrypts data by using CBC mode with chained initialization vectors, which allows man-in-the-middle attackers to obtain plaintext HTTP headers via a blockwise chosen-boundary attack (BCBA) on an HTTPS session, in conjunction with JavaScript code that uses (1) the HTML5 WebSocket API, (2) the Java URLConnection API, or (3) the Silverlight WebClient API, aka a "BEAST" attack.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2016-0777Mediumopenssh:1:6.7p1-5The resend_bytes function in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2 allows remote servers to obtain sensitive information from process memory by requesting transmission of an entire buffer, as demonstrated by reading a private key.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2016-0778Mediumopenssh:1:6.7p1-5The (1) roaming_read and (2) roaming_write functions in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2, when certain proxy and forward options are enabled, do not properly maintain connection file descriptors, which allows remote servers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact by requesting many forwardings.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2016-3115Mediumopenssh:1:6.7p1-5Multiple CRLF injection vulnerabilities in session.c in sshd in OpenSSH before 7.2p2 allow remote authenticated users to bypass intended shell-command restrictions via crafted X11 forwarding data, related to the (1) do_authenticated1 and (2) session_x11_req functions.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-5352Mediumopenssh:1:6.7p1-5The x11_open_helper function in channels.c in ssh in OpenSSH before 6.9, when ForwardX11Trusted mode is not used, lacks a check of the refusal deadline for X connections, which makes it easier for remote attackers to bypass intended access restrictions via a connection outside of the permitted time window.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-6564Mediumopenssh:1:6.7p1-5Use-after-free vulnerability in the mm_answer_pam_free_ctx function in monitor.c in sshd in OpenSSH before 7.0 on non-OpenBSD platforms might allow local users to gain privileges by leveraging control of the sshd uid to send an unexpectedly early MONITOR_REQ_PAM_FREE_CTX request.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-8631Mediumkrb5:1.12.1+dfsg-19+deb8u1Multiple memory leaks in kadmin/server/server_stubs.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (memory consumption) via a request specifying a NULL principal name.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-2694Mediumkrb5:1.12.1+dfsg-19+deb8u1The kdcpreauth modules in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.2 do not properly track whether a client's request has been validated, which allows remote attackers to bypass an intended preauthentication requirement by providing (1) zero bytes of data or (2) an arbitrary realm name, related to plugins/preauth/otp/main.c and plugins/preauth/pkinit/pkinit_srv.c.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-8630Mediumkrb5:1.12.1+dfsg-19+deb8u1The (1) kadm5_create_principal_3 and (2) kadm5_modify_principal functions in lib/kadm5/srv/svr_principal.c in kadmind in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) by specifying KADM5_POLICY with a NULL policy name.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-2632Mediumicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u95, 7u80, and 8u45 allows remote attackers to affect confidentiality via unknown vectors related to 2D.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2016-0797Mediumopenssl:1.0.1k-3+deb8u2Multiple integer overflows in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allow remote attackers to cause a denial of service (heap memory corruption or NULL pointer dereference) or possibly have unspecified other impact via a long digit string that is mishandled by the (1) BN_dec2bn or (2) BN_hex2bn function, related to crypto/bn/bn.h and crypto/bn/bn_print.c.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2014-8121Mediumglibc:2.19-18+deb8u1DB_LOOKUP in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) 2.21 and earlier does not properly check if a file is open, which allows remote attackers to cause a denial of service (infinite loop) by performing a look-up while the database is iterated over the database, which triggers the file pointer to be reset.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-7547Mediumglibc:2.19-18+deb8u1Multiple stack-based buffer overflows in the (1) send_dg and (2) send_vc functions in the libresolv library in the GNU C Library (aka glibc or libc6) before 2.23 allow remote attackers to cause a denial of service (crash) or possibly execute arbitrary code via a crafted DNS response that triggers a call to the getaddrinfo function with the AF_UNSPEC or AF_INET6 address family, related to performing "dual A/AAAA DNS queries" and the libnss_dns.so.2 NSS module.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-8767Mediumlinux:3.16.7-ckt20-1+deb8u2net/sctp/sm_sideeffect.c in the Linux kernel before 4.3 does not properly manage the relationship between a lock and a socket, which allows local users to cause a denial of service (deadlock) via a crafted sctp_accept call.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-7566Mediumlinux:3.16.7-ckt20-1+deb8u2The clie_5_attach function in drivers/usb/serial/visor.c in the Linux kernel through 4.4.1 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact by inserting a USB device that lacks a bulk-out endpoint.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2013-4312Mediumlinux:3.16.7-ckt20-1+deb8u2The Linux kernel before 4.4.1 allows local users to bypass file-descriptor limits and cause a denial of service (memory consumption) by sending each descriptor over a UNIX socket before closing it, related to net/unix/af_unix.c and net/unix/garbage.c.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-8785Mediumlinux:3.16.7-ckt20-1+deb8u2The fuse_fill_write_pages function in fs/fuse/file.c in the Linux kernel before 4.4 allows local users to cause a denial of service (infinite loop) via a writev system call that triggers a zero length for the first segment of an iov.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2016-0723Mediumlinux:3.16.7-ckt20-1+deb8u2Race condition in the tty_ioctl function in drivers/tty/tty_io.c in the Linux kernel through 4.4.1 allows local users to obtain sensitive information from kernel memory or cause a denial of service (use-after-free and system crash) by making a TIOCGETD ioctl call during processing of a TIOCSETD ioctl call.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2016-0821Mediumlinux:3.16.7-ckt20-1+deb8u2The LIST_POISON feature in include/linux/poison.h in the Linux kernel before 4.3, as used in Android 6.0.1 before 2016-03-01, does not properly consider the relationship to the mmap_min_addr value, which makes it easier for attackers to bypass a poison-pointer protection mechanism by triggering the use of an uninitialized list entry, aka Android internal bug 26186802, a different vulnerability than CVE-2015-3636.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-8382Mediumpcre3:2:8.35-3.3The match function in pcre_exec.c in PCRE before 8.37 mishandles the /(?:((abcd))|(((?:(?:(?:(?:abc|(?:abcdef))))b)abcdefghi)abc)|((*ACCEPT)))/ pattern and related patterns involving (*ACCEPT), which allows remote attackers to obtain sensitive information from process memory or cause a denial of service (partially initialized memory and application crash) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-2547.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-8393Mediumpcre3:2:8.35-3.3pcregrep in PCRE before 8.38 mishandles the -q option for binary files, which might allow remote attackers to obtain sensitive information via a crafted file, as demonstrated by a CGI script that sends stdout data to a client.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-5276Mediumgcc-4.9:4.9.2-10The std::random_device class in libstdc++ in the GNU Compiler Collection (aka GCC) before 4.9.4 does not properly handle short reads from blocking sources, which makes it easier for context-dependent attackers to predict the random values via unspecified vectors.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-3238Mediumpam:1.1.8-3.1The _unix_run_helper_binary function in the pam_unix module in Linux-PAM (aka pam) before 1.2.1, when unable to directly access passwords, allows local users to enumerate usernames or cause a denial of service (hang) via a large password.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2016-0755Mediumcurl:7.38.0-4+deb8u2The ConnectionExists function in lib/url.c in libcurl before 7.47.0 does not properly re-use NTLM-authenticated proxy connections, which might allow remote attackers to authenticate as other users via a request, a similar issue to CVE-2014-0015.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-5276Mediumgcc-4.9:4.9.2-10The std::random_device class in libstdc++ in the GNU Compiler Collection (aka GCC) before 4.9.4 does not properly handle short reads from blocking sources, which makes it easier for context-dependent attackers to predict the random values via unspecified vectors.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-2632Mediumicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u95, 7u80, and 8u45 allows remote attackers to affect confidentiality via unknown vectors related to 2D.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-3238Mediumpam:1.1.8-3.1The _unix_run_helper_binary function in the pam_unix module in Linux-PAM (aka pam) before 1.2.1, when unable to directly access passwords, allows local users to enumerate usernames or cause a denial of service (hang) via a large password.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-8767Mediumlinux:3.16.7-ckt20-1+deb8u2net/sctp/sm_sideeffect.c in the Linux kernel before 4.3 does not properly manage the relationship between a lock and a socket, which allows local users to cause a denial of service (deadlock) via a crafted sctp_accept call.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-7566Mediumlinux:3.16.7-ckt20-1+deb8u2The clie_5_attach function in drivers/usb/serial/visor.c in the Linux kernel through 4.4.1 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact by inserting a USB device that lacks a bulk-out endpoint.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2013-4312Mediumlinux:3.16.7-ckt20-1+deb8u2The Linux kernel before 4.4.1 allows local users to bypass file-descriptor limits and cause a denial of service (memory consumption) by sending each descriptor over a UNIX socket before closing it, related to net/unix/af_unix.c and net/unix/garbage.c.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-8785Mediumlinux:3.16.7-ckt20-1+deb8u2The fuse_fill_write_pages function in fs/fuse/file.c in the Linux kernel before 4.4 allows local users to cause a denial of service (infinite loop) via a writev system call that triggers a zero length for the first segment of an iov.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2016-0723Mediumlinux:3.16.7-ckt20-1+deb8u2Race condition in the tty_ioctl function in drivers/tty/tty_io.c in the Linux kernel through 4.4.1 allows local users to obtain sensitive information from kernel memory or cause a denial of service (use-after-free and system crash) by making a TIOCGETD ioctl call during processing of a TIOCSETD ioctl call.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2016-0821Mediumlinux:3.16.7-ckt20-1+deb8u2The LIST_POISON feature in include/linux/poison.h in the Linux kernel before 4.3, as used in Android 6.0.1 before 2016-03-01, does not properly consider the relationship to the mmap_min_addr value, which makes it easier for attackers to bypass a poison-pointer protection mechanism by triggering the use of an uninitialized list entry, aka Android internal bug 26186802, a different vulnerability than CVE-2015-3636.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-8631Mediumkrb5:1.12.1+dfsg-19+deb8u1Multiple memory leaks in kadmin/server/server_stubs.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (memory consumption) via a request specifying a NULL principal name.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-2694Mediumkrb5:1.12.1+dfsg-19+deb8u1The kdcpreauth modules in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.2 do not properly track whether a client's request has been validated, which allows remote attackers to bypass an intended preauthentication requirement by providing (1) zero bytes of data or (2) an arbitrary realm name, related to plugins/preauth/otp/main.c and plugins/preauth/pkinit/pkinit_srv.c.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-8630Mediumkrb5:1.12.1+dfsg-19+deb8u1The (1) kadm5_create_principal_3 and (2) kadm5_modify_principal functions in lib/kadm5/srv/svr_principal.c in kadmind in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) by specifying KADM5_POLICY with a NULL policy name.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2011-3389Mediumgnutls28:3.3.8-6+deb8u3The SSL protocol, as used in certain configurations in Microsoft Windows and Microsoft Internet Explorer, Mozilla Firefox, Google Chrome, Opera, and other products, encrypts data by using CBC mode with chained initialization vectors, which allows man-in-the-middle attackers to obtain plaintext HTTP headers via a blockwise chosen-boundary attack (BCBA) on an HTTPS session, in conjunction with JavaScript code that uses (1) the HTML5 WebSocket API, (2) the Java URLConnection API, or (3) the Silverlight WebClient API, aka a "BEAST" attack.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2014-8121Mediumglibc:2.19-18+deb8u1DB_LOOKUP in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) 2.21 and earlier does not properly check if a file is open, which allows remote attackers to cause a denial of service (infinite loop) by performing a look-up while the database is iterated over the database, which triggers the file pointer to be reset.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-7547Mediumglibc:2.19-18+deb8u1Multiple stack-based buffer overflows in the (1) send_dg and (2) send_vc functions in the libresolv library in the GNU C Library (aka glibc or libc6) before 2.23 allow remote attackers to cause a denial of service (crash) or possibly execute arbitrary code via a crafted DNS response that triggers a call to the getaddrinfo function with the AF_UNSPEC or AF_INET6 address family, related to performing "dual A/AAAA DNS queries" and the libnss_dns.so.2 NSS module.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2016-0797Mediumopenssl:1.0.1k-3+deb8u2Multiple integer overflows in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allow remote attackers to cause a denial of service (heap memory corruption or NULL pointer dereference) or possibly have unspecified other impact via a long digit string that is mishandled by the (1) BN_dec2bn or (2) BN_hex2bn function, related to crypto/bn/bn.h and crypto/bn/bn_print.c.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-8382Mediumpcre3:2:8.35-3.3The match function in pcre_exec.c in PCRE before 8.37 mishandles the /(?:((abcd))|(((?:(?:(?:(?:abc|(?:abcdef))))b)abcdefghi)abc)|((*ACCEPT)))/ pattern and related patterns involving (*ACCEPT), which allows remote attackers to obtain sensitive information from process memory or cause a denial of service (partially initialized memory and application crash) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-2547.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-8393Mediumpcre3:2:8.35-3.3pcregrep in PCRE before 8.38 mishandles the -q option for binary files, which might allow remote attackers to obtain sensitive information via a crafted file, as demonstrated by a CGI script that sends stdout data to a client.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2016-0755Mediumcurl:7.38.0-4+deb8u2The ConnectionExists function in lib/url.c in libcurl before 7.47.0 does not properly re-use NTLM-authenticated proxy connections, which might allow remote attackers to authenticate as other users via a request, a similar issue to CVE-2014-0015.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2016-0777Mediumopenssh:1:6.7p1-5The resend_bytes function in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2 allows remote servers to obtain sensitive information from process memory by requesting transmission of an entire buffer, as demonstrated by reading a private key.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2016-0778Mediumopenssh:1:6.7p1-5The (1) roaming_read and (2) roaming_write functions in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2, when certain proxy and forward options are enabled, do not properly maintain connection file descriptors, which allows remote servers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact by requesting many forwardings.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2016-3115Mediumopenssh:1:6.7p1-5Multiple CRLF injection vulnerabilities in session.c in sshd in OpenSSH before 7.2p2 allow remote authenticated users to bypass intended shell-command restrictions via crafted X11 forwarding data, related to the (1) do_authenticated1 and (2) session_x11_req functions.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-5352Mediumopenssh:1:6.7p1-5The x11_open_helper function in channels.c in ssh in OpenSSH before 6.9, when ForwardX11Trusted mode is not used, lacks a check of the refusal deadline for X connections, which makes it easier for remote attackers to bypass intended access restrictions via a connection outside of the permitted time window.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-6564Mediumopenssh:1:6.7p1-5Use-after-free vulnerability in the mm_answer_pam_free_ctx function in monitor.c in sshd in OpenSSH before 7.0 on non-OpenBSD platforms might allow local users to gain privileges by leveraging control of the sshd uid to send an unexpectedly early MONITOR_REQ_PAM_FREE_CTX request.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-2632Mediumicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u95, 7u80, and 8u45 allows remote attackers to affect confidentiality via unknown vectors related to 2D.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2011-3389Mediumgnutls28:3.3.8-6+deb8u3The SSL protocol, as used in certain configurations in Microsoft Windows and Microsoft Internet Explorer, Mozilla Firefox, Google Chrome, Opera, and other products, encrypts data by using CBC mode with chained initialization vectors, which allows man-in-the-middle attackers to obtain plaintext HTTP headers via a blockwise chosen-boundary attack (BCBA) on an HTTPS session, in conjunction with JavaScript code that uses (1) the HTML5 WebSocket API, (2) the Java URLConnection API, or (3) the Silverlight WebClient API, aka a "BEAST" attack.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2016-0755Mediumcurl:7.38.0-4+deb8u2The ConnectionExists function in lib/url.c in libcurl before 7.47.0 does not properly re-use NTLM-authenticated proxy connections, which might allow remote attackers to authenticate as other users via a request, a similar issue to CVE-2014-0015.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-8631Mediumkrb5:1.12.1+dfsg-19+deb8u1Multiple memory leaks in kadmin/server/server_stubs.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (memory consumption) via a request specifying a NULL principal name.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-2694Mediumkrb5:1.12.1+dfsg-19+deb8u1The kdcpreauth modules in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.2 do not properly track whether a client's request has been validated, which allows remote attackers to bypass an intended preauthentication requirement by providing (1) zero bytes of data or (2) an arbitrary realm name, related to plugins/preauth/otp/main.c and plugins/preauth/pkinit/pkinit_srv.c.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-8630Mediumkrb5:1.12.1+dfsg-19+deb8u1The (1) kadm5_create_principal_3 and (2) kadm5_modify_principal functions in lib/kadm5/srv/svr_principal.c in kadmind in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) by specifying KADM5_POLICY with a NULL policy name.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-5276Mediumgcc-4.9:4.9.2-10The std::random_device class in libstdc++ in the GNU Compiler Collection (aka GCC) before 4.9.4 does not properly handle short reads from blocking sources, which makes it easier for context-dependent attackers to predict the random values via unspecified vectors.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2016-0777Mediumopenssh:1:6.7p1-5The resend_bytes function in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2 allows remote servers to obtain sensitive information from process memory by requesting transmission of an entire buffer, as demonstrated by reading a private key.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2016-0778Mediumopenssh:1:6.7p1-5The (1) roaming_read and (2) roaming_write functions in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2, when certain proxy and forward options are enabled, do not properly maintain connection file descriptors, which allows remote servers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact by requesting many forwardings.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2016-3115Mediumopenssh:1:6.7p1-5Multiple CRLF injection vulnerabilities in session.c in sshd in OpenSSH before 7.2p2 allow remote authenticated users to bypass intended shell-command restrictions via crafted X11 forwarding data, related to the (1) do_authenticated1 and (2) session_x11_req functions.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-5352Mediumopenssh:1:6.7p1-5The x11_open_helper function in channels.c in ssh in OpenSSH before 6.9, when ForwardX11Trusted mode is not used, lacks a check of the refusal deadline for X connections, which makes it easier for remote attackers to bypass intended access restrictions via a connection outside of the permitted time window.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-6564Mediumopenssh:1:6.7p1-5Use-after-free vulnerability in the mm_answer_pam_free_ctx function in monitor.c in sshd in OpenSSH before 7.0 on non-OpenBSD platforms might allow local users to gain privileges by leveraging control of the sshd uid to send an unexpectedly early MONITOR_REQ_PAM_FREE_CTX request.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-8767Mediumlinux:3.16.7-ckt20-1+deb8u2net/sctp/sm_sideeffect.c in the Linux kernel before 4.3 does not properly manage the relationship between a lock and a socket, which allows local users to cause a denial of service (deadlock) via a crafted sctp_accept call.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-7566Mediumlinux:3.16.7-ckt20-1+deb8u2The clie_5_attach function in drivers/usb/serial/visor.c in the Linux kernel through 4.4.1 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact by inserting a USB device that lacks a bulk-out endpoint.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2013-4312Mediumlinux:3.16.7-ckt20-1+deb8u2The Linux kernel before 4.4.1 allows local users to bypass file-descriptor limits and cause a denial of service (memory consumption) by sending each descriptor over a UNIX socket before closing it, related to net/unix/af_unix.c and net/unix/garbage.c.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-8785Mediumlinux:3.16.7-ckt20-1+deb8u2The fuse_fill_write_pages function in fs/fuse/file.c in the Linux kernel before 4.4 allows local users to cause a denial of service (infinite loop) via a writev system call that triggers a zero length for the first segment of an iov.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2016-0723Mediumlinux:3.16.7-ckt20-1+deb8u2Race condition in the tty_ioctl function in drivers/tty/tty_io.c in the Linux kernel through 4.4.1 allows local users to obtain sensitive information from kernel memory or cause a denial of service (use-after-free and system crash) by making a TIOCGETD ioctl call during processing of a TIOCSETD ioctl call.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2016-0821Mediumlinux:3.16.7-ckt20-1+deb8u2The LIST_POISON feature in include/linux/poison.h in the Linux kernel before 4.3, as used in Android 6.0.1 before 2016-03-01, does not properly consider the relationship to the mmap_min_addr value, which makes it easier for attackers to bypass a poison-pointer protection mechanism by triggering the use of an uninitialized list entry, aka Android internal bug 26186802, a different vulnerability than CVE-2015-3636.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-8382Mediumpcre3:2:8.35-3.3The match function in pcre_exec.c in PCRE before 8.37 mishandles the /(?:((abcd))|(((?:(?:(?:(?:abc|(?:abcdef))))b)abcdefghi)abc)|((*ACCEPT)))/ pattern and related patterns involving (*ACCEPT), which allows remote attackers to obtain sensitive information from process memory or cause a denial of service (partially initialized memory and application crash) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-2547.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-8393Mediumpcre3:2:8.35-3.3pcregrep in PCRE before 8.38 mishandles the -q option for binary files, which might allow remote attackers to obtain sensitive information via a crafted file, as demonstrated by a CGI script that sends stdout data to a client.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2016-0797Mediumopenssl:1.0.1k-3+deb8u2Multiple integer overflows in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allow remote attackers to cause a denial of service (heap memory corruption or NULL pointer dereference) or possibly have unspecified other impact via a long digit string that is mishandled by the (1) BN_dec2bn or (2) BN_hex2bn function, related to crypto/bn/bn.h and crypto/bn/bn_print.c.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2014-8121Mediumglibc:2.19-18+deb8u1DB_LOOKUP in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) 2.21 and earlier does not properly check if a file is open, which allows remote attackers to cause a denial of service (infinite loop) by performing a look-up while the database is iterated over the database, which triggers the file pointer to be reset.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-7547Mediumglibc:2.19-18+deb8u1Multiple stack-based buffer overflows in the (1) send_dg and (2) send_vc functions in the libresolv library in the GNU C Library (aka glibc or libc6) before 2.23 allow remote attackers to cause a denial of service (crash) or possibly execute arbitrary code via a crafted DNS response that triggers a call to the getaddrinfo function with the AF_UNSPEC or AF_INET6 address family, related to performing "dual A/AAAA DNS queries" and the libnss_dns.so.2 NSS module.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-3238Mediumpam:1.1.8-3.1The _unix_run_helper_binary function in the pam_unix module in Linux-PAM (aka pam) before 1.2.1, when unable to directly access passwords, allows local users to enumerate usernames or cause a denial of service (hang) via a large password.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-8631Mediumkrb5:1.12.1+dfsg-19+deb8u1Multiple memory leaks in kadmin/server/server_stubs.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (memory consumption) via a request specifying a NULL principal name.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-2694Mediumkrb5:1.12.1+dfsg-19+deb8u1The kdcpreauth modules in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.2 do not properly track whether a client's request has been validated, which allows remote attackers to bypass an intended preauthentication requirement by providing (1) zero bytes of data or (2) an arbitrary realm name, related to plugins/preauth/otp/main.c and plugins/preauth/pkinit/pkinit_srv.c.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-8630Mediumkrb5:1.12.1+dfsg-19+deb8u1The (1) kadm5_create_principal_3 and (2) kadm5_modify_principal functions in lib/kadm5/srv/svr_principal.c in kadmind in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) by specifying KADM5_POLICY with a NULL policy name.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2016-0777Mediumopenssh:1:6.7p1-5The resend_bytes function in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2 allows remote servers to obtain sensitive information from process memory by requesting transmission of an entire buffer, as demonstrated by reading a private key.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2016-0778Mediumopenssh:1:6.7p1-5The (1) roaming_read and (2) roaming_write functions in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2, when certain proxy and forward options are enabled, do not properly maintain connection file descriptors, which allows remote servers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact by requesting many forwardings.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2016-3115Mediumopenssh:1:6.7p1-5Multiple CRLF injection vulnerabilities in session.c in sshd in OpenSSH before 7.2p2 allow remote authenticated users to bypass intended shell-command restrictions via crafted X11 forwarding data, related to the (1) do_authenticated1 and (2) session_x11_req functions.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-5352Mediumopenssh:1:6.7p1-5The x11_open_helper function in channels.c in ssh in OpenSSH before 6.9, when ForwardX11Trusted mode is not used, lacks a check of the refusal deadline for X connections, which makes it easier for remote attackers to bypass intended access restrictions via a connection outside of the permitted time window.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-6564Mediumopenssh:1:6.7p1-5Use-after-free vulnerability in the mm_answer_pam_free_ctx function in monitor.c in sshd in OpenSSH before 7.0 on non-OpenBSD platforms might allow local users to gain privileges by leveraging control of the sshd uid to send an unexpectedly early MONITOR_REQ_PAM_FREE_CTX request.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2014-8121Mediumglibc:2.19-18+deb8u1DB_LOOKUP in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) 2.21 and earlier does not properly check if a file is open, which allows remote attackers to cause a denial of service (infinite loop) by performing a look-up while the database is iterated over the database, which triggers the file pointer to be reset.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-7547Mediumglibc:2.19-18+deb8u1Multiple stack-based buffer overflows in the (1) send_dg and (2) send_vc functions in the libresolv library in the GNU C Library (aka glibc or libc6) before 2.23 allow remote attackers to cause a denial of service (crash) or possibly execute arbitrary code via a crafted DNS response that triggers a call to the getaddrinfo function with the AF_UNSPEC or AF_INET6 address family, related to performing "dual A/AAAA DNS queries" and the libnss_dns.so.2 NSS module.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-5276Mediumgcc-4.9:4.9.2-10The std::random_device class in libstdc++ in the GNU Compiler Collection (aka GCC) before 4.9.4 does not properly handle short reads from blocking sources, which makes it easier for context-dependent attackers to predict the random values via unspecified vectors.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2016-0755Mediumcurl:7.38.0-4+deb8u2The ConnectionExists function in lib/url.c in libcurl before 7.47.0 does not properly re-use NTLM-authenticated proxy connections, which might allow remote attackers to authenticate as other users via a request, a similar issue to CVE-2014-0015.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-8767Mediumlinux:3.16.7-ckt20-1+deb8u2net/sctp/sm_sideeffect.c in the Linux kernel before 4.3 does not properly manage the relationship between a lock and a socket, which allows local users to cause a denial of service (deadlock) via a crafted sctp_accept call.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-7566Mediumlinux:3.16.7-ckt20-1+deb8u2The clie_5_attach function in drivers/usb/serial/visor.c in the Linux kernel through 4.4.1 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact by inserting a USB device that lacks a bulk-out endpoint.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2013-4312Mediumlinux:3.16.7-ckt20-1+deb8u2The Linux kernel before 4.4.1 allows local users to bypass file-descriptor limits and cause a denial of service (memory consumption) by sending each descriptor over a UNIX socket before closing it, related to net/unix/af_unix.c and net/unix/garbage.c.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-8785Mediumlinux:3.16.7-ckt20-1+deb8u2The fuse_fill_write_pages function in fs/fuse/file.c in the Linux kernel before 4.4 allows local users to cause a denial of service (infinite loop) via a writev system call that triggers a zero length for the first segment of an iov.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2016-0723Mediumlinux:3.16.7-ckt20-1+deb8u2Race condition in the tty_ioctl function in drivers/tty/tty_io.c in the Linux kernel through 4.4.1 allows local users to obtain sensitive information from kernel memory or cause a denial of service (use-after-free and system crash) by making a TIOCGETD ioctl call during processing of a TIOCSETD ioctl call.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2016-0821Mediumlinux:3.16.7-ckt20-1+deb8u2The LIST_POISON feature in include/linux/poison.h in the Linux kernel before 4.3, as used in Android 6.0.1 before 2016-03-01, does not properly consider the relationship to the mmap_min_addr value, which makes it easier for attackers to bypass a poison-pointer protection mechanism by triggering the use of an uninitialized list entry, aka Android internal bug 26186802, a different vulnerability than CVE-2015-3636.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2011-3389Mediumgnutls28:3.3.8-6+deb8u3The SSL protocol, as used in certain configurations in Microsoft Windows and Microsoft Internet Explorer, Mozilla Firefox, Google Chrome, Opera, and other products, encrypts data by using CBC mode with chained initialization vectors, which allows man-in-the-middle attackers to obtain plaintext HTTP headers via a blockwise chosen-boundary attack (BCBA) on an HTTPS session, in conjunction with JavaScript code that uses (1) the HTML5 WebSocket API, (2) the Java URLConnection API, or (3) the Silverlight WebClient API, aka a "BEAST" attack.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-3238Mediumpam:1.1.8-3.1The _unix_run_helper_binary function in the pam_unix module in Linux-PAM (aka pam) before 1.2.1, when unable to directly access passwords, allows local users to enumerate usernames or cause a denial of service (hang) via a large password.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-2632Mediumicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u95, 7u80, and 8u45 allows remote attackers to affect confidentiality via unknown vectors related to 2D.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-8382Mediumpcre3:2:8.35-3.3The match function in pcre_exec.c in PCRE before 8.37 mishandles the /(?:((abcd))|(((?:(?:(?:(?:abc|(?:abcdef))))b)abcdefghi)abc)|((*ACCEPT)))/ pattern and related patterns involving (*ACCEPT), which allows remote attackers to obtain sensitive information from process memory or cause a denial of service (partially initialized memory and application crash) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-2547.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-8393Mediumpcre3:2:8.35-3.3pcregrep in PCRE before 8.38 mishandles the -q option for binary files, which might allow remote attackers to obtain sensitive information via a crafted file, as demonstrated by a CGI script that sends stdout data to a client.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2016-0797Mediumopenssl:1.0.1k-3+deb8u2Multiple integer overflows in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allow remote attackers to cause a denial of service (heap memory corruption or NULL pointer dereference) or possibly have unspecified other impact via a long digit string that is mishandled by the (1) BN_dec2bn or (2) BN_hex2bn function, related to crypto/bn/bn.h and crypto/bn/bn_print.c.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-2632Mediumicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u95, 7u80, and 8u45 allows remote attackers to affect confidentiality via unknown vectors related to 2D.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2011-3389Mediumgnutls28:3.3.8-6+deb8u3The SSL protocol, as used in certain configurations in Microsoft Windows and Microsoft Internet Explorer, Mozilla Firefox, Google Chrome, Opera, and other products, encrypts data by using CBC mode with chained initialization vectors, which allows man-in-the-middle attackers to obtain plaintext HTTP headers via a blockwise chosen-boundary attack (BCBA) on an HTTPS session, in conjunction with JavaScript code that uses (1) the HTML5 WebSocket API, (2) the Java URLConnection API, or (3) the Silverlight WebClient API, aka a "BEAST" attack.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-3238Mediumpam:1.1.8-3.1The _unix_run_helper_binary function in the pam_unix module in Linux-PAM (aka pam) before 1.2.1, when unable to directly access passwords, allows local users to enumerate usernames or cause a denial of service (hang) via a large password.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2016-0777Mediumopenssh:1:6.7p1-5The resend_bytes function in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2 allows remote servers to obtain sensitive information from process memory by requesting transmission of an entire buffer, as demonstrated by reading a private key.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2016-0778Mediumopenssh:1:6.7p1-5The (1) roaming_read and (2) roaming_write functions in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2, when certain proxy and forward options are enabled, do not properly maintain connection file descriptors, which allows remote servers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact by requesting many forwardings.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2016-3115Mediumopenssh:1:6.7p1-5Multiple CRLF injection vulnerabilities in session.c in sshd in OpenSSH before 7.2p2 allow remote authenticated users to bypass intended shell-command restrictions via crafted X11 forwarding data, related to the (1) do_authenticated1 and (2) session_x11_req functions.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-5352Mediumopenssh:1:6.7p1-5The x11_open_helper function in channels.c in ssh in OpenSSH before 6.9, when ForwardX11Trusted mode is not used, lacks a check of the refusal deadline for X connections, which makes it easier for remote attackers to bypass intended access restrictions via a connection outside of the permitted time window.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-6564Mediumopenssh:1:6.7p1-5Use-after-free vulnerability in the mm_answer_pam_free_ctx function in monitor.c in sshd in OpenSSH before 7.0 on non-OpenBSD platforms might allow local users to gain privileges by leveraging control of the sshd uid to send an unexpectedly early MONITOR_REQ_PAM_FREE_CTX request.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-8382Mediumpcre3:2:8.35-3.3The match function in pcre_exec.c in PCRE before 8.37 mishandles the /(?:((abcd))|(((?:(?:(?:(?:abc|(?:abcdef))))b)abcdefghi)abc)|((*ACCEPT)))/ pattern and related patterns involving (*ACCEPT), which allows remote attackers to obtain sensitive information from process memory or cause a denial of service (partially initialized memory and application crash) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-2547.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-8393Mediumpcre3:2:8.35-3.3pcregrep in PCRE before 8.38 mishandles the -q option for binary files, which might allow remote attackers to obtain sensitive information via a crafted file, as demonstrated by a CGI script that sends stdout data to a client.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-8767Mediumlinux:3.16.7-ckt20-1+deb8u2net/sctp/sm_sideeffect.c in the Linux kernel before 4.3 does not properly manage the relationship between a lock and a socket, which allows local users to cause a denial of service (deadlock) via a crafted sctp_accept call.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-7566Mediumlinux:3.16.7-ckt20-1+deb8u2The clie_5_attach function in drivers/usb/serial/visor.c in the Linux kernel through 4.4.1 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact by inserting a USB device that lacks a bulk-out endpoint.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2013-4312Mediumlinux:3.16.7-ckt20-1+deb8u2The Linux kernel before 4.4.1 allows local users to bypass file-descriptor limits and cause a denial of service (memory consumption) by sending each descriptor over a UNIX socket before closing it, related to net/unix/af_unix.c and net/unix/garbage.c.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-8785Mediumlinux:3.16.7-ckt20-1+deb8u2The fuse_fill_write_pages function in fs/fuse/file.c in the Linux kernel before 4.4 allows local users to cause a denial of service (infinite loop) via a writev system call that triggers a zero length for the first segment of an iov.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2016-0723Mediumlinux:3.16.7-ckt20-1+deb8u2Race condition in the tty_ioctl function in drivers/tty/tty_io.c in the Linux kernel through 4.4.1 allows local users to obtain sensitive information from kernel memory or cause a denial of service (use-after-free and system crash) by making a TIOCGETD ioctl call during processing of a TIOCSETD ioctl call.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2016-0821Mediumlinux:3.16.7-ckt20-1+deb8u2The LIST_POISON feature in include/linux/poison.h in the Linux kernel before 4.3, as used in Android 6.0.1 before 2016-03-01, does not properly consider the relationship to the mmap_min_addr value, which makes it easier for attackers to bypass a poison-pointer protection mechanism by triggering the use of an uninitialized list entry, aka Android internal bug 26186802, a different vulnerability than CVE-2015-3636.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-8631Mediumkrb5:1.12.1+dfsg-19+deb8u1Multiple memory leaks in kadmin/server/server_stubs.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (memory consumption) via a request specifying a NULL principal name.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-2694Mediumkrb5:1.12.1+dfsg-19+deb8u1The kdcpreauth modules in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.2 do not properly track whether a client's request has been validated, which allows remote attackers to bypass an intended preauthentication requirement by providing (1) zero bytes of data or (2) an arbitrary realm name, related to plugins/preauth/otp/main.c and plugins/preauth/pkinit/pkinit_srv.c.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-8630Mediumkrb5:1.12.1+dfsg-19+deb8u1The (1) kadm5_create_principal_3 and (2) kadm5_modify_principal functions in lib/kadm5/srv/svr_principal.c in kadmind in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) by specifying KADM5_POLICY with a NULL policy name.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2014-8121Mediumglibc:2.19-18+deb8u1DB_LOOKUP in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) 2.21 and earlier does not properly check if a file is open, which allows remote attackers to cause a denial of service (infinite loop) by performing a look-up while the database is iterated over the database, which triggers the file pointer to be reset.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-7547Mediumglibc:2.19-18+deb8u1Multiple stack-based buffer overflows in the (1) send_dg and (2) send_vc functions in the libresolv library in the GNU C Library (aka glibc or libc6) before 2.23 allow remote attackers to cause a denial of service (crash) or possibly execute arbitrary code via a crafted DNS response that triggers a call to the getaddrinfo function with the AF_UNSPEC or AF_INET6 address family, related to performing "dual A/AAAA DNS queries" and the libnss_dns.so.2 NSS module.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-5276Mediumgcc-4.9:4.9.2-10The std::random_device class in libstdc++ in the GNU Compiler Collection (aka GCC) before 4.9.4 does not properly handle short reads from blocking sources, which makes it easier for context-dependent attackers to predict the random values via unspecified vectors.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2016-0755Mediumcurl:7.38.0-4+deb8u2The ConnectionExists function in lib/url.c in libcurl before 7.47.0 does not properly re-use NTLM-authenticated proxy connections, which might allow remote attackers to authenticate as other users via a request, a similar issue to CVE-2014-0015.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2016-0797Mediumopenssl:1.0.1k-3+deb8u2Multiple integer overflows in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allow remote attackers to cause a denial of service (heap memory corruption or NULL pointer dereference) or possibly have unspecified other impact via a long digit string that is mishandled by the (1) BN_dec2bn or (2) BN_hex2bn function, related to crypto/bn/bn.h and crypto/bn/bn_print.c.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2016-0797Mediumopenssl:1.0.1k-3+deb8u2Multiple integer overflows in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allow remote attackers to cause a denial of service (heap memory corruption or NULL pointer dereference) or possibly have unspecified other impact via a long digit string that is mishandled by the (1) BN_dec2bn or (2) BN_hex2bn function, related to crypto/bn/bn.h and crypto/bn/bn_print.c.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2016-0755Mediumcurl:7.38.0-4+deb8u2The ConnectionExists function in lib/url.c in libcurl before 7.47.0 does not properly re-use NTLM-authenticated proxy connections, which might allow remote attackers to authenticate as other users via a request, a similar issue to CVE-2014-0015.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-3238Mediumpam:1.1.8-3.1The _unix_run_helper_binary function in the pam_unix module in Linux-PAM (aka pam) before 1.2.1, when unable to directly access passwords, allows local users to enumerate usernames or cause a denial of service (hang) via a large password.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-8631Mediumkrb5:1.12.1+dfsg-19+deb8u1Multiple memory leaks in kadmin/server/server_stubs.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (memory consumption) via a request specifying a NULL principal name.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-2694Mediumkrb5:1.12.1+dfsg-19+deb8u1The kdcpreauth modules in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.2 do not properly track whether a client's request has been validated, which allows remote attackers to bypass an intended preauthentication requirement by providing (1) zero bytes of data or (2) an arbitrary realm name, related to plugins/preauth/otp/main.c and plugins/preauth/pkinit/pkinit_srv.c.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-8630Mediumkrb5:1.12.1+dfsg-19+deb8u1The (1) kadm5_create_principal_3 and (2) kadm5_modify_principal functions in lib/kadm5/srv/svr_principal.c in kadmind in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) by specifying KADM5_POLICY with a NULL policy name.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-8382Mediumpcre3:2:8.35-3.3The match function in pcre_exec.c in PCRE before 8.37 mishandles the /(?:((abcd))|(((?:(?:(?:(?:abc|(?:abcdef))))b)abcdefghi)abc)|((*ACCEPT)))/ pattern and related patterns involving (*ACCEPT), which allows remote attackers to obtain sensitive information from process memory or cause a denial of service (partially initialized memory and application crash) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-2547.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-8393Mediumpcre3:2:8.35-3.3pcregrep in PCRE before 8.38 mishandles the -q option for binary files, which might allow remote attackers to obtain sensitive information via a crafted file, as demonstrated by a CGI script that sends stdout data to a client.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-2632Mediumicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u95, 7u80, and 8u45 allows remote attackers to affect confidentiality via unknown vectors related to 2D.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-5276Mediumgcc-4.9:4.9.2-10The std::random_device class in libstdc++ in the GNU Compiler Collection (aka GCC) before 4.9.4 does not properly handle short reads from blocking sources, which makes it easier for context-dependent attackers to predict the random values via unspecified vectors.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2016-0777Mediumopenssh:1:6.7p1-5The resend_bytes function in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2 allows remote servers to obtain sensitive information from process memory by requesting transmission of an entire buffer, as demonstrated by reading a private key.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2016-0778Mediumopenssh:1:6.7p1-5The (1) roaming_read and (2) roaming_write functions in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2, when certain proxy and forward options are enabled, do not properly maintain connection file descriptors, which allows remote servers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact by requesting many forwardings.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2016-3115Mediumopenssh:1:6.7p1-5Multiple CRLF injection vulnerabilities in session.c in sshd in OpenSSH before 7.2p2 allow remote authenticated users to bypass intended shell-command restrictions via crafted X11 forwarding data, related to the (1) do_authenticated1 and (2) session_x11_req functions.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-5352Mediumopenssh:1:6.7p1-5The x11_open_helper function in channels.c in ssh in OpenSSH before 6.9, when ForwardX11Trusted mode is not used, lacks a check of the refusal deadline for X connections, which makes it easier for remote attackers to bypass intended access restrictions via a connection outside of the permitted time window.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-6564Mediumopenssh:1:6.7p1-5Use-after-free vulnerability in the mm_answer_pam_free_ctx function in monitor.c in sshd in OpenSSH before 7.0 on non-OpenBSD platforms might allow local users to gain privileges by leveraging control of the sshd uid to send an unexpectedly early MONITOR_REQ_PAM_FREE_CTX request.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2014-8121Mediumglibc:2.19-18+deb8u1DB_LOOKUP in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) 2.21 and earlier does not properly check if a file is open, which allows remote attackers to cause a denial of service (infinite loop) by performing a look-up while the database is iterated over the database, which triggers the file pointer to be reset.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-7547Mediumglibc:2.19-18+deb8u1Multiple stack-based buffer overflows in the (1) send_dg and (2) send_vc functions in the libresolv library in the GNU C Library (aka glibc or libc6) before 2.23 allow remote attackers to cause a denial of service (crash) or possibly execute arbitrary code via a crafted DNS response that triggers a call to the getaddrinfo function with the AF_UNSPEC or AF_INET6 address family, related to performing "dual A/AAAA DNS queries" and the libnss_dns.so.2 NSS module.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2011-3389Mediumgnutls28:3.3.8-6+deb8u3The SSL protocol, as used in certain configurations in Microsoft Windows and Microsoft Internet Explorer, Mozilla Firefox, Google Chrome, Opera, and other products, encrypts data by using CBC mode with chained initialization vectors, which allows man-in-the-middle attackers to obtain plaintext HTTP headers via a blockwise chosen-boundary attack (BCBA) on an HTTPS session, in conjunction with JavaScript code that uses (1) the HTML5 WebSocket API, (2) the Java URLConnection API, or (3) the Silverlight WebClient API, aka a "BEAST" attack.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-8767Mediumlinux:3.16.7-ckt20-1+deb8u2net/sctp/sm_sideeffect.c in the Linux kernel before 4.3 does not properly manage the relationship between a lock and a socket, which allows local users to cause a denial of service (deadlock) via a crafted sctp_accept call.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-7566Mediumlinux:3.16.7-ckt20-1+deb8u2The clie_5_attach function in drivers/usb/serial/visor.c in the Linux kernel through 4.4.1 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact by inserting a USB device that lacks a bulk-out endpoint.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2013-4312Mediumlinux:3.16.7-ckt20-1+deb8u2The Linux kernel before 4.4.1 allows local users to bypass file-descriptor limits and cause a denial of service (memory consumption) by sending each descriptor over a UNIX socket before closing it, related to net/unix/af_unix.c and net/unix/garbage.c.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-8785Mediumlinux:3.16.7-ckt20-1+deb8u2The fuse_fill_write_pages function in fs/fuse/file.c in the Linux kernel before 4.4 allows local users to cause a denial of service (infinite loop) via a writev system call that triggers a zero length for the first segment of an iov.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2016-0723Mediumlinux:3.16.7-ckt20-1+deb8u2Race condition in the tty_ioctl function in drivers/tty/tty_io.c in the Linux kernel through 4.4.1 allows local users to obtain sensitive information from kernel memory or cause a denial of service (use-after-free and system crash) by making a TIOCGETD ioctl call during processing of a TIOCSETD ioctl call.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2016-0821Mediumlinux:3.16.7-ckt20-1+deb8u2The LIST_POISON feature in include/linux/poison.h in the Linux kernel before 4.3, as used in Android 6.0.1 before 2016-03-01, does not properly consider the relationship to the mmap_min_addr value, which makes it easier for attackers to bypass a poison-pointer protection mechanism by triggering the use of an uninitialized list entry, aka Android internal bug 26186802, a different vulnerability than CVE-2015-3636.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-5276Mediumgcc-4.9:4.9.2-10The std::random_device class in libstdc++ in the GNU Compiler Collection (aka GCC) before 4.9.4 does not properly handle short reads from blocking sources, which makes it easier for context-dependent attackers to predict the random values via unspecified vectors.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-8382Mediumpcre3:2:8.35-3.3The match function in pcre_exec.c in PCRE before 8.37 mishandles the /(?:((abcd))|(((?:(?:(?:(?:abc|(?:abcdef))))b)abcdefghi)abc)|((*ACCEPT)))/ pattern and related patterns involving (*ACCEPT), which allows remote attackers to obtain sensitive information from process memory or cause a denial of service (partially initialized memory and application crash) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-2547.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-8393Mediumpcre3:2:8.35-3.3pcregrep in PCRE before 8.38 mishandles the -q option for binary files, which might allow remote attackers to obtain sensitive information via a crafted file, as demonstrated by a CGI script that sends stdout data to a client.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2014-8121Mediumglibc:2.19-18+deb8u1DB_LOOKUP in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) 2.21 and earlier does not properly check if a file is open, which allows remote attackers to cause a denial of service (infinite loop) by performing a look-up while the database is iterated over the database, which triggers the file pointer to be reset.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-7547Mediumglibc:2.19-18+deb8u1Multiple stack-based buffer overflows in the (1) send_dg and (2) send_vc functions in the libresolv library in the GNU C Library (aka glibc or libc6) before 2.23 allow remote attackers to cause a denial of service (crash) or possibly execute arbitrary code via a crafted DNS response that triggers a call to the getaddrinfo function with the AF_UNSPEC or AF_INET6 address family, related to performing "dual A/AAAA DNS queries" and the libnss_dns.so.2 NSS module.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2011-3389Mediumgnutls28:3.3.8-6+deb8u3The SSL protocol, as used in certain configurations in Microsoft Windows and Microsoft Internet Explorer, Mozilla Firefox, Google Chrome, Opera, and other products, encrypts data by using CBC mode with chained initialization vectors, which allows man-in-the-middle attackers to obtain plaintext HTTP headers via a blockwise chosen-boundary attack (BCBA) on an HTTPS session, in conjunction with JavaScript code that uses (1) the HTML5 WebSocket API, (2) the Java URLConnection API, or (3) the Silverlight WebClient API, aka a "BEAST" attack.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-3238Mediumpam:1.1.8-3.1The _unix_run_helper_binary function in the pam_unix module in Linux-PAM (aka pam) before 1.2.1, when unable to directly access passwords, allows local users to enumerate usernames or cause a denial of service (hang) via a large password.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-8631Mediumkrb5:1.12.1+dfsg-19+deb8u1Multiple memory leaks in kadmin/server/server_stubs.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (memory consumption) via a request specifying a NULL principal name.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-2694Mediumkrb5:1.12.1+dfsg-19+deb8u1The kdcpreauth modules in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.2 do not properly track whether a client's request has been validated, which allows remote attackers to bypass an intended preauthentication requirement by providing (1) zero bytes of data or (2) an arbitrary realm name, related to plugins/preauth/otp/main.c and plugins/preauth/pkinit/pkinit_srv.c.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-8630Mediumkrb5:1.12.1+dfsg-19+deb8u1The (1) kadm5_create_principal_3 and (2) kadm5_modify_principal functions in lib/kadm5/srv/svr_principal.c in kadmind in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) by specifying KADM5_POLICY with a NULL policy name.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2016-0755Mediumcurl:7.38.0-4+deb8u2The ConnectionExists function in lib/url.c in libcurl before 7.47.0 does not properly re-use NTLM-authenticated proxy connections, which might allow remote attackers to authenticate as other users via a request, a similar issue to CVE-2014-0015.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2016-0777Mediumopenssh:1:6.7p1-5The resend_bytes function in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2 allows remote servers to obtain sensitive information from process memory by requesting transmission of an entire buffer, as demonstrated by reading a private key.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2016-0778Mediumopenssh:1:6.7p1-5The (1) roaming_read and (2) roaming_write functions in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2, when certain proxy and forward options are enabled, do not properly maintain connection file descriptors, which allows remote servers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact by requesting many forwardings.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2016-3115Mediumopenssh:1:6.7p1-5Multiple CRLF injection vulnerabilities in session.c in sshd in OpenSSH before 7.2p2 allow remote authenticated users to bypass intended shell-command restrictions via crafted X11 forwarding data, related to the (1) do_authenticated1 and (2) session_x11_req functions.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-5352Mediumopenssh:1:6.7p1-5The x11_open_helper function in channels.c in ssh in OpenSSH before 6.9, when ForwardX11Trusted mode is not used, lacks a check of the refusal deadline for X connections, which makes it easier for remote attackers to bypass intended access restrictions via a connection outside of the permitted time window.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-6564Mediumopenssh:1:6.7p1-5Use-after-free vulnerability in the mm_answer_pam_free_ctx function in monitor.c in sshd in OpenSSH before 7.0 on non-OpenBSD platforms might allow local users to gain privileges by leveraging control of the sshd uid to send an unexpectedly early MONITOR_REQ_PAM_FREE_CTX request.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-8767Mediumlinux:3.16.7-ckt20-1+deb8u2net/sctp/sm_sideeffect.c in the Linux kernel before 4.3 does not properly manage the relationship between a lock and a socket, which allows local users to cause a denial of service (deadlock) via a crafted sctp_accept call.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-7566Mediumlinux:3.16.7-ckt20-1+deb8u2The clie_5_attach function in drivers/usb/serial/visor.c in the Linux kernel through 4.4.1 allows physically proximate attackers to cause a denial of service (NULL pointer dereference and system crash) or possibly have unspecified other impact by inserting a USB device that lacks a bulk-out endpoint.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2013-4312Mediumlinux:3.16.7-ckt20-1+deb8u2The Linux kernel before 4.4.1 allows local users to bypass file-descriptor limits and cause a denial of service (memory consumption) by sending each descriptor over a UNIX socket before closing it, related to net/unix/af_unix.c and net/unix/garbage.c.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-8785Mediumlinux:3.16.7-ckt20-1+deb8u2The fuse_fill_write_pages function in fs/fuse/file.c in the Linux kernel before 4.4 allows local users to cause a denial of service (infinite loop) via a writev system call that triggers a zero length for the first segment of an iov.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2016-0723Mediumlinux:3.16.7-ckt20-1+deb8u2Race condition in the tty_ioctl function in drivers/tty/tty_io.c in the Linux kernel through 4.4.1 allows local users to obtain sensitive information from kernel memory or cause a denial of service (use-after-free and system crash) by making a TIOCGETD ioctl call during processing of a TIOCSETD ioctl call.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2016-0821Mediumlinux:3.16.7-ckt20-1+deb8u2The LIST_POISON feature in include/linux/poison.h in the Linux kernel before 4.3, as used in Android 6.0.1 before 2016-03-01, does not properly consider the relationship to the mmap_min_addr value, which makes it easier for attackers to bypass a poison-pointer protection mechanism by triggering the use of an uninitialized list entry, aka Android internal bug 26186802, a different vulnerability than CVE-2015-3636.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-2632Mediumicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u95, 7u80, and 8u45 allows remote attackers to affect confidentiality via unknown vectors related to 2D.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2016-0797Mediumopenssl:1.0.1k-3+deb8u2Multiple integer overflows in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allow remote attackers to cause a denial of service (heap memory corruption or NULL pointer dereference) or possibly have unspecified other impact via a long digit string that is mishandled by the (1) BN_dec2bn or (2) BN_hex2bn function, related to crypto/bn/bn.h and crypto/bn/bn_print.c.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2016-0755Mediumcurl:7.38.0-4+deb8u2The ConnectionExists function in lib/url.c in libcurl before 7.47.0 does not properly re-use NTLM-authenticated proxy connections, which might allow remote attackers to authenticate as other users via a request, a similar issue to CVE-2014-0015.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-3238Mediumpam:1.1.8-3.1The _unix_run_helper_binary function in the pam_unix module in Linux-PAM (aka pam) before 1.2.1, when unable to directly access passwords, allows local users to enumerate usernames or cause a denial of service (hang) via a large password.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-8382Mediumpcre3:2:8.35-3.3The match function in pcre_exec.c in PCRE before 8.37 mishandles the /(?:((abcd))|(((?:(?:(?:(?:abc|(?:abcdef))))b)abcdefghi)abc)|((*ACCEPT)))/ pattern and related patterns involving (*ACCEPT), which allows remote attackers to obtain sensitive information from process memory or cause a denial of service (partially initialized memory and application crash) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-2547.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-8393Mediumpcre3:2:8.35-3.3pcregrep in PCRE before 8.38 mishandles the -q option for binary files, which might allow remote attackers to obtain sensitive information via a crafted file, as demonstrated by a CGI script that sends stdout data to a client.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2011-3389Mediumgnutls28:3.3.8-6+deb8u3The SSL protocol, as used in certain configurations in Microsoft Windows and Microsoft Internet Explorer, Mozilla Firefox, Google Chrome, Opera, and other products, encrypts data by using CBC mode with chained initialization vectors, which allows man-in-the-middle attackers to obtain plaintext HTTP headers via a blockwise chosen-boundary attack (BCBA) on an HTTPS session, in conjunction with JavaScript code that uses (1) the HTML5 WebSocket API, (2) the Java URLConnection API, or (3) the Silverlight WebClient API, aka a "BEAST" attack.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2016-0797Mediumopenssl:1.0.1k-3+deb8u2Multiple integer overflows in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allow remote attackers to cause a denial of service (heap memory corruption or NULL pointer dereference) or possibly have unspecified other impact via a long digit string that is mishandled by the (1) BN_dec2bn or (2) BN_hex2bn function, related to crypto/bn/bn.h and crypto/bn/bn_print.c.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2014-8121Mediumglibc:2.19-18+deb8u1DB_LOOKUP in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) 2.21 and earlier does not properly check if a file is open, which allows remote attackers to cause a denial of service (infinite loop) by performing a look-up while the database is iterated over the database, which triggers the file pointer to be reset.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-7547Mediumglibc:2.19-18+deb8u1Multiple stack-based buffer overflows in the (1) send_dg and (2) send_vc functions in the libresolv library in the GNU C Library (aka glibc or libc6) before 2.23 allow remote attackers to cause a denial of service (crash) or possibly execute arbitrary code via a crafted DNS response that triggers a call to the getaddrinfo function with the AF_UNSPEC or AF_INET6 address family, related to performing "dual A/AAAA DNS queries" and the libnss_dns.so.2 NSS module.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-2632Mediumicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u95, 7u80, and 8u45 allows remote attackers to affect confidentiality via unknown vectors related to 2D.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-5276Mediumgcc-4.9:4.9.2-10The std::random_device class in libstdc++ in the GNU Compiler Collection (aka GCC) before 4.9.4 does not properly handle short reads from blocking sources, which makes it easier for context-dependent attackers to predict the random values via unspecified vectors.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2016-0777Mediumopenssh:1:6.7p1-5The resend_bytes function in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2 allows remote servers to obtain sensitive information from process memory by requesting transmission of an entire buffer, as demonstrated by reading a private key.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2016-0778Mediumopenssh:1:6.7p1-5The (1) roaming_read and (2) roaming_write functions in roaming_common.c in the client in OpenSSH 5.x, 6.x, and 7.x before 7.1p2, when certain proxy and forward options are enabled, do not properly maintain connection file descriptors, which allows remote servers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact by requesting many forwardings.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2016-3115Mediumopenssh:1:6.7p1-5Multiple CRLF injection vulnerabilities in session.c in sshd in OpenSSH before 7.2p2 allow remote authenticated users to bypass intended shell-command restrictions via crafted X11 forwarding data, related to the (1) do_authenticated1 and (2) session_x11_req functions.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-5352Mediumopenssh:1:6.7p1-5The x11_open_helper function in channels.c in ssh in OpenSSH before 6.9, when ForwardX11Trusted mode is not used, lacks a check of the refusal deadline for X connections, which makes it easier for remote attackers to bypass intended access restrictions via a connection outside of the permitted time window.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-6564Mediumopenssh:1:6.7p1-5Use-after-free vulnerability in the mm_answer_pam_free_ctx function in monitor.c in sshd in OpenSSH before 7.0 on non-OpenBSD platforms might allow local users to gain privileges by leveraging control of the sshd uid to send an unexpectedly early MONITOR_REQ_PAM_FREE_CTX request.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-8631Mediumkrb5:1.12.1+dfsg-19+deb8u1Multiple memory leaks in kadmin/server/server_stubs.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (memory consumption) via a request specifying a NULL principal name.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-2694Mediumkrb5:1.12.1+dfsg-19+deb8u1The kdcpreauth modules in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.2 do not properly track whether a client's request has been validated, which allows remote attackers to bypass an intended preauthentication requirement by providing (1) zero bytes of data or (2) an arbitrary realm name, related to plugins/preauth/otp/main.c and plugins/preauth/pkinit/pkinit_srv.c.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-8630Mediumkrb5:1.12.1+dfsg-19+deb8u1The (1) kadm5_create_principal_3 and (2) kadm5_modify_principal functions in lib/kadm5/srv/svr_principal.c in kadmind in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) by specifying KADM5_POLICY with a NULL policy name.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-5276Mediumgcc-4.9:4.9.2-10The std::random_device class in libstdc++ in the GNU Compiler Collection (aka GCC) before 4.9.4 does not properly handle short reads from blocking sources, which makes it easier for context-dependent attackers to predict the random values via unspecified vectors.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2011-3389Mediumgnutls28:3.3.8-6+deb8u3The SSL protocol, as used in certain configurations in Microsoft Windows and Microsoft Internet Explorer, Mozilla Firefox, Google Chrome, Opera, and other products, encrypts data by using CBC mode with chained initialization vectors, which allows man-in-the-middle attackers to obtain plaintext HTTP headers via a blockwise chosen-boundary attack (BCBA) on an HTTPS session, in conjunction with JavaScript code that uses (1) the HTML5 WebSocket API, (2) the Java URLConnection API, or (3) the Silverlight WebClient API, aka a "BEAST" attack.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-2632Mediumicu:52.1-8+deb8u3Unspecified vulnerability in Oracle Java SE 6u95, 7u80, and 8u45 allows remote attackers to affect confidentiality via unknown vectors related to 2D.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2016-0755Mediumcurl:7.38.0-4+deb8u2The ConnectionExists function in lib/url.c in libcurl before 7.47.0 does not properly re-use NTLM-authenticated proxy connections, which might allow remote attackers to authenticate as other users via a request, a similar issue to CVE-2014-0015.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-8382Mediumpcre3:2:8.35-3.3The match function in pcre_exec.c in PCRE before 8.37 mishandles the /(?:((abcd))|(((?:(?:(?:(?:abc|(?:abcdef))))b)abcdefghi)abc)|((*ACCEPT)))/ pattern and related patterns involving (*ACCEPT), which allows remote attackers to obtain sensitive information from process memory or cause a denial of service (partially initialized memory and application crash) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-2547.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-8393Mediumpcre3:2:8.35-3.3pcregrep in PCRE before 8.38 mishandles the -q option for binary files, which might allow remote attackers to obtain sensitive information via a crafted file, as demonstrated by a CGI script that sends stdout data to a client.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-8631Mediumkrb5:1.12.1+dfsg-19+deb8u1Multiple memory leaks in kadmin/server/server_stubs.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (memory consumption) via a request specifying a NULL principal name.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-2694Mediumkrb5:1.12.1+dfsg-19+deb8u1The kdcpreauth modules in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.2 do not properly track whether a client's request has been validated, which allows remote attackers to bypass an intended preauthentication requirement by providing (1) zero bytes of data or (2) an arbitrary realm name, related to plugins/preauth/otp/main.c and plugins/preauth/pkinit/pkinit_srv.c.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-8630Mediumkrb5:1.12.1+dfsg-19+deb8u1The (1) kadm5_create_principal_3 and (2) kadm5_modify_principal functions in lib/kadm5/srv/svr_principal.c in kadmind in MIT Kerberos 5 (aka krb5) 1.12.x and 1.13.x before 1.13.4 and 1.14.x before 1.14.1 allow remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) by specifying KADM5_POLICY with a NULL policy name.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-3238Mediumpam:1.1.8-3.1The _unix_run_helper_binary function in the pam_unix module in Linux-PAM (aka pam) before 1.2.1, when unable to directly access passwords, allows local users to enumerate usernames or cause a denial of service (hang) via a large password.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2016-0797Mediumopenssl:1.0.1k-3+deb8u2Multiple integer overflows in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allow remote attackers to cause a denial of service (heap memory corruption or NULL pointer dereference) or possibly have unspecified other impact via a long digit string that is mishandled by the (1) BN_dec2bn or (2) BN_hex2bn function, related to crypto/bn/bn.h and crypto/bn/bn_print.c.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2014-8121Mediumglibc:2.19-18+deb8u1DB_LOOKUP in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) 2.21 and earlier does not properly check if a file is open, which allows remote attackers to cause a denial of service (infinite loop) by performing a look-up while the database is iterated over the database, which triggers the file pointer to be reset.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-7547Mediumglibc:2.19-18+deb8u1Multiple stack-based buffer overflows in the (1) send_dg and (2) send_vc functions in the libresolv library in the GNU C Library (aka glibc or libc6) before 2.23 allow remote attackers to cause a denial of service (crash) or possibly execute arbitrary code via a crafted DNS response that triggers a call to the getaddrinfo function with the AF_UNSPEC or AF_INET6 address family, related to performing "dual A/AAAA DNS queries" and the libnss_dns.so.2 NSS module.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-3238Mediumpam:1.1.8-3.1The _unix_run_helper_binary function in the pam_unix module in Linux-PAM (aka pam) before 1.2.1, when unable to directly access passwords, allows local users to enumerate usernames or cause a denial of service (hang) via a large password.sha256:c648cd6a73969d01003f84dcb558aa19f153fdbb63f6e7bc096cf204c1d46280
CVE-2015-5276Mediumgcc-4.9:4.9.2-10The std::random_device class in libstdc++ in the GNU Compiler Collection (aka GCC) before 4.9.4 does not properly handle short reads from blocking sources, which makes it easier for context-dependent attackers to predict the random values via unspecified vectors.sha256:c648cd6a73969d01003f84dcb558aa19f153fdbb63f6e7bc096cf204c1d46280
CVE-2015-8382Mediumpcre3:2:8.35-3.3The match function in pcre_exec.c in PCRE before 8.37 mishandles the /(?:((abcd))|(((?:(?:(?:(?:abc|(?:abcdef))))b)abcdefghi)abc)|((*ACCEPT)))/ pattern and related patterns involving (*ACCEPT), which allows remote attackers to obtain sensitive information from process memory or cause a denial of service (partially initialized memory and application crash) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-2547.sha256:c648cd6a73969d01003f84dcb558aa19f153fdbb63f6e7bc096cf204c1d46280
CVE-2015-8393Mediumpcre3:2:8.35-3.3pcregrep in PCRE before 8.38 mishandles the -q option for binary files, which might allow remote attackers to obtain sensitive information via a crafted file, as demonstrated by a CGI script that sends stdout data to a client.sha256:c648cd6a73969d01003f84dcb558aa19f153fdbb63f6e7bc096cf204c1d46280
CVE-2014-8121Mediumglibc:2.19-18+deb8u1DB_LOOKUP in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) 2.21 and earlier does not properly check if a file is open, which allows remote attackers to cause a denial of service (infinite loop) by performing a look-up while the database is iterated over the database, which triggers the file pointer to be reset.sha256:c648cd6a73969d01003f84dcb558aa19f153fdbb63f6e7bc096cf204c1d46280
CVE-2015-7547Mediumglibc:2.19-18+deb8u1Multiple stack-based buffer overflows in the (1) send_dg and (2) send_vc functions in the libresolv library in the GNU C Library (aka glibc or libc6) before 2.23 allow remote attackers to cause a denial of service (crash) or possibly execute arbitrary code via a crafted DNS response that triggers a call to the getaddrinfo function with the AF_UNSPEC or AF_INET6 address family, related to performing "dual A/AAAA DNS queries" and the libnss_dns.so.2 NSS module.sha256:c648cd6a73969d01003f84dcb558aa19f153fdbb63f6e7bc096cf204c1d46280
CVE-2014-8121Mediumglibc:2.19-18+deb8u1DB_LOOKUP in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) 2.21 and earlier does not properly check if a file is open, which allows remote attackers to cause a denial of service (infinite loop) by performing a look-up while the database is iterated over the database, which triggers the file pointer to be reset.sha256:440e9f8ae5cb10857c9b901fe6ed10eb9aa67b997981d16bc4d52f3713908f4e
CVE-2015-7547Mediumglibc:2.19-18+deb8u1Multiple stack-based buffer overflows in the (1) send_dg and (2) send_vc functions in the libresolv library in the GNU C Library (aka glibc or libc6) before 2.23 allow remote attackers to cause a denial of service (crash) or possibly execute arbitrary code via a crafted DNS response that triggers a call to the getaddrinfo function with the AF_UNSPEC or AF_INET6 address family, related to performing "dual A/AAAA DNS queries" and the libnss_dns.so.2 NSS module.sha256:440e9f8ae5cb10857c9b901fe6ed10eb9aa67b997981d16bc4d52f3713908f4e
CVE-2015-5276Mediumgcc-4.9:4.9.2-10The std::random_device class in libstdc++ in the GNU Compiler Collection (aka GCC) before 4.9.4 does not properly handle short reads from blocking sources, which makes it easier for context-dependent attackers to predict the random values via unspecified vectors.sha256:440e9f8ae5cb10857c9b901fe6ed10eb9aa67b997981d16bc4d52f3713908f4e
CVE-2015-8382Mediumpcre3:2:8.35-3.3The match function in pcre_exec.c in PCRE before 8.37 mishandles the /(?:((abcd))|(((?:(?:(?:(?:abc|(?:abcdef))))b)abcdefghi)abc)|((*ACCEPT)))/ pattern and related patterns involving (*ACCEPT), which allows remote attackers to obtain sensitive information from process memory or cause a denial of service (partially initialized memory and application crash) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-2547.sha256:440e9f8ae5cb10857c9b901fe6ed10eb9aa67b997981d16bc4d52f3713908f4e
CVE-2015-8393Mediumpcre3:2:8.35-3.3pcregrep in PCRE before 8.38 mishandles the -q option for binary files, which might allow remote attackers to obtain sensitive information via a crafted file, as demonstrated by a CGI script that sends stdout data to a client.sha256:440e9f8ae5cb10857c9b901fe6ed10eb9aa67b997981d16bc4d52f3713908f4e
CVE-2015-3238Mediumpam:1.1.8-3.1The _unix_run_helper_binary function in the pam_unix module in Linux-PAM (aka pam) before 1.2.1, when unable to directly access passwords, allows local users to enumerate usernames or cause a denial of service (hang) via a large password.sha256:440e9f8ae5cb10857c9b901fe6ed10eb9aa67b997981d16bc4d52f3713908f4e
CVE-2015-6563Lowopenssh:1:6.7p1-5The monitor component in sshd in OpenSSH before 7.0 on non-OpenBSD platforms accepts extraneous username data in MONITOR_REQ_PAM_INIT_CTX requests, which allows local users to conduct impersonation attacks by leveraging any SSH login access in conjunction with control of the sshd uid to send a crafted MONITOR_REQ_PWNAM request, related to monitor.c and monitor_wrap.c.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-5180Lowglibc:2.19-18+deb8u1sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2013-2207Lowglibc:2.19-18+deb8u1pt_chown in GNU C Library (aka glibc or libc6) before 2.18 does not properly check permissions for tty files, which allows local users to change the permission on the files and obtain access to arbitrary pseudo-terminals by leveraging a FUSE file system.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-8777Lowglibc:2.19-18+deb8u1The process_envvars function in elf/rtld.c in the GNU C Library (aka glibc or libc6) before 2.23 allows local users to bypass a pointer-guarding protection mechanism via a zero value of the LD_POINTER_GUARD environment variable.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2016-0702Lowopenssl:1.0.1k-3+deb8u2The MOD_EXP_CTIME_COPY_FROM_PREBUF function in crypto/bn/bn_exp.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not properly consider cache-bank access times during modular exponentiation, which makes it easier for local users to discover RSA keys by running a crafted application on the same Intel Sandy Bridge CPU core as a victim and leveraging cache-bank conflicts, aka a "CacheBleed" attack.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2014-9717Lowlinux:3.16.7-ckt20-1+deb8u2sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2016-3136Lowlinux:3.16.7-ckt20-1+deb8u2sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2016-3140Lowlinux:3.16.7-ckt20-1+deb8u2sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2016-3139Lowlinux:3.16.7-ckt20-1+deb8u2sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2016-2185Lowlinux:3.16.7-ckt20-1+deb8u2sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2016-0823Lowlinux:3.16.7-ckt20-1+deb8u2The pagemap_open function in fs/proc/task_mmu.c in the Linux kernel before 3.19.3, as used in Android 6.0.1 before 2016-03-01, allows local users to obtain sensitive physical-address information by reading a pagemap file, aka Android internal bug 25739721.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2016-2186Lowlinux:3.16.7-ckt20-1+deb8u2sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2016-3138Lowlinux:3.16.7-ckt20-1+deb8u2sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2016-3137Lowlinux:3.16.7-ckt20-1+deb8u2sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2016-2184Lowlinux:3.16.7-ckt20-1+deb8u2sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-8629Lowkrb5:1.12.1+dfsg-19+deb8u1The xdr_nullstring function in lib/kadm5/kadm_rpc_xdr.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 does not verify whether '\0' characters exist as expected, which allows remote authenticated users to obtain sensitive information or cause a denial of service (out-of-bounds read) via a crafted string.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2016-3119Lowkrb5:1.12.1+dfsg-19+deb8u1The process_db_args function in plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c in the LDAP KDB module in kadmind in MIT Kerberos 5 (aka krb5) through 1.13.4 and 1.14.x through 1.14.1 mishandles the DB argument, which allows remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) via a crafted request to modify a principal.sha256:ef227da735c18376c5d640bdd969fe55a067cd4ae92956d193326355d9ae9190
CVE-2015-6563Lowopenssh:1:6.7p1-5The monitor component in sshd in OpenSSH before 7.0 on non-OpenBSD platforms accepts extraneous username data in MONITOR_REQ_PAM_INIT_CTX requests, which allows local users to conduct impersonation attacks by leveraging any SSH login access in conjunction with control of the sshd uid to send a crafted MONITOR_REQ_PWNAM request, related to monitor.c and monitor_wrap.c.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-5180Lowglibc:2.19-18+deb8u1sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2013-2207Lowglibc:2.19-18+deb8u1pt_chown in GNU C Library (aka glibc or libc6) before 2.18 does not properly check permissions for tty files, which allows local users to change the permission on the files and obtain access to arbitrary pseudo-terminals by leveraging a FUSE file system.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-8777Lowglibc:2.19-18+deb8u1The process_envvars function in elf/rtld.c in the GNU C Library (aka glibc or libc6) before 2.23 allows local users to bypass a pointer-guarding protection mechanism via a zero value of the LD_POINTER_GUARD environment variable.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2014-9717Lowlinux:3.16.7-ckt20-1+deb8u2sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-3136Lowlinux:3.16.7-ckt20-1+deb8u2sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-3140Lowlinux:3.16.7-ckt20-1+deb8u2sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-3139Lowlinux:3.16.7-ckt20-1+deb8u2sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-2185Lowlinux:3.16.7-ckt20-1+deb8u2sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-0823Lowlinux:3.16.7-ckt20-1+deb8u2The pagemap_open function in fs/proc/task_mmu.c in the Linux kernel before 3.19.3, as used in Android 6.0.1 before 2016-03-01, allows local users to obtain sensitive physical-address information by reading a pagemap file, aka Android internal bug 25739721.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-2186Lowlinux:3.16.7-ckt20-1+deb8u2sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-3138Lowlinux:3.16.7-ckt20-1+deb8u2sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-3137Lowlinux:3.16.7-ckt20-1+deb8u2sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-2184Lowlinux:3.16.7-ckt20-1+deb8u2sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-8629Lowkrb5:1.12.1+dfsg-19+deb8u1The xdr_nullstring function in lib/kadm5/kadm_rpc_xdr.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 does not verify whether '\0' characters exist as expected, which allows remote authenticated users to obtain sensitive information or cause a denial of service (out-of-bounds read) via a crafted string.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-3119Lowkrb5:1.12.1+dfsg-19+deb8u1The process_db_args function in plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c in the LDAP KDB module in kadmind in MIT Kerberos 5 (aka krb5) through 1.13.4 and 1.14.x through 1.14.1 mishandles the DB argument, which allows remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) via a crafted request to modify a principal.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2016-0702Lowopenssl:1.0.1k-3+deb8u2The MOD_EXP_CTIME_COPY_FROM_PREBUF function in crypto/bn/bn_exp.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not properly consider cache-bank access times during modular exponentiation, which makes it easier for local users to discover RSA keys by running a crafted application on the same Intel Sandy Bridge CPU core as a victim and leveraging cache-bank conflicts, aka a "CacheBleed" attack.sha256:e898aede6d3be11018f7b5d263738aa662e6c3bf118cd3e20a69865b73c24d56
CVE-2015-6563Lowopenssh:1:6.7p1-5The monitor component in sshd in OpenSSH before 7.0 on non-OpenBSD platforms accepts extraneous username data in MONITOR_REQ_PAM_INIT_CTX requests, which allows local users to conduct impersonation attacks by leveraging any SSH login access in conjunction with control of the sshd uid to send a crafted MONITOR_REQ_PWNAM request, related to monitor.c and monitor_wrap.c.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-8629Lowkrb5:1.12.1+dfsg-19+deb8u1The xdr_nullstring function in lib/kadm5/kadm_rpc_xdr.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 does not verify whether '\0' characters exist as expected, which allows remote authenticated users to obtain sensitive information or cause a denial of service (out-of-bounds read) via a crafted string.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2016-3119Lowkrb5:1.12.1+dfsg-19+deb8u1The process_db_args function in plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c in the LDAP KDB module in kadmind in MIT Kerberos 5 (aka krb5) through 1.13.4 and 1.14.x through 1.14.1 mishandles the DB argument, which allows remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) via a crafted request to modify a principal.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2014-9717Lowlinux:3.16.7-ckt20-1+deb8u2sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2016-3136Lowlinux:3.16.7-ckt20-1+deb8u2sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2016-3140Lowlinux:3.16.7-ckt20-1+deb8u2sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2016-3139Lowlinux:3.16.7-ckt20-1+deb8u2sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2016-2185Lowlinux:3.16.7-ckt20-1+deb8u2sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2016-0823Lowlinux:3.16.7-ckt20-1+deb8u2The pagemap_open function in fs/proc/task_mmu.c in the Linux kernel before 3.19.3, as used in Android 6.0.1 before 2016-03-01, allows local users to obtain sensitive physical-address information by reading a pagemap file, aka Android internal bug 25739721.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2016-2186Lowlinux:3.16.7-ckt20-1+deb8u2sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2016-3138Lowlinux:3.16.7-ckt20-1+deb8u2sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2016-3137Lowlinux:3.16.7-ckt20-1+deb8u2sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2016-2184Lowlinux:3.16.7-ckt20-1+deb8u2sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-5180Lowglibc:2.19-18+deb8u1sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2013-2207Lowglibc:2.19-18+deb8u1pt_chown in GNU C Library (aka glibc or libc6) before 2.18 does not properly check permissions for tty files, which allows local users to change the permission on the files and obtain access to arbitrary pseudo-terminals by leveraging a FUSE file system.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-8777Lowglibc:2.19-18+deb8u1The process_envvars function in elf/rtld.c in the GNU C Library (aka glibc or libc6) before 2.23 allows local users to bypass a pointer-guarding protection mechanism via a zero value of the LD_POINTER_GUARD environment variable.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2016-0702Lowopenssl:1.0.1k-3+deb8u2The MOD_EXP_CTIME_COPY_FROM_PREBUF function in crypto/bn/bn_exp.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not properly consider cache-bank access times during modular exponentiation, which makes it easier for local users to discover RSA keys by running a crafted application on the same Intel Sandy Bridge CPU core as a victim and leveraging cache-bank conflicts, aka a "CacheBleed" attack.sha256:e3255fa43233655173bbddb3250a5037060c469ed363328aedefd3e4e34eca8d
CVE-2015-5180Lowglibc:2.19-18+deb8u1sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2013-2207Lowglibc:2.19-18+deb8u1pt_chown in GNU C Library (aka glibc or libc6) before 2.18 does not properly check permissions for tty files, which allows local users to change the permission on the files and obtain access to arbitrary pseudo-terminals by leveraging a FUSE file system.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-8777Lowglibc:2.19-18+deb8u1The process_envvars function in elf/rtld.c in the GNU C Library (aka glibc or libc6) before 2.23 allows local users to bypass a pointer-guarding protection mechanism via a zero value of the LD_POINTER_GUARD environment variable.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-8629Lowkrb5:1.12.1+dfsg-19+deb8u1The xdr_nullstring function in lib/kadm5/kadm_rpc_xdr.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 does not verify whether '\0' characters exist as expected, which allows remote authenticated users to obtain sensitive information or cause a denial of service (out-of-bounds read) via a crafted string.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2016-3119Lowkrb5:1.12.1+dfsg-19+deb8u1The process_db_args function in plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c in the LDAP KDB module in kadmind in MIT Kerberos 5 (aka krb5) through 1.13.4 and 1.14.x through 1.14.1 mishandles the DB argument, which allows remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) via a crafted request to modify a principal.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2016-0702Lowopenssl:1.0.1k-3+deb8u2The MOD_EXP_CTIME_COPY_FROM_PREBUF function in crypto/bn/bn_exp.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not properly consider cache-bank access times during modular exponentiation, which makes it easier for local users to discover RSA keys by running a crafted application on the same Intel Sandy Bridge CPU core as a victim and leveraging cache-bank conflicts, aka a "CacheBleed" attack.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-6563Lowopenssh:1:6.7p1-5The monitor component in sshd in OpenSSH before 7.0 on non-OpenBSD platforms accepts extraneous username data in MONITOR_REQ_PAM_INIT_CTX requests, which allows local users to conduct impersonation attacks by leveraging any SSH login access in conjunction with control of the sshd uid to send a crafted MONITOR_REQ_PWNAM request, related to monitor.c and monitor_wrap.c.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2014-9717Lowlinux:3.16.7-ckt20-1+deb8u2sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2016-3136Lowlinux:3.16.7-ckt20-1+deb8u2sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2016-3140Lowlinux:3.16.7-ckt20-1+deb8u2sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2016-3139Lowlinux:3.16.7-ckt20-1+deb8u2sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2016-2185Lowlinux:3.16.7-ckt20-1+deb8u2sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2016-0823Lowlinux:3.16.7-ckt20-1+deb8u2The pagemap_open function in fs/proc/task_mmu.c in the Linux kernel before 3.19.3, as used in Android 6.0.1 before 2016-03-01, allows local users to obtain sensitive physical-address information by reading a pagemap file, aka Android internal bug 25739721.sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2016-2186Lowlinux:3.16.7-ckt20-1+deb8u2sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2016-3138Lowlinux:3.16.7-ckt20-1+deb8u2sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2016-3137Lowlinux:3.16.7-ckt20-1+deb8u2sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2016-2184Lowlinux:3.16.7-ckt20-1+deb8u2sha256:a98b8d4ed7cd0b0efc531a2e6320fa916deb1e90d3a1b4463749fd0138e79f31
CVE-2015-8629Lowkrb5:1.12.1+dfsg-19+deb8u1The xdr_nullstring function in lib/kadm5/kadm_rpc_xdr.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 does not verify whether '\0' characters exist as expected, which allows remote authenticated users to obtain sensitive information or cause a denial of service (out-of-bounds read) via a crafted string.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-3119Lowkrb5:1.12.1+dfsg-19+deb8u1The process_db_args function in plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c in the LDAP KDB module in kadmind in MIT Kerberos 5 (aka krb5) through 1.13.4 and 1.14.x through 1.14.1 mishandles the DB argument, which allows remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) via a crafted request to modify a principal.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-6563Lowopenssh:1:6.7p1-5The monitor component in sshd in OpenSSH before 7.0 on non-OpenBSD platforms accepts extraneous username data in MONITOR_REQ_PAM_INIT_CTX requests, which allows local users to conduct impersonation attacks by leveraging any SSH login access in conjunction with control of the sshd uid to send a crafted MONITOR_REQ_PWNAM request, related to monitor.c and monitor_wrap.c.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-0702Lowopenssl:1.0.1k-3+deb8u2The MOD_EXP_CTIME_COPY_FROM_PREBUF function in crypto/bn/bn_exp.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not properly consider cache-bank access times during modular exponentiation, which makes it easier for local users to discover RSA keys by running a crafted application on the same Intel Sandy Bridge CPU core as a victim and leveraging cache-bank conflicts, aka a "CacheBleed" attack.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-5180Lowglibc:2.19-18+deb8u1sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2013-2207Lowglibc:2.19-18+deb8u1pt_chown in GNU C Library (aka glibc or libc6) before 2.18 does not properly check permissions for tty files, which allows local users to change the permission on the files and obtain access to arbitrary pseudo-terminals by leveraging a FUSE file system.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2015-8777Lowglibc:2.19-18+deb8u1The process_envvars function in elf/rtld.c in the GNU C Library (aka glibc or libc6) before 2.23 allows local users to bypass a pointer-guarding protection mechanism via a zero value of the LD_POINTER_GUARD environment variable.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2014-9717Lowlinux:3.16.7-ckt20-1+deb8u2sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-3136Lowlinux:3.16.7-ckt20-1+deb8u2sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-3140Lowlinux:3.16.7-ckt20-1+deb8u2sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-3139Lowlinux:3.16.7-ckt20-1+deb8u2sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-2185Lowlinux:3.16.7-ckt20-1+deb8u2sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-0823Lowlinux:3.16.7-ckt20-1+deb8u2The pagemap_open function in fs/proc/task_mmu.c in the Linux kernel before 3.19.3, as used in Android 6.0.1 before 2016-03-01, allows local users to obtain sensitive physical-address information by reading a pagemap file, aka Android internal bug 25739721.sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-2186Lowlinux:3.16.7-ckt20-1+deb8u2sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-3138Lowlinux:3.16.7-ckt20-1+deb8u2sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-3137Lowlinux:3.16.7-ckt20-1+deb8u2sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-2184Lowlinux:3.16.7-ckt20-1+deb8u2sha256:982f7a61ed69ea684a9c326dceabd74fcc6e25aafd179b0b55861a048902dd2e
CVE-2016-0702Lowopenssl:1.0.1k-3+deb8u2The MOD_EXP_CTIME_COPY_FROM_PREBUF function in crypto/bn/bn_exp.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not properly consider cache-bank access times during modular exponentiation, which makes it easier for local users to discover RSA keys by running a crafted application on the same Intel Sandy Bridge CPU core as a victim and leveraging cache-bank conflicts, aka a "CacheBleed" attack.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-6563Lowopenssh:1:6.7p1-5The monitor component in sshd in OpenSSH before 7.0 on non-OpenBSD platforms accepts extraneous username data in MONITOR_REQ_PAM_INIT_CTX requests, which allows local users to conduct impersonation attacks by leveraging any SSH login access in conjunction with control of the sshd uid to send a crafted MONITOR_REQ_PWNAM request, related to monitor.c and monitor_wrap.c.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-8629Lowkrb5:1.12.1+dfsg-19+deb8u1The xdr_nullstring function in lib/kadm5/kadm_rpc_xdr.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 does not verify whether '\0' characters exist as expected, which allows remote authenticated users to obtain sensitive information or cause a denial of service (out-of-bounds read) via a crafted string.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2016-3119Lowkrb5:1.12.1+dfsg-19+deb8u1The process_db_args function in plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c in the LDAP KDB module in kadmind in MIT Kerberos 5 (aka krb5) through 1.13.4 and 1.14.x through 1.14.1 mishandles the DB argument, which allows remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) via a crafted request to modify a principal.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2014-9717Lowlinux:3.16.7-ckt20-1+deb8u2sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2016-3136Lowlinux:3.16.7-ckt20-1+deb8u2sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2016-3140Lowlinux:3.16.7-ckt20-1+deb8u2sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2016-3139Lowlinux:3.16.7-ckt20-1+deb8u2sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2016-2185Lowlinux:3.16.7-ckt20-1+deb8u2sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2016-0823Lowlinux:3.16.7-ckt20-1+deb8u2The pagemap_open function in fs/proc/task_mmu.c in the Linux kernel before 3.19.3, as used in Android 6.0.1 before 2016-03-01, allows local users to obtain sensitive physical-address information by reading a pagemap file, aka Android internal bug 25739721.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2016-2186Lowlinux:3.16.7-ckt20-1+deb8u2sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2016-3138Lowlinux:3.16.7-ckt20-1+deb8u2sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2016-3137Lowlinux:3.16.7-ckt20-1+deb8u2sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2016-2184Lowlinux:3.16.7-ckt20-1+deb8u2sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-5180Lowglibc:2.19-18+deb8u1sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2013-2207Lowglibc:2.19-18+deb8u1pt_chown in GNU C Library (aka glibc or libc6) before 2.18 does not properly check permissions for tty files, which allows local users to change the permission on the files and obtain access to arbitrary pseudo-terminals by leveraging a FUSE file system.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2015-8777Lowglibc:2.19-18+deb8u1The process_envvars function in elf/rtld.c in the GNU C Library (aka glibc or libc6) before 2.23 allows local users to bypass a pointer-guarding protection mechanism via a zero value of the LD_POINTER_GUARD environment variable.sha256:d7e1456bd365c6216808365c91244122ac2a9186ede65176b6e4949a3b6b7c57
CVE-2014-9717Lowlinux:3.16.7-ckt20-1+deb8u2sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2016-3136Lowlinux:3.16.7-ckt20-1+deb8u2sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2016-3140Lowlinux:3.16.7-ckt20-1+deb8u2sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2016-3139Lowlinux:3.16.7-ckt20-1+deb8u2sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2016-2185Lowlinux:3.16.7-ckt20-1+deb8u2sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2016-0823Lowlinux:3.16.7-ckt20-1+deb8u2The pagemap_open function in fs/proc/task_mmu.c in the Linux kernel before 3.19.3, as used in Android 6.0.1 before 2016-03-01, allows local users to obtain sensitive physical-address information by reading a pagemap file, aka Android internal bug 25739721.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2016-2186Lowlinux:3.16.7-ckt20-1+deb8u2sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2016-3138Lowlinux:3.16.7-ckt20-1+deb8u2sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2016-3137Lowlinux:3.16.7-ckt20-1+deb8u2sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2016-2184Lowlinux:3.16.7-ckt20-1+deb8u2sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2016-0702Lowopenssl:1.0.1k-3+deb8u2The MOD_EXP_CTIME_COPY_FROM_PREBUF function in crypto/bn/bn_exp.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not properly consider cache-bank access times during modular exponentiation, which makes it easier for local users to discover RSA keys by running a crafted application on the same Intel Sandy Bridge CPU core as a victim and leveraging cache-bank conflicts, aka a "CacheBleed" attack.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-5180Lowglibc:2.19-18+deb8u1sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2013-2207Lowglibc:2.19-18+deb8u1pt_chown in GNU C Library (aka glibc or libc6) before 2.18 does not properly check permissions for tty files, which allows local users to change the permission on the files and obtain access to arbitrary pseudo-terminals by leveraging a FUSE file system.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-8777Lowglibc:2.19-18+deb8u1The process_envvars function in elf/rtld.c in the GNU C Library (aka glibc or libc6) before 2.23 allows local users to bypass a pointer-guarding protection mechanism via a zero value of the LD_POINTER_GUARD environment variable.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-6563Lowopenssh:1:6.7p1-5The monitor component in sshd in OpenSSH before 7.0 on non-OpenBSD platforms accepts extraneous username data in MONITOR_REQ_PAM_INIT_CTX requests, which allows local users to conduct impersonation attacks by leveraging any SSH login access in conjunction with control of the sshd uid to send a crafted MONITOR_REQ_PWNAM request, related to monitor.c and monitor_wrap.c.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-8629Lowkrb5:1.12.1+dfsg-19+deb8u1The xdr_nullstring function in lib/kadm5/kadm_rpc_xdr.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 does not verify whether '\0' characters exist as expected, which allows remote authenticated users to obtain sensitive information or cause a denial of service (out-of-bounds read) via a crafted string.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2016-3119Lowkrb5:1.12.1+dfsg-19+deb8u1The process_db_args function in plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c in the LDAP KDB module in kadmind in MIT Kerberos 5 (aka krb5) through 1.13.4 and 1.14.x through 1.14.1 mishandles the DB argument, which allows remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) via a crafted request to modify a principal.sha256:243f57a9cb9df05873855de5061e338c5e0573878754e3a4a2fb5dd34d298599
CVE-2015-6563Lowopenssh:1:6.7p1-5The monitor component in sshd in OpenSSH before 7.0 on non-OpenBSD platforms accepts extraneous username data in MONITOR_REQ_PAM_INIT_CTX requests, which allows local users to conduct impersonation attacks by leveraging any SSH login access in conjunction with control of the sshd uid to send a crafted MONITOR_REQ_PWNAM request, related to monitor.c and monitor_wrap.c.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2016-0702Lowopenssl:1.0.1k-3+deb8u2The MOD_EXP_CTIME_COPY_FROM_PREBUF function in crypto/bn/bn_exp.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not properly consider cache-bank access times during modular exponentiation, which makes it easier for local users to discover RSA keys by running a crafted application on the same Intel Sandy Bridge CPU core as a victim and leveraging cache-bank conflicts, aka a "CacheBleed" attack.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-5180Lowglibc:2.19-18+deb8u1sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2013-2207Lowglibc:2.19-18+deb8u1pt_chown in GNU C Library (aka glibc or libc6) before 2.18 does not properly check permissions for tty files, which allows local users to change the permission on the files and obtain access to arbitrary pseudo-terminals by leveraging a FUSE file system.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-8777Lowglibc:2.19-18+deb8u1The process_envvars function in elf/rtld.c in the GNU C Library (aka glibc or libc6) before 2.23 allows local users to bypass a pointer-guarding protection mechanism via a zero value of the LD_POINTER_GUARD environment variable.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2014-9717Lowlinux:3.16.7-ckt20-1+deb8u2sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2016-3136Lowlinux:3.16.7-ckt20-1+deb8u2sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2016-3140Lowlinux:3.16.7-ckt20-1+deb8u2sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2016-3139Lowlinux:3.16.7-ckt20-1+deb8u2sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2016-2185Lowlinux:3.16.7-ckt20-1+deb8u2sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2016-0823Lowlinux:3.16.7-ckt20-1+deb8u2The pagemap_open function in fs/proc/task_mmu.c in the Linux kernel before 3.19.3, as used in Android 6.0.1 before 2016-03-01, allows local users to obtain sensitive physical-address information by reading a pagemap file, aka Android internal bug 25739721.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2016-2186Lowlinux:3.16.7-ckt20-1+deb8u2sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2016-3138Lowlinux:3.16.7-ckt20-1+deb8u2sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2016-3137Lowlinux:3.16.7-ckt20-1+deb8u2sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2016-2184Lowlinux:3.16.7-ckt20-1+deb8u2sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2015-8629Lowkrb5:1.12.1+dfsg-19+deb8u1The xdr_nullstring function in lib/kadm5/kadm_rpc_xdr.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 does not verify whether '\0' characters exist as expected, which allows remote authenticated users to obtain sensitive information or cause a denial of service (out-of-bounds read) via a crafted string.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2016-3119Lowkrb5:1.12.1+dfsg-19+deb8u1The process_db_args function in plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c in the LDAP KDB module in kadmind in MIT Kerberos 5 (aka krb5) through 1.13.4 and 1.14.x through 1.14.1 mishandles the DB argument, which allows remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) via a crafted request to modify a principal.sha256:410efbf0f33e16aaa59a4bf7e110795d204bb2349a6c4e181de43210e90586b6
CVE-2014-9717Lowlinux:3.16.7-ckt20-1+deb8u2sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2016-3136Lowlinux:3.16.7-ckt20-1+deb8u2sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2016-3140Lowlinux:3.16.7-ckt20-1+deb8u2sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2016-3139Lowlinux:3.16.7-ckt20-1+deb8u2sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2016-2185Lowlinux:3.16.7-ckt20-1+deb8u2sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2016-0823Lowlinux:3.16.7-ckt20-1+deb8u2The pagemap_open function in fs/proc/task_mmu.c in the Linux kernel before 3.19.3, as used in Android 6.0.1 before 2016-03-01, allows local users to obtain sensitive physical-address information by reading a pagemap file, aka Android internal bug 25739721.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2016-2186Lowlinux:3.16.7-ckt20-1+deb8u2sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2016-3138Lowlinux:3.16.7-ckt20-1+deb8u2sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2016-3137Lowlinux:3.16.7-ckt20-1+deb8u2sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2016-2184Lowlinux:3.16.7-ckt20-1+deb8u2sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-6563Lowopenssh:1:6.7p1-5The monitor component in sshd in OpenSSH before 7.0 on non-OpenBSD platforms accepts extraneous username data in MONITOR_REQ_PAM_INIT_CTX requests, which allows local users to conduct impersonation attacks by leveraging any SSH login access in conjunction with control of the sshd uid to send a crafted MONITOR_REQ_PWNAM request, related to monitor.c and monitor_wrap.c.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-5180Lowglibc:2.19-18+deb8u1sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2013-2207Lowglibc:2.19-18+deb8u1pt_chown in GNU C Library (aka glibc or libc6) before 2.18 does not properly check permissions for tty files, which allows local users to change the permission on the files and obtain access to arbitrary pseudo-terminals by leveraging a FUSE file system.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-8777Lowglibc:2.19-18+deb8u1The process_envvars function in elf/rtld.c in the GNU C Library (aka glibc or libc6) before 2.23 allows local users to bypass a pointer-guarding protection mechanism via a zero value of the LD_POINTER_GUARD environment variable.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2015-8629Lowkrb5:1.12.1+dfsg-19+deb8u1The xdr_nullstring function in lib/kadm5/kadm_rpc_xdr.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 does not verify whether '\0' characters exist as expected, which allows remote authenticated users to obtain sensitive information or cause a denial of service (out-of-bounds read) via a crafted string.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2016-3119Lowkrb5:1.12.1+dfsg-19+deb8u1The process_db_args function in plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c in the LDAP KDB module in kadmind in MIT Kerberos 5 (aka krb5) through 1.13.4 and 1.14.x through 1.14.1 mishandles the DB argument, which allows remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) via a crafted request to modify a principal.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2016-0702Lowopenssl:1.0.1k-3+deb8u2The MOD_EXP_CTIME_COPY_FROM_PREBUF function in crypto/bn/bn_exp.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not properly consider cache-bank access times during modular exponentiation, which makes it easier for local users to discover RSA keys by running a crafted application on the same Intel Sandy Bridge CPU core as a victim and leveraging cache-bank conflicts, aka a "CacheBleed" attack.sha256:6239c10e33a84c9edebfc15d99fcb9521f6e062b2b393266d07fb0e36f5980e1
CVE-2014-9717Lowlinux:3.16.7-ckt20-1+deb8u2sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2016-3136Lowlinux:3.16.7-ckt20-1+deb8u2sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2016-3140Lowlinux:3.16.7-ckt20-1+deb8u2sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2016-3139Lowlinux:3.16.7-ckt20-1+deb8u2sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2016-2185Lowlinux:3.16.7-ckt20-1+deb8u2sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2016-0823Lowlinux:3.16.7-ckt20-1+deb8u2The pagemap_open function in fs/proc/task_mmu.c in the Linux kernel before 3.19.3, as used in Android 6.0.1 before 2016-03-01, allows local users to obtain sensitive physical-address information by reading a pagemap file, aka Android internal bug 25739721.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2016-2186Lowlinux:3.16.7-ckt20-1+deb8u2sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2016-3138Lowlinux:3.16.7-ckt20-1+deb8u2sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2016-3137Lowlinux:3.16.7-ckt20-1+deb8u2sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2016-2184Lowlinux:3.16.7-ckt20-1+deb8u2sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-8629Lowkrb5:1.12.1+dfsg-19+deb8u1The xdr_nullstring function in lib/kadm5/kadm_rpc_xdr.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 does not verify whether '\0' characters exist as expected, which allows remote authenticated users to obtain sensitive information or cause a denial of service (out-of-bounds read) via a crafted string.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2016-3119Lowkrb5:1.12.1+dfsg-19+deb8u1The process_db_args function in plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c in the LDAP KDB module in kadmind in MIT Kerberos 5 (aka krb5) through 1.13.4 and 1.14.x through 1.14.1 mishandles the DB argument, which allows remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) via a crafted request to modify a principal.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-5180Lowglibc:2.19-18+deb8u1sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2013-2207Lowglibc:2.19-18+deb8u1pt_chown in GNU C Library (aka glibc or libc6) before 2.18 does not properly check permissions for tty files, which allows local users to change the permission on the files and obtain access to arbitrary pseudo-terminals by leveraging a FUSE file system.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-8777Lowglibc:2.19-18+deb8u1The process_envvars function in elf/rtld.c in the GNU C Library (aka glibc or libc6) before 2.23 allows local users to bypass a pointer-guarding protection mechanism via a zero value of the LD_POINTER_GUARD environment variable.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-6563Lowopenssh:1:6.7p1-5The monitor component in sshd in OpenSSH before 7.0 on non-OpenBSD platforms accepts extraneous username data in MONITOR_REQ_PAM_INIT_CTX requests, which allows local users to conduct impersonation attacks by leveraging any SSH login access in conjunction with control of the sshd uid to send a crafted MONITOR_REQ_PWNAM request, related to monitor.c and monitor_wrap.c.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2016-0702Lowopenssl:1.0.1k-3+deb8u2The MOD_EXP_CTIME_COPY_FROM_PREBUF function in crypto/bn/bn_exp.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not properly consider cache-bank access times during modular exponentiation, which makes it easier for local users to discover RSA keys by running a crafted application on the same Intel Sandy Bridge CPU core as a victim and leveraging cache-bank conflicts, aka a "CacheBleed" attack.sha256:19e278f7ac0ae60be568b71fb5cbdbfd92b023604912ca1295a6337f1507ed9e
CVE-2015-5180Lowglibc:2.19-18+deb8u1sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2013-2207Lowglibc:2.19-18+deb8u1pt_chown in GNU C Library (aka glibc or libc6) before 2.18 does not properly check permissions for tty files, which allows local users to change the permission on the files and obtain access to arbitrary pseudo-terminals by leveraging a FUSE file system.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-8777Lowglibc:2.19-18+deb8u1The process_envvars function in elf/rtld.c in the GNU C Library (aka glibc or libc6) before 2.23 allows local users to bypass a pointer-guarding protection mechanism via a zero value of the LD_POINTER_GUARD environment variable.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2016-0702Lowopenssl:1.0.1k-3+deb8u2The MOD_EXP_CTIME_COPY_FROM_PREBUF function in crypto/bn/bn_exp.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not properly consider cache-bank access times during modular exponentiation, which makes it easier for local users to discover RSA keys by running a crafted application on the same Intel Sandy Bridge CPU core as a victim and leveraging cache-bank conflicts, aka a "CacheBleed" attack.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-8629Lowkrb5:1.12.1+dfsg-19+deb8u1The xdr_nullstring function in lib/kadm5/kadm_rpc_xdr.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 does not verify whether '\0' characters exist as expected, which allows remote authenticated users to obtain sensitive information or cause a denial of service (out-of-bounds read) via a crafted string.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2016-3119Lowkrb5:1.12.1+dfsg-19+deb8u1The process_db_args function in plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c in the LDAP KDB module in kadmind in MIT Kerberos 5 (aka krb5) through 1.13.4 and 1.14.x through 1.14.1 mishandles the DB argument, which allows remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) via a crafted request to modify a principal.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-6563Lowopenssh:1:6.7p1-5The monitor component in sshd in OpenSSH before 7.0 on non-OpenBSD platforms accepts extraneous username data in MONITOR_REQ_PAM_INIT_CTX requests, which allows local users to conduct impersonation attacks by leveraging any SSH login access in conjunction with control of the sshd uid to send a crafted MONITOR_REQ_PWNAM request, related to monitor.c and monitor_wrap.c.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2014-9717Lowlinux:3.16.7-ckt20-1+deb8u2sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2016-3136Lowlinux:3.16.7-ckt20-1+deb8u2sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2016-3140Lowlinux:3.16.7-ckt20-1+deb8u2sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2016-3139Lowlinux:3.16.7-ckt20-1+deb8u2sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2016-2185Lowlinux:3.16.7-ckt20-1+deb8u2sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2016-0823Lowlinux:3.16.7-ckt20-1+deb8u2The pagemap_open function in fs/proc/task_mmu.c in the Linux kernel before 3.19.3, as used in Android 6.0.1 before 2016-03-01, allows local users to obtain sensitive physical-address information by reading a pagemap file, aka Android internal bug 25739721.sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2016-2186Lowlinux:3.16.7-ckt20-1+deb8u2sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2016-3138Lowlinux:3.16.7-ckt20-1+deb8u2sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2016-3137Lowlinux:3.16.7-ckt20-1+deb8u2sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2016-2184Lowlinux:3.16.7-ckt20-1+deb8u2sha256:941d6f30f213b003998e30d6eabb22903853cfdd8cfbcee01471be9d3007ea35
CVE-2015-5180Lowglibc:2.19-18+deb8u1sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2013-2207Lowglibc:2.19-18+deb8u1pt_chown in GNU C Library (aka glibc or libc6) before 2.18 does not properly check permissions for tty files, which allows local users to change the permission on the files and obtain access to arbitrary pseudo-terminals by leveraging a FUSE file system.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-8777Lowglibc:2.19-18+deb8u1The process_envvars function in elf/rtld.c in the GNU C Library (aka glibc or libc6) before 2.23 allows local users to bypass a pointer-guarding protection mechanism via a zero value of the LD_POINTER_GUARD environment variable.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-6563Lowopenssh:1:6.7p1-5The monitor component in sshd in OpenSSH before 7.0 on non-OpenBSD platforms accepts extraneous username data in MONITOR_REQ_PAM_INIT_CTX requests, which allows local users to conduct impersonation attacks by leveraging any SSH login access in conjunction with control of the sshd uid to send a crafted MONITOR_REQ_PWNAM request, related to monitor.c and monitor_wrap.c.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2014-9717Lowlinux:3.16.7-ckt20-1+deb8u2sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2016-3136Lowlinux:3.16.7-ckt20-1+deb8u2sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2016-3140Lowlinux:3.16.7-ckt20-1+deb8u2sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2016-3139Lowlinux:3.16.7-ckt20-1+deb8u2sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2016-2185Lowlinux:3.16.7-ckt20-1+deb8u2sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2016-0823Lowlinux:3.16.7-ckt20-1+deb8u2The pagemap_open function in fs/proc/task_mmu.c in the Linux kernel before 3.19.3, as used in Android 6.0.1 before 2016-03-01, allows local users to obtain sensitive physical-address information by reading a pagemap file, aka Android internal bug 25739721.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2016-2186Lowlinux:3.16.7-ckt20-1+deb8u2sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2016-3138Lowlinux:3.16.7-ckt20-1+deb8u2sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2016-3137Lowlinux:3.16.7-ckt20-1+deb8u2sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2016-2184Lowlinux:3.16.7-ckt20-1+deb8u2sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2016-0702Lowopenssl:1.0.1k-3+deb8u2The MOD_EXP_CTIME_COPY_FROM_PREBUF function in crypto/bn/bn_exp.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not properly consider cache-bank access times during modular exponentiation, which makes it easier for local users to discover RSA keys by running a crafted application on the same Intel Sandy Bridge CPU core as a victim and leveraging cache-bank conflicts, aka a "CacheBleed" attack.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-8629Lowkrb5:1.12.1+dfsg-19+deb8u1The xdr_nullstring function in lib/kadm5/kadm_rpc_xdr.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 does not verify whether '\0' characters exist as expected, which allows remote authenticated users to obtain sensitive information or cause a denial of service (out-of-bounds read) via a crafted string.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2016-3119Lowkrb5:1.12.1+dfsg-19+deb8u1The process_db_args function in plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c in the LDAP KDB module in kadmind in MIT Kerberos 5 (aka krb5) through 1.13.4 and 1.14.x through 1.14.1 mishandles the DB argument, which allows remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) via a crafted request to modify a principal.sha256:1b28184d5b69f8d98e8d4cffd6868f94cef053ac1efd8fc568084779c8463499
CVE-2015-6563Lowopenssh:1:6.7p1-5The monitor component in sshd in OpenSSH before 7.0 on non-OpenBSD platforms accepts extraneous username data in MONITOR_REQ_PAM_INIT_CTX requests, which allows local users to conduct impersonation attacks by leveraging any SSH login access in conjunction with control of the sshd uid to send a crafted MONITOR_REQ_PWNAM request, related to monitor.c and monitor_wrap.c.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2014-9717Lowlinux:3.16.7-ckt20-1+deb8u2sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2016-3136Lowlinux:3.16.7-ckt20-1+deb8u2sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2016-3140Lowlinux:3.16.7-ckt20-1+deb8u2sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2016-3139Lowlinux:3.16.7-ckt20-1+deb8u2sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2016-2185Lowlinux:3.16.7-ckt20-1+deb8u2sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2016-0823Lowlinux:3.16.7-ckt20-1+deb8u2The pagemap_open function in fs/proc/task_mmu.c in the Linux kernel before 3.19.3, as used in Android 6.0.1 before 2016-03-01, allows local users to obtain sensitive physical-address information by reading a pagemap file, aka Android internal bug 25739721.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2016-2186Lowlinux:3.16.7-ckt20-1+deb8u2sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2016-3138Lowlinux:3.16.7-ckt20-1+deb8u2sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2016-3137Lowlinux:3.16.7-ckt20-1+deb8u2sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2016-2184Lowlinux:3.16.7-ckt20-1+deb8u2sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-5180Lowglibc:2.19-18+deb8u1sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2013-2207Lowglibc:2.19-18+deb8u1pt_chown in GNU C Library (aka glibc or libc6) before 2.18 does not properly check permissions for tty files, which allows local users to change the permission on the files and obtain access to arbitrary pseudo-terminals by leveraging a FUSE file system.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-8777Lowglibc:2.19-18+deb8u1The process_envvars function in elf/rtld.c in the GNU C Library (aka glibc or libc6) before 2.23 allows local users to bypass a pointer-guarding protection mechanism via a zero value of the LD_POINTER_GUARD environment variable.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-8629Lowkrb5:1.12.1+dfsg-19+deb8u1The xdr_nullstring function in lib/kadm5/kadm_rpc_xdr.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 does not verify whether '\0' characters exist as expected, which allows remote authenticated users to obtain sensitive information or cause a denial of service (out-of-bounds read) via a crafted string.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2016-3119Lowkrb5:1.12.1+dfsg-19+deb8u1The process_db_args function in plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c in the LDAP KDB module in kadmind in MIT Kerberos 5 (aka krb5) through 1.13.4 and 1.14.x through 1.14.1 mishandles the DB argument, which allows remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) via a crafted request to modify a principal.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2016-0702Lowopenssl:1.0.1k-3+deb8u2The MOD_EXP_CTIME_COPY_FROM_PREBUF function in crypto/bn/bn_exp.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not properly consider cache-bank access times during modular exponentiation, which makes it easier for local users to discover RSA keys by running a crafted application on the same Intel Sandy Bridge CPU core as a victim and leveraging cache-bank conflicts, aka a "CacheBleed" attack.sha256:7f7f57d387eecde53e2b1cc178afcaf7538a37e79c41c7ebe22589b6c9a32565
CVE-2015-6563Lowopenssh:1:6.7p1-5The monitor component in sshd in OpenSSH before 7.0 on non-OpenBSD platforms accepts extraneous username data in MONITOR_REQ_PAM_INIT_CTX requests, which allows local users to conduct impersonation attacks by leveraging any SSH login access in conjunction with control of the sshd uid to send a crafted MONITOR_REQ_PWNAM request, related to monitor.c and monitor_wrap.c.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-5180Lowglibc:2.19-18+deb8u1sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2013-2207Lowglibc:2.19-18+deb8u1pt_chown in GNU C Library (aka glibc or libc6) before 2.18 does not properly check permissions for tty files, which allows local users to change the permission on the files and obtain access to arbitrary pseudo-terminals by leveraging a FUSE file system.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-8777Lowglibc:2.19-18+deb8u1The process_envvars function in elf/rtld.c in the GNU C Library (aka glibc or libc6) before 2.23 allows local users to bypass a pointer-guarding protection mechanism via a zero value of the LD_POINTER_GUARD environment variable.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2014-9717Lowlinux:3.16.7-ckt20-1+deb8u2sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2016-3136Lowlinux:3.16.7-ckt20-1+deb8u2sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2016-3140Lowlinux:3.16.7-ckt20-1+deb8u2sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2016-3139Lowlinux:3.16.7-ckt20-1+deb8u2sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2016-2185Lowlinux:3.16.7-ckt20-1+deb8u2sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2016-0823Lowlinux:3.16.7-ckt20-1+deb8u2The pagemap_open function in fs/proc/task_mmu.c in the Linux kernel before 3.19.3, as used in Android 6.0.1 before 2016-03-01, allows local users to obtain sensitive physical-address information by reading a pagemap file, aka Android internal bug 25739721.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2016-2186Lowlinux:3.16.7-ckt20-1+deb8u2sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2016-3138Lowlinux:3.16.7-ckt20-1+deb8u2sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2016-3137Lowlinux:3.16.7-ckt20-1+deb8u2sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2016-2184Lowlinux:3.16.7-ckt20-1+deb8u2sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2016-0702Lowopenssl:1.0.1k-3+deb8u2The MOD_EXP_CTIME_COPY_FROM_PREBUF function in crypto/bn/bn_exp.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not properly consider cache-bank access times during modular exponentiation, which makes it easier for local users to discover RSA keys by running a crafted application on the same Intel Sandy Bridge CPU core as a victim and leveraging cache-bank conflicts, aka a "CacheBleed" attack.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-8629Lowkrb5:1.12.1+dfsg-19+deb8u1The xdr_nullstring function in lib/kadm5/kadm_rpc_xdr.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 does not verify whether '\0' characters exist as expected, which allows remote authenticated users to obtain sensitive information or cause a denial of service (out-of-bounds read) via a crafted string.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2016-3119Lowkrb5:1.12.1+dfsg-19+deb8u1The process_db_args function in plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c in the LDAP KDB module in kadmind in MIT Kerberos 5 (aka krb5) through 1.13.4 and 1.14.x through 1.14.1 mishandles the DB argument, which allows remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) via a crafted request to modify a principal.sha256:0a01a60e642e26d1fd83e55df574747c15c7e1981bc640e66258a6c7a25b7015
CVE-2015-6563Lowopenssh:1:6.7p1-5The monitor component in sshd in OpenSSH before 7.0 on non-OpenBSD platforms accepts extraneous username data in MONITOR_REQ_PAM_INIT_CTX requests, which allows local users to conduct impersonation attacks by leveraging any SSH login access in conjunction with control of the sshd uid to send a crafted MONITOR_REQ_PWNAM request, related to monitor.c and monitor_wrap.c.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-8629Lowkrb5:1.12.1+dfsg-19+deb8u1The xdr_nullstring function in lib/kadm5/kadm_rpc_xdr.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 does not verify whether '\0' characters exist as expected, which allows remote authenticated users to obtain sensitive information or cause a denial of service (out-of-bounds read) via a crafted string.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2016-3119Lowkrb5:1.12.1+dfsg-19+deb8u1The process_db_args function in plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c in the LDAP KDB module in kadmind in MIT Kerberos 5 (aka krb5) through 1.13.4 and 1.14.x through 1.14.1 mishandles the DB argument, which allows remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) via a crafted request to modify a principal.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2014-9717Lowlinux:3.16.7-ckt20-1+deb8u2sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2016-3136Lowlinux:3.16.7-ckt20-1+deb8u2sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2016-3140Lowlinux:3.16.7-ckt20-1+deb8u2sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2016-3139Lowlinux:3.16.7-ckt20-1+deb8u2sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2016-2185Lowlinux:3.16.7-ckt20-1+deb8u2sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2016-0823Lowlinux:3.16.7-ckt20-1+deb8u2The pagemap_open function in fs/proc/task_mmu.c in the Linux kernel before 3.19.3, as used in Android 6.0.1 before 2016-03-01, allows local users to obtain sensitive physical-address information by reading a pagemap file, aka Android internal bug 25739721.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2016-2186Lowlinux:3.16.7-ckt20-1+deb8u2sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2016-3138Lowlinux:3.16.7-ckt20-1+deb8u2sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2016-3137Lowlinux:3.16.7-ckt20-1+deb8u2sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2016-2184Lowlinux:3.16.7-ckt20-1+deb8u2sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-5180Lowglibc:2.19-18+deb8u1sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2013-2207Lowglibc:2.19-18+deb8u1pt_chown in GNU C Library (aka glibc or libc6) before 2.18 does not properly check permissions for tty files, which allows local users to change the permission on the files and obtain access to arbitrary pseudo-terminals by leveraging a FUSE file system.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-8777Lowglibc:2.19-18+deb8u1The process_envvars function in elf/rtld.c in the GNU C Library (aka glibc or libc6) before 2.23 allows local users to bypass a pointer-guarding protection mechanism via a zero value of the LD_POINTER_GUARD environment variable.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2016-0702Lowopenssl:1.0.1k-3+deb8u2The MOD_EXP_CTIME_COPY_FROM_PREBUF function in crypto/bn/bn_exp.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not properly consider cache-bank access times during modular exponentiation, which makes it easier for local users to discover RSA keys by running a crafted application on the same Intel Sandy Bridge CPU core as a victim and leveraging cache-bank conflicts, aka a "CacheBleed" attack.sha256:1f19472cfca06fbe1d07f3376688beeda792d9bbdaba42fd4bead26bb838eaba
CVE-2015-6563Lowopenssh:1:6.7p1-5The monitor component in sshd in OpenSSH before 7.0 on non-OpenBSD platforms accepts extraneous username data in MONITOR_REQ_PAM_INIT_CTX requests, which allows local users to conduct impersonation attacks by leveraging any SSH login access in conjunction with control of the sshd uid to send a crafted MONITOR_REQ_PWNAM request, related to monitor.c and monitor_wrap.c.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-8629Lowkrb5:1.12.1+dfsg-19+deb8u1The xdr_nullstring function in lib/kadm5/kadm_rpc_xdr.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 does not verify whether '\0' characters exist as expected, which allows remote authenticated users to obtain sensitive information or cause a denial of service (out-of-bounds read) via a crafted string.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2016-3119Lowkrb5:1.12.1+dfsg-19+deb8u1The process_db_args function in plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c in the LDAP KDB module in kadmind in MIT Kerberos 5 (aka krb5) through 1.13.4 and 1.14.x through 1.14.1 mishandles the DB argument, which allows remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) via a crafted request to modify a principal.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2016-0702Lowopenssl:1.0.1k-3+deb8u2The MOD_EXP_CTIME_COPY_FROM_PREBUF function in crypto/bn/bn_exp.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not properly consider cache-bank access times during modular exponentiation, which makes it easier for local users to discover RSA keys by running a crafted application on the same Intel Sandy Bridge CPU core as a victim and leveraging cache-bank conflicts, aka a "CacheBleed" attack.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-5180Lowglibc:2.19-18+deb8u1sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2013-2207Lowglibc:2.19-18+deb8u1pt_chown in GNU C Library (aka glibc or libc6) before 2.18 does not properly check permissions for tty files, which allows local users to change the permission on the files and obtain access to arbitrary pseudo-terminals by leveraging a FUSE file system.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2015-8777Lowglibc:2.19-18+deb8u1The process_envvars function in elf/rtld.c in the GNU C Library (aka glibc or libc6) before 2.23 allows local users to bypass a pointer-guarding protection mechanism via a zero value of the LD_POINTER_GUARD environment variable.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2014-9717Lowlinux:3.16.7-ckt20-1+deb8u2sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2016-3136Lowlinux:3.16.7-ckt20-1+deb8u2sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2016-3140Lowlinux:3.16.7-ckt20-1+deb8u2sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2016-3139Lowlinux:3.16.7-ckt20-1+deb8u2sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2016-2185Lowlinux:3.16.7-ckt20-1+deb8u2sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2016-0823Lowlinux:3.16.7-ckt20-1+deb8u2The pagemap_open function in fs/proc/task_mmu.c in the Linux kernel before 3.19.3, as used in Android 6.0.1 before 2016-03-01, allows local users to obtain sensitive physical-address information by reading a pagemap file, aka Android internal bug 25739721.sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2016-2186Lowlinux:3.16.7-ckt20-1+deb8u2sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2016-3138Lowlinux:3.16.7-ckt20-1+deb8u2sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2016-3137Lowlinux:3.16.7-ckt20-1+deb8u2sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2016-2184Lowlinux:3.16.7-ckt20-1+deb8u2sha256:685e6bc3c0cfae5498d9d040a2248198d3fbacf0807989e9fcd131de49a62eb1
CVE-2014-9717Lowlinux:3.16.7-ckt20-1+deb8u2sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2016-3136Lowlinux:3.16.7-ckt20-1+deb8u2sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2016-3140Lowlinux:3.16.7-ckt20-1+deb8u2sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2016-3139Lowlinux:3.16.7-ckt20-1+deb8u2sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2016-2185Lowlinux:3.16.7-ckt20-1+deb8u2sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2016-0823Lowlinux:3.16.7-ckt20-1+deb8u2The pagemap_open function in fs/proc/task_mmu.c in the Linux kernel before 3.19.3, as used in Android 6.0.1 before 2016-03-01, allows local users to obtain sensitive physical-address information by reading a pagemap file, aka Android internal bug 25739721.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2016-2186Lowlinux:3.16.7-ckt20-1+deb8u2sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2016-3138Lowlinux:3.16.7-ckt20-1+deb8u2sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2016-3137Lowlinux:3.16.7-ckt20-1+deb8u2sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2016-2184Lowlinux:3.16.7-ckt20-1+deb8u2sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-8629Lowkrb5:1.12.1+dfsg-19+deb8u1The xdr_nullstring function in lib/kadm5/kadm_rpc_xdr.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 does not verify whether '\0' characters exist as expected, which allows remote authenticated users to obtain sensitive information or cause a denial of service (out-of-bounds read) via a crafted string.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2016-3119Lowkrb5:1.12.1+dfsg-19+deb8u1The process_db_args function in plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c in the LDAP KDB module in kadmind in MIT Kerberos 5 (aka krb5) through 1.13.4 and 1.14.x through 1.14.1 mishandles the DB argument, which allows remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) via a crafted request to modify a principal.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-5180Lowglibc:2.19-18+deb8u1sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2013-2207Lowglibc:2.19-18+deb8u1pt_chown in GNU C Library (aka glibc or libc6) before 2.18 does not properly check permissions for tty files, which allows local users to change the permission on the files and obtain access to arbitrary pseudo-terminals by leveraging a FUSE file system.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-8777Lowglibc:2.19-18+deb8u1The process_envvars function in elf/rtld.c in the GNU C Library (aka glibc or libc6) before 2.23 allows local users to bypass a pointer-guarding protection mechanism via a zero value of the LD_POINTER_GUARD environment variable.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2016-0702Lowopenssl:1.0.1k-3+deb8u2The MOD_EXP_CTIME_COPY_FROM_PREBUF function in crypto/bn/bn_exp.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not properly consider cache-bank access times during modular exponentiation, which makes it easier for local users to discover RSA keys by running a crafted application on the same Intel Sandy Bridge CPU core as a victim and leveraging cache-bank conflicts, aka a "CacheBleed" attack.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-6563Lowopenssh:1:6.7p1-5The monitor component in sshd in OpenSSH before 7.0 on non-OpenBSD platforms accepts extraneous username data in MONITOR_REQ_PAM_INIT_CTX requests, which allows local users to conduct impersonation attacks by leveraging any SSH login access in conjunction with control of the sshd uid to send a crafted MONITOR_REQ_PWNAM request, related to monitor.c and monitor_wrap.c.sha256:099ca01b81b831a7c24c755904abf8d76b8ded3b56bd0b4941fa71a990c49b1b
CVE-2015-8629Lowkrb5:1.12.1+dfsg-19+deb8u1The xdr_nullstring function in lib/kadm5/kadm_rpc_xdr.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 does not verify whether '\0' characters exist as expected, which allows remote authenticated users to obtain sensitive information or cause a denial of service (out-of-bounds read) via a crafted string.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2016-3119Lowkrb5:1.12.1+dfsg-19+deb8u1The process_db_args function in plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c in the LDAP KDB module in kadmind in MIT Kerberos 5 (aka krb5) through 1.13.4 and 1.14.x through 1.14.1 mishandles the DB argument, which allows remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) via a crafted request to modify a principal.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-6563Lowopenssh:1:6.7p1-5The monitor component in sshd in OpenSSH before 7.0 on non-OpenBSD platforms accepts extraneous username data in MONITOR_REQ_PAM_INIT_CTX requests, which allows local users to conduct impersonation attacks by leveraging any SSH login access in conjunction with control of the sshd uid to send a crafted MONITOR_REQ_PWNAM request, related to monitor.c and monitor_wrap.c.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2014-9717Lowlinux:3.16.7-ckt20-1+deb8u2sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2016-3136Lowlinux:3.16.7-ckt20-1+deb8u2sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2016-3140Lowlinux:3.16.7-ckt20-1+deb8u2sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2016-3139Lowlinux:3.16.7-ckt20-1+deb8u2sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2016-2185Lowlinux:3.16.7-ckt20-1+deb8u2sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2016-0823Lowlinux:3.16.7-ckt20-1+deb8u2The pagemap_open function in fs/proc/task_mmu.c in the Linux kernel before 3.19.3, as used in Android 6.0.1 before 2016-03-01, allows local users to obtain sensitive physical-address information by reading a pagemap file, aka Android internal bug 25739721.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2016-2186Lowlinux:3.16.7-ckt20-1+deb8u2sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2016-3138Lowlinux:3.16.7-ckt20-1+deb8u2sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2016-3137Lowlinux:3.16.7-ckt20-1+deb8u2sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2016-2184Lowlinux:3.16.7-ckt20-1+deb8u2sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2016-0702Lowopenssl:1.0.1k-3+deb8u2The MOD_EXP_CTIME_COPY_FROM_PREBUF function in crypto/bn/bn_exp.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not properly consider cache-bank access times during modular exponentiation, which makes it easier for local users to discover RSA keys by running a crafted application on the same Intel Sandy Bridge CPU core as a victim and leveraging cache-bank conflicts, aka a "CacheBleed" attack.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-5180Lowglibc:2.19-18+deb8u1sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2013-2207Lowglibc:2.19-18+deb8u1pt_chown in GNU C Library (aka glibc or libc6) before 2.18 does not properly check permissions for tty files, which allows local users to change the permission on the files and obtain access to arbitrary pseudo-terminals by leveraging a FUSE file system.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-8777Lowglibc:2.19-18+deb8u1The process_envvars function in elf/rtld.c in the GNU C Library (aka glibc or libc6) before 2.23 allows local users to bypass a pointer-guarding protection mechanism via a zero value of the LD_POINTER_GUARD environment variable.sha256:4323cfe4a34cafb6531b86b597f2088efe536e6f71056eda6687566875d84841
CVE-2015-8629Lowkrb5:1.12.1+dfsg-19+deb8u1The xdr_nullstring function in lib/kadm5/kadm_rpc_xdr.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 does not verify whether '\0' characters exist as expected, which allows remote authenticated users to obtain sensitive information or cause a denial of service (out-of-bounds read) via a crafted string.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2016-3119Lowkrb5:1.12.1+dfsg-19+deb8u1The process_db_args function in plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c in the LDAP KDB module in kadmind in MIT Kerberos 5 (aka krb5) through 1.13.4 and 1.14.x through 1.14.1 mishandles the DB argument, which allows remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) via a crafted request to modify a principal.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-6563Lowopenssh:1:6.7p1-5The monitor component in sshd in OpenSSH before 7.0 on non-OpenBSD platforms accepts extraneous username data in MONITOR_REQ_PAM_INIT_CTX requests, which allows local users to conduct impersonation attacks by leveraging any SSH login access in conjunction with control of the sshd uid to send a crafted MONITOR_REQ_PWNAM request, related to monitor.c and monitor_wrap.c.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-5180Lowglibc:2.19-18+deb8u1sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2013-2207Lowglibc:2.19-18+deb8u1pt_chown in GNU C Library (aka glibc or libc6) before 2.18 does not properly check permissions for tty files, which allows local users to change the permission on the files and obtain access to arbitrary pseudo-terminals by leveraging a FUSE file system.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-8777Lowglibc:2.19-18+deb8u1The process_envvars function in elf/rtld.c in the GNU C Library (aka glibc or libc6) before 2.23 allows local users to bypass a pointer-guarding protection mechanism via a zero value of the LD_POINTER_GUARD environment variable.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2014-9717Lowlinux:3.16.7-ckt20-1+deb8u2sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2016-3136Lowlinux:3.16.7-ckt20-1+deb8u2sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2016-3140Lowlinux:3.16.7-ckt20-1+deb8u2sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2016-3139Lowlinux:3.16.7-ckt20-1+deb8u2sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2016-2185Lowlinux:3.16.7-ckt20-1+deb8u2sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2016-0823Lowlinux:3.16.7-ckt20-1+deb8u2The pagemap_open function in fs/proc/task_mmu.c in the Linux kernel before 3.19.3, as used in Android 6.0.1 before 2016-03-01, allows local users to obtain sensitive physical-address information by reading a pagemap file, aka Android internal bug 25739721.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2016-2186Lowlinux:3.16.7-ckt20-1+deb8u2sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2016-3138Lowlinux:3.16.7-ckt20-1+deb8u2sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2016-3137Lowlinux:3.16.7-ckt20-1+deb8u2sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2016-2184Lowlinux:3.16.7-ckt20-1+deb8u2sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2016-0702Lowopenssl:1.0.1k-3+deb8u2The MOD_EXP_CTIME_COPY_FROM_PREBUF function in crypto/bn/bn_exp.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not properly consider cache-bank access times during modular exponentiation, which makes it easier for local users to discover RSA keys by running a crafted application on the same Intel Sandy Bridge CPU core as a victim and leveraging cache-bank conflicts, aka a "CacheBleed" attack.sha256:c14dc11f457de7a2edf0b1a770ef8ce115b937e651c5e53a8a854d177c5e5a1b
CVE-2015-6563Lowopenssh:1:6.7p1-5The monitor component in sshd in OpenSSH before 7.0 on non-OpenBSD platforms accepts extraneous username data in MONITOR_REQ_PAM_INIT_CTX requests, which allows local users to conduct impersonation attacks by leveraging any SSH login access in conjunction with control of the sshd uid to send a crafted MONITOR_REQ_PWNAM request, related to monitor.c and monitor_wrap.c.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2014-9717Lowlinux:3.16.7-ckt20-1+deb8u2sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2016-3136Lowlinux:3.16.7-ckt20-1+deb8u2sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2016-3140Lowlinux:3.16.7-ckt20-1+deb8u2sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2016-3139Lowlinux:3.16.7-ckt20-1+deb8u2sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2016-2185Lowlinux:3.16.7-ckt20-1+deb8u2sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2016-0823Lowlinux:3.16.7-ckt20-1+deb8u2The pagemap_open function in fs/proc/task_mmu.c in the Linux kernel before 3.19.3, as used in Android 6.0.1 before 2016-03-01, allows local users to obtain sensitive physical-address information by reading a pagemap file, aka Android internal bug 25739721.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2016-2186Lowlinux:3.16.7-ckt20-1+deb8u2sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2016-3138Lowlinux:3.16.7-ckt20-1+deb8u2sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2016-3137Lowlinux:3.16.7-ckt20-1+deb8u2sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2016-2184Lowlinux:3.16.7-ckt20-1+deb8u2sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-8629Lowkrb5:1.12.1+dfsg-19+deb8u1The xdr_nullstring function in lib/kadm5/kadm_rpc_xdr.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 does not verify whether '\0' characters exist as expected, which allows remote authenticated users to obtain sensitive information or cause a denial of service (out-of-bounds read) via a crafted string.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2016-3119Lowkrb5:1.12.1+dfsg-19+deb8u1The process_db_args function in plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c in the LDAP KDB module in kadmind in MIT Kerberos 5 (aka krb5) through 1.13.4 and 1.14.x through 1.14.1 mishandles the DB argument, which allows remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) via a crafted request to modify a principal.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-5180Lowglibc:2.19-18+deb8u1sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2013-2207Lowglibc:2.19-18+deb8u1pt_chown in GNU C Library (aka glibc or libc6) before 2.18 does not properly check permissions for tty files, which allows local users to change the permission on the files and obtain access to arbitrary pseudo-terminals by leveraging a FUSE file system.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2015-8777Lowglibc:2.19-18+deb8u1The process_envvars function in elf/rtld.c in the GNU C Library (aka glibc or libc6) before 2.23 allows local users to bypass a pointer-guarding protection mechanism via a zero value of the LD_POINTER_GUARD environment variable.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2016-0702Lowopenssl:1.0.1k-3+deb8u2The MOD_EXP_CTIME_COPY_FROM_PREBUF function in crypto/bn/bn_exp.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not properly consider cache-bank access times during modular exponentiation, which makes it easier for local users to discover RSA keys by running a crafted application on the same Intel Sandy Bridge CPU core as a victim and leveraging cache-bank conflicts, aka a "CacheBleed" attack.sha256:412879add0bfb870bca6a1319925e9c641981fae441c7a46df174c5adb73b4cc
CVE-2016-0702Lowopenssl:1.0.1k-3+deb8u2The MOD_EXP_CTIME_COPY_FROM_PREBUF function in crypto/bn/bn_exp.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not properly consider cache-bank access times during modular exponentiation, which makes it easier for local users to discover RSA keys by running a crafted application on the same Intel Sandy Bridge CPU core as a victim and leveraging cache-bank conflicts, aka a "CacheBleed" attack.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-8629Lowkrb5:1.12.1+dfsg-19+deb8u1The xdr_nullstring function in lib/kadm5/kadm_rpc_xdr.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 does not verify whether '\0' characters exist as expected, which allows remote authenticated users to obtain sensitive information or cause a denial of service (out-of-bounds read) via a crafted string.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2016-3119Lowkrb5:1.12.1+dfsg-19+deb8u1The process_db_args function in plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c in the LDAP KDB module in kadmind in MIT Kerberos 5 (aka krb5) through 1.13.4 and 1.14.x through 1.14.1 mishandles the DB argument, which allows remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) via a crafted request to modify a principal.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-6563Lowopenssh:1:6.7p1-5The monitor component in sshd in OpenSSH before 7.0 on non-OpenBSD platforms accepts extraneous username data in MONITOR_REQ_PAM_INIT_CTX requests, which allows local users to conduct impersonation attacks by leveraging any SSH login access in conjunction with control of the sshd uid to send a crafted MONITOR_REQ_PWNAM request, related to monitor.c and monitor_wrap.c.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-5180Lowglibc:2.19-18+deb8u1sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2013-2207Lowglibc:2.19-18+deb8u1pt_chown in GNU C Library (aka glibc or libc6) before 2.18 does not properly check permissions for tty files, which allows local users to change the permission on the files and obtain access to arbitrary pseudo-terminals by leveraging a FUSE file system.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-8777Lowglibc:2.19-18+deb8u1The process_envvars function in elf/rtld.c in the GNU C Library (aka glibc or libc6) before 2.23 allows local users to bypass a pointer-guarding protection mechanism via a zero value of the LD_POINTER_GUARD environment variable.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2014-9717Lowlinux:3.16.7-ckt20-1+deb8u2sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2016-3136Lowlinux:3.16.7-ckt20-1+deb8u2sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2016-3140Lowlinux:3.16.7-ckt20-1+deb8u2sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2016-3139Lowlinux:3.16.7-ckt20-1+deb8u2sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2016-2185Lowlinux:3.16.7-ckt20-1+deb8u2sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2016-0823Lowlinux:3.16.7-ckt20-1+deb8u2The pagemap_open function in fs/proc/task_mmu.c in the Linux kernel before 3.19.3, as used in Android 6.0.1 before 2016-03-01, allows local users to obtain sensitive physical-address information by reading a pagemap file, aka Android internal bug 25739721.sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2016-2186Lowlinux:3.16.7-ckt20-1+deb8u2sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2016-3138Lowlinux:3.16.7-ckt20-1+deb8u2sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2016-3137Lowlinux:3.16.7-ckt20-1+deb8u2sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2016-2184Lowlinux:3.16.7-ckt20-1+deb8u2sha256:f99481f284b54cdb60b2bd3a666a77c5ed31cf7fb98b665e3e7d28d7fe5dd1d5
CVE-2015-5180Lowglibc:2.19-18+deb8u1sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2013-2207Lowglibc:2.19-18+deb8u1pt_chown in GNU C Library (aka glibc or libc6) before 2.18 does not properly check permissions for tty files, which allows local users to change the permission on the files and obtain access to arbitrary pseudo-terminals by leveraging a FUSE file system.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-8777Lowglibc:2.19-18+deb8u1The process_envvars function in elf/rtld.c in the GNU C Library (aka glibc or libc6) before 2.23 allows local users to bypass a pointer-guarding protection mechanism via a zero value of the LD_POINTER_GUARD environment variable.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-8629Lowkrb5:1.12.1+dfsg-19+deb8u1The xdr_nullstring function in lib/kadm5/kadm_rpc_xdr.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 does not verify whether '\0' characters exist as expected, which allows remote authenticated users to obtain sensitive information or cause a denial of service (out-of-bounds read) via a crafted string.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2016-3119Lowkrb5:1.12.1+dfsg-19+deb8u1The process_db_args function in plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c in the LDAP KDB module in kadmind in MIT Kerberos 5 (aka krb5) through 1.13.4 and 1.14.x through 1.14.1 mishandles the DB argument, which allows remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) via a crafted request to modify a principal.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2015-6563Lowopenssh:1:6.7p1-5The monitor component in sshd in OpenSSH before 7.0 on non-OpenBSD platforms accepts extraneous username data in MONITOR_REQ_PAM_INIT_CTX requests, which allows local users to conduct impersonation attacks by leveraging any SSH login access in conjunction with control of the sshd uid to send a crafted MONITOR_REQ_PWNAM request, related to monitor.c and monitor_wrap.c.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2014-9717Lowlinux:3.16.7-ckt20-1+deb8u2sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2016-3136Lowlinux:3.16.7-ckt20-1+deb8u2sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2016-3140Lowlinux:3.16.7-ckt20-1+deb8u2sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2016-3139Lowlinux:3.16.7-ckt20-1+deb8u2sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2016-2185Lowlinux:3.16.7-ckt20-1+deb8u2sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2016-0823Lowlinux:3.16.7-ckt20-1+deb8u2The pagemap_open function in fs/proc/task_mmu.c in the Linux kernel before 3.19.3, as used in Android 6.0.1 before 2016-03-01, allows local users to obtain sensitive physical-address information by reading a pagemap file, aka Android internal bug 25739721.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2016-2186Lowlinux:3.16.7-ckt20-1+deb8u2sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2016-3138Lowlinux:3.16.7-ckt20-1+deb8u2sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2016-3137Lowlinux:3.16.7-ckt20-1+deb8u2sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2016-2184Lowlinux:3.16.7-ckt20-1+deb8u2sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2016-0702Lowopenssl:1.0.1k-3+deb8u2The MOD_EXP_CTIME_COPY_FROM_PREBUF function in crypto/bn/bn_exp.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not properly consider cache-bank access times during modular exponentiation, which makes it easier for local users to discover RSA keys by running a crafted application on the same Intel Sandy Bridge CPU core as a victim and leveraging cache-bank conflicts, aka a "CacheBleed" attack.sha256:a39d28f32bec2ae87a064773fe9cd8e1399a6a25f2d8b99128353807a24b065d
CVE-2016-0702Lowopenssl:1.0.1k-3+deb8u2The MOD_EXP_CTIME_COPY_FROM_PREBUF function in crypto/bn/bn_exp.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not properly consider cache-bank access times during modular exponentiation, which makes it easier for local users to discover RSA keys by running a crafted application on the same Intel Sandy Bridge CPU core as a victim and leveraging cache-bank conflicts, aka a "CacheBleed" attack.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-5180Lowglibc:2.19-18+deb8u1sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2013-2207Lowglibc:2.19-18+deb8u1pt_chown in GNU C Library (aka glibc or libc6) before 2.18 does not properly check permissions for tty files, which allows local users to change the permission on the files and obtain access to arbitrary pseudo-terminals by leveraging a FUSE file system.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-8777Lowglibc:2.19-18+deb8u1The process_envvars function in elf/rtld.c in the GNU C Library (aka glibc or libc6) before 2.23 allows local users to bypass a pointer-guarding protection mechanism via a zero value of the LD_POINTER_GUARD environment variable.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-6563Lowopenssh:1:6.7p1-5The monitor component in sshd in OpenSSH before 7.0 on non-OpenBSD platforms accepts extraneous username data in MONITOR_REQ_PAM_INIT_CTX requests, which allows local users to conduct impersonation attacks by leveraging any SSH login access in conjunction with control of the sshd uid to send a crafted MONITOR_REQ_PWNAM request, related to monitor.c and monitor_wrap.c.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-8629Lowkrb5:1.12.1+dfsg-19+deb8u1The xdr_nullstring function in lib/kadm5/kadm_rpc_xdr.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 does not verify whether '\0' characters exist as expected, which allows remote authenticated users to obtain sensitive information or cause a denial of service (out-of-bounds read) via a crafted string.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2016-3119Lowkrb5:1.12.1+dfsg-19+deb8u1The process_db_args function in plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c in the LDAP KDB module in kadmind in MIT Kerberos 5 (aka krb5) through 1.13.4 and 1.14.x through 1.14.1 mishandles the DB argument, which allows remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) via a crafted request to modify a principal.sha256:a58c4db729df8076e870544f91c997141bca59d6e182e9e1f0e2ce680b9418d4
CVE-2015-8629Lowkrb5:1.12.1+dfsg-19+deb8u1The xdr_nullstring function in lib/kadm5/kadm_rpc_xdr.c in kadmind in MIT Kerberos 5 (aka krb5) before 1.13.4 and 1.14.x before 1.14.1 does not verify whether '\0' characters exist as expected, which allows remote authenticated users to obtain sensitive information or cause a denial of service (out-of-bounds read) via a crafted string.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2016-3119Lowkrb5:1.12.1+dfsg-19+deb8u1The process_db_args function in plugins/kdb/ldap/libkdb_ldap/ldap_principal2.c in the LDAP KDB module in kadmind in MIT Kerberos 5 (aka krb5) through 1.13.4 and 1.14.x through 1.14.1 mishandles the DB argument, which allows remote authenticated users to cause a denial of service (NULL pointer dereference and daemon crash) via a crafted request to modify a principal.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2016-0702Lowopenssl:1.0.1k-3+deb8u2The MOD_EXP_CTIME_COPY_FROM_PREBUF function in crypto/bn/bn_exp.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not properly consider cache-bank access times during modular exponentiation, which makes it easier for local users to discover RSA keys by running a crafted application on the same Intel Sandy Bridge CPU core as a victim and leveraging cache-bank conflicts, aka a "CacheBleed" attack.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-5180Lowglibc:2.19-18+deb8u1sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2013-2207Lowglibc:2.19-18+deb8u1pt_chown in GNU C Library (aka glibc or libc6) before 2.18 does not properly check permissions for tty files, which allows local users to change the permission on the files and obtain access to arbitrary pseudo-terminals by leveraging a FUSE file system.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-8777Lowglibc:2.19-18+deb8u1The process_envvars function in elf/rtld.c in the GNU C Library (aka glibc or libc6) before 2.23 allows local users to bypass a pointer-guarding protection mechanism via a zero value of the LD_POINTER_GUARD environment variable.sha256:dea600df515e324cc6ba3bf597932b425b8183ccd832963ef79abf7140d61d62
CVE-2015-5180Lowglibc:2.19-18+deb8u1sha256:c648cd6a73969d01003f84dcb558aa19f153fdbb63f6e7bc096cf204c1d46280
CVE-2013-2207Lowglibc:2.19-18+deb8u1pt_chown in GNU C Library (aka glibc or libc6) before 2.18 does not properly check permissions for tty files, which allows local users to change the permission on the files and obtain access to arbitrary pseudo-terminals by leveraging a FUSE file system.sha256:c648cd6a73969d01003f84dcb558aa19f153fdbb63f6e7bc096cf204c1d46280
CVE-2015-8777Lowglibc:2.19-18+deb8u1The process_envvars function in elf/rtld.c in the GNU C Library (aka glibc or libc6) before 2.23 allows local users to bypass a pointer-guarding protection mechanism via a zero value of the LD_POINTER_GUARD environment variable.sha256:c648cd6a73969d01003f84dcb558aa19f153fdbb63f6e7bc096cf204c1d46280
CVE-2015-5180Lowglibc:2.19-18+deb8u1sha256:440e9f8ae5cb10857c9b901fe6ed10eb9aa67b997981d16bc4d52f3713908f4e
CVE-2013-2207Lowglibc:2.19-18+deb8u1pt_chown in GNU C Library (aka glibc or libc6) before 2.18 does not properly check permissions for tty files, which allows local users to change the permission on the files and obtain access to arbitrary pseudo-terminals by leveraging a FUSE file system.sha256:440e9f8ae5cb10857c9b901fe6ed10eb9aa67b997981d16bc4d52f3713908f4e
CVE-2015-8777Lowglibc:2.19-18+deb8u1The process_envvars function in elf/rtld.c in the GNU C Library (aka glibc or libc6) before 2.23 allows local users to bypass a pointer-guarding protection mechanism via a zero value of the LD_POINTER_GUARD environment variable.sha256:440e9f8ae5cb10857c9b901fe6ed10eb9aa67b997981d16bc4d52f3713908f4e
+
+ + + + diff --git a/cmd/clairclt/reports/html/analysis-jgsqware-ubuntu-git-latest.html b/cmd/clairclt/reports/html/analysis-jgsqware-ubuntu-git-latest.html new file mode 100644 index 00000000..c64eff0a --- /dev/null +++ b/cmd/clairclt/reports/html/analysis-jgsqware-ubuntu-git-latest.html @@ -0,0 +1,698 @@ + + + + + + + + + Hyperclair Reports + + + + + +
+
+

+ Hyperclair reports +

+

+ Image: jgsqware/ubuntu-git +

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameSeverityIntroduceByDescriptionLayer
CVE-2015-7547Higheglibc:2.19-0ubuntu6.6Multiple stack-based buffer overflows in the (1) send_dg and (2) send_vc functions in the libresolv library in the GNU C Library (aka glibc or libc6) before 2.23 allow remote attackers to cause a denial of service (crash) or possibly execute arbitrary code via a crafted DNS response that triggers a call to the getaddrinfo function with the AF_UNSPEC or AF_INET6 address family, related to performing "dual A/AAAA DNS queries" and the libnss_dns.so.2 NSS module.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-7575Mediumgnutls26:2.12.23-12ubuntu2.3Mozilla Network Security Services (NSS) before 3.20.2, as used in Mozilla Firefox before 43.0.2 and Firefox ESR 38.x before 38.5.2, does not reject MD5 signatures in Server Key Exchange messages in TLS 1.2 Handshake Protocol traffic, which makes it easier for man-in-the-middle attackers to spoof servers by triggering a collision.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-8540Mediumlibpng:1.2.50-1ubuntu2.14.04.1underflow read in png_check_keyword in pngwutil.csha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-8472Mediumlibpng:1.2.50-1ubuntu2.14.04.1Buffer overflow in the png_set_PLTE function in libpng before 1.0.65, 1.1.x and 1.2.x before 1.2.55, 1.3.x, 1.4.x before 1.4.18, 1.5.x before 1.5.25, and 1.6.x before 1.6.20 allows remote attackers to cause a denial of service (application crash) or possibly have unspecified other impact via a small bit-depth value in an IHDR (aka image header) chunk in a PNG image. NOTE: this vulnerability exists because of an incomplete fix for CVE-2015-8126.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2011-5325Mediumbusybox:1:1.21.0-1ubuntu1path traversal vulnerability in busybox tarsha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-5277Mediumeglibc:2.19-0ubuntu6.6The get_contents function in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) before 2.20 might allow local users to cause a denial of service (heap corruption) or gain privileges via a long line in the NSS files database.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2016-1234Mediumeglibc:2.19-0ubuntu6.6glob: buffer overflow with GLOB_ALTDIRFUNC due to incorrect NAME_MAX limit assumptionsha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2016-2842Mediumopenssl:1.0.1f-1ubuntu2.16The doapr_outch function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not verify that a certain memory allocation succeeds, which allows remote attackers to cause a denial of service (out-of-bounds write or memory consumption) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-0799.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2016-2037Mediumcpio:2.11+dfsg-1ubuntu1.1The cpio_safer_name_suffix function in util.c in cpio 2.11 allows remote attackers to cause a denial of service (out-of-bounds write) via a crafted cpio file.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-8239Mediumsudo:1.8.9p5-1ubuntu1.2race condition checking digests/checksums in sudoerssha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-5602Mediumsudo:1.8.9p5-1ubuntu1.2sudoedit in Sudo before 1.8.15 allows local users to gain privileges via a symlink attack on a file whose full path is defined using multiple wildcards in /etc/sudoers, as demonstrated by "/home/*/*/file.txt."sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2016-2781Mediumcoreutils:8.21-1ubuntu5.3nonpriv session can escape to the parent session by using the TIOCSTI ioctlsha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-8138Mediumntp:1:4.2.6.p5+dfsg-3ubuntu2.14.04.6ntp: missing check for zero originate timestampsha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-7977Mediumntp:1:4.2.6.p5+dfsg-3ubuntu2.14.04.6reslist NULL pointer dereferencesha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-7978Mediumntp:1:4.2.6.p5+dfsg-3ubuntu2.14.04.6Stack exhaustion in recursive traversal of restriction listsha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-7511Mediumlibgcrypt11:1.5.3-2ubuntu4.2ECDH Key-Extraction via Low-Bandwidth Electromagnetic Attacks on PCssha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2016-2381Mediumperl:5.18.2-2ubuntu1environment variable confusionsha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2016-3191Mediumpcre3:1:8.31-2ubuntu2.1The compile_branch function in pcre_compile.c in PCRE 8.x before 8.39 and pcre2_compile.c in PCRE2 before 10.22 mishandles patterns containing an (*ACCEPT) substring in conjunction with nested parentheses, which allows remote attackers to execute arbitrary code or cause a denial of service (stack-based buffer overflow) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-3542.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-8605Mediumisc-dhcp:4.2.4-7ubuntu12.3ISC DHCP 4.x before 4.1-ESV-R12-P1 and 4.2.x and 4.3.x before 4.3.3-P1 allows remote attackers to cause a denial of service (application crash) via an invalid length field in a UDP IPv4 packet.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2014-2667Lowpython3.4:3.4.3-1ubuntu1~14.04.3Race condition in the _get_masked_mode function in Lib/os.py in Python 3.2 through 3.5, when exist_ok is set to true and multiple threads are used, might allow local users to bypass intended file permissions by leveraging a separate application vulnerability before the umask has been set to the expected value.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2014-9621Lowfile:1:5.14-2ubuntu3.3The ELF parser in file 5.16 through 5.21 allows remote attackers to cause a denial of service via a long string.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2014-9620Lowfile:1:5.14-2ubuntu3.3The ELF parser in file 5.08 through 5.21 allows remote attackers to cause a denial of service via a large number of notes.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2014-9653Lowfile:1:5.14-2ubuntu3.3readelf.c in file before 5.22, as used in the Fileinfo component in PHP before 5.4.37, 5.5.x before 5.5.21, and 5.6.x before 5.6.5, does not consider that pread calls sometimes read only a subset of the available data, which allows remote attackers to cause a denial of service (uninitialized memory access) or possibly have unspecified other impact via a crafted ELF file.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2013-4235Lowshadow:1:4.1.5.1-1ubuntu9.1TOCTOU race conditions by copying and removing directory treessha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2016-2090Lowlibbsd:0.6.0-2ubuntu1Heap buffer overflow in fgetwln function of libbsdsha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-0245Lowdbus:1.6.18-0ubuntu4.3D-Bus 1.4.x through 1.6.x before 1.6.30, 1.8.x before 1.8.16, and 1.9.x before 1.9.10 does not validate the source of ActivationFailure signals, which allows local users to cause a denial of service (activation failure error returned) by leveraging a race condition involving sending an ActivationFailure signal before systemd responds.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2014-9645Lowbusybox:1:1.21.0-1ubuntu1modprobe wrongly accepts paths as module namessha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2016-2147Lowbusybox:1:1.21.0-1ubuntu1OOB heap write due to integer underflowsha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2016-2148Lowbusybox:1:1.21.0-1ubuntu1heap overflow in OPTION_6RD parsingsha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2014-5044Lowgcc-4.8:4.8.4-2ubuntu1~14.04Array memory allocations could cause an integer overflow and thus memory overflow issues at runtime.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-5276Lowgcc-4.8:4.8.4-2ubuntu1~14.04The std::random_device class in libstdc++ in the GNU Compiler Collection (aka GCC) before 4.9.4 does not properly handle short reads from blocking sources, which makes it easier for context-dependent attackers to predict the random values via unspecified vectors.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-8778Loweglibc:2.19-0ubuntu6.6hcreate((size_t)-1) should fail with ENOMEMsha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2014-9761Loweglibc:2.19-0ubuntu6.6nan function unbounded stack allocationsha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-5180Loweglibc:2.19-0ubuntu6.6DNS resolver NULL pointer dereference with crafted record typesha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2013-2207Loweglibc:2.19-0ubuntu6.6pt_chown in GNU C Library (aka glibc or libc6) before 2.18 does not properly check permissions for tty files, which allows local users to change the permission on the files and obtain access to arbitrary pseudo-terminals by leveraging a FUSE file system.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-8776Loweglibc:2.19-0ubuntu6.6Passing out of range data to strftime() causes a segfaultsha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-8779Loweglibc:2.19-0ubuntu6.6catopen() Multiple unbounded stack allocationssha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2014-8121Loweglibc:2.19-0ubuntu6.6DB_LOOKUP in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) 2.21 and earlier does not properly check if a file is open, which allows remote attackers to cause a denial of service (infinite loop) by performing a look-up while the database is iterated over the database, which triggers the file pointer to be reset.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-1781Loweglibc:2.19-0ubuntu6.6Buffer overflow in the gethostbyname_r and other unspecified NSS functions in the GNU C Library (aka glibc or libc6) before 2.22 allows context-dependent attackers to cause a denial of service (crash) or execute arbitrary code via a crafted DNS response, which triggers a call with a misaligned buffer.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-8777Loweglibc:2.19-0ubuntu6.6The process_envvars function in elf/rtld.c in the GNU C Library (aka glibc or libc6) before 2.23 allows local users to bypass a pointer-guarding protection mechanism via a zero value of the LD_POINTER_GUARD environment variable.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2016-0797Lowopenssl:1.0.1f-1ubuntu2.16Multiple integer overflows in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allow remote attackers to cause a denial of service (heap memory corruption or NULL pointer dereference) or possibly have unspecified other impact via a long digit string that is mishandled by the (1) BN_dec2bn or (2) BN_hex2bn function, related to crypto/bn/bn.h and crypto/bn/bn_print.c.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2016-0702Lowopenssl:1.0.1f-1ubuntu2.16The MOD_EXP_CTIME_COPY_FROM_PREBUF function in crypto/bn/bn_exp.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not properly consider cache-bank access times during modular exponentiation, which makes it easier for local users to discover RSA keys by running a crafted application on the same Intel Sandy Bridge CPU core as a victim and leveraging cache-bank conflicts, aka a "CacheBleed" attack.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2016-0705Lowopenssl:1.0.1f-1ubuntu2.16Double free vulnerability in the dsa_priv_decode function in crypto/dsa/dsa_ameth.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory corruption) or possibly have unspecified other impact via a malformed DSA private key.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2016-0798Lowopenssl:1.0.1f-1ubuntu2.16Memory leak in the SRP_VBASE_get_by_user implementation in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory consumption) by providing an invalid username in a connection attempt, related to apps/s_server.c and crypto/srp/srp_vfy.c.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2016-0799Lowopenssl:1.0.1f-1ubuntu2.16The fmtstr function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g improperly calculates string lengths, which allows remote attackers to cause a denial of service (overflow and out-of-bounds read) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-2842.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-1197Lowcpio:2.11+dfsg-1ubuntu1.1cpio 2.11, when using the --no-absolute-filenames option, allows local users to write to arbitrary files via a symlink attack on a file in an archive.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2014-9488Lowless:458-2The is_utf8_well_formed function in GNU less before 475 allows remote attackers to have unspecified impact via malformed UTF-8 characters, which triggers an out-of-bounds read.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2014-9114Lowutil-linux:2.20.1-5.1ubuntu20.7blkid command injectionsha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2013-0157Lowutil-linux:2.20.1-5.1ubuntu20.7(a) mount and (b) umount in util-linux 2.14.1, 2.17.2, and probably other versions allow local users to determine the existence of restricted directories by (1) using the --guess-fstype command-line option or (2) attempting to mount a non-existent device, which generates different error messages depending on whether the directory exists.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-1865Lowcoreutils:8.21-1ubuntu5.3"time of check to time of use" race condition fts.csha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-3238Lowpam:1.1.8-1ubuntu2The _unix_run_helper_binary function in the pam_unix module in Linux-PAM (aka pam) before 1.2.1, when unable to directly access passwords, allows local users to enumerate usernames or cause a denial of service (hang) via a large password.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2013-7041Lowpam:1.1.8-1ubuntu2The pam_userdb module for Pam uses a case-insensitive method to compare hashed passwords, which makes it easier for attackers to guess the password via a brute force attack.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2014-2583Lowpam:1.1.8-1ubuntu2Multiple directory traversal vulnerabilities in pam_timestamp.c in the pam_timestamp module for Linux-PAM (aka pam) 1.1.8 allow local users to create aribitrary files or possibly bypass authentication via a .. (dot dot) in the (1) PAM_RUSER value to the get_ruser function or (2) PAM_TTY value to the check_tty funtion, which is used by the format_timestamp_name function.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2016-0727Lowntp:1:4.2.6.p5+dfsg-3ubuntu2.14.04.6NTP statsdir cleanup cronjob insecuresha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-8158Lowntp:1:4.2.6.p5+dfsg-3ubuntu2.14.04.6Potential Infinite Loop in ntpqsha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-7973Lowntp:1:4.2.6.p5+dfsg-3ubuntu2.14.04.6Deja Vu: Replay attack on authenticated broadcast modesha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-8140Lowntp:1:4.2.6.p5+dfsg-3ubuntu2.14.04.6ntpq vulnerable to replay attackssha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-8139Lowntp:1:4.2.6.p5+dfsg-3ubuntu2.14.04.6Origin Leak: ntpq and ntpdc, disclose originsha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-7976Lowntp:1:4.2.6.p5+dfsg-3ubuntu2.14.04.6ntpq saveconfig command allows dangerous characters in filenamessha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-7979Lowntp:1:4.2.6.p5+dfsg-3ubuntu2.14.04.6Off-path Denial of Service (DoS) attack on authenticated broadcast modesha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-7974Lowntp:1:4.2.6.p5+dfsg-3ubuntu2.14.04.6NTP 4.x before 4.2.8p6 and 4.3.x before 4.3.90 do not verify peer associations of symmetric keys when authenticating packets, which might allow remote attackers to conduct impersonation attacks via an arbitrary trusted key, aka a "skeleton key."sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2014-2524Lowreadline6:6.3-4ubuntu2The _rl_tropen function in util.c in GNU readline before 6.3 patch 3 allows local users to create or overwrite arbitrary files via a symlink attack on a /var/tmp/rltrace.[PID] file.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2013-7422Lowperl:5.18.2-2ubuntu1Integer underflow in regcomp.c in Perl before 5.20, as used in Apple OS X before 10.10.5 and other products, allows context-dependent attackers to execute arbitrary code or cause a denial of service (application crash) via a long digit string associated with an invalid backreference within a regular expression.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2014-4330Lowperl:5.18.2-2ubuntu1The Dumper method in Data::Dumper before 2.154, as used in Perl 5.20.1 and earlier, allows context-dependent attackers to cause a denial of service (stack consumption and crash) via an Array-Reference with many nested Array-References, which triggers a large number of recursive calls to the DD_dump function.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-2328Lowpcre3:1:8.31-2ubuntu2.1PCRE before 8.36 mishandles the /((?(R)a|(?1)))+/ pattern and related patterns with certain recursion, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-8394Lowpcre3:1:8.31-2ubuntu2.1PCRE before 8.38 mishandles the (?() and (?(R) conditions, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-8391Lowpcre3:1:8.31-2ubuntu2.1The pcre_compile function in pcre_compile.c in PCRE before 8.38 mishandles certain [: nesting, which allows remote attackers to cause a denial of service (CPU consumption) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-8390Lowpcre3:1:8.31-2ubuntu2.1PCRE before 8.38 mishandles the [: and \\ substrings in character classes, which allows remote attackers to cause a denial of service (uninitialized memory read) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-8382Lowpcre3:1:8.31-2ubuntu2.1The match function in pcre_exec.c in PCRE before 8.37 mishandles the /(?:((abcd))|(((?:(?:(?:(?:abc|(?:abcdef))))b)abcdefghi)abc)|((*ACCEPT)))/ pattern and related patterns involving (*ACCEPT), which allows remote attackers to obtain sensitive information from process memory or cause a denial of service (partially initialized memory and application crash) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-2547.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-8387Lowpcre3:1:8.31-2ubuntu2.1PCRE before 8.38 mishandles (?123) subroutine calls and related subroutine calls, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-8393Lowpcre3:1:8.31-2ubuntu2.1pcregrep in PCRE before 8.38 mishandles the -q option for binary files, which might allow remote attackers to obtain sensitive information via a crafted file, as demonstrated by a CGI script that sends stdout data to a client.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-8386Lowpcre3:1:8.31-2ubuntu2.1PCRE before 8.38 mishandles the interaction of lookbehind assertions and mutually recursive subpatterns, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-8380Lowpcre3:1:8.31-2ubuntu2.1The pcre_exec function in pcre_exec.c in PCRE before 8.38 mishandles a // pattern with a \01 string, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2015-8385Lowpcre3:1:8.31-2ubuntu2.1PCRE before 8.38 mishandles the /(?|(\k'Pm')|(?'Pm'))/ pattern and related patterns with certain forward references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2014-8625Lowdpkg:1.17.5ubuntu5.5Multiple format string vulnerabilities in the parse_error_msg function in parsehelp.c in dpkg before 1.17.22 allow remote attackers to cause a denial of service (crash) and possibly execute arbitrary code via format string specifiers in the (1) package or (2) architecture name.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
CVE-2016-2774Lowisc-dhcp:4.2.4-7ubuntu12.3ISC DHCP 4.1.x before 4.1-ESV-R13 and 4.2.x and 4.3.x before 4.3.4 does not restrict the number of concurrent TCP sessions, which allows remote attackers to cause a denial of service (INSIST assertion failure or request-processing outage) by establishing many sessions.sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845
+
+ + + + diff --git a/cmd/clairclt/reports/json/analysis-jgsqware-ubuntu-git-latest.json b/cmd/clairclt/reports/json/analysis-jgsqware-ubuntu-git-latest.json new file mode 100644 index 00000000..1497cb58 --- /dev/null +++ b/cmd/clairclt/reports/json/analysis-jgsqware-ubuntu-git-latest.json @@ -0,0 +1,1580 @@ +{ + "Registry": "registry:5000", + "ImageName": "jgsqware/ubuntu-git", + "Tag": "latest", + "Layers": [ + { + "Layer": { + "Name": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845", + "Namespace": "ubuntu:14.04", + "ParentName": "sha256:9e0bc8a71bde464f710bc2b593a1fc21521517671e918687892303151331fa56", + "IndexedByVersion": 2, + "Features": [ + { + "Name": "sudo", + "Namespace": "ubuntu:14.04", + "Version": "1.8.9p5-1ubuntu1.2", + "Vulnerabilities": [ + { + "Name": "CVE-2015-8239", + "Namespace": "ubuntu:14.04", + "Description": "race condition checking digests/checksums in sudoers", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8239", + "Severity": "Medium" + }, + { + "Name": "CVE-2015-5602", + "Namespace": "ubuntu:14.04", + "Description": "sudoedit in Sudo before 1.8.15 allows local users to gain privileges via a symlink attack on a file whose full path is defined using multiple wildcards in /etc/sudoers, as demonstrated by \"/home/*/*/file.txt.\"", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-5602", + "Severity": "Medium" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libtext-soundex-perl", + "Namespace": "ubuntu:14.04", + "Version": "3.4-1build1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "dash", + "Namespace": "ubuntu:14.04", + "Version": "0.5.7-4ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "eject", + "Namespace": "ubuntu:14.04", + "Version": "2.1.5+deb1+cvs20081104-13.1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "gcc-4.8", + "Namespace": "ubuntu:14.04", + "Version": "4.8.4-2ubuntu1~14.04", + "Vulnerabilities": [ + { + "Name": "CVE-2014-5044", + "Namespace": "ubuntu:14.04", + "Description": "Array memory allocations could cause an integer overflow and thus memory overflow issues at runtime.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2014-5044", + "Severity": "Low" + }, + { + "Name": "CVE-2015-5276", + "Namespace": "ubuntu:14.04", + "Description": "The std::random_device class in libstdc++ in the GNU Compiler Collection (aka GCC) before 4.9.4 does not properly handle short reads from blocking sources, which makes it easier for context-dependent attackers to predict the random values via unspecified vectors.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-5276", + "Severity": "Low" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "lvm2", + "Namespace": "ubuntu:14.04", + "Version": "2.02.98-6ubuntu2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "net-tools", + "Namespace": "ubuntu:14.04", + "Version": "1.60-25ubuntu2.1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libsepol", + "Namespace": "ubuntu:14.04", + "Version": "2.2-1ubuntu0.1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libtext-charwidth-perl", + "Namespace": "ubuntu:14.04", + "Version": "0.04-7build3", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "cdebconf", + "Namespace": "ubuntu:14.04", + "Version": "0.187ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "vim", + "Namespace": "ubuntu:14.04", + "Version": "2:7.4.052-1ubuntu3", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "attr", + "Namespace": "ubuntu:14.04", + "Version": "1:2.4.47-1ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "gnutls26", + "Namespace": "ubuntu:14.04", + "Version": "2.12.23-12ubuntu2.3", + "Vulnerabilities": [ + { + "Name": "CVE-2015-7575", + "Namespace": "ubuntu:14.04", + "Description": "Mozilla Network Security Services (NSS) before 3.20.2, as used in Mozilla Firefox before 43.0.2 and Firefox ESR 38.x before 38.5.2, does not reject MD5 signatures in Server Key Exchange messages in TLS 1.2 Handshake Protocol traffic, which makes it easier for man-in-the-middle attackers to spoof servers by triggering a collision.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-7575", + "Severity": "Medium", + "FixedBy": "2.12.23-12ubuntu2.4" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "python3.4", + "Namespace": "ubuntu:14.04", + "Version": "3.4.3-1ubuntu1~14.04.3", + "Vulnerabilities": [ + { + "Name": "CVE-2014-2667", + "Namespace": "ubuntu:14.04", + "Description": "Race condition in the _get_masked_mode function in Lib/os.py in Python 3.2 through 3.5, when exist_ok is set to true and multiple threads are used, might allow local users to bypass intended file permissions by leveraging a separate application vulnerability before the umask has been set to the expected value.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2014-2667", + "Severity": "Low" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "logrotate", + "Namespace": "ubuntu:14.04", + "Version": "3.8.7-1ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "adduser", + "Namespace": "ubuntu:14.04", + "Version": "3.113+nmu3ubuntu3", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "base-passwd", + "Namespace": "ubuntu:14.04", + "Version": "3.5.33", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "grep", + "Namespace": "ubuntu:14.04", + "Version": "2.16-1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "dpkg", + "Namespace": "ubuntu:14.04", + "Version": "1.17.5ubuntu5.5", + "Vulnerabilities": [ + { + "Name": "CVE-2014-8625", + "Namespace": "ubuntu:14.04", + "Description": "Multiple format string vulnerabilities in the parse_error_msg function in parsehelp.c in dpkg before 1.17.22 allow remote attackers to cause a denial of service (crash) and possibly execute arbitrary code via format string specifiers in the (1) package or (2) architecture name.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2014-8625", + "Severity": "Low" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "ustr", + "Namespace": "ubuntu:14.04", + "Version": "1.0.4-3ubuntu2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "db5.3", + "Namespace": "ubuntu:14.04", + "Version": "5.3.28-3ubuntu3", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libtext-iconv-perl", + "Namespace": "ubuntu:14.04", + "Version": "1.7-5build2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "gccgo-4.9", + "Namespace": "ubuntu:14.04", + "Version": "4.9.1-0ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "xz-utils", + "Namespace": "ubuntu:14.04", + "Version": "5.1.1alpha+20120614-2ubuntu2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "netcat-openbsd", + "Namespace": "ubuntu:14.04", + "Version": "1.105-7ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "coreutils", + "Namespace": "ubuntu:14.04", + "Version": "8.21-1ubuntu5.3", + "Vulnerabilities": [ + { + "Name": "CVE-2015-1865", + "Namespace": "ubuntu:14.04", + "Description": "\"time of check to time of use\" race condition fts.c", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-1865", + "Severity": "Low" + }, + { + "Name": "CVE-2016-2781", + "Namespace": "ubuntu:14.04", + "Description": "nonpriv session can escape to the parent session by using the TIOCSTI ioctl", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-2781", + "Severity": "Medium" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "cpio", + "Namespace": "ubuntu:14.04", + "Version": "2.11+dfsg-1ubuntu1.1", + "Vulnerabilities": [ + { + "Name": "CVE-2016-2037", + "Namespace": "ubuntu:14.04", + "Description": "The cpio_safer_name_suffix function in util.c in cpio 2.11 allows remote attackers to cause a denial of service (out-of-bounds write) via a crafted cpio file.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-2037", + "Severity": "Medium", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 4.3, + "Vectors": "AV:N/AC:M/Au:N/C:N/I:N" + } + } + }, + "FixedBy": "2.11+dfsg-1ubuntu1.2" + }, + { + "Name": "CVE-2015-1197", + "Namespace": "ubuntu:14.04", + "Description": "cpio 2.11, when using the --no-absolute-filenames option, allows local users to write to arbitrary files via a symlink attack on a file in an archive.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-1197", + "Severity": "Low", + "FixedBy": "2.11+dfsg-1ubuntu1.2" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "tar", + "Namespace": "ubuntu:14.04", + "Version": "1.27.1-1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libffi", + "Namespace": "ubuntu:14.04", + "Version": "3.1~rc1+r3.0.13-12ubuntu0.1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libgcrypt11", + "Namespace": "ubuntu:14.04", + "Version": "1.5.3-2ubuntu4.2", + "Vulnerabilities": [ + { + "Name": "CVE-2015-7511", + "Namespace": "ubuntu:14.04", + "Description": "ECDH Key-Extraction via Low-Bandwidth Electromagnetic Attacks on PCs", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-7511", + "Severity": "Medium", + "FixedBy": "1.5.3-2ubuntu4.3" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "findutils", + "Namespace": "ubuntu:14.04", + "Version": "4.4.2-7", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "gzip", + "Namespace": "ubuntu:14.04", + "Version": "1.6-3ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "klibc", + "Namespace": "ubuntu:14.04", + "Version": "2.0.3-0ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "gnupg", + "Namespace": "ubuntu:14.04", + "Version": "1.4.16-1ubuntu2.3", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "readline6", + "Namespace": "ubuntu:14.04", + "Version": "6.3-4ubuntu2", + "Vulnerabilities": [ + { + "Name": "CVE-2014-2524", + "Namespace": "ubuntu:14.04", + "Description": "The _rl_tropen function in util.c in GNU readline before 6.3 patch 3 allows local users to create or overwrite arbitrary files via a symlink attack on a /var/tmp/rltrace.[PID] file.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2014-2524", + "Severity": "Low" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "lockfile-progs", + "Namespace": "ubuntu:14.04", + "Version": "0.1.17", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "fribidi", + "Namespace": "ubuntu:14.04", + "Version": "0.19.6-1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "json-c", + "Namespace": "ubuntu:14.04", + "Version": "0.11-3ubuntu1.2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "sysvinit", + "Namespace": "ubuntu:14.04", + "Version": "2.88dsf-41ubuntu6.2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "base-files", + "Namespace": "ubuntu:14.04", + "Version": "7.2ubuntu5.3", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "ifupdown", + "Namespace": "ubuntu:14.04", + "Version": "0.7.47.2ubuntu4.1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "resolvconf", + "Namespace": "ubuntu:14.04", + "Version": "1.69ubuntu1.1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "bash", + "Namespace": "ubuntu:14.04", + "Version": "4.3-7ubuntu1.5", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "console-setup", + "Namespace": "ubuntu:14.04", + "Version": "1.70ubuntu8", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "pcre3", + "Namespace": "ubuntu:14.04", + "Version": "1:8.31-2ubuntu2.1", + "Vulnerabilities": [ + { + "Name": "CVE-2015-2328", + "Namespace": "ubuntu:14.04", + "Description": "PCRE before 8.36 mishandles the /((?(R)a|(?1)))+/ pattern and related patterns with certain recursion, which allows remote attackers to cause a denial of service (segmentation fault) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-2328", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 7.5, + "Vectors": "AV:N/AC:L/Au:N/C:P/I:P" + } + } + } + }, + { + "Name": "CVE-2016-3191", + "Namespace": "ubuntu:14.04", + "Description": "The compile_branch function in pcre_compile.c in PCRE 8.x before 8.39 and pcre2_compile.c in PCRE2 before 10.22 mishandles patterns containing an (*ACCEPT) substring in conjunction with nested parentheses, which allows remote attackers to execute arbitrary code or cause a denial of service (stack-based buffer overflow) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-3542.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-3191", + "Severity": "Medium", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 7.5, + "Vectors": "AV:N/AC:L/Au:N/C:P/I:P" + } + } + } + }, + { + "Name": "CVE-2015-8394", + "Namespace": "ubuntu:14.04", + "Description": "PCRE before 8.38 mishandles the (?(\u003cdigits\u003e) and (?(R\u003cdigits\u003e) conditions, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8394", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 7.5, + "Vectors": "AV:N/AC:L/Au:N/C:P/I:P" + } + } + } + }, + { + "Name": "CVE-2015-8391", + "Namespace": "ubuntu:14.04", + "Description": "The pcre_compile function in pcre_compile.c in PCRE before 8.38 mishandles certain [: nesting, which allows remote attackers to cause a denial of service (CPU consumption) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8391", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 9, + "Vectors": "AV:N/AC:L/Au:N/C:P/I:P" + } + } + } + }, + { + "Name": "CVE-2015-8390", + "Namespace": "ubuntu:14.04", + "Description": "PCRE before 8.38 mishandles the [: and \\\\ substrings in character classes, which allows remote attackers to cause a denial of service (uninitialized memory read) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8390", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 7.5, + "Vectors": "AV:N/AC:L/Au:N/C:P/I:P" + } + } + } + }, + { + "Name": "CVE-2015-8382", + "Namespace": "ubuntu:14.04", + "Description": "The match function in pcre_exec.c in PCRE before 8.37 mishandles the /(?:((abcd))|(((?:(?:(?:(?:abc|(?:abcdef))))b)abcdefghi)abc)|((*ACCEPT)))/ pattern and related patterns involving (*ACCEPT), which allows remote attackers to obtain sensitive information from process memory or cause a denial of service (partially initialized memory and application crash) via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror, aka ZDI-CAN-2547.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8382", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 6.4, + "Vectors": "AV:N/AC:L/Au:N/C:P/I:N" + } + } + } + }, + { + "Name": "CVE-2015-8387", + "Namespace": "ubuntu:14.04", + "Description": "PCRE before 8.38 mishandles (?123) subroutine calls and related subroutine calls, which allows remote attackers to cause a denial of service (integer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8387", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 7.5, + "Vectors": "AV:N/AC:L/Au:N/C:P/I:P" + } + } + } + }, + { + "Name": "CVE-2015-8393", + "Namespace": "ubuntu:14.04", + "Description": "pcregrep in PCRE before 8.38 mishandles the -q option for binary files, which might allow remote attackers to obtain sensitive information via a crafted file, as demonstrated by a CGI script that sends stdout data to a client.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8393", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 5, + "Vectors": "AV:N/AC:L/Au:N/C:P/I:N" + } + } + } + }, + { + "Name": "CVE-2015-8386", + "Namespace": "ubuntu:14.04", + "Description": "PCRE before 8.38 mishandles the interaction of lookbehind assertions and mutually recursive subpatterns, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8386", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 7.5, + "Vectors": "AV:N/AC:L/Au:N/C:P/I:P" + } + } + } + }, + { + "Name": "CVE-2015-8380", + "Namespace": "ubuntu:14.04", + "Description": "The pcre_exec function in pcre_exec.c in PCRE before 8.38 mishandles a // pattern with a \\01 string, which allows remote attackers to cause a denial of service (heap-based buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8380", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 7.5, + "Vectors": "AV:N/AC:L/Au:N/C:P/I:P" + } + } + } + }, + { + "Name": "CVE-2015-8385", + "Namespace": "ubuntu:14.04", + "Description": "PCRE before 8.38 mishandles the /(?|(\\k'Pm')|(?'Pm'))/ pattern and related patterns with certain forward references, which allows remote attackers to cause a denial of service (buffer overflow) or possibly have unspecified other impact via a crafted regular expression, as demonstrated by a JavaScript RegExp object encountered by Konqueror.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8385", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 7.5, + "Vectors": "AV:N/AC:L/Au:N/C:P/I:P" + } + } + } + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libsemanage", + "Namespace": "ubuntu:14.04", + "Version": "2.2-1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "gdbm", + "Namespace": "ubuntu:14.04", + "Version": "1.8.3-12build1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "xkeyboard-config", + "Namespace": "ubuntu:14.04", + "Version": "2.10.1-1ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "ncurses", + "Namespace": "ubuntu:14.04", + "Version": "5.9+20140118-1ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "python3-defaults", + "Namespace": "ubuntu:14.04", + "Version": "3.4.0-0ubuntu2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libarchive-extract-perl", + "Namespace": "ubuntu:14.04", + "Version": "0.70-1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "iproute2", + "Namespace": "ubuntu:14.04", + "Version": "3.12.0-2ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "liblocale-gettext-perl", + "Namespace": "ubuntu:14.04", + "Version": "1.05-7build3", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "mawk", + "Namespace": "ubuntu:14.04", + "Version": "1.3.3-17ubuntu2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "expat", + "Namespace": "ubuntu:14.04", + "Version": "2.1.0-4ubuntu1.1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libcap2", + "Namespace": "ubuntu:14.04", + "Version": "1:2.24-0ubuntu2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "initramfs-tools", + "Namespace": "ubuntu:14.04", + "Version": "0.103ubuntu4.2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libestr", + "Namespace": "ubuntu:14.04", + "Version": "0.1.9-0ubuntu2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libtext-wrapi18n-perl", + "Namespace": "ubuntu:14.04", + "Version": "0.06-7", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "debianutils", + "Namespace": "ubuntu:14.04", + "Version": "4.4", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "insserv", + "Namespace": "ubuntu:14.04", + "Version": "1.14.0-5ubuntu2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "slang2", + "Namespace": "ubuntu:14.04", + "Version": "2.2.4-15ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "systemd", + "Namespace": "ubuntu:14.04", + "Version": "204-5ubuntu20.15", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "upstart", + "Namespace": "ubuntu:14.04", + "Version": "1.12.1-0ubuntu4.2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "kbd", + "Namespace": "ubuntu:14.04", + "Version": "1.15.5-1ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "busybox", + "Namespace": "ubuntu:14.04", + "Version": "1:1.21.0-1ubuntu1", + "Vulnerabilities": [ + { + "Name": "CVE-2014-9645", + "Namespace": "ubuntu:14.04", + "Description": "modprobe wrongly accepts paths as module names", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2014-9645", + "Severity": "Low" + }, + { + "Name": "CVE-2011-5325", + "Namespace": "ubuntu:14.04", + "Description": "path traversal vulnerability in busybox tar", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2011-5325", + "Severity": "Medium" + }, + { + "Name": "CVE-2016-2147", + "Namespace": "ubuntu:14.04", + "Description": "OOB heap write due to integer underflow", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-2147", + "Severity": "Low" + }, + { + "Name": "CVE-2016-2148", + "Namespace": "ubuntu:14.04", + "Description": "heap overflow in OPTION_6RD parsing", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-2148", + "Severity": "Low" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "eglibc", + "Namespace": "ubuntu:14.04", + "Version": "2.19-0ubuntu6.6", + "Vulnerabilities": [ + { + "Name": "CVE-2015-8778", + "Namespace": "ubuntu:14.04", + "Description": "hcreate((size_t)-1) should fail with ENOMEM", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8778", + "Severity": "Low" + }, + { + "Name": "CVE-2014-9761", + "Namespace": "ubuntu:14.04", + "Description": "nan function unbounded stack allocation", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2014-9761", + "Severity": "Low" + }, + { + "Name": "CVE-2015-5180", + "Namespace": "ubuntu:14.04", + "Description": "DNS resolver NULL pointer dereference with crafted record type", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-5180", + "Severity": "Low" + }, + { + "Name": "CVE-2013-2207", + "Namespace": "ubuntu:14.04", + "Description": "pt_chown in GNU C Library (aka glibc or libc6) before 2.18 does not properly check permissions for tty files, which allows local users to change the permission on the files and obtain access to arbitrary pseudo-terminals by leveraging a FUSE file system.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2013-2207", + "Severity": "Low" + }, + { + "Name": "CVE-2015-8776", + "Namespace": "ubuntu:14.04", + "Description": "Passing out of range data to strftime() causes a segfault", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8776", + "Severity": "Low" + }, + { + "Name": "CVE-2015-8779", + "Namespace": "ubuntu:14.04", + "Description": "catopen() Multiple unbounded stack allocations", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8779", + "Severity": "Low" + }, + { + "Name": "CVE-2015-5277", + "Namespace": "ubuntu:14.04", + "Description": "The get_contents function in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) before 2.20 might allow local users to cause a denial of service (heap corruption) or gain privileges via a long line in the NSS files database.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-5277", + "Severity": "Medium" + }, + { + "Name": "CVE-2015-7547", + "Namespace": "ubuntu:14.04", + "Description": "Multiple stack-based buffer overflows in the (1) send_dg and (2) send_vc functions in the libresolv library in the GNU C Library (aka glibc or libc6) before 2.23 allow remote attackers to cause a denial of service (crash) or possibly execute arbitrary code via a crafted DNS response that triggers a call to the getaddrinfo function with the AF_UNSPEC or AF_INET6 address family, related to performing \"dual A/AAAA DNS queries\" and the libnss_dns.so.2 NSS module.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-7547", + "Severity": "High", + "FixedBy": "2.19-0ubuntu6.7" + }, + { + "Name": "CVE-2014-8121", + "Namespace": "ubuntu:14.04", + "Description": "DB_LOOKUP in nss_files/files-XXX.c in the Name Service Switch (NSS) in GNU C Library (aka glibc or libc6) 2.21 and earlier does not properly check if a file is open, which allows remote attackers to cause a denial of service (infinite loop) by performing a look-up while the database is iterated over the database, which triggers the file pointer to be reset.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2014-8121", + "Severity": "Low" + }, + { + "Name": "CVE-2015-1781", + "Namespace": "ubuntu:14.04", + "Description": "Buffer overflow in the gethostbyname_r and other unspecified NSS functions in the GNU C Library (aka glibc or libc6) before 2.22 allows context-dependent attackers to cause a denial of service (crash) or execute arbitrary code via a crafted DNS response, which triggers a call with a misaligned buffer.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-1781", + "Severity": "Low" + }, + { + "Name": "CVE-2016-1234", + "Namespace": "ubuntu:14.04", + "Description": "glob: buffer overflow with GLOB_ALTDIRFUNC due to incorrect NAME_MAX limit assumption", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-1234", + "Severity": "Medium" + }, + { + "Name": "CVE-2015-8777", + "Namespace": "ubuntu:14.04", + "Description": "The process_envvars function in elf/rtld.c in the GNU C Library (aka glibc or libc6) before 2.23 allows local users to bypass a pointer-guarding protection mechanism via a zero value of the LD_POINTER_GUARD environment variable.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8777", + "Severity": "Low" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "hostname", + "Namespace": "ubuntu:14.04", + "Version": "3.15ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "bzip2", + "Namespace": "ubuntu:14.04", + "Version": "1.0.6-5", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libnih", + "Namespace": "ubuntu:14.04", + "Version": "1.0.3-4ubuntu25", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "mpdecimal", + "Namespace": "ubuntu:14.04", + "Version": "2.4.0-6", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "openssl", + "Namespace": "ubuntu:14.04", + "Version": "1.0.1f-1ubuntu2.16", + "Vulnerabilities": [ + { + "Name": "CVE-2016-0797", + "Namespace": "ubuntu:14.04", + "Description": "Multiple integer overflows in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allow remote attackers to cause a denial of service (heap memory corruption or NULL pointer dereference) or possibly have unspecified other impact via a long digit string that is mishandled by the (1) BN_dec2bn or (2) BN_hex2bn function, related to crypto/bn/bn.h and crypto/bn/bn_print.c.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-0797", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 5, + "Vectors": "AV:N/AC:L/Au:N/C:N/I:N" + } + } + }, + "FixedBy": "1.0.1f-1ubuntu2.18" + }, + { + "Name": "CVE-2016-2842", + "Namespace": "ubuntu:14.04", + "Description": "The doapr_outch function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not verify that a certain memory allocation succeeds, which allows remote attackers to cause a denial of service (out-of-bounds write or memory consumption) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-0799.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-2842", + "Severity": "Medium", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 10, + "Vectors": "AV:N/AC:L/Au:N/C:C/I:C" + } + } + }, + "FixedBy": "1.0.1f-1ubuntu2.18" + }, + { + "Name": "CVE-2016-0702", + "Namespace": "ubuntu:14.04", + "Description": "The MOD_EXP_CTIME_COPY_FROM_PREBUF function in crypto/bn/bn_exp.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g does not properly consider cache-bank access times during modular exponentiation, which makes it easier for local users to discover RSA keys by running a crafted application on the same Intel Sandy Bridge CPU core as a victim and leveraging cache-bank conflicts, aka a \"CacheBleed\" attack.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-0702", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 1.9, + "Vectors": "AV:L/AC:M/Au:N/C:P/I:N" + } + } + }, + "FixedBy": "1.0.1f-1ubuntu2.18" + }, + { + "Name": "CVE-2016-0705", + "Namespace": "ubuntu:14.04", + "Description": "Double free vulnerability in the dsa_priv_decode function in crypto/dsa/dsa_ameth.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory corruption) or possibly have unspecified other impact via a malformed DSA private key.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-0705", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 10, + "Vectors": "AV:N/AC:L/Au:N/C:C/I:C" + } + } + }, + "FixedBy": "1.0.1f-1ubuntu2.18" + }, + { + "Name": "CVE-2016-0798", + "Namespace": "ubuntu:14.04", + "Description": "Memory leak in the SRP_VBASE_get_by_user implementation in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g allows remote attackers to cause a denial of service (memory consumption) by providing an invalid username in a connection attempt, related to apps/s_server.c and crypto/srp/srp_vfy.c.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-0798", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 7.8, + "Vectors": "AV:N/AC:L/Au:N/C:N/I:N" + } + } + }, + "FixedBy": "1.0.1f-1ubuntu2.18" + }, + { + "Name": "CVE-2016-0799", + "Namespace": "ubuntu:14.04", + "Description": "The fmtstr function in crypto/bio/b_print.c in OpenSSL 1.0.1 before 1.0.1s and 1.0.2 before 1.0.2g improperly calculates string lengths, which allows remote attackers to cause a denial of service (overflow and out-of-bounds read) or possibly have unspecified other impact via a long string, as demonstrated by a large amount of ASN.1 data, a different vulnerability than CVE-2016-2842.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-0799", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 10, + "Vectors": "AV:N/AC:L/Au:N/C:C/I:C" + } + } + }, + "FixedBy": "1.0.1f-1ubuntu2.18" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "diffutils", + "Namespace": "ubuntu:14.04", + "Version": "1:3.3-1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "apt", + "Namespace": "ubuntu:14.04", + "Version": "1.0.1ubuntu2.10", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "debconf", + "Namespace": "ubuntu:14.04", + "Version": "1.5.51ubuntu2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "ubuntu-meta", + "Namespace": "ubuntu:14.04", + "Version": "1.325", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "rsyslog", + "Namespace": "ubuntu:14.04", + "Version": "7.4.4-1ubuntu2.6", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "dh-python", + "Namespace": "ubuntu:14.04", + "Version": "1.20140128-1ubuntu8.2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libpng", + "Namespace": "ubuntu:14.04", + "Version": "1.2.50-1ubuntu2.14.04.1", + "Vulnerabilities": [ + { + "Name": "CVE-2015-8540", + "Namespace": "ubuntu:14.04", + "Description": "underflow read in png_check_keyword in pngwutil.c", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8540", + "Severity": "Medium", + "FixedBy": "1.2.50-1ubuntu2.14.04.2" + }, + { + "Name": "CVE-2015-8472", + "Namespace": "ubuntu:14.04", + "Description": "Buffer overflow in the png_set_PLTE function in libpng before 1.0.65, 1.1.x and 1.2.x before 1.2.55, 1.3.x, 1.4.x before 1.4.18, 1.5.x before 1.5.25, and 1.6.x before 1.6.20 allows remote attackers to cause a denial of service (application crash) or possibly have unspecified other impact via a small bit-depth value in an IHDR (aka image header) chunk in a PNG image. NOTE: this vulnerability exists because of an incomplete fix for CVE-2015-8126.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8472", + "Severity": "Medium", + "FixedBy": "1.2.50-1ubuntu2.14.04.2" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libmodule-pluggable-perl", + "Namespace": "ubuntu:14.04", + "Version": "5.1-1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "mountall", + "Namespace": "ubuntu:14.04", + "Version": "2.53", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "cron", + "Namespace": "ubuntu:14.04", + "Version": "3.0pl1-124ubuntu2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "acl", + "Namespace": "ubuntu:14.04", + "Version": "2.2.52-1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libdrm", + "Namespace": "ubuntu:14.04", + "Version": "2.4.60-2~ubuntu14.04.1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "util-linux", + "Namespace": "ubuntu:14.04", + "Version": "2.20.1-5.1ubuntu20.7", + "Vulnerabilities": [ + { + "Name": "CVE-2014-9114", + "Namespace": "ubuntu:14.04", + "Description": "blkid command injection", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2014-9114", + "Severity": "Low" + }, + { + "Name": "CVE-2013-0157", + "Namespace": "ubuntu:14.04", + "Description": "(a) mount and (b) umount in util-linux 2.14.1, 2.17.2, and probably other versions allow local users to determine the existence of restricted directories by (1) using the --guess-fstype command-line option or (2) attempting to mount a non-existent device, which generates different error messages depending on whether the directory exists.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2013-0157", + "Severity": "Low" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "tzdata", + "Namespace": "ubuntu:14.04", + "Version": "2015g-0ubuntu0.14.04", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "less", + "Namespace": "ubuntu:14.04", + "Version": "458-2", + "Vulnerabilities": [ + { + "Name": "CVE-2014-9488", + "Namespace": "ubuntu:14.04", + "Description": "The is_utf8_well_formed function in GNU less before 475 allows remote attackers to have unspecified impact via malformed UTF-8 characters, which triggers an out-of-bounds read.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2014-9488", + "Severity": "Low" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "popt", + "Namespace": "ubuntu:14.04", + "Version": "1.16-8ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "init-system-helpers", + "Namespace": "ubuntu:14.04", + "Version": "1.14", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "mime-support", + "Namespace": "ubuntu:14.04", + "Version": "3.54ubuntu1.1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "p11-kit", + "Namespace": "ubuntu:14.04", + "Version": "0.20.2-2ubuntu2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "cgmanager", + "Namespace": "ubuntu:14.04", + "Version": "0.24-0ubuntu7.5", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libselinux", + "Namespace": "ubuntu:14.04", + "Version": "2.2.2-1ubuntu0.1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "langpack-locales", + "Namespace": "ubuntu:14.04", + "Version": "2.13+git20120306-12.1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "procps", + "Namespace": "ubuntu:14.04", + "Version": "1:3.3.9-1ubuntu2.2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "ureadahead", + "Namespace": "ubuntu:14.04", + "Version": "0.100.0-16", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "file", + "Namespace": "ubuntu:14.04", + "Version": "1:5.14-2ubuntu3.3", + "Vulnerabilities": [ + { + "Name": "CVE-2014-9621", + "Namespace": "ubuntu:14.04", + "Description": "The ELF parser in file 5.16 through 5.21 allows remote attackers to cause a denial of service via a long string.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2014-9621", + "Severity": "Low" + }, + { + "Name": "CVE-2014-9620", + "Namespace": "ubuntu:14.04", + "Description": "The ELF parser in file 5.08 through 5.21 allows remote attackers to cause a denial of service via a large number of notes.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2014-9620", + "Severity": "Low" + }, + { + "Name": "CVE-2014-9653", + "Namespace": "ubuntu:14.04", + "Description": "readelf.c in file before 5.22, as used in the Fileinfo component in PHP before 5.4.37, 5.5.x before 5.5.21, and 5.6.x before 5.6.5, does not consider that pread calls sometimes read only a subset of the available data, which allows remote attackers to cause a denial of service (uninitialized memory access) or possibly have unspecified other impact via a crafted ELF file.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2014-9653", + "Severity": "Low" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "dbus", + "Namespace": "ubuntu:14.04", + "Version": "1.6.18-0ubuntu4.3", + "Vulnerabilities": [ + { + "Name": "CVE-2015-0245", + "Namespace": "ubuntu:14.04", + "Description": "D-Bus 1.4.x through 1.6.x before 1.6.30, 1.8.x before 1.8.16, and 1.9.x before 1.9.10 does not validate the source of ActivationFailure signals, which allows local users to cause a denial of service (activation failure error returned) by leveraging a race condition involving sending an ActivationFailure signal before systemd responds.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-0245", + "Severity": "Low" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "zlib", + "Namespace": "ubuntu:14.04", + "Version": "1:1.2.8.dfsg-1ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "netbase", + "Namespace": "ubuntu:14.04", + "Version": "5.2", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libtasn1-6", + "Namespace": "ubuntu:14.04", + "Version": "3.4-3ubuntu0.3", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "sed", + "Namespace": "ubuntu:14.04", + "Version": "4.2.2-4ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "e2fsprogs", + "Namespace": "ubuntu:14.04", + "Version": "1.42.9-3ubuntu1.3", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "sensible-utils", + "Namespace": "ubuntu:14.04", + "Version": "0.0.9", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libusb", + "Namespace": "ubuntu:14.04", + "Version": "2:0.1.12-23.3ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "shadow", + "Namespace": "ubuntu:14.04", + "Version": "1:4.1.5.1-1ubuntu9.1", + "Vulnerabilities": [ + { + "Name": "CVE-2013-4235", + "Namespace": "ubuntu:14.04", + "Description": "TOCTOU race conditions by copying and removing directory trees", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2013-4235", + "Severity": "Low" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "kmod", + "Namespace": "ubuntu:14.04", + "Version": "15-0ubuntu6", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "ucf", + "Namespace": "ubuntu:14.04", + "Version": "3.0027+nmu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libpod-latex-perl", + "Namespace": "ubuntu:14.04", + "Version": "0.61-1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "ubuntu-keyring", + "Namespace": "ubuntu:14.04", + "Version": "2012.05.19", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "perl", + "Namespace": "ubuntu:14.04", + "Version": "5.18.2-2ubuntu1", + "Vulnerabilities": [ + { + "Name": "CVE-2016-2381", + "Namespace": "ubuntu:14.04", + "Description": "environment variable confusion", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-2381", + "Severity": "Medium", + "FixedBy": "5.18.2-2ubuntu1.1" + }, + { + "Name": "CVE-2013-7422", + "Namespace": "ubuntu:14.04", + "Description": "Integer underflow in regcomp.c in Perl before 5.20, as used in Apple OS X before 10.10.5 and other products, allows context-dependent attackers to execute arbitrary code or cause a denial of service (application crash) via a long digit string associated with an invalid backreference within a regular expression.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2013-7422", + "Severity": "Low", + "FixedBy": "5.18.2-2ubuntu1.1" + }, + { + "Name": "CVE-2014-4330", + "Namespace": "ubuntu:14.04", + "Description": "The Dumper method in Data::Dumper before 2.154, as used in Perl 5.20.1 and earlier, allows context-dependent attackers to cause a denial of service (stack consumption and crash) via an Array-Reference with many nested Array-References, which triggers a large number of recursive calls to the DD_dump function.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2014-4330", + "Severity": "Low", + "FixedBy": "5.18.2-2ubuntu1.1" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "lsb", + "Namespace": "ubuntu:14.04", + "Version": "4.1+Debian11ubuntu6", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "makedev", + "Namespace": "ubuntu:14.04", + "Version": "2.3.1-93ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libterm-ui-perl", + "Namespace": "ubuntu:14.04", + "Version": "0.42-1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "isc-dhcp", + "Namespace": "ubuntu:14.04", + "Version": "4.2.4-7ubuntu12.3", + "Vulnerabilities": [ + { + "Name": "CVE-2015-8605", + "Namespace": "ubuntu:14.04", + "Description": "ISC DHCP 4.x before 4.1-ESV-R12-P1 and 4.2.x and 4.3.x before 4.3.3-P1 allows remote attackers to cause a denial of service (application crash) via an invalid length field in a UDP IPv4 packet.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8605", + "Severity": "Medium", + "FixedBy": "4.2.4-7ubuntu12.4" + }, + { + "Name": "CVE-2016-2774", + "Namespace": "ubuntu:14.04", + "Description": "ISC DHCP 4.1.x before 4.1-ESV-R13 and 4.2.x and 4.3.x before 4.3.4 does not restrict the number of concurrent TCP sessions, which allows remote attackers to cause a denial of service (INSIST assertion failure or request-processing outage) by establishing many sessions.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-2774", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 7.1, + "Vectors": "AV:N/AC:M/Au:N/C:N/I:N" + } + } + } + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "liblog-message-simple-perl", + "Namespace": "ubuntu:14.04", + "Version": "0.10-1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "plymouth", + "Namespace": "ubuntu:14.04", + "Version": "0.8.8-0ubuntu17.1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "audit", + "Namespace": "ubuntu:14.04", + "Version": "1:2.3.2-2ubuntu1", + "Vulnerabilities": [ + { + "Name": "CVE-2015-5186", + "Namespace": "ubuntu:14.04", + "Description": "log terminal emulator escape sequences handling", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-5186", + "Severity": "Negligible" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libbsd", + "Namespace": "ubuntu:14.04", + "Version": "0.6.0-2ubuntu1", + "Vulnerabilities": [ + { + "Name": "CVE-2016-2090", + "Namespace": "ubuntu:14.04", + "Description": "Heap buffer overflow in fgetwln function of libbsd", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-2090", + "Severity": "Low" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "iputils", + "Namespace": "ubuntu:14.04", + "Version": "3:20121221-4ubuntu1.1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "libgpg-error", + "Namespace": "ubuntu:14.04", + "Version": "1.12-0.2ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "pam", + "Namespace": "ubuntu:14.04", + "Version": "1.1.8-1ubuntu2", + "Vulnerabilities": [ + { + "Name": "CVE-2015-3238", + "Namespace": "ubuntu:14.04", + "Description": "The _unix_run_helper_binary function in the pam_unix module in Linux-PAM (aka pam) before 1.2.1, when unable to directly access passwords, allows local users to enumerate usernames or cause a denial of service (hang) via a large password.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-3238", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 5.8, + "Vectors": "AV:N/AC:M/Au:N/C:P/I:N" + } + } + }, + "FixedBy": "1.1.8-1ubuntu2.1" + }, + { + "Name": "CVE-2013-7041", + "Namespace": "ubuntu:14.04", + "Description": "The pam_userdb module for Pam uses a case-insensitive method to compare hashed passwords, which makes it easier for attackers to guess the password via a brute force attack.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2013-7041", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 4.3, + "Vectors": "AV:N/AC:M/Au:N/C:P/I:N" + } + } + }, + "FixedBy": "1.1.8-1ubuntu2.1" + }, + { + "Name": "CVE-2014-2583", + "Namespace": "ubuntu:14.04", + "Description": "Multiple directory traversal vulnerabilities in pam_timestamp.c in the pam_timestamp module for Linux-PAM (aka pam) 1.1.8 allow local users to create aribitrary files or possibly bypass authentication via a .. (dot dot) in the (1) PAM_RUSER value to the get_ruser function or (2) PAM_TTY value to the check_tty funtion, which is used by the format_timestamp_name function.", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2014-2583", + "Severity": "Low", + "Metadata": { + "NVD": { + "CVSSv2": { + "Score": 5.8, + "Vectors": "AV:N/AC:M/Au:N/C:P/I:P" + } + } + }, + "FixedBy": "1.1.8-1ubuntu2.1" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "liblockfile", + "Namespace": "ubuntu:14.04", + "Version": "1.09-6ubuntu1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "ntp", + "Namespace": "ubuntu:14.04", + "Version": "1:4.2.6.p5+dfsg-3ubuntu2.14.04.6", + "Vulnerabilities": [ + { + "Name": "CVE-2016-0727", + "Namespace": "ubuntu:14.04", + "Description": "NTP statsdir cleanup cronjob insecure", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2016-0727", + "Severity": "Low" + }, + { + "Name": "CVE-2015-8158", + "Namespace": "ubuntu:14.04", + "Description": "Potential Infinite Loop in ntpq", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8158", + "Severity": "Low" + }, + { + "Name": "CVE-2015-7973", + "Namespace": "ubuntu:14.04", + "Description": "Deja Vu: Replay attack on authenticated broadcast mode", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-7973", + "Severity": "Low" + }, + { + "Name": "CVE-2015-8140", + "Namespace": "ubuntu:14.04", + "Description": "ntpq vulnerable to replay attacks", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8140", + "Severity": "Low" + }, + { + "Name": "CVE-2015-8139", + "Namespace": "ubuntu:14.04", + "Description": "Origin Leak: ntpq and ntpdc, disclose origin", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8139", + "Severity": "Low" + }, + { + "Name": "CVE-2015-7976", + "Namespace": "ubuntu:14.04", + "Description": "ntpq saveconfig command allows dangerous characters in filenames", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-7976", + "Severity": "Low" + }, + { + "Name": "CVE-2015-7979", + "Namespace": "ubuntu:14.04", + "Description": "Off-path Denial of Service (DoS) attack on authenticated broadcast mode", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-7979", + "Severity": "Low" + }, + { + "Name": "CVE-2015-8138", + "Namespace": "ubuntu:14.04", + "Description": "ntp: missing check for zero originate timestamp", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-8138", + "Severity": "Medium" + }, + { + "Name": "CVE-2015-7977", + "Namespace": "ubuntu:14.04", + "Description": "reslist NULL pointer dereference", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-7977", + "Severity": "Medium" + }, + { + "Name": "CVE-2015-7978", + "Namespace": "ubuntu:14.04", + "Description": "Stack exhaustion in recursive traversal of restriction list", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-7978", + "Severity": "Medium" + }, + { + "Name": "CVE-2015-7974", + "Namespace": "ubuntu:14.04", + "Description": "NTP 4.x before 4.2.8p6 and 4.3.x before 4.3.90 do not verify peer associations of symmetric keys when authenticating packets, which might allow remote attackers to conduct impersonation attacks via an arbitrary trusted key, aka a \"skeleton key.\"", + "Link": "http://people.ubuntu.com/~ubuntu-security/cve/CVE-2015-7974", + "Severity": "Low" + } + ], + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "newt", + "Namespace": "ubuntu:14.04", + "Version": "0.52.15-2ubuntu5", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + }, + { + "Name": "sqlite3", + "Namespace": "ubuntu:14.04", + "Version": "3.8.2-1ubuntu2.1", + "AddedBy": "sha256:d89e1bee20d9cb344674e213b581f14fbd8e70274ecf9d10c514bab78a307845" + } + ] + } + }, + { + "Layer": { + "Name": "sha256:9e0bc8a71bde464f710bc2b593a1fc21521517671e918687892303151331fa56", + "Namespace": "ubuntu:14.04", + "ParentName": "sha256:27aa681c95e5165caf287dcfe896532df4ae8b10e099500f2f8f71acf4002a89", + "IndexedByVersion": 2 + } + }, + { + "Layer": { + "Name": "sha256:27aa681c95e5165caf287dcfe896532df4ae8b10e099500f2f8f71acf4002a89", + "Namespace": "ubuntu:14.04", + "ParentName": "sha256:a3ed95caeb02ffe68cdd9fd84406680ae93d633cb16422d00e8a7c22955b46d4", + "IndexedByVersion": 2 + } + }, + { + "Layer": { + "Name": "sha256:a3ed95caeb02ffe68cdd9fd84406680ae93d633cb16422d00e8a7c22955b46d4", + "IndexedByVersion": 2 + } + } + ] +} \ No newline at end of file diff --git a/cmd/clairclt/server/server.go b/cmd/clairclt/server/server.go new file mode 100644 index 00000000..502030d4 --- /dev/null +++ b/cmd/clairclt/server/server.go @@ -0,0 +1,99 @@ +package server + +import ( + "net" + "net/http" + "net/http/httputil" + "net/url" + "os" + "regexp" + "strings" + "time" + + "github.com/Sirupsen/logrus" + "github.com/coreos/clair/cmd/clairclt/docker" + "github.com/coreos/clair/cmd/clairclt/docker/httpclient" + "github.com/spf13/viper" +) + +//Serve run a local server with the fileserver and the reverse proxy +func Serve(sURL string) error { + + go func() { + http.Handle("/v2/", newSingleHostReverseProxy()) + http.Handle("/local/", http.StripPrefix("/local", restrictedFileServer(docker.TmpLocal()))) + + listener := tcpListener(sURL) + logrus.Info("Starting Server on ", listener.Addr()) + + if err := http.Serve(listener, nil); err != nil { + logrus.Fatalf("local server error: %v", err) + } + }() + //sleep needed to wait the server start. Maybe use a channel for that + time.Sleep(5 * time.Millisecond) + return nil +} + +func tcpListener(sURL string) (listener net.Listener) { + listener, err := net.Listen("tcp", sURL) + if err != nil { + logrus.Fatalf("cannot instanciate listener: %v", err) + } + + if viper.GetInt("hyperclair.port") == 0 { + port := strings.Split(listener.Addr().String(), ":")[1] + logrus.Debugf("Update local server port from %q to %q", "0", port) + viper.Set("hyperclair.port", port) + } + + return +} + +func restrictedFileServer(path string) http.Handler { + if _, err := os.Stat(path); os.IsNotExist(err) { + os.Mkdir(path, 0777) + } + + fc := func(w http.ResponseWriter, r *http.Request) { + http.FileServer(http.Dir(path)).ServeHTTP(w, r) + } + return http.HandlerFunc(fc) +} + +func newSingleHostReverseProxy() *httputil.ReverseProxy { + director := func(request *http.Request) { + + var validID = regexp.MustCompile(`.*/blobs/(.*)$`) + u := request.URL.Path + logrus.Debugf("request url: %v", u) + if !validID.MatchString(u) { + logrus.Errorf("cannot parse url: %v", u) + } + + host, _ := docker.GetRegistryMapping(validID.FindStringSubmatch(u)[1]) + out, _ := url.Parse(host) + request.URL.Scheme = out.Scheme + request.URL.Host = out.Host + client := httpclient.Get() + req, _ := http.NewRequest("HEAD", request.URL.String(), nil) + resp, err := client.Do(req) + if err != nil { + logrus.Errorf("response error: %v", err) + return + } + + if resp.StatusCode == http.StatusUnauthorized { + logrus.Info("pull from clair is unauthorized") + docker.AuthenticateResponse(resp, request) + } + + r, _ := http.NewRequest("GET", request.URL.String(), nil) + r.Header.Set("Authorization", request.Header.Get("Authorization")) + r.Header.Set("Accept-Encoding", request.Header.Get("Accept-Encoding")) + *request = *r + } + return &httputil.ReverseProxy{ + Director: director, + } +} diff --git a/cmd/clairclt/xstrings/xstrings.go b/cmd/clairclt/xstrings/xstrings.go new file mode 100644 index 00000000..eb38292e --- /dev/null +++ b/cmd/clairclt/xstrings/xstrings.go @@ -0,0 +1,30 @@ +package xstrings + +import ( + "encoding/json" + "strings" +) + +//Substr extract string of length in s starting at pos +func Substr(s string, pos, length int) string { + runes := []rune(s) + l := pos + length + if l > len(runes) { + l = len(runes) + } + return string(runes[pos:l]) +} + +//TrimPrefixSuffix combine TrimPrefix and TrimSuffix +func TrimPrefixSuffix(s string, prefix string, suffix string) string { + return strings.TrimSuffix(strings.TrimPrefix(s, prefix), suffix) +} + +//ToIndentJSON apply json.MarshalIndent with tabulation on an interface and return the formatted string +func ToIndentJSON(v interface{}) ([]byte, error) { + b, err := json.MarshalIndent(v, "", "\t") + if err != nil { + return nil, err + } + return b, nil +} diff --git a/cmd/clairclt/xstrings/xstrings_test.go b/cmd/clairclt/xstrings/xstrings_test.go new file mode 100644 index 00000000..d58dd13c --- /dev/null +++ b/cmd/clairclt/xstrings/xstrings_test.go @@ -0,0 +1,27 @@ +package xstrings + +import "testing" + +func TestSubstrFromBeginning(t *testing.T) { + commitID := "e3ff9321271b0a5cec45ca6e0cdc72b2f376afd2" + expected := "e3ff9" + if s := Substr(commitID, 0, 5); s != expected { + t.Errorf("is %v, expect %v", s, expected) + } +} + +func TestSubstrFromCharFive(t *testing.T) { + commitID := "e3ff9321271b0a5cec45ca6e0cdc72b2f376afd2" + expected := "32127" + if s := Substr(commitID, 5, 5); s != expected { + t.Errorf("is %v, expect %v", s, expected) + } +} + +func TestTrimPrefixSuffix(t *testing.T) { + v := "http://registry:5555/v2" + e := "registry:5555" + if s := TrimPrefixSuffix(v, "http://", "/v2"); s != e { + t.Errorf("is %v, expect %v", s, e) + } +}