Skip to main content

Eclipse ThreadX GUIX EUVDEUVD-2026-89200

| CVE-2026-102729 MEDIUM
Incorrect Calculation of Buffer Size (CWE-131)
2026-09-29 eclipse GHSA-xj26-f3rj-75vp
5.9
CVSS 4.0 · Vendor: eclipse
View

Attack ChainAIDerived

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

  1. Access
    Craft malicious GUIX theme resource
  2. Delivery
    Deliver resource to target application
  3. Exploit
    App loads resource via gx_binres_theme_load()
  4. Execution
    Zero-byte buffer allocated for out-of-range id
  5. Persist
    GX_THEME written past table into heap
  6. Impact
    Memory corruption / potential code execution

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Buffer size calculation
Exploitation Conditions

Exploitation requires the GUIX application to load an attacker-supplied or attacker-modified binary theme resource whose requested theme id is at or beyond the theme count declared by that resource; gx_binres_theme_load() then allocates a zero-byte buffer and writes a GX_THEME structure past the theme table. Limiting factors: the attack vector is local (AV:L) - the attacker must place or substitute the malicious resource file - and it requires user/application interaction (UI:P) to actually load that resource, plus the specific out-of-range-id attack condition (AT:P). It does not affect default operation unless a crafted resource is loaded, and there is no remote unauthenticated network path.

Impact

This is a genuine memory-corruption bug (CWE-131 incorrect buffer-size calculation leading to a heap out-of-bounds write) in Eclipse ThreadX GUIX, but the real-world risk is moderate rather than high. The vendor CVSS 4.0 vector (AV:L/AC:L/AT:P/PR:N/UI:P) scores it 5.9 medium, and the signals are internally consistent: the vulnerability is local (AV:L), requires a specific attack condition (AT:P - the resource must contain an out-of-range theme id), and needs user/application interaction (UI:P) to load the malicious binary resource. Impact skews to integrity and availability (VI:H/VA:H) with only limited confidentiality exposure (VC:L), consistent with a controlled heap write that corrupts adjacent structures rather than leaking data. There is no EPSS score, no CISA KEV listing, and no public exploit code identified at time of analysis, so there is no evidence of active exploitation - the primary risk driver is the wide embedded footprint of GUIX, not ease of remote attack. Note one metadata conflict: the CVE is tagged 'Information Disclosure' while the CVSS vector clearly indicates a write-corruption bug (VI:H/VA:H, VC:L) - the impact is memory corruption, not primarily disclosure. Priority is medium: legitimate flaw in ubiquitous embedded software, but exploitation requires local delivery of a crafted resource and user interaction.

Exploit ScenarioDerived

An attacker crafts a malicious GUIX binary resource (theme) file in which a requested theme id sits at or beyond the theme count declared by the resource. When a GUIX application loads this resource via gx_binres_theme_load(), a zero-byte buffer is allocated and the loader writes a full GX_THEME structure and its tables into it, corrupting the heap and potentially enabling code execution or a crash. No public proof-of-concept is known; exploitation requires local delivery of the resource file and the application loading it.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.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 – Sep 29, 2026

A heap-based out-of-bounds write in Eclipse ThreadX GUIX's gx_binres_theme_load() lets a local attacker corrupt memory by supplying a binary theme resource in which the requested theme id is at or beyond the theme count the resource declares. The loader sizes and allocates a zero-byte buffer for that out-of-range id, then walks past the end of the theme table and writes a GX_THEME structure and its tables into the empty allocation, producing out-of-bounds heap corruption. Exploitation requires local placement or substitution of the malicious resource plus application/user interaction to load it (AV:L, PR:N, UI:R), so risk is moderate rather than high; no public exploit has been identified at time of analysis.

RemediationAI

No vendor-released patch version is specified in the available data, so the first step is to consult the GitHub advisory GHSA-372w-c338-xj8p (https://github.com/eclipse-threadx/guix/security/advisories/GHSA-372w-c338-xj8p) to obtain the current fixed release and upgrade to it; until then treat this as unfixed. Practical compensating controls are: validate that the requested theme id is strictly less than the resource's declared theme count and reject any resource whose theme count is zero or whose table is truncated, ideally by adding an explicit bounds check inside or ahead of gx_binres_theme_load() - the trade-off is that this requires patching or wrapping the loader and rebuilding GUIX, and a too-broad check can reject legitimate themes. Restrict write access to the directory holding binary theme (.gx_binres) resources so only privileged, trusted accounts or the signed firmware/image update path can place them, which closes the local AV:L prerequisite but complicates developer workflows that drop custom themes onto the device; combine with cryptographic signing/verification of resource blobs when they must be sourced externally, accepting the key-management and provisioning overhead. Also avoid loading theme resources from untrusted or user-writable storage (removable media, writable data partitions, cache directories) in production firmware, since that simply removes the attacker's ability to reach the vulnerable code path.

Affected VersionsENISA

Guix 0 ≤6.5.1.202602a

Affected Packages

euvd guix 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

Eclipse ThreadX GUIX is the embedded GUI framework in the Eclipse ThreadX RTOS family; it can load prebuilt binary resources (fonts, themes, strings) from files, and gx_binres_theme_load() is the routine that resolves a requested theme id inside such a resource. The root cause is CWE-131, incorrect calculation of buffer size: the function derives its buffer size from the requested theme's entry in the resource's theme table, but when the requested id is at or past the resource's declared theme count, that lookup walks off the end of the table and the computed size collapses to zero bytes, yet the allocation still succeeds. The subsequent load pass takes whatever data follows the theme table as a theme header and writes a GX_THEME structure and its associated tables into that zero-byte buffer, yielding a heap out-of-bounds write (memory corruption, not merely a read). The affected product set is tracked by the wildcard CPE cpe:2.3:a:eclipse_foundation:guix:*:*:*:*:*:*:*:*, i.e. all GUIX versions without a version-specific fix; the third-party tags label this class as information disclosure, but the authoritative assessment is integrity and availability impact (VI:H/VA:H) from memory corruption.

Know when Guix 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 5.9 MEDIUM
CVSS:4.0/AV:L/AC:L/AT:P/PR:N/UI:P/VC:L/VI:H/VA:H/SC:N/SI:N/SA:N
vuln.today AI 7.3 HIGH

Local delivery of a crafted resource that the app must load gives AV:L/UI:R/PR:N; deterministic out-of-range write is AC:L; heap corruption yields I:H/A:H with only minor C:L.

3.1 AV:L/AC:L/PR:N/UI:R/S:U/C:L/I:H/A:H
4.0 AV:L/AC:L/AT:P/PR:N/UI:P/VC:L/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
Present
Privileges Required
None
User Interaction
Passive
Vulnerable system: Confidentiality
Low
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

gx_binres_theme_load() sizes its theme buffer for the theme it was asked for, and allocates it even when the resource holds no theme with that id. A theme id at or past the theme count declared by the resource gets a buffer of zero bytes. The load pass then walks past the end of the theme table, takes whatever follows as a theme header, and writes a GX_THEME and its tables into that zero-byte buffer.

Threat Intelligence Overview

EPSS Score
0.1%
Top 98% exploitable
Prevalence
High
GUIX is the GUI toolkit of the widely deployed Eclipse ThreadX embedded RTOS
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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.1%
Patch available No
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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
None
System Exposure· derived
Small
Automatable
No
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

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

Attack Technique

A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

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