Skip to main content

glibc EUVDEUVD-2026-84558

| CVE-2026-95818 LOW
Stack-based Buffer Overflow (CWE-121)
2026-09-22 glibc GHSA-h8x4-734c-9753
3.6
CVSS 3.1 · Vendor: glibc
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Obtain local unprivileged shell
  2. Delivery
    Locate setuid binary with $ORIGIN-prefixed RPATH/RUNPATH
  3. Exploit
    Execute binary to invoke ld.so path parsing
  4. Execution
    Trigger stack buffer over-read/over-write in loader
  5. Impact
    Crash 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.

Monitor Track and reassess. Why: LOW severity (CVSS 0.1-3.9).
Patch available 0.1% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

glibc 2.14 <2.45

Affected Packages

euvd glibc fix: 2.45

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

Vendor (glibc) PRIMARY 3.6 LOW
AV:L/AC:H/PR:L/UI:N/S:U/C:L/I:L/A:N
vuln.today AI 3.6 LOW

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).

3.1 AV:L/AC:H/PR:L/UI:N/S:U/C:L/I:L/A:N
4.0 AV:L/AC:H/AT:N/PR:L/UI:N/VC:L/VI:L/VA:N/SC:N/SI:N/SA:N

Primary rating from Vendor (glibc).

CVSS VectorVendor: glibc

Attack Vector
Local
Attack Complexity
High
Privileges Required
Low
User Interaction
None
Scope
Unchanged
Confidentiality
Low
Integrity
Low
Availability
None

Lifecycle Timeline

2
Patch available
Sep 22, 2026 - 18:02 EUVD
CVE Published
Sep 22, 2026 - 16:50 cve.org
LOW 3.6

DescriptionCVE.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

EPSS Score
0.1%
Top 97% exploitable
Prevalence
Ubiquitous
glibc is the standard C library on virtually all Linux distributions
Data Quality
5 sources
Confidence: Medium

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.

SignalValue
Severity LOW
CISA KEV No
Public POC No
EPSS 0.1%
Patch available Yes
Active threat No
Deciding rule
LOW severity (CVSS 0.1-3.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation
None
System Exposure· derived
Small
Automatable
No
Human Impact· derived
High
Technical Impact
Partial

Priority Score

18
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +18
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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.

More in Glibc

View all
CVE-2023-4911 HIGH POC
7.8 Oct 03

Local privilege escalation in the GNU C Library (glibc) dynamic loader ld.so allows unprivileged local users on affected

CVE-2015-0235 CRITICAL POC
10.0 Jan 28

Heap-based buffer overflow in the __nss_hostname_digits_dots function in glibc 2.2, and other 2.x versions before 2.18,

CVE-2024-2961 HIGH POC
7.3 Apr 17

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

CVE-2015-7547 HIGH POC
8.1 Feb 18

Multiple stack-based buffer overflows in the (1) send_dg and (2) send_vc functions in the libresolv library in the GNU C

CVE-2023-6246 HIGH POC
8.4 Jan 31

Local privilege escalation in GNU glibc 2.36 and newer arises from a heap-based buffer overflow in __vsyslog_internal, r

CVE-2014-5119 HIGH POC
7.5 Aug 29

Off-by-one error in the __gconv_translit_find function in gconv_trans.c in GNU C Library (aka glibc) allows context-depe

CVE-2012-4412 HIGH POC
7.5 Oct 09

Integer overflow in string/strcoll_l.c in the GNU C Library (aka glibc or libc6) 2.17 and earlier allows context-depende

CVE-2018-1000001 HIGH POC
7.8 Jan 31

In glibc 2.26 and earlier there is confusion in the usage of getcwd() by realpath() which can be used to write before th

CVE-2019-9169 CRITICAL POC
9.8 Feb 26

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

CVE-2019-1010022 CRITICAL POC
9.8 Jul 15

GNU Libc current is affected by: Mitigation bypass. Rated critical severity (CVSS 9.8), this vulnerability is remotely e

CVE-2021-33574 CRITICAL POC
9.8 May 25

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

CVE-2023-25139 CRITICAL POC
9.8 Feb 03

sprintf in the GNU C Library (glibc) 2.37 has a buffer overflow (out-of-bounds write) in some situations with a correct

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy