Skip to main content

Eclipse ThreadX CVE-2026-94202

| EUVDEUVD-2026-105150 MEDIUM
Out-of-bounds Read (CWE-125)
2026-10-20 eclipse
4.8
CVSS 4.0 · Vendor: eclipse
View

Attack ChainAIDerived

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

  1. Access
    Load attacker-controlled memory-protected module
  2. Delivery
    Invoke block-pool create dispatch
  3. Exploit
    Supply crafted extra-parameter array near region boundary
  4. Execution
    Dispatcher reads unproved words 1-3 out of bounds
  5. Impact
    Disclose adjacent kernel/module memory

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 the ThreadX Module Manager to be in use with memory-protected (MPU-isolated) modules, and the attacker must control a module that calls the block-pool create dispatcher (_txm_module_manager_tx_block_pool_create_dispatch) with an extra-parameter array laid out so indices 1, 2, and 3 fall outside the two ALIGN_TYPE words the manager verified as module-owned. Limiting factors: not remotely reachable (AV:L); requires an already-loaded, low-privilege module context (PR:L), so it presupposes the ability to run untrusted module code; builds that do not use the module manager or do not enable memory protection are not affected; impact is confined to a bounded out-of-bounds read (information disclosure and possible fault), not code execution or memory corruption.

Impact

All signals point to a medium-severity, low-urgency issue rather than an emergency. The input CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:L/UI:N/VC:L/VI:N/VA:L) and score of 4.8 describe a local, low-privilege attack with only low confidentiality and low availability impact and no integrity impact - consistent with a bounded out-of-bounds read (CWE-125) of at most two ALIGN_TYPE words beyond the region the Module Manager actually proved the module owns. There is no CISA KEV entry and no POC referenced in the provided data, so exploitation status is 'no public exploit identified at time of analysis.' No EPSS score and no SSVC decision data were provided, so automatable/exploitation-maturity cannot be scored - this absence should not be read as 'safe,' only as 'unmeasured.' The vector is local and requires PR:L, meaning the attacker must already be running a memory-protected module inside the module manager; this is precisely the threat model ThreadX's MPU isolation is meant to contain, which is why the finding matters despite the modest score. Net: a real but low-priority hardening fix for embedded/RTOS vendors shipping the module manager, not a drop-everything issue. No conflicting signals were detected in the input (description's local/module-supplied-parameter framing agrees with AV:L and PR:L).

Exploit ScenarioDerived

A memory-protected module running under the ThreadX Module Manager invokes the block-pool create service and supplies an extra-parameter array positioned so that only the first two ALIGN_TYPE words fall inside the module's verified data region. When the dispatcher reads index 1 (pool start) and index 2 (length) to range-check the request - and later index 3 while building the service argument list - it reads words the manager never proved the module owns, disclosing adjacent memory and validating the pool start against attacker-adjacent data. No public exploit code is referenced in the provided data.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
No patch listed yet 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 20, 2026

Out-of-bounds read in the Eclipse ThreadX Module Manager's block-pool create dispatcher (_txm_module_manager_tx_block_pool_create_dispatch) lets a loaded, memory-protected module cause the kernel to read words it does not own. The dispatcher verifies only two ALIGN_TYPE words of the caller-supplied extra-parameter array, but then uses indices 0 through 3, and the out-of-bounds access happens inside the validation path itself: index 1 is taken as the pool start and index 2 as the length used to range-check it, so the size the pool start is checked against is itself an unverified word, and a further unverified word is consumed when the service argument list is built. Affected are builds using the ThreadX Module Manager with MPU-isolated modules; the vector is CVSS:4.0/AV:L/AC:L/PR:L/UI:N/VC:L/VI:N/VA:L (4.8) and our independent assessment agrees it is local, requires an already-loaded low-privilege module, and is bounded to information disclosure plus possible fault rather than code execution. No public exploit identified at time of analysis, and the issue is not in CISA KEV.

RemediationAI

