Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft ELF with e_phnum=0xffff, small resolved count
-
DeliveryDeliver crafted binary to analyst
-
ExploitAnalyst opens file in radare2/rabin2
-
ExecutionConsumers iterate past allocated phdr array
-
PersistHeap out-of-bounds read
-
ImpactProcess crash (denial of service)
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, read limits
MITRE ATT&CK
1 technique across 1 tactic: Collection The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Requires an analyst to locally open or process an attacker-supplied ELF file with radare2/rabin2 (AV:L, UI:R) - there is no remote or network-triggerable path. The malicious file must specifically set e_phnum = 0xffff (the PN_XNUM extended-count sentinel) while the real program-header count resolved from shdr[0].sh_info is much smaller, so that consumers iterating on the stale e_phnum value read beyond the allocated program-header array. No authentication or special configuration is needed on the victim side, but exploitation is gated entirely by the analyst choosing to analyze an untrusted binary; affected versions are radare2 prior to 6.2.0. |
| Impact | This is a genuine but low-priority defect. The vendor CVSS 3.1 vector (AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:H = 5.5 MEDIUM) is internally consistent with the description: exploitation requires an analyst to locally open or process a crafted ELF file (AV:L, UI:R), and the only demonstrated impact is a heap out-of-bounds read causing process termination (C:N/I:N/A:H - availability-only DoS). No EPSS score, no CISA KEV listing, and no public exploit code are provided, so real-world exploitation is 'no public exploit identified at time of analysis'. There is a signal conflict in the metadata rather than in the CVSS: the input Tags include 'RCE' and 'Information Disclosure', but the CVE description explicitly states that 'memory disclosure and code execution have not been demonstrated' - those tags overstate impact and should be disregarded. The realistic risk is a crash/DoS of the analyst's radare2 process when triaging an untrusted binary, not a server-side or remotely-triggerable condition. High-CVSS optics do not apply here; this is a modest local DoS in analyst tooling with a straightforward patched version available. |
| Exploit ScenarioDerived | An attacker crafts a malicious ELF file whose header declares e_phnum = 0xffff (the PN_XNUM sentinel) while shdr[0].sh_info resolves to a much smaller real program-header count, then distributes it (e.g. malware sample, CTF binary, email attachment). When an analyst opens or analyzes the file with radare2/rabin2, several ELF consumers iterate up to 65535 entries against a smaller allocated program-header array, causing a heap out-of-bounds read and terminating the process. No public exploit code is identified, and impact is limited to denial of service - code execution and memory disclosure were not demonstrated. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 22, 2026
Opening a crafted ELF binary with radare2 or rabin2 before version 6.2.0 can drive a heap out-of-bounds read in the ELF parser and terminate the process, giving anyone who can supply the file to an analyst a local denial of service (CWE-125, CVSS 3.1 5.5, AV:L/AC:L/PR:N/UI:R, C:N/I:N/A:H). The trigger is a program-header count of 0xffff (ELF's PN_XNUM sentinel) paired with a small real count in shdr[0].sh_info: the parser allocates the program-header array using the resolved count while several consumers still iterate over the original 65535 value, reading past the allocation. Exploitation requires the user to open an untrusted binary, no public exploit code or confirmed in-the-wild activity has been reported, and memory disclosure or code execution has not been demonstrated, so the practical impact is a crash of the analysis process rather than a compromise.
RemediationAI
Vendor-released patch: radare2 6.2.0 (https://github.com/radareorg/radare2/releases/tag/6.2.0), which resolves the issue documented in GHSA-jqfq-hvcp-xh4p and referenced by issue #26223; upgrade all installations, including rabin2 and any embedded copies of libr/bin shipped with r2pipe tooling. If a full upgrade is not immediately possible, backport the upstream fix from PR #26178 (https://github.com/radareorg/radare2/pull/26178), specifically commit 9449b07579c19b6b187c1a0918fbec2cef1a036e - this is a self-contained change to libr/bin/format/elf/elf.c that introduces the eo->phnum field, adds e_shoff and phdr_size bounds checks, and converts consumer loops from eo->ehdr.e_phnum to eo->phnum; note that until it is applied, the parser remains vulnerable. As a compensating control, treat every untrusted ELF as hostile and open it only inside a disposable container, VM or sandbox (no network, read-only mounts, unprivileged user, memory limits) so that a crash of the parser terminates the sandbox rather than a long-lived analysis host - the trade-off is that this adds operational overhead and cannot protect daemonised r2pipe/r2 -A services where a single crash destroys shared session state, which should therefore be fed only pre-screened inputs. Pre-screening files with an independent, hardened ELF reader (e.g. a bounds-checked readelf/llvm-readobj or a small script that rejects e_phnum == 0xffff with a mismatched shdr[0].sh_info) can filter the known trigger before handing the file to radare2, but this is a narrow filter: it blocks the documented PN_XNUM path only, may miss variants, and is not a substitute for patching. Do not rely on disabling features or ports - the bug is reached through normal local file parsing with no network component to block.
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
ELF uses the value PN_XNUM (0xffff) in e_phnum as an escape hatch: when the real number of program headers exceeds 65535 (or simply when a producer chooses to use the extended form), the true count is stored in the sh_info field of the first section header at e_shoff. radare2's ELF parser in libr/bin/format/elf/elf.c resolved this correctly enough to size the eo->phdr allocation, but it left eo->ehdr.e_phnum untouched at 65535 and many downstream routines - init_strtab, fill_dynamic_entries, qnx_has_nx, has_relro, get_baddr, get_boffset, has_interp_program_header, intrp, is_static, get_bits, grab_regstate, create_section_from_phdr, get_phdr_symtab_upper_bound and load_fields - kept looping on eo->ehdr.e_phnum. Iterating 65535 entries over an array allocated for only a handful of Phdr structures produces a heap out-of-bounds read of roughly 65535 x sizeof(Elf_(Phdr)) bytes, which is the root cause class CWE-125 and manifests as a crash. The upstream fix (PR #26178, commit 9449b07579c19b6b187c1a0918fbec2cef1a036e) adds bounds validation when reading the initial section header (e_shoff > eo->size or a short read now returns 0), computes a single authoritative eo->phnum before allocating, hardens phdr_size with UT64_MUL plus e_phoff/phdr_size file-size checks, converts every consumer loop and the num_fields calculation from eo->ehdr.e_phnum to eo->phnum, and clamps oversized section sh_size in init_shdr. The affected component is the generic ELF object parser used by both the r2 CLI and rabin2, so the CPE cpe:2.3:a:radareorg:radare2:*:*:*:*:*:*:*:* applies to all builds regardless of host platform or target architecture. Community tagging on this record includes 'RCE', 'Buffer Overflow' and 'Information Disclosure' labels, but neither code execution nor memory disclosure was demonstrated; the assessed impact is confined to the OOB read and resulting denial of service.
Know when Radare2 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:L/PR:N/UI:R/S:U/C:L/I:N/A:H
Local file processing by an analyst (AV:L, UI:R) with no auth (PR:N); only demonstrated impact is a crash, so C:N/I:N/A:H.
AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:H
Primary rating from Vendor (GitHub_M).
CVSS VectorNVD
Lifecycle Timeline
2DescriptionNVD
radare2 is a UNIX-like reverse engineering framework and command-line toolset. Prior to 6.2.0, radare2's ELF PN_XNUM handling was vulnerable because the ELF parser allocated the program-header array using the resolved PN_XNUM count but several consumers still iterated with the original e_phnum value of 65535. The vulnerability is triggered by processing a crafted ELF file with e_phnum = 0xffff and a much smaller resolved count in shdr[0].sh_info. Consumers iterated beyond the allocated program-header array. This can cause a heap out-of-bounds read and process termination, resulting in denial of service; memory disclosure and code execution have not been demonstrated. This issue is fixed in version 6.2.0.
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.
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
An out-of-bounds read in radare2 v.5.8.9 and before exists in the print_insn32 function of libr/arch/p/nds32/nds32-dis.h
An out-of-bounds read in radare2 v.5.8.9 and before exists in the print_insn32_fpu function of libr/arch/p/nds32/nds32-d
Heap-based Buffer Overflow in GitHub repository radareorg/radare2 prior to 5.9.0. Rated critical severity (CVSS 9.8), th
OS command injection in radare2-mcp (the Model Context Protocol server that bridges the radare2 reverse-engineering fram
Out-of-bounds Read in GitHub repository radareorg/radare2 prior to 5.7.0. Rated critical severity (CVSS 9.1), this vulne
Out-of-bounds Read in r_bin_ne_get_entrypoints function in GitHub repository radareorg/radare2 prior to 5.6.8. Rated cri
Out-of-bounds read in `r_bin_ne_get_relocs` function in GitHub repository radareorg/radare2 prior to 5.6.8. Rated critic
Heap-based Buffer Overflow in GitHub repository radareorg/radare2 prior to 5.9.0. Rated high severity (CVSS 8.8), this v
Command injection in radare2's PDB parser (versions <6.1.4) enables arbitrary command execution when analysts process ma
Command injection in radare2 PDB parser (versions before 6.1.4) enables arbitrary OS command execution when users analyz
In radare 2.0.1, a memory corruption vulnerability exists in store_versioninfo_gnu_verdef() and store_versioninfo_gnu_ve
In radare2 2.0.1, an integer exception (negative number leading to an invalid memory access) exists in store_versioninfo
Same weakness CWE-125 – Out-of-bounds Read
View allSame technique Buffer Overflow
View allVendor StatusVendor
SUSE
Severity: Moderate| Product | Status |
|---|---|
| openSUSE Leap 16.0 | Fixed |
EUVD-2026-84504
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB