Eclipse ThreadX CVE-2025-55080
HIGHAttack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessGain low-priv code execution in ThreadX module
-
DeliveryCraft malicious syscall parameters
-
ExploitBypass insufficient parameter validation
-
ExecutionObtain arbitrary kernel memory read/write
-
ImpactEscalate privileges / disclose protected memory
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V2 - Validation and Business Logic Parameter handling completeness
|
| Exploitation Conditions | Exploitation requires ALL of the following: (1) the device runs Eclipse ThreadX before 6.4.3; (2) ThreadX memory protection (the MPU/module memory-protection feature) is ENABLED - the advisory explicitly scopes the flaw to 'when memory protection is enabled', so devices without memory protection are not in scope; (3) the attacker already has local, low-privilege code execution on the device (CVSS PR:L, AV:L), such as control of a less-privileged ThreadX module from which to issue system calls; and (4) the attacker can craft syscall parameters that evade the insufficient validation (reflected by AT:P). Limiting factors: this is not remotely reachable without a prior foothold, requires the non-universal memory-protection configuration, and depends on the presence of an exploitable syscall path - these substantially narrow realistic exploitation despite full read/write impact. |
| Impact | This is a moderate, defense-in-depth vulnerability rather than an urgent, widely-exploitable priority. The CVSS 4.0 vector (AV:L/AC:L/AT:P/PR:L) describes a LOCAL attack that already requires low-level privileges - i.e. the attacker must already be executing code on the device, typically within a less-privileged ThreadX module/thread - and additionally carries an attack requirement (AT:P) meaning the target must be running with memory protection (MPU) enabled, the exact feature this flaw subverts. All three independent prioritization signals point the same, consistent direction: EPSS is very low at 0.14% (3rd percentile), the CVE is NOT in CISA KEV, and no public exploit code was identified in the provided data. There is no conflict among the signals here. The 7.2 'High' score is driven by VC:H/VI:H (full confidentiality and integrity impact - arbitrary read/write of kernel/other-module memory), not by ease of reach; the local vector and pre-existing privilege requirement sharply constrain real-world risk. The realistic concern is privilege escalation / sandbox-escape within an already-compromised embedded device, not remote mass exploitation. One caveat: the input provides only a CVSS 4.0 vector and no NVD-published CVSS 3.1 score, so cross-framework comparison relies on a single vendor-supplied vector. |
| Exploit ScenarioDerived | An attacker who has already achieved code execution inside a low-privileged ThreadX module on a device running with memory protection (MPU) enabled issues a system call with crafted/malformed parameters. Because syscall parameter validation is insufficient, the kernel acts on attacker-controlled pointers, giving the attacker an arbitrary read/write primitive to access protected kernel or other-module memory and escalate privileges. No public proof-of-concept was identified at the time of analysis; this would require local execution and a non-default memory-protection configuration. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 08, 2026
Insufficient validation of syscall parameters in Eclipse ThreadX before 6.4.3, when the memory-protection feature is enabled, allows a local attacker who already holds low-privilege code execution on the device - for example, control of a less-privileged ThreadX module - to craft system calls that escape intended isolation and obtain arbitrary memory read and write. The flaw is not remotely reachable on its own: it requires the non-universal memory-protection configuration, an existing foothold, and an exploitable syscall path, so this is a moderate, defense-in-depth vulnerability rather than an urgent, widely-exploitable priority. No public exploit identified at time of analysis, and EPSS is low at 0.14% (3rd percentile).
RemediationAI
The primary fix is to upgrade to Eclipse ThreadX 6.4.3 or later (vendor-released patch: 6.4.3), which hardens the syscall parameter verification so that module-supplied arguments cannot drive out-of-bounds kernel memory access; apply the corresponding firmware update from your silicon or board vendor if you consume ThreadX as a BSP rather than upstream, and consult the advisory at https://github.com/eclipse-threadx/threadx/security/advisories/GHSA-76hh-wrj5-hr2v for the vendor's own guidance and version confirmation. Because the flaw is only reachable when memory protection is enabled, a device that does not actually use module isolation can recompile with the memory-protection feature disabled to remove the vulnerable syscall path entirely - but this forfeits the compartmentalization benefit of MPU isolation for all other bugs and is only advisable where untrusted modules are never loaded. Where upgrading immediately is not possible, reduce the attack surface instead of disabling protection wholesale: restrict the device to a minimal set of signed/trusted modules so an attacker has fewer places to obtain the required low-privilege execution, avoid loading third-party or field-replaceable modules that can issue arbitrary syscalls, and audit or temporarily remove custom syscall handlers that dereference module-supplied pointers so the exploitable parameter path is eliminated; each of these narrows but does not close the underlying validation gap, so the 6.4.3 upgrade remains the definitive remediation.
Affects your stack
Find out whether the stacks and servers you run are on an affected version.
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 (RTOS) widely deployed in embedded and IoT devices, and the CPE entry cpe:2.3:a:eclipse:threadx:*:*:*:*:*:*:*:* indicates that all releases prior to 6.4.3 are affected. When ThreadX memory protection is compiled in, application code is compartmentalized into modules that are constrained by the MPU and interact with the kernel through a system-call interface. That interface is the trust boundary: the kernel must verify every argument (pointers, buffer sizes, handles) supplied by an unprivileged module before acting on it. CWE-233 (Improper Handling of Parameters) captures the root cause here - the parameter checks performed by the syscall handler were not sufficient, so a module able to supply carefully crafted values can cause the kernel to operate on addresses outside the module's permitted memory, yielding arbitrary read and write of memory that should have been protected. Note that the CVSS 4.0 vector shows AT:P (attack requirements present) and PR:L, and our independent CVSS 3.1 assessment (AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:N) reinforces that this is a locally triggered, high-complexity condition rather than an unauthenticated remote primitive, while confirming high confidentiality and integrity impact on the vulnerable component. The practical consequence is loss of the isolation guarantee that memory protection is supposed to provide, not a kernel-wide or remote compromise on its own.
Know when 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:N/SC:N/SI:N/SA:N
Local vector and pre-existing low privilege give AV:L/PR:L; the memory-protection-enabled requirement maps the 4.0 AT:P to AC:H; arbitrary read/write yields C:H/I:H, with no availability impact.
Primary rating from Vendor (eclipse).
CVSS VectorVendor: eclipse
DescriptionCVE.org
In Eclipse ThreadX before 6.4.3, when memory protection is enabled, syscall parameters verification wasn't enough, allowing an attacker to obtain an arbitrary memory read/write.
Executive ViewAI
Eclipse ThreadX, a real-time operating system embedded in IoT and industrial devices, contains a high-severity flaw that allows a local attacker with existing low-privilege code execution to escape memory isolation and gain arbitrary read/write access when the memory-protection feature is enabled. This impacts organizations deploying ThreadX in connected or safety-critical products, potentially compromising device integrity, data confidentiality, and operational continuity, though exploitation requires a non-default configuration and an existing foothold. Leadership should treat this as a defense-in-depth concern rather than an urgent remote threat, as no public exploit identified at time of analysis and the EPSS score is very low.
No vendor-released patch identified at time of analysis. Interim mitigations include disabling the memory-protection feature if feasible, enforcing strict least-privilege for ThreadX modules, monitoring for anomalous syscall patterns, and applying secure boot and hardware isolation where available. Apply vendor patch when released.
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
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Affected Products (CPE)CVE.org
In Eclipse ThreadX before 6.4.0, xQueueCreate() and xQueueCreateSet() functions from the FreeRTOS compatibility API (uti
Eclipse ThreadX releases prior to 6.4.3 contain an incomplete pointer-validation flaw that lets a module-level caller cr
Eclipse ThreadX versions before 6.4.3 fail to enforce the configured maximum thread priority in certain thread-creation
Privilege escalation in Eclipse ThreadX allows an unprivileged, memory-protected ThreadX module to break out of its MPU
Secure memory disclosure in Eclipse ThreadX occurs because multiple TrustZone-M non-secure callable (NSC) entry function
Memory corruption in ThreadX RTOS CreateCounter() function allows local attackers with user privileges to trigger hard f
In Eclipse ThreadX before version 6.4.0, the _Mtxinit() function in the Xtensa port was missing an array size check caus
NVD
CVE.org
EPSS
GitHub
Exploit-DB