Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAccess application exposing pybddisasm decode APIs
-
ExploitSupply short buffer or oversized length to nd_decode/nd_decode_ex
-
ExecutionDecoder reads up to 15 bytes beyond the Python buffer
-
ImpactAdjacent process memory disclosed via nd_get_instrux_bytes
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 | Exploitation requires a host application that (1) invokes nd_decode with a Python buffer shorter than 15 bytes, or invokes nd_decode_ex, nd_decode_ex2, or nd_decode_with_context with a caller-supplied length larger than the actual Python buffer, and (2) exposes the resulting bytes to the attacker (e.g., by returning the fixed 16-byte list from nd_get_instrux_bytes). The flaw is therefore not self-contained in the library's default use: it is gated by how the integrating application supplies buffer/length arguments and whether it surfaces decoded bytes externally. Limiting factors per the CVSS vector: local access (AV:L) and low-privilege access (PR:L) are required, impact is confined to a small, bounded confidentiality leak (up to ~15 adjacent bytes), and no integrity or availability impact occurs. Because the package is no longer maintained, remediation depends on the integrating application avoiding or sanitizing these calls rather than on a vendor patch. |
| Impact | All quantitative signals point to a modest, non-urgent issue. The supplied CVSS 4.0 vector scores 4.8 (medium): AV:L (local), AC:L, AT:N, PR:L (low-privileged access required), UI:N, with impact limited to VC:L (low confidentiality) and no integrity or availability impact (VI:N/VA:N) and no scope change to subsequent systems. No EPSS probability was provided, the CVE is not listed in CISA KEV, and the only reference is the PyPI project page - there is no public exploit identified at time of analysis. The vuln.today decision label is 'this_month', not act_now or emergency, consistent with a low-to-moderate priority. One signal worth flagging: CVSS marks the vector as local (AV:L), but the real attack surface depends entirely on the consuming application - if an application feeds attacker-controlled bytes into the affected APIs and returns the result over a network, the effective reachability could be remote; verify against the actual deployment. The disclosed data is bounded (the decoder may read up to 15 bytes, and nd_get_instrux_bytes returns a fixed 16-byte list), so this is a small adjacent-memory leak rather than a broad read primitive. A significant practical factor is that the pybddisasm package is no longer maintained, so no vendor fix is expected. Net: a real but low-severity information-disclosure bug whose exploitability is gated by how a given application uses the library. |
| Exploit ScenarioDerived | An application that uses pybddisasm to decode instruction bytes supplied (directly or indirectly) by an attacker calls nd_decode with a buffer shorter than 15 bytes, or calls nd_decode_ex/nd_decode_ex2/nd_decode_with_context with a length larger than the actual Python buffer, and then exposes the decoded instruction via nd_get_instrux_bytes. The decoder reads past the end of the buffer into adjacent process memory, and those out-of-bounds bytes are returned to the attacker as part of the fixed 16-byte list. No public exploit code has been identified. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 03, 2026
Out-of-bounds reads in the pybddisasm Python bindings for the Bitdefender disassembler can expose up to roughly 15 bytes of adjacent process memory when an integrating application decodes a buffer that is shorter than the length it declares. nd_decode may read up to 15 bytes regardless of the actual Python buffer length, while nd_decode_ex, nd_decode_ex2, and nd_decode_with_context pass a caller-supplied size to the decoder without checking it against the real buffer, and nd_get_instrux_bytes then returns a fixed 16-byte list that can carry the leaked bytes. Exploitation is not self-contained: it requires a host application to make these calls with mismatched buffer/length arguments and to surface the decoded bytes to an attacker, and the affected package is no longer maintained, so fix responsibility falls to integrators. All quantitative signals point to a modest, non-urgent issue; no public exploit code and no confirmed active exploitation were identified at time of analysis.
RemediationAI
No vendor-released patch is expected: pybddisasm is unmaintained and no fixed version is identified in the available data, so remediation must happen in the integrating application. Where the bindings are used, validate lengths before decoding - ensure every buffer passed to nd_decode is at least 15 bytes, and reject or clamp any caller-supplied length for nd_decode_ex, nd_decode_ex2 and nd_decode_with_context that exceeds the real Python buffer length (for example, compare against memoryview.nbytes or len()) so the decoder never receives an inflated size. Treat the 16-byte list from nd_get_instrux_bytes as sensitive: do not return it, log it, or include it in error messages or network responses delivered to untrusted parties, since that is the channel through which over-read bytes would be disclosed. Where these guarantees cannot be enforced by the calling code, isolate or replace pybddisasm with a maintained decoder, or run the decoding component with reduced privileges given the AV:L/PR:L prerequisites, accepting the operational cost of that separation. The project page at https://pypi.org/project/pybddisasm/ is the only listed reference and can be consulted to track whether maintenance is ever resumed.
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
pybddisasm is a Python binding over Bitdefender's ndisasm-style x86/x86-64 instruction decoder, exposing functions such as nd_decode, nd_decode_ex, nd_decode_ex2 and nd_decode_with_context, plus nd_get_instrux_bytes for retrieving the raw instruction bytes. The root cause is CWE-125 (out-of-bounds read): the C extension layer trusts length information it receives from Python rather than reconciling it with the real size of the underlying buffer object. In the simple nd_decode path, a fixed read window of up to 15 bytes is used regardless of how short the supplied Python buffer is; in the extended decode paths, the caller's declared size is forwarded to the native decoder without a bounds check against the actual Python buffer length. Leaked content becomes observable only through the fixed-length, 16-byte list returned by nd_get_instrux_bytes, which means the disclosure is bounded to a small, adjacent-memory window rather than an arbitrary or unbounded read. The assessed vector (AV:L/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:N) reflects that the defect is reachable only through a host application's misuse of the API contract, yields limited confidentiality impact, and has no integrity or availability effect. Because the package has been abandoned upstream, there is no maintainer-driven fix cycle; the effective trust boundary is the integrating application, which must control both buffer length and length arguments and must decide whether decoded byte output is exposed.
Know when Pybddisasm 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
CVSS:4.0/AV:L/AC:L/AT:N/PR:L/UI:N/VC:L/VI:N/VA:N/SC:N/SI:N/SA:N
Triggered via local library calls needing an integrating application and some privilege (AV:L/PR:L); only a small adjacent-memory read, so C:L with no integrity or availability impact.
Primary rating from Vendor (Bitdefender).
CVSS VectorVendor: Bitdefender
DescriptionCVE.org
Out-of-bounds read vulnerabilities in the pybddisasm Python bindings may disclose adjacent process memory during instruction decoding. The nd_decode function may read up to 15 bytes without checking the actual length of the supplied Python buffer. The nd_decode_ex, nd_decode_ex2, and nd_decode_with_context functions pass the caller-supplied buffer size to the decoder without validating it against the actual length of the Python buffer. Data read beyond the buffer may be exposed through nd_get_instrux_bytes, which returns a fixed-length list of 16 bytes. Exploitation requires an application to invoke the affected APIs with a short buffer or an oversized length and to expose the resulting bytes to an attacker. The pybddisasm package is no longer maintained.
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.
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
More in Pybddisasm
View allUninitialized-memory handling in the pybddisasm Python bindings can cause nd_to_text to turn an uninitialized output buf
A use-after-free in the pybddisasm Python bindings lets a local, low-privileged consumer of the library read freed heap
Use-after-free in the unmaintained pybddisasm Python bindings lets a local, low-privileged process crash the Python inte
pybddisasm 0.3.0 and earlier can disclose residual process memory to any consuming application that reads an INSTRUX obj
EUVD-2026-115704
GHSA-p5f7-36qg-83fr
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB