Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessLoad crafted module into Module Manager
-
ExploitCall object pointer lookup with oversized/unbounded search name
-
ExecutionName walk reads unmapped privileged memory
-
ImpactRead fault with preemption disabled halts kernel permanently
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 that the target build uses the ThreadX Module Manager and loads modules whose trust is not guaranteed, and that the attacker can supply or compromise such a module so it invokes txm_module_object_pointer_get_extended (which is passed a length but never uses it to bound the buffer) or the deprecated txm_module_object_pointer_get (which supplies UINT max, removing the bound entirely) with a crafted object search name. Limiting factors: local vector only (AV:L) - no network reachability; PR:L - the attacker needs the privilege to load/run a module within the Module Manager, so a system that runs only vendor-trusted, statically-verified modules or that does not enable the Module Manager is not realistically exposed; no user interaction is required (UI:N) once a hostile module runs. The realistic outcome is a permanent scheduler hang (DoS), not privilege escalation or code execution. |
| Impact | The vendor-supplied CVSS 4.0 base score is 6.9 (Medium) with vector AV:L/AC:L/AT:N/PR:L/UI:N/VC:L/VI:N/VA:H/SC:N/SI:N/SA:N, and the primary impact is availability (VA:H): an attacker-controlled module forces an unbounded out-of-bounds read (CWE-125) in privileged kernel mode while the preemption count is raised, so a read fault permanently disables scheduling for the remaining uptime of the device - a durable, non-recoverable denial of service rather than code execution (VI:N) or meaningful data theft (VC:L only). The decisive limiting signal is PR:L combined with AV:L: this is NOT remotely reachable; the attacker must already be able to load and run a module within the Module Manager, so it is primarily a sandbox-escape-to-DoS (confidentiality of the module sandbox) rather than an internet-facing threat. No EPSS score, no CISA KEV listing, no SSVC decision data, and no POC indicator were provided in the input, so there is no public exploit identified at time of analysis and no evidence of active exploitation. Note a discrepancy to verify: the input Tags label this 'Buffer Overflow' and 'Information Disclosure', but the CWE (125, out-of-bounds read) and the description's own emphasis indicate the dominant real-world outcome is a permanent kernel hang (DoS), not a write-based overflow or a significant information leak - treat the tags as approximate, not as the actual impact profile. Overall this is a genuine but situational issue: high impact where loadable modules are used and partially untrusted, low urgency where the module set is fully trusted or the Module Manager is not deployed. |
| Exploit ScenarioDerived | In a ThreadX deployment that uses the Module Manager to run partially-trusted loadable modules, a malicious or compromised module calls an object-pointer lookup dispatcher with a search name whose declared length is oversized (or, via the deprecated path, effectively unbounded). The kernel walks the name comparison past the module's buffer into memory a privileged read cannot access; the resulting fault occurs while preemption is disabled, hanging the scheduler for the rest of the system's life. No public exploit code is identified in the provided data, and the local attack vector (AV:L, PR:L) means the attacker must first be able to load/run a module. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 20, 2026
A crafted ThreadX module can permanently hang the entire kernel by abusing the Module Manager's object-lookup path: the search name for a memory-protected module is validated on only one byte and then walked in privileged mode for as far as the module declares. Both lookup dispatchers are affected - the recommended txm_module_object_pointer_get_extended accepts a length argument but never uses it to bound the buffer, while the deprecated txm_module_object_pointer_get passes the maximum UINT value, removing the bound entirely - so a hostile module forces an out-of-bounds read (CWE-125) without needing to know anything about the memory it reaches. Because the walk happens with the kernel's preemption count raised, an unrecoverable read fault leaves the scheduler disabled for the remainder of the device's uptime, making this a durable denial of service rather than privilege escalation or code execution. The local attack vector (CVSS 4.0 base 6.9; assessed 3.1 AV:L/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:H) requires the attacker to already be able to load or compromise a module in a build that enables the Module Manager; no public exploit code has been identified at time of analysis and there is no confirmed active exploitation (no CISA KEV listing).
RemediationAI
No vendor-released patch version is identified in the available data; the upstream advisory GHSA-39rx-hq8c-4px8 (https://github.com/eclipse-threadx/threadx/security/advisories/GHSA-39rx-hq8c-4px8) should be consulted for the fixed release and the exact commit, since the references point only to that advisory. Until a patched ThreadX build is deployed, the highest-value control is to stop untrusted module code from reaching the lookup path: enforce signature or hash verification of every module at load time and refuse unsigned modules (trade-off: an out-of-band signing/provisioning pipeline and key management burden, and any legacy unsigned modules must be re-signed or retired), or disable the Module Manager entirely in builds that do not require runtime module loading (trade-off: loss of field-updatable module functionality, requiring a full firmware rebuild for changes). Where modules must still load, migrate callers off the deprecated txm_module_object_pointer_get to txm_module_object_pointer_get_extended and additionally patch or wrap the comparison so the supplied length actually bounds the walk, since the extended API in affected builds ignores its length argument (trade-off: a local source patch must be carried and re-applied on every upstream rebase and is not a substitute for an official fix). Restricting who can load modules to a privileged, audited provisioning channel limits the PR:L prerequisite but does not help once a malicious module is resident. Because a fault here is unrecoverable, enabling a hardware watchdog is only a partial compensating control - it converts a permanent hang into a reboot loop rather than preventing the denial of service.
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
Eclipse ThreadX is a real-time operating system whose Module Manager lets separately compiled, memory-protected modules be loaded at runtime and resolve kernel objects by name. The vulnerable logic lives in _txm_module_manager_txm_module_object_pointer_get_dispatch and _txm_module_manager_txm_module_object_pointer_get_extended_dispatch (common_modules/module_manager/inc/txm_module_manager_dispatch.h), which hand the caller-supplied (or defaulted) search name to _txm_module_manager_object_name_compare (common_modules/module_manager/src/txm_module_manager_util.c). That comparison validates a single byte of the module-supplied name and then continues walking memory for as long as the module's declared length dictates, executing in privileged mode with the kernel preemption count raised. The extended API is given an explicit length but does not apply it as a bound, and the deprecated API supplies UINT_MAX, which eliminates the bound rather than merely omitting it. The root cause class is CWE-125 (out-of-bounds read): the module controls traversal distance, not the contents of the memory traversed. If the walk touches an address a privileged read cannot access, the resulting fault occurs while preemption is disabled and cannot be unwound, leaving the scheduler dead - hence high availability impact (VA:H) with only limited confidentiality exposure (VC:L) and no integrity impact (VI:N). The affected CPE is cpe:2.3:a:eclipse_foundation:eclipse_threadx with a wildcard version, indicating the flaw is tracked at the product level rather than tied to a single release.
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
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
A loadable module (PR:L) locally (AV:L) triggers the read with low complexity; impact is a permanent scheduler hang (A:H) with minor memory exposure (C:L) and no write/integrity effect (I:N).
Primary rating from Vendor (eclipse).
CVSS VectorVendor: eclipse
DescriptionCVE.org
The Module Manager's object lookup validated one byte of a memory-protected module's search name and then walked as much of it as the module declared, in privileged mode, with the kernel's preemption count raised. Both lookup dispatchers are affected: the recommended txm_module_object_pointer_get_extended is handed a length and does not use it to bound the buffer, and the deprecated txm_module_object_pointer_get supplies the largest value a UINT can hold, so it removes the bound rather than lacking one.
A module can make the walk unbounded without knowing anything about the memory it reaches, and where the walk reaches memory a privileged read cannot take, the resulting fault leaves the kernel unable to preempt for the rest of the system's life.
Vulnerable functions: _txm_module_manager_txm_module_object_pointer_get_dispatch, _txm_module_manager_txm_module_object_pointer_get_extended_dispatch (both in common_modules/module_manager/inc/txm_module_manager_dispatch.h) and _txm_module_manager_object_name_compare (common_modules/module_manager/src/txm_module_manager_util.c).
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 Eclipse Threadx
View allEclipse ThreadX's Cortex-A7 MMU module port accepts a caller-supplied buffer range after validating only its first byte,
Eclipse ThreadX firmware built with Module Manager and loadable modules enabled contains a use-after-free in txm_module_
Integer overflow in the Eclipse ThreadX module manager lets a loaded module under-allocate an object-pool block and corr
Eclipse ThreadX deployments that use the Module Manager to load untrusted or mixed-trust modules let a module destroy ke
Denial of service in the Eclipse ThreadX Module Manager (CWE-400) lets a loaded user-mode module permanently drain the s
Out-of-bounds read in the Eclipse ThreadX Module Manager's block-pool create dispatcher (_txm_module_manager_tx_block_po
Eclipse ThreadX's memory-protected module support under-validates queue extents in the front-send path: the Module Manag
EUVD-2026-105147
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB