CVE-2026-5928
Memory Safety in Gnu Glibc ≤ 2.43
Raw vector
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:HSummary
CVE-2026-5928 is a high-severity Buffer Under-read (CWE-127) vulnerability in Gnu Glibc. Its CVSS base score is 7.5 (High).
Operationally, exploitation aligns with the MITRE ATT&CK technique Exploitation for Privilege Escalation (T1068); ranked at the 30th percentile by exploit likelihood (below the median); it is not currently listed in the CISA KEV catalog; a public proof-of-concept is referenced.
The strongest mitigations our analysis identified map to RA-5 (Vulnerability Monitoring and Scanning) and SA-11 (Developer Testing and Evaluation) — see the control section below for these in your framework.
Deeper analysis AI-assisted summary
Synthesised by an AI model from the NVD description and linked references — a reading aid, not an authoritative source.
CVE-2026-5928 is a vulnerability in the GNU C Library (glibc) versions 2.43 and earlier, specifically in the implementation of the ungetwc function for wide character streams. When ungetwc is called on a FILE stream using wide characters encoded in a character set with overlaps between single-byte and multi-byte representations, it may attempt to read bytes before an allocated buffer. This stems from a bug in _IO_wdefault_pbackfail within libio/wgenops.c, where ungetwc operates on the regular character buffer (fp->_IO_read_ptr) rather than the wide-stream read pointer (fp->_wide_data->_IO_read_ptr), potentially leading to unintentional disclosure of neighboring heap data or a program crash if the pointer is uninitialized (e.g., NULL).
Remote attackers can exploit this vulnerability with network access, low attack complexity, no privileges, and no user interaction required, as reflected in its CVSS v3.1 base score of 7.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) and association with CWE-127 (Buffer Under-read). Successful exploitation typically results in a denial of service via program crash, while heap data disclosure requires a rare condition of encoding overlaps that enable spurious matches—such matches are not possible in standard Unicode character sets.
Mitigation details are documented in the Sourceware Bugzilla report at https://sourceware.org/bugzilla/show_bug.cgi?id=33998.
EU & UK References
- 🇪🇺 ENISA EUVD: EUVD-2026-23980
Vulnerability Data
Calling the ungetwc function on a FILE stream with wide characters encoded in a character set that has overlaps between its single byte and multi-byte character encodings, in the GNU C Library version 2.43 or earlier, may result in an…
more
attempt to read bytes before an allocated buffer, potentially resulting in unintentional disclosure of neighboring data in the heap, or a program crash. A bug in the wide character pushback implementation (_IO_wdefault_pbackfail in libio/wgenops.c) causes ungetwc() to operate on the regular character buffer (fp->_IO_read_ptr) instead of the actual wide-stream read pointer (fp->_wide_data->_IO_read_ptr). The program crash may happen in cases where fp->_IO_read_ptr is not initialized and hence points to NULL. The buffer under-read requires a special situation where the input character encoding is such that there are overlaps between single byte representations and multibyte representations in that encoding, resulting in spurious matches. The spurious match case is not possible in the standard Unicode character sets.
- CWE(s)
Related Threats
MITRE ATT&CK Enterprise Techniques
CVEs Like This One
Affected Assets
Mitigating Controls
Mitigating Controls (NIST 800-53 r5) AI
Vulnerability scanning can locate known buffer-under-read instances in deployed code.
Developer testing and evaluation (static analysis, fuzzing, bounds checkers) directly finds buffer under-read flaws before deployment.
Security engineering principles require bounds-checked memory accesses and safe pointer arithmetic that structurally stop buffer under-reads from being introduced.
Mitigating Controls (NIST CSF 2.0) AI
Derived directly from the weakness types (CWEs) cited in the NVD entry via our AI-authored CWE→CSF cross-walk (authority under review) — links open the control.
Secure-development practices such as bounds checking and static analysis directly prevent introduction of buffer under-reads.
Vulnerability scanning can discover buffer under-read flaws so they can be recorded and fixed.
Patching or replacing vulnerable software removes known instances of buffer under-read.
Mitigating Controls (ISO/IEC 27001:2022 Annex A) AI
Derived directly from the weakness types (CWEs) cited in the NVD entry via our AI-authored CWE→ISO cross-walk (authority under review) — links open the control.
Security testing can detect buffer under-reads before release.
Secure SDLC mandates input validation and bounds checking that can prevent buffer under-reads.
Application security requirements can specify safe buffer handling and bounds checking.
Secure architecture principles include memory-safety and bounds-checking mechanisms.
Secure coding standards directly require bounds checking and safe pointer arithmetic.