Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessGain code execution in user-mode module
-
DeliveryRegister callback via tx_trace_buffer_full_notify
-
ExploitTrigger module stop and unload
-
ExecutionKernel trace buffer wraps and invokes stale callback
-
ImpactRetained module code runs in privileged context
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Memory lifecycle management
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 a specific build and deployment: ThreadX Modules in use, TX_ENABLE_EVENT_TRACE enabled with trace-buffer-full notification exposed to modules and the registered callback invoked directly on buffer wrap, a kernel-owned trace buffer that remains active after the module is unloaded, and released module code left in executable memory. The attacker must already be able to execute code inside a loaded user-mode module (PR:L) and must win a timing/sequencing condition (AT:P): the module unload must be followed by a trace-buffer wrap before the freed code allocation is overwritten or becomes inaccessible - conditions the module does not fully control. Limiting factors: the vector is local (AV:L, no remote/network path), the reported configuration is a user-mode MPU-protected GNU Cortex-M3 module with dynamically allocated module code (available from ThreadX 6.1.7), and whether the stale callback actually executes depends on the code-allocation and executable-memory configuration. Privileged modules are out of scope - they are trusted and not a security boundary. |
| Impact | Signals point to a genuine but conditional, non-urgent issue rather than a high-CVSS/low-real-risk false alarm. The CVSS v4.0 base is 7.3 (High) with AV:L/AC:L/AT:P/PR:L/UI:N - exploitation is LOCAL, requires the attacker to already have code execution inside a loaded user-mode module (PR:L), and carries AT:P because success depends on an attack timing/sequencing condition the module cannot fully control (unload must be followed by a trace-buffer wrap before the released code is overwritten or made inaccessible). Impact is high (VC:H/VI:H/VA:H) because a stale callback can run in privileged/kernel context, defeating module isolation. The vuln.today Decision label is 'this_week' (meaningful but not act_now/emergency). Exploitation status: no public exploit identified at time of analysis - the reporter observed post-unload privileged invocation in ten Cortex-M3 runs, but these have NOT been independently reproduced by the maintainers, and the reporter did NOT demonstrate code reuse, attacker-controlled payload, information disclosure, or a product-level exploit. No CISA KEV listing and no EPSS score are present in the input, so widespread-exploitation probability cannot be quantified - absence of EPSS/KEV is a data gap, not evidence of safety. Net: a real defense-in-depth/isolation-boundary bug that matters most to systems loading untrusted modules with event tracing enabled, but the local foothold requirement plus timing dependency make it a scheduled-remediation priority rather than a drop-everything emergency. |
| Exploit ScenarioDerived | An attacker who can already run code inside an MPU-isolated user-mode ThreadX module (with TX_ENABLE_EVENT_TRACE built in) calls tx_trace_buffer_full_notify to register a trace-buffer-full callback, then arranges for the module to be stopped and unloaded while a kernel-owned trace buffer stays active. A later trace-buffer wrap from ordinary kernel activity invokes the now-stale callback in privileged thread context - either executing the unloaded module's retained code with kernel privileges or, if the freed allocation was reused, redirecting control flow or faulting. No public exploit code exists; the behavior was only observed by the reporter on Cortex-M3 and has not been independently reproduced by maintainers. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 03, 2026
Use-after-free in Eclipse ThreadX Modules (6.0.1 through 6.5.2.202603) leaves a user-mode module's trace-buffer-full callback registered after the module is stopped and unloaded, so a later wrap of a still-active kernel-owned trace buffer can call into released module code from privileged thread context and compromise kernel confidentiality, integrity and availability. Reaching it is conditional: a local attacker must already execute code inside a loaded user-mode module, the build must enable TX_ENABLE_EVENT_TRACE with trace-buffer-full notification exposed to modules, and the trace wrap must occur after unload but before the freed code allocation is reused or becomes inaccessible - a sequence the module does not fully control. No public exploit identified at time of analysis; the reporter reproduced the post-unload invocation on a user-mode MPU-protected GNU Cortex-M3 module, and the vendor has fixed the issue in 6.5.2.202603b.
RemediationAI
Vendor-released patch: ThreadX 6.5.2.202603b, in which the Module Manager dispatcher refuses tx_trace_buffer_full_notify from user-mode modules with TXM_MODULE_INVALID_PROPERTIES (for a null pointer as well as a function), so a user-mode module can no longer leave a callback registered past unload; upgrade to that release per the advisory at https://github.com/eclipse-threadx/threadx/security/advisories/GHSA-8pgj-qvjv-j4fq. If upgrading is not immediately possible, build without TX_ENABLE_EVENT_TRACE or leave tracing disabled at run time on systems that load untrusted modules - at the cost of losing event-trace diagnostics - or define TXM_TRACE_BUFFER_FULL_NOTIFY_CALL_NOT_USED when building the Module Manager to remove the service from the dispatch table, which similarly removes that notification capability from all modules. Explicitly unregistering the callback before unload prevented the reported invocation in the reporter's ten control runs, but the vendor chose to refuse the user-mode registration outright, so the patched release is the complete fix; privileged modules are trusted and remain able to register an outliving callback by design.
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 Modules run application code in MPU-protected user mode on Cortex-M class devices, isolated from the privileged kernel, and expose kernel services through a module dispatcher table. A module calling tx_trace_buffer_full_notify has its function pointer forwarded by the module dispatcher into _tx_trace_buffer_full_notify, which stores it globally in _tx_trace_full_notify_function; trace insertion then calls that pointer directly whenever the active event-trace buffer wraps. _txm_module_manager_stop disables tracing only when the trace buffer belongs to the module being stopped, and _txm_module_manager_unload releases the module's allocations without clearing the registration. The result is a CWE-416 use-after-free of a stale function pointer into freed module code: ordinary kernel operations that generate trace events can reach the callback after unload. The reporter observed the invocation in ten independent Cortex-M3 runs with the callback address inside the unloaded module's returned code range and execution in privileged thread context, and unregister-before-unload controls suppressed it in ten runs; the maintainers have not independently reproduced these observations, and code reuse, information disclosure and an attacker-controlled payload were not demonstrated. Whether a stale callback actually executes depends on the code-allocation and executable-memory configuration of the deployment; the reported GNU Cortex-M3 user-mode module configuration with dynamically allocated module code is available from ThreadX 6.1.7. The vendor fix changes the dispatcher to reject tx_trace_buffer_full_notify from user-mode modules with TXM_MODULE_INVALID_PROPERTIES (also covering GHSA-xr9m-8j99-rw4m), which removes the user-mode attack path rather than revoking the callback at unload; privileged modules may still register a callback that outlives them, but they run with kernel privileges and are trusted, so that is not a security boundary.
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:P/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Local foothold in a low-privileged module (AV:L/PR:L); AC:H for the unload-then-wrap timing race; S:C as the MPU module-isolation boundary is crossed into privileged kernel context with full C/I/A impact.
Primary rating from Vendor (eclipse).
CVSS VectorVendor: eclipse
DescriptionCVE.org
In Eclipse ThreadX versions 6.0.1 through 6.5.2.202603, ThreadX Modules does not revoke a module's trace-buffer-full callback when the module is stopped and unloaded. With event tracing enabled and a kernel-owned trace buffer still active, a later buffer wrap invokes the callback from privileged thread context after the module's code has been released, so a user-mode module can have its code run with kernel privileges after unload, or, once the memory is reused, redirect control flow or cause a fault.
Technical POC Analysis
CWE-416, use-after-free of a function pointer.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
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
Use-after-free vulnerabilities occur when a program continues to access memory through a pointer after that memory has been deallocated.
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.
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
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
Privilege escalation in the Eclipse ThreadX Module Manager (versions 6.0.1 through 6.5.2.202603) lets a user-mode, memor
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
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-115717
NVD
CVE.org
EPSS
GitHub
Exploit-DB