Skip to main content

Eclipse ThreadX CVE-2025-55080

HIGH
Improper Handling of Parameters (CWE-233)
2025-10-15 emo@eclipse.org
7.2
CVSS 4.0 · Vendor: eclipse
View

Attack ChainAIDerived

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

  1. Access
    Gain low-priv code execution in ThreadX module
  2. Delivery
    Craft malicious syscall parameters
  3. Exploit
    Bypass insufficient parameter validation
  4. Execution
    Obtain arbitrary kernel memory read/write
  5. Impact
    Escalate 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.

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

Vendor (eclipse) PRIMARY 7.2 HIGH
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
vuln.today AI 6.3 MEDIUM

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.

3.1 AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:N
4.0 AV:L/AC:L/AT:P/PR:L/UI:N/VC:H/VI:H/VA:N/SC:N/SI:N/SA:N

Primary rating from Vendor (eclipse).

CVSS VectorVendor: eclipse

Attack Vector
Local
Attack Complexity
Low
Attack Requirements
Present
Privileges Required
Low
User Interaction
None
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
None
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

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

Why It Matters

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.

Business Impact: Medium
Compensating Controls

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

EPSS Score
0.1%
Top 97% exploitable
Prevalence
High
ThreadX (ex-Azure RTOS) is among the most deployed embedded RTOS, billions of devices
Data Quality
4 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
Medium

Priority Score

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

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

cpe:2.3:a:eclipse:threadx:*:*:*:*:*:*:*:*

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