Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessControl a loaded user-mode module
-
DeliveryEnumerate module queues via tx_queue_info_get
-
ExploitPost forged TXM_QUEUE_SEND_CALLBACK to a privileged module's queue
-
ExecutionCallback thread invokes attacker-supplied function pointer
-
PersistAttacker code runs in privileged mode
-
ImpactModule-to-kernel privilege escalation
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V8 - Authorization Least privilege enforcement
MITRE ATT&CK
1 technique across 1 tactic: 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 the device to use the ThreadX Module Manager and to load at least one user-mode, memory-protected module that the attacker controls or can influence; no special build option is needed. The concrete trigger: the attacker's module walks the kernel's created-queue list (tx_queue_info_get) to reach another module's callback request queue and sends a message of type TXM_QUEUE_SEND_CALLBACK (or another callback type) naming an attacker-chosen function and argument, which the receiving module's callback thread calls without authenticating the sender. Full privilege escalation additionally requires that the targeted receiving module runs in privileged mode; against a user-mode receiving module the attacker can still invoke functions in that module's context or fault/drain its callback thread. Limiting factors: no network vector (local, on-device only), the attacker must already be able to run a memory-protected module, and kernel-level escalation specifically depends on a privileged module being present alongside the attacker's. |
| Impact | The CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H, 8.5 High) describes a locally-exploitable, low-complexity flaw that requires the attacker to already hold some privilege on the device - specifically the ability to run a user-mode, memory-protected module (PR:L). It is not network-reachable, so mass remote exploitation is not the threat model; the realistic risk is a malicious or compromised module escaping its isolation. Impact is severe where it applies: full confidentiality, integrity and availability loss via module-to-kernel privilege escalation, defeating the Module Manager's entire isolation guarantee. The vuln.today decision label is 'this_week', indicating elevated but not emergency urgency, consistent with a high-impact bug gated by a meaningful access precondition. This is NOT in CISA KEV and no EPSS score was provided in the input, so there is no signal of active or widespread exploitation; absence of those signals is expected for an on-device RTOS escalation that is hard to exploit at internet scale. The subsequent-system metrics are None (SC:N/SI:N/SA:N) because the flaw and its impact are both confined to the device. Net: a genuine high-priority issue for anyone running the Module Manager with attacker-influenced modules alongside a privileged module, but the local, loaded-module precondition keeps it below drop-everything emergency level. |
| Exploit ScenarioDerived | An attacker who can get a malicious user-mode, memory-protected module loaded on a ThreadX device running the Module Manager enumerates the kernel's queue list to find another module's callback request queue, then posts a forged callback message naming a function of the attacker's choosing. The target module's callback thread invokes that function pointer without verifying it came from the Module Manager, so when the target runs in privileged mode the attacker's code executes with kernel privilege. No public exploit code is referenced, but the reporter (SounLabs) privately reproduced it on Cortex-M3 under QEMU (mps2-an385), observing the function run with CONTROL.nPRIV=0. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 03, 2026
Privilege escalation in the Eclipse ThreadX Module Manager (versions 6.0.1 through 6.5.2.202603) lets a user-mode, memory-protected module post a forged callback request into another module's callback request queue, and the receiving module's callback thread invokes the attacker-supplied function pointer without verifying that the Module Manager sent the request. Where the targeted receiving module runs in privileged mode, a user-mode module therefore achieves execution at kernel privilege, defeating the isolation the Module Manager is meant to enforce; against a user-mode receiving module the attacker can still run code in that module's context or fault and drain its callback thread. The flaw is local-only and requires the attacker to already be able to load or control a memory-protected module (CVSS 4.0 base 8.5, PR:L), and no public exploit code was identified at the time of analysis, although the reporter reproduced the escalation on a Cortex-M3 target under QEMU. A vendor fix is available in ThreadX 6.5.2.202603b.
RemediationAI
Upgrade to Eclipse ThreadX 6.5.2.202603b, the vendor-released patch listed in the GHSA advisory; in that release the queue dispatchers reject a memory-protected module's send, front-send, flush, prioritize and send-notify requests on any module's callback request queue, and its receive requests on any callback request queue other than its own, returning TXM_MODULE_INVALID_MEMORY. The Module Manager marks the queues it creates with a name pointer a module cannot assign, so the check needs no list walk, and a new regression test exercises every gated service and fails without the fix. Note that the object authentication added in 6.5.2.202603 does not close this issue, so that intermediate release should not be treated as a mitigation. Until 6.5.2.202603b can be deployed, the exposure is defined by the documented preconditions rather than by a configuration toggle: restrict the device to loading only authenticated, trusted memory-protected modules (trade-off: it removes the untrusted-module use case the Module Manager exists to support), and avoid co-residency of an attacker-influenced user-mode module with a module running in privileged mode, which is the specific combination required for kernel-level escalation (trade-off: it reduces functionality available on the device and requires an inventory of which modules run privileged). Running modules without memory protection is documented as unaffected by the flaw but forfeits the isolation boundary entirely and should not be adopted as a hardening measure. Monitor the vendor advisory at https://github.com/eclipse-threadx/threadx/security/advisories/GHSA-q2rc-f35r-2hw6 and the CVE work item at https://gitlab.eclipse.org/security/cve-assignment/-/work_items/484 for updates.
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
ThreadX's Module Manager isolates memory-protected modules from the kernel and from each other. During _txm_module_manager_start() it creates a callback request queue for every module in Module Manager memory outside all modules, and only the Module Manager is supposed to post to it: notify trampolines enqueue a TXM_MODULE_CALLBACK_MESSAGE naming the module's own callback function when a timer expires or an object notify fires. The root cause is a missing authorization check (CWE-862) that yields improper privilege management (CWE-269): nothing binds a callback request queue to its owning module or validates the sender. Because tx_queue_info_get() walks the kernel's created-queue list, a module can enumerate every other module's callback request queue; _txm_module_manager_tx_queue_send_dispatch() accepts any live queue object outside the calling module, and a callback request queue qualifies. The attacker sends a message of type TXM_QUEUE_SEND_CALLBACK (or another callback type) with a function pointer and argument of its choosing, and _txm_module_callback_request_thread_entry() - the receiving module's callback worker - calls txm_module_callback_message_application_function with those parameters without establishing that the Module Manager originated the message or that the function belongs to the receiving module. The same queues can also be reached with front-send, receive, prioritize, send-notify and flush operations, allowing one module to consume or discard another module's legitimate callbacks. The object authentication introduced in 6.5.2.202603 does not prevent this, because a callback request queue is itself a genuine live queue object. Modules built without memory protection are unaffected, as the attack depends on the protected-module boundary being crossed.
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:H/VI:H/VA:H/SC:N/SI:N/SA:N
On-device trigger via an attacker-controlled loaded module (AV:L, PR:L), low complexity, no UI; escaping module isolation into kernel privilege crosses the security scope (S:C) with full CIA loss.
Primary rating from Vendor (eclipse).
CVSS VectorVendor: eclipse
DescriptionCVE.org
In Eclipse ThreadX versions 6.0.1 through 6.5.2.202603, the Module Manager lets a user-mode, memory-protected module post a forged callback request to another module's callback request queue. The receiving module's callback thread calls the function pointer in the request without checking that the Module Manager sent it, so the attacker's code runs with the receiving module's privilege; when that module runs in privileged mode, a user-mode module gains privileged execution.
Technical POC Analysis
CWE-269 (Improper Privilege Management), with CWE-862 (Missing Authorization) also assigned.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
A high-severity privilege escalation flaw in Eclipse ThreadX Module Manager (versions 6.0.1 through 6.5.2.202603) allows a malicious user-mode module to break memory isolation and execute code with kernel privileges, potentially compromising the entire device. Organizations using ThreadX in embedded products face supply chain and product security risks, as exploitation could lead to persistent control over affected devices, though the attack requires local access and the ability to load a module.
No vendor-released patch identified at time of analysis. Interim mitigations: restrict module loading to trusted, signed modules only; enforce strict validation of callback queue sources in custom code; disable privileged-mode modules where feasible; isolate module callback threads and monitor for anomalies.
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
Privilege escalation occurs when an attacker leverages flaws in access control mechanisms to gain permissions beyond what they were originally granted.
More in Eclipse Threadx
View allDenial of service in the Eclipse ThreadX NetX Duo NetX Secure DTLS server (versions 6.0 through 6.5.2.202603a) lets remo
A NULL pointer dereference in the Eclipse ThreadX NetX Duo IPv6 stack lets an unauthenticated sender on the network cras
Eclipse 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_
Denial of service in Eclipse ThreadX NetX Duo 6.0 through 6.5.2.202603a: the BSD raw IPv6 send path adds a destination-t
Use-after-free in Eclipse ThreadX Modules (6.0.1 through 6.5.2.202603) leaves a user-mode module's trace-buffer-full cal
Out-of-bounds write in the Cortex-M module ports of Eclipse ThreadX 6.0.1 through 6.5.2.202603 lets a user-mode, memory-
Integer overflow in the Eclipse ThreadX module manager lets a loaded module under-allocate an object-pool block and corr
The Eclipse ThreadX Module Manager fails to enforce thread ownership in its thread-control dispatchers, so a loaded user
A crafted ThreadX module can permanently hang the entire kernel by abusing the Module Manager's object-lookup path: the
Eclipse ThreadX deployments that use the Module Manager to load untrusted or mixed-trust modules let a module destroy ke
Eclipse ThreadX 6.0.1 through 6.5.2.202603 can be left with its Module Manager permanently deadlocked: when a module pre
EUVD-2026-115718
NVD
CVE.org
EPSS
GitHub
Exploit-DB