Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAccess local Python app using pybddisasm
-
DeliveryRetain INSTRUX array element reference
-
ExploitParent INSTRUX object freed
-
ExecutionAccess stale element (use-after-free)
-
ImpactProcess crash or freed-memory disclosure
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Memory lifecycle management
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Privilege Escalation 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 consuming application to retain a Python reference to an element of an INSTRUX array member (for example an ND_OPERAND from the operands list, or another array-valued INSTRUX member) and then access that element after the parent INSTRUX object has been freed, because retaining the child element does not keep the parent allocation alive. It is a local, same-process condition (AV:L, PR:L) with no network vector and no attacker-supplied user interaction; it is bounded by the application's own object-lifetime behavior rather than by external input. Whether the outcome is a crash or disclosure of process memory depends on whether the freed allocation has been reused, and the memory-disclosure path is limited (VC:L). |
| Impact | This is a medium-severity, low-urgency issue rather than a top priority. The authoritative signal is the CVSS 4.0 vector (CVSS:4.0/AV:L/AC:L/AT:N/PR:L/UI:N/VC:L/VI:N/VA:H...), scored 6.9: the vector is local (AV:L), not network, and requires privileges/application context (PR:L), with impact dominated by availability (VA:H, process crash) and only limited confidentiality (VC:L, possible freed-memory exposure) and no integrity impact (VI:N). The vuln.today decision label is 'this_month' - meaningful but not act_now or emergency. No EPSS score, KEV listing, or PoC reference was provided, so there is no evidence of active exploitation or public exploit code. The strongest limiting factor beyond CVSS is structural: exploitation is not attacker-driven over a network but depends on the consuming application itself retaining and then using a stale array element after the parent INSTRUX object is freed - a self-inflicted use-after-free. Combined with the fact that pybddisasm is no longer maintained and niche, this reads as a genuine but low-real-world-risk memory-safety defect, not a widespread exploitable threat. No signals conflict here; the main gap is the absence of EPSS/KEV/PoC data, consistent with a non-trending, non-exploited issue. |
| Exploit ScenarioDerived | An application using pybddisasm decodes an instruction, extracts an element from an INSTRUX array (such as an ND_OPERAND from the operands list), and keeps a reference to that element while allowing the parent INSTRUX object to be garbage-collected. When the application later reads from the retained element, it accesses freed memory, which either crashes the Python process or, if the freed allocation has been reused, exposes unrelated process memory. No public exploit identified at time of analysis. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 03, 2026
A use-after-free in the pybddisasm Python bindings lets a local, low-privileged consumer of the library read freed heap memory or crash the Python interpreter when it keeps a reference to an element of an INSTRUX array member (such as an entry in the operands/ND_OPERAND list) after the owning INSTRUX object has been destroyed, because the child element does not keep the parent allocation alive. All versions of Bitdefender's pybddisasm package are affected (CPE cpe:2.3:a:bitdefender:pybddisasm:*), and the package is no longer maintained, so no vendor-released patch was identified at time of analysis. The trigger depends on the host application's own object-lifetime handling rather than on network input: no public exploit was identified at time of analysis, and the outcome is bounded to a likely process crash (availability) with only a limited memory-disclosure path (C:L), making this a medium-severity, low-urgency issue rather than a top priority.
RemediationAI
No vendor-released patch was identified at time of analysis, and the CVE record notes that pybddisasm is no longer maintained, so remediation must come from the consuming application. The effective control is object-lifetime discipline: never retain an element of an INSTRUX array member (for example an ND_OPERAND taken from the operands list) beyond the lifetime of the parent INSTRUX - either copy the fields you need into independent Python objects immediately while the parent is alive, or hold an explicit reference to the parent INSTRUX for as long as any child list or element is in use. Both approaches have costs: eager copying adds per-instruction allocation and defeats lazy traversal of decoded operands, while keeping parent references alive extends memory retention and can inflate footprint in long-lived caches of decoded instructions. Where the application parses untrusted binaries, running the decode path in a separate, resource-limited worker process confines the worst case to a crash of that worker instead of the main interpreter, at the price of IPC overhead. Longer term, migrate instruction decoding to a maintained binding or the upstream bddisasm interface rather than relying on this unmaintained package; no patched pybddisasm version exists to cite.
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
bddisasm is Bitdefender's x86/x86-64 instruction decoder, and pybddisasm is a thin Python binding over that C library. INSTRUX objects own the underlying allocations, and several of their array-valued members, including the ND_OPERAND operand array, are surfaced to Python as lists whose elements are views into memory owned by the parent INSTRUX rather than independent copies. The binding does not establish an ownership or keep-alive relationship between a returned list (or one of its elements) and the parent object, so dropping the last reference to the INSTRUX frees the backing storage while Python-side child references remain valid from the interpreter's point of view. This is classic CWE-416 use-after-free: any later read of such an element dereferences freed heap, which either raises a fault and terminates the process or, if the allocation has been reused, surfaces unrelated process memory. The exposure is local to the consuming process (CVSS 4.0 AV:L with PR:L; assessed 3.1 AV:L/AC:L/PR:L/UI:N), requires no attacker-supplied user interaction, and is gated by the application's own object-lifetime behavior rather than by malformed input sent over a network. The precise allocation pattern and reuse window that determine disclosure versus crash are not described in the available sources; what is confirmed is that retaining a child does not extend the parent's lifetime, and that the memory-disclosure impact is assessed as limited.
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:H/SC:N/SI:N/SA:N
Local same-process use-after-free triggered by the application's own object lifetime, so AV:L/PR:L/UI:N; impact is mainly a crash (A:H) with limited freed-memory exposure (C:L) and no integrity effect.
Primary rating from Vendor (Bitdefender).
CVSS VectorVendor: Bitdefender
DescriptionCVE.org
A use-after-free vulnerability in the pybddisasm Python bindings affects array-valued members of INSTRUX objects, including ND_OPERAND arrays. These arrays are exposed as Python lists whose elements reference memory owned by the parent INSTRUX object. Retaining a list or an element does not keep the parent allocation alive. Accessing an element after the parent INSTRUX object has been freed therefore accesses freed memory. Depending on how the element is used and whether the freed allocation has been reused, this may expose process memory or cause the Python process to crash. Exploitation requires an application to retain and subsequently access an array element after the parent object has been freed. 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
Use-after-free vulnerabilities occur when a program continues to access memory through a pointer after that memory has been deallocated.
Memory corruption occurs when a program writes data beyond the boundaries of allocated memory regions or accesses memory in unintended ways, violating the integrity of the process's address space.
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
More in Pybddisasm
View allUninitialized-memory handling in the pybddisasm Python bindings can cause nd_to_text to turn an uninitialized output buf
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
Out-of-bounds reads in the pybddisasm Python bindings for the Bitdefender disassembler can expose up to roughly 15 bytes
EUVD-2026-115702
GHSA-wqpq-pvq4-433g
NVD
CVE.org
EPSS
Exploit-DB