Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft malicious GUIX theme resource
-
DeliveryDeliver resource to target application
-
ExploitApp loads resource via gx_binres_theme_load()
-
ExecutionZero-byte buffer allocated for out-of-range id
-
PersistGX_THEME written past table into heap
-
ImpactMemory 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
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
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
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
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.
Primary rating from Vendor (eclipse).
CVSS VectorVendor: eclipse
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
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
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.
GNU Guix 1.0.1 allows local users to gain access to an arbitrary user's account because the parent directory of the user
Heap out-of-bounds write in Eclipse ThreadX GUIX's binary theme resource loader (gx_binres_theme_load) lets a crafted bi
A security vulnerability that can lead to local privilege escalation has been found in ’guix-daemon’. Rated medium sever
EUVD-2026-89200
GHSA-xj26-f3rj-75vp
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB