Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSupply attacker-controlled NAND flash image
-
DeliveryDevice mounts image via lx_nand_flash_open()
-
ExploitParser reads unchecked on-flash count
-
ExecutionOOB heap write overwrites control-block function pointer
-
PersistHijacked pointer invoked, RIP = attacker value
-
ImpactArbitrary code execution on device
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, write limits
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 that the device mount an attacker-controlled or attacker-modified NAND flash image through LevelX's lx_nand_flash_open() entry point; the trigger is a malformed on-flash metadata count field that the AI-generated parser (noted as partly Copilot/Sonnet 4.6 generated) fails to bounds-check. No authentication or user interaction is needed once the image is presented (PR:N/UI:N), but the attack vector is local (AV:L) - the attacker must be able to supply the flash contents, e.g. via removable/attached NAND media, a tampered firmware or OTA image, or a supply-chain/provisioning substitution. This is the primary limiting factor: products that only ever mount flash images produced in a trusted internal supply chain are not realistically reachable, whereas devices accepting externally-sourced or field-swappable NAND media are directly exposed. Impact is highest on bare-metal or non-memory-protected targets where the hijacked function pointer yields code execution rather than a fault. |
| Impact | This is a genuinely serious flaw whose real-world risk hinges almost entirely on one gating condition: the attacker must get the device to mount a NAND flash image they control. The vendor CVSS 4.0 vector (8.6) is explicitly local (AV:L) with no privileges or user interaction (PR:N/UI:N) and full triple-impact (VC:H/VI:H/VA:H), which is internally consistent - this is not a network-reachable bug despite the high score, so it should not be triaged like a remote RCE. The technical impact is unusually strong and well-substantiated: the description reports a demonstrated control-flow hijack with RIP set to a full 8-byte attacker-chosen value, register-verified, and reproduced verbatim under AddressSanitizer at HEAD 9f1cfdc - i.e., the vendor has a working reproduction, not a theoretical write primitive. No EPSS score, CISA KEV entry, or public exploit indicator is present in the supplied intelligence, so at analysis time there is no public exploit identified and no evidence of active exploitation; the vendor's own ASan reproduction is a proof-of-concept in the research sense but is not published exploit code in the feed. The conflict to flag for defenders is scope-of-reach versus impact: SSVC-style reasoning would rate technical impact 'total' but automatability 'no' and exploitation 'none', because the local, image-supply prerequisite makes this targeted rather than wormable. Net: high priority for any product that mounts externally-sourced or removable NAND media, but a lower operational priority where flash images are provisioned only in a trusted supply chain. |
| Exploit ScenarioDerived | An attacker supplies a maliciously crafted NAND flash image - via removable/attached flash media, a compromised firmware/OTA image, or a manufacturing/supply-chain substitution - that the device mounts with lx_nand_flash_open(). The FTL metadata parser trusts an on-flash count field without bounds-checking, driving an out-of-bounds heap write that overwrites a driver function pointer in the LevelX control block; when that pointer is later invoked, execution jumps to an attacker-chosen 8-byte address. The vendor has demonstrated this end-to-end under ASan with a register-verified RIP hijack, so a reliable exploit is realistic, though no public exploit code appears in the supplied data. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 29, 2026
An out-of-bounds heap write in Eclipse ThreadX LevelX's NAND flash-translation-layer metadata parser can give a local attacker control-flow hijack when the device mounts a crafted NAND flash image through lx_nand_flash_open(), overwriting a driver function pointer with an attacker-chosen 8-byte value; two accompanying out-of-bounds reads were also demonstrated. The bug (CWE-787) is rated 8.6 under CVSS 4.0 and independently assessed as CVSS 3.1 AV:L/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, meaning no authentication or user interaction is needed but the attacker must first supply or tamper with the flash image (removable or attached NAND media, modified firmware or OTA image, or supply-chain/provisioning substitution). No public exploit code was identified at time of analysis, though the issue was reproduced verbatim under ASan at HEAD 9f1cfdc; devices that only mount internally trusted flash images are not realistically reachable, while those accepting field-swappable or externally sourced NAND are directly exposed, with the worst impact on bare-metal or non-memory-protected targets where the hijacked pointer yields code execution.
RemediationAI
No vendor-released patch was identified in the provided data at time of analysis; consult the Eclipse ThreadX LevelX advisory GHSA-q6ph-7238-777g (https://github.com/eclipse-threadx/levelx/security/advisories/GHSA-q6ph-7238-777g) for the current fixed release and apply it as soon as a patched LevelX version is published. Because the missing control is a bounds check on the on-flash metadata count, the durable fix is an updated parser that validates the count against the destination buffer size before copying. Until that patch is available, restrict the reachability of lx_nand_flash_open() to trusted images: require cryptographic signature or MAC verification of NAND images and metadata in the bootloader before LevelX mounts them, and reject unsigned or externally sourced images; this prevents exploitation but adds provisioning and key-management overhead and can block legitimate field updates unless signing infrastructure is in place. If the device does not need field-swappable NAND boot, disable or physically protect removable NAND interfaces and provisioning ports, and enforce physical access controls, since AV:L requires the attacker to supply the flash contents. As a defense-in-depth measure, enable an MPU or MMU configuration that marks the LevelX control block non-executable or read-only between updates where the hardware supports it, recognizing that this may only convert code execution into a crash rather than eliminate the corruption. Finally, ensure secure-boot and OTA verification paths cannot be bypassed by mounting an alternate NAND image, and monitor for abnormal resets or faults during flash open operations.
Affected VersionsENISA
Affects your stack
Find out whether the stacks and servers you run are on an affected version.
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
LevelX is Eclipse ThreadX's flash translation layer for NOR and NAND flash, providing wear leveling and logical-to-physical mapping for embedded RTOS targets. The NAND driver's metadata parser processes an on-flash metadata header, including a count field that is copied into a heap-allocated control block; because the count is not bounds-checked, the copy can overflow the control block and overwrite an adjacent driver function pointer, which the attacker then controls (CWE-787, out-of-bounds write). The affected header notes that some portions were generated by Copilot (Sonnet 4.6), and the unchecked on-flash count is the direct root cause. The affected component is identified by CPE cpe:2.3:a:eclipse_foundation:eclipse-threadx/levelx(nand_driver):*:*:*:*:*:*:*:* and the trigger is lx_nand_flash_open(); two additional out-of-bounds reads occur during the same parsing path. Successful exploitation depends on the platform's memory protections, since the overwritten function pointer is invoked during normal driver operation, turning the corruption into a control-flow hijack.
Know when Eclipse Threadx Levelx Nand Driver 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:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Local because the attacker must supply the mounted flash image (AV:L), no auth or interaction once presented (PR:N/UI:N), and demonstrated arbitrary code execution yields full C/I/A impact.
Primary rating from Vendor (eclipse).
CVSS VectorVendor: eclipse
DescriptionCVE.org
Mounting an attacker-controlled NAND flash image (lx_nand_flash_open()) triggers an unbounded out-of-bounds heap write in LevelX's NAND flash-translation-layer metadata parser that overwrites a driver function pointer in the control block, giving a demonstrated control-flow hijack - RIP set to a full 8-byte attacker-chosen value (register-verified). Two accompanying OOB reads. All reproduced verbatim under ASan at HEAD 9f1cfdc. (The affected metadata-parser header states "Some portions generated by Copilot (Sonnet 4.6)" - an AI-generated parser with an unchecked on-flash count.)
Executive ViewAI
Eclipse ThreadX LevelX, the NAND flash translation layer used in a broad range of embedded and IoT devices, contains a high-severity heap memory corruption flaw (CVE-2026-102730, CVSS 8.6) that allows a local attacker to seize control of a device's execution flow if it mounts a tampered NAND flash image. The practical exposure is concentrated in products that accept field-swappable, removable, or externally sourced NAND media, or that update firmware via supply-chain or over-the-air channels an adversary could substitute - devices that only ever mount internally trusted flash images face minimal realistic risk. Leadership should care because a successful attack yields full loss of confidentiality and integrity on the affected device, potentially enabling persistent compromise of deployed hardware, and no vendor patch is currently available to close the gap.
No vendor-released patch identified at time of analysis. Interim mitigations: restrict physical and supply-chain access to NAND media and provisioning equipment; reject or disable mounting of untrusted, field-swappable, or externally sourced NAND images; cryptographically sign and verify flash images before calling lx_nand_flash_open(); enforce secure boot and firmware-image authenticity checks; enable memory-safety hardening (for example ASan in test builds) and runtime integrity or pointer-protection mechanisms where the platform supports them; and monitor for anomalous mount activity on affected devices.
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.
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.
EUVD-2026-89201
GHSA-g54v-9g2q-gvrg
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB