CVE-2019-1010022
Description
[Disputed] GNU Libc is impacted by a mitigation bypass issue in its nptl component, which could allow an attacker to bypass stack guard protections. The stack canary (designed to prevent stack-based buffer overflows) can be overwritten if an attacker already have exploited any stack buffer overflow vulnerability. The vulnerability arises when creating new threads with pthread_create(), where the tcbhead_t structure containing the stack_guard is placed on the thread stack, making it susceptible to overwriting. Although this weakens the stack canary protection, it is categorized as a post-attack mitigation rather than a direct security flaw. Upstream maintainers have indicated that this is being treated as a non-security issue with no immediate threat.
Statement
Red Hat Product Security does not consider this to be a vulnerability. Also, the upstream project recognizes it as a hardening issue [1], they do not classify it as a security flaw.
Here are some technical notes regarding the issue:
The issue relates to a mitigation bypass in the GNU Libc library's NPTL component, allowing attackers to circumvent stack guard protection via a stack buffer overflow. However, this is considered a post-attack mitigation rather than a direct vulnerability. According to the glibc security process [2], an issue must meet specific criteria for direct exploitation to be deemed a security bug.
In this case, the bypass of stack canary protection occurs by overwriting the stack_guard in the tcbhead_t structure, but only after a successful stack overflow attack. This issue does not directly lead to code execution. Instead, it weakens an additional layer of protection after an attack has already occurred, thus classifying it as a post-attack hardening issue.
In summary, while the issue has security implications, it does not meet the criteria to be classified as a direct security vulnerability.
[1] https://sourceware.org/bugzilla/show_bug.cgi?id=22850#c3 [2] https://sourceware.org/git/?p=glibc.git;a=blob;f=SECURITY.md
Common Vulnerability Scoring System (CVSS) Score Details
Info alert:Important note
CVSS scores for open source components depend on vendor-specific factors (e.g. version or build chain). Therefore, Red Hat's score and impact rating can be different from NVD and other vendors. Red Hat remains the authoritative CVE Naming Authority (CNA) source for its products and services (see Red Hat classifications).
The following CVSS metrics and score provided are preliminary and subject to review.
CVSS v3 Score Breakdown
| Red Hat | NVD | cve.org | |
|---|---|---|---|
| Base Score | 0 | 9.8 | N/A |
| Attack Vector | Network | Network | N/A |
| Attack Complexity | High | Low | N/A |
| Privileges Required | None | None | N/A |
| User Interaction | None | None | N/A |
| Scope | Unchanged | Unchanged | N/A |
| Confidentiality | None | High | N/A |
| Integrity Impact | None | High | N/A |
| Availability Impact | None | High | N/A |
Vector
Red Hat: CVSS:3.0/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:N
NVD: CVSS:3.0/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
Understanding the Weakness (CWE)
Confidentiality,Access Control,Availability,Other
Technical Impact: Bypass Protection Mechanism; Gain Privileges or Assume Identity; Varies by Context
Attackers can bypass the security decision to access whatever is being protected. The consequences will depend on the associated functionality, but they can range from granting additional privileges to untrusted users to bypassing important security checks. Ultimately, this weakness may lead to exposure or modification of sensitive data, system crash, or execution of arbitrary code.
Frequently Asked Questions
Not sure what something means? Check out our Security Glossary.
Want to get errata notifications? Sign up here.