No vendor-released patch version was identified in the available data, so the first step is to consult the Eclipse ThreadX security advisory GHSA-5w57-xhwq-v7wq (https://github.com/eclipse-threadx/threadx/security/advisories/GHSA-5w57-xhwq-v7wq) and move to whatever release it designates as fixed; downstream integrators who vendor ThreadX should track that advisory directly since the CPE is version-wildcarded. Where an immediate upgrade is not possible, the effective mitigations are architectural and have real trade-offs. Strongest is to eliminate the trigger: do not run untrusted or third-party modules under the Module Manager, and load only code that has been reviewed and signed, which removes the low-privilege attacker prerequisite but does not fix the defect. Next is to disable the module manager or the block-pool create service entirely in builds that do not need dynamic module loading (compile-time removal of the dispatcher path), at the cost of losing module support. Disabling MPU/memory protection is not an acceptable workaround - it removes the isolation this bug abuses and broadens exposure elsewhere. If the source can be rebuilt, harden the dispatcher itself so that indices 0 through 3 of the extra-parameter array are bounds-checked against the verified, module-owned region before index 1 is used as the pool start and index 2 as the length, and before the argument list is assembled; this is a small, targeted change but must be carried as a local patch until the upstream fix is published. Finally, treat module loading as a privileged operation and gate it behind an authenticated, audited control path, accepting that this only raises the bar for the required PR:L foothold rather than eliminating the out-of-bounds read.

Affected VersionsENISA

Eclipse ThreadX 6.0.1 ≤6.5.1.202602a

Affected Packages

euvd eclipse_threadx no fix

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

ThreadX is a real-time operating system whose Module Manager allows application code to be loaded as separate modules that run under MPU protection, with kernel services reached through dispatcher stubs in common_modules/module_manager/inc/txm_module_manager_dispatch.h. Because a module cannot be trusted with kernel memory, the dispatcher is supposed to copy and validate only the parameter words it has proven lie inside the module's own data region before forwarding a request to the kernel service. In this case that contract is broken for the block-pool create dispatcher: only two ALIGN_TYPE words of the extra-parameter array are attested as module-owned, yet indices 0 through 3 are dereferenced. CWE-125 (out-of-bounds read) is the root-cause class, and the placement of the bug is what makes it notable - the buffer range check itself reads index 1 as the pool start and index 2 as the length to range-check against, so the validation is performed with an unverified size before the kernel service is ever entered; a second unverified word is read later while constructing the service argument list. The primitive is a read only, bounded by whatever adjacent memory the unverified indices land on, so the realistic outcomes are leakage of adjacent module or manager memory into the validation logic and a possible fault if the read crosses an unmapped or MPU-protected boundary. Builds without the module manager, or with memory protection disabled, do not exercise this dispatcher path.

Know when Eclipse Threadx 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 4.8 MEDIUM
CVSS:4.0/AV:L/AC:L/AT:N/PR:L/UI:N/VC:L/VI:N/VA:L/SC:N/SI:N/SA:N
vuln.today AI 4.4 MEDIUM

Attack originates from a loaded low-privilege module (AV:L, PR:L, AC:L); bounded OOB read yields low confidentiality and possible fault (A:L) with no integrity or scope change.

3.1 AV:L/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:L
4.0 AV:L/AC:L/AT:N/PR:L/UI:N/VC:L/VI:N/VA:L/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
Low
User Interaction
None
Vulnerable system: Confidentiality
Low
Vulnerable system: Integrity
None
Vulnerable system: Availability
Low
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

The Module Manager's block-pool create dispatcher proved that two ALIGN_TYPE words of the extra-parameter array a memory-protected module supplies lay inside the module's data, and then used indices 0 through 3 of that array.

One of the two unproved words is read by the dispatcher's own buffer check, which takes index 1 as the pool start and index 2 as the length to range-check it over. So the out-of-bounds read is performed by the validation code itself, before the kernel service is reached, and the size the caller's pool start is then validated against is a word the manager has not proved the module owns. The other unproved word is read when the service's argument list is built.

Vulnerable function: _txm_module_manager_tx_block_pool_create_dispatch, in common_modules/module_manager/inc/txm_module_manager_dispatch.h.

Threat Intelligence Overview

EPSS Score
0.2%
Top 96% exploitable
Prevalence
Medium
widely-used embedded RTOS, but module-manager MPU feature is a specific deployment subset
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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.2%
Patch available No
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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· derived
Defer
Exploitation
None
System Exposure· derived
Small
Automatable
No
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

24
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +24
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.

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

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