Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain local unprivileged shell
-
DeliveryLocate setuid binary with $ORIGIN-prefixed RPATH/RUNPATH
-
ExploitExecute binary to invoke ld.so path parsing
-
ExecutionTrigger stack buffer over-read/over-write in loader
-
ImpactCrash loader or disclose limited process memory
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Stack buffer bounds checking
MITRE ATT&CK
1 technique across 1 tactic: Execution The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Requires local access to the host and the presence on that host of a setuid or setgid (AT_SECURE) program whose DT_RPATH or DT_RUNPATH begins with the string $ORIGIN immediately followed by a NUL byte or a '/' character; the attacker must be able to execute that specific binary so the glibc dynamic loader parses the malformed path. Exploitation is limited by the need for local privileges (PR:L), the non-universal requirement that such a specially-linked setuid/setgid binary actually exist (driving AC:H), and the modest impact ceiling - a loader crash of the invoked program plus limited memory disclosure rather than privilege escalation to root. There is no remote or unauthenticated path and no user-interaction dependency on a victim. |
| Impact | All signals converge on this being a LOW real-world priority despite affecting an ubiquitous product. The vendor CVSS of 3.6 (AV:L/AC:H/PR:L/UI:N/S:U/C:L/I:L/A:N) reflects a genuinely constrained bug: local access only, high attack complexity, and partial confidentiality/integrity impact with no availability impact scored. No EPSS score, KEV listing, or POC was provided in the intelligence set, so per the precision rules there is no public exploit identified at time of analysis and no evidence of active exploitation. The most important limiter is not in the numeric vector but in the description: exploitation requires a setuid/setgid (AT_SECURE) binary whose DT_RPATH or DT_RUNPATH begins with $ORIGIN followed by NUL or '/'. That is a specific link-time property of a target binary, not something an attacker freely controls, which justifies AC:H. The primary demonstrated impact is a loader crash of a program the attacker themselves invokes plus limited memory disclosure - the vendor's A:N (rather than A:L) is defensible because the DoS is self-inflicted rather than affecting other users or services, though the description's explicit mention of 'crash (denial of service)' makes a marginal A:L arguable. No signals conflict; the picture is internally consistent: high-footprint library, narrow exploitation surface, low impact. |
| Exploit ScenarioDerived | A local, low-privileged attacker on a Linux host locates a setuid/setgid (AT_SECURE) binary that was linked with a DT_RPATH or DT_RUNPATH beginning with $ORIGIN followed by NUL or '/'. The attacker executes that binary so the glibc dynamic loader parses the malformed path, over-reading the path buffer and over-writing a stack-allocated internal buffer, causing a loader crash and limited disclosure of adjacent process memory. No public exploit code was identified in the provided intelligence, and the high complexity (AC:H) is driven by the requirement that such a specifically-linked setuid binary exist on the system. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 22, 2026
The GNU C Library dynamic loader (ld.so) in glibc 2.14 through 2.44 mishandles DT_RPATH/DT_RUNPATH values that begin with the literal string $ORIGIN immediately followed by a NUL byte or a '/' character, producing a stack-based buffer overflow (CWE-121) when such a path is parsed in a setuid or setgid (AT_SECURE) program. A local attacker who can execute an affected privileged binary causes the loader to read past the end of the path buffer and write past the end of a stack-allocated internal buffer, resulting in a loader crash (denial of service) and limited disclosure of process memory, with a low CVSS 3.6 score reflecting the local, high-complexity, non-privilege-escalating nature of the flaw. There is no public exploit identified at time of analysis and no CISA KEV listing; exploitation requires local access (PR:L) plus the pre-existing, non-universal condition that a specially-linked setuid/setgid binary exists on the host and is executable by the attacker, which is why all signals converge on this being a LOW real-world priority despite the ubiquity of glibc.
RemediationAI
No explicit fixed version is stated in the available intelligence, so the authoritative remediation source is the upstream advisory GLIBC-SA-2026-0023 (https://sourceware.org/git/?p=glibc.git;a=blob_plain;f=advisories/GLIBC-SA-2026-0023) together with the sourceware bug 34360 (https://sourceware.org/bugzilla/show_bug.cgi?id=34360); track and apply your distribution's glibc update for CVE-2026-95818 as soon as it is released, since distros backport fixes rather than always bumping the upstream version. Because the flaw only triggers when a privileged binary's RPATH/RUNPATH starts with $ORIGIN plus NUL or '/', an effective compensating control is to inventory setuid/setgid binaries (find / -perm -4000 -o -perm -2000) and inspect their dynamic tags with readelf -d or objdump -p, then remove the problematic $ORIGIN prefix from any DT_RPATH/DT_RUNPATH using patchelf or by relinking with -Wl,-rpath=$ORIGIN/... replaced by an absolute, non-$ORIGIN path - the trade-off being that relocatable-install assumptions for that binary are broken and library resolution may fail. Where such a binary is not strictly required, clearing the setuid/setgid bit (chmod u-s / g-s) eliminates the AT_SECURE code path entirely, at the cost of losing the privileged function the binary provided. If neither change is feasible, restrict which local users can execute the specific affected binaries (for example via dedicated groups and file permissions, or noexec/exec-restricted mounts for user-writable directories containing them), accepting that this is an operational restriction rather than a true fix. Note these are mitigating steps only - they reduce reachability of the malformed-path parsing but do not correct the underlying stack buffer overflow in ld.so.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
This issue lives in the ELF dynamic linker/loader component of glibc (ld.so), the code that maps shared objects and resolves library search paths at program startup. The relevant ELF metadata are DT_RPATH and DT_RUNPATH, the tags that define a binary's library search path, and the token $ORIGIN, which the loader expands to the directory containing the executable. Because $ORIGIN-based paths are security-sensitive for privileged binaries, the loader applies special handling when the kernel marks the process as AT_SECURE (the auxiliary vector flag set for setuid/setgid executables); the defect is in that secure-mode path-parsing logic. When an AT_SECURE program's RPATH/RUNPATH begins with $ORIGIN and the next byte is either a NUL terminator or '/', the code computes a length/offset incorrectly, reading past the end of the path buffer and writing past the end of a stack-allocated internal buffer. This is a classic CWE-121 stack-based buffer overflow, caused by missing or off-by-one bounds validation rather than by a logic flaw in library resolution itself. The affected package is identified as cpe:2.3:a:the_gnu_c_library:glibc, and the practical blast radius is any distribution or product that ships glibc in the 2.14-2.44 range together with setuid/setgid binaries carrying the malformed RPATH/RUNPATH pattern. The assessed impact ceiling is deliberately modest: primary impact is availability (A:N in the CVSS vector, but the described outcome is a loader crash of the invoked program) and confidentiality (C:L) from limited memory disclosure; integrity is limited (I:L) to loader stack corruption, and there is no demonstrated path to privilege escalation, since the corrupted stack belongs to the loader processing a program the attacker already invoked.
Know when Glibc gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:L/AC:H/PR:L/UI:N/S:U/C:L/I:L/A:N
Local-only vector (AV:L) needing a specially-linked setuid binary raises complexity (AC:H) with low-priv local access (PR:L); disclosure and corruption are limited (C:L/I:L) and the crash is self-invoked so no availability impact to others (A:N).
Primary rating from Vendor (glibc).
CVSS VectorVendor: glibc
Lifecycle Timeline
2DescriptionCVE.org
A stack-based buffer overflow in the dynamic loader (ld.so) of the GNU C Library (glibc) versions 2.14 through 2.44 allows a local attacker to crash or corrupt the memory of setuid/setgid (AT_SECURE) programs.
When such a program's DT_RPATH or DT_RUNPATH begins with $ORIGIN and is followed by NUL or '/' the loader both reads past the end of the path buffer and writes past the end of a stack-allocated internal buffer. The corrupted loader stack can lead to a loader crash (denial of service) and limited disclosure of process memory.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.
A stack-based buffer overflow occurs when a program writes more data to a buffer located on the stack than it was allocated to hold.
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
Local privilege escalation in the GNU C Library (glibc) dynamic loader ld.so allows unprivileged local users on affected
Heap-based buffer overflow in the __nss_hostname_digits_dots function in glibc 2.2, and other 2.x versions before 2.18,
The iconv() function in the GNU C Library versions 2.39 and older may overflow the output buffer passed to it by up to 4
Multiple stack-based buffer overflows in the (1) send_dg and (2) send_vc functions in the libresolv library in the GNU C
Local privilege escalation in GNU glibc 2.36 and newer arises from a heap-based buffer overflow in __vsyslog_internal, r
Off-by-one error in the __gconv_translit_find function in gconv_trans.c in GNU C Library (aka glibc) allows context-depe
Integer overflow in string/strcoll_l.c in the GNU C Library (aka glibc or libc6) 2.17 and earlier allows context-depende
In glibc 2.26 and earlier there is confusion in the usage of getcwd() by realpath() which can be used to write before th
In the GNU C Library (aka glibc or libc6) through 2.29, proceed_next_node in posix/regexec.c has a heap-based buffer ove
GNU Libc current is affected by: Mitigation bypass. Rated critical severity (CVSS 9.8), this vulnerability is remotely e
The mq_notify function in the GNU C Library (aka glibc) versions 2.32 and 2.33 has a use-after-free. Rated critical seve
sprintf in the GNU C Library (glibc) 2.37 has a buffer overflow (out-of-bounds write) in some situations with a correct
EUVD-2026-84558
GHSA-h8x4-734c-9753
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB