Skip to main content

Eclipse ThreadX CVE-2026-115231

| EUVDEUVD-2026-115718 HIGH
Improper Privilege Management (CWE-269)
2026-11-03 eclipse
8.5
CVSS 4.0 · Vendor: eclipse
View

Attack ChainAIDerived

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

  1. Access
    Control a loaded user-mode module
  2. Delivery
    Enumerate module queues via tx_queue_info_get
  3. Exploit
    Post forged TXM_QUEUE_SEND_CALLBACK to a privileged module's queue
  4. Execution
    Callback thread invokes attacker-supplied function pointer
  5. Persist
    Attacker code runs in privileged mode
  6. Impact
    Module-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.

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

Eclipse ThreadX 6.0.1 ≤6.5.2.202603

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'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

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

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.

3.1 AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H
4.0 AV:L/AC:L/AT:N/PR:L/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
Low
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

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

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.1%
Top 99% exploitable
Prevalence
High
widely deployed embedded/IoT RTOS; Module Manager MPU config is a subset
Social Media
2
Sightings
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· derived
Defer
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact
High

Priority Score

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

Attack Technique

Privilege escalation occurs when an attacker leverages flaws in access control mechanisms to gain permissions beyond what they were originally granted.

CVE-2026-115215 HIGH
8.7 Nov 02

Denial of service in the Eclipse ThreadX NetX Duo NetX Secure DTLS server (versions 6.0 through 6.5.2.202603a) lets remo

CVE-2026-114408 HIGH
8.7 Nov 02

A NULL pointer dereference in the Eclipse ThreadX NetX Duo IPv6 stack lets an unauthenticated sender on the network cras

CVE-2026-95109 HIGH
8.5 Oct 20

Eclipse ThreadX's Cortex-A7 MMU module port accepts a caller-supplied buffer range after validating only its first byte,

CVE-2026-94192 HIGH
8.5 Oct 20

Eclipse ThreadX firmware built with Module Manager and loadable modules enabled contains a use-after-free in txm_module_

CVE-2026-115403 HIGH
8.2 Nov 02

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

CVE-2026-113421 HIGH
7.3 Nov 03

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

CVE-2026-115653 HIGH
7.0 Nov 02

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-

CVE-2026-95107 HIGH
7.0 Oct 20

Integer overflow in the Eclipse ThreadX module manager lets a loaded module under-allocate an object-pool block and corr

CVE-2026-115654 MEDIUM
6.9 Nov 02

The Eclipse ThreadX Module Manager fails to enforce thread ownership in its thread-control dispatchers, so a loaded user

CVE-2026-94024 MEDIUM
6.9 Oct 20

A crafted ThreadX module can permanently hang the entire kernel by abusing the Module Manager's object-lookup path: the

CVE-2026-94023 MEDIUM
6.9 Oct 20

Eclipse ThreadX deployments that use the Module Manager to load untrusted or mixed-trust modules let a module destroy ke

CVE-2026-118052 MEDIUM
6.8 Nov 02

Eclipse ThreadX 6.0.1 through 6.5.2.202603 can be left with its Module Manager permanently deadlocked: when a module pre

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