Skip to main content

Eclipse ThreadX LevelX EUVDEUVD-2026-89201

| CVE-2026-102730 HIGH
Out-of-bounds Write (CWE-787)
2026-09-29 eclipse GHSA-g54v-9g2q-gvrg
8.6
CVSS 4.0 · Vendor: eclipse
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Supply attacker-controlled NAND flash image
  2. Delivery
    Device mounts image via lx_nand_flash_open()
  3. Exploit
    Parser reads unchecked on-flash count
  4. Execution
    OOB heap write overwrites control-block function pointer
  5. Persist
    Hijacked pointer invoked, RIP = attacker value
  6. Impact
    Arbitrary 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet 0.1% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

eclipse-threadx/levelx(NAND driver) HEAD `9f1cfdc` and prior; Finding 1 introduced by commit `47b2a17d`; Finding 2 is the un-patched half of the Nov-2025 fix `0f7dd521`.

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

Vendor (eclipse) PRIMARY 8.6 HIGH
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
vuln.today AI 8.4 HIGH

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.

3.1 AV:L/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
4.0 AV:L/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (eclipse).

CVSS VectorVendor: eclipse

Attack Vector
Local
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

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

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.1%
Top 99% exploitable
Prevalence
High
LevelX NAND FTL ships with the widely-deployed Eclipse ThreadX embedded RTOS ecosystem
Data Quality
5 sources
Confidence: Medium

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.1%
Patch available No
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Defer
Exploitation
None
System Exposure· derived
Small
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

43
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +43
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy