Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessDeliver crafted JPEG to GUIX application
-
ExploitDefault software decoder parses marker segments
-
ExecutionMissing length check reads past image buffer / zero chroma factor loops forever
-
ImpactMemory disclosure or permanent device hang
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, read limits
MITRE ATT&CK
1 technique across 1 tactic: Collection The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Requires that the application be built with the default GX_SOFTWARE_DECODER_SUPPORT enabled AND that it pass an attacker-controlled JPEG to the GUIX software JPEG decoder (user interaction / UI:R - the image must be opened, loaded, or rendered). The two concrete triggers are: (1) a JPEG marker segment of one of four types that is truncated shorter than the fields the decoder reads, triggering the out-of-bounds read; and (2) a JPEG declaring a zero chroma sampling factor, triggering the non-terminating block-decode loop. Limiting factors: the vector is local (AV:L) and exploitation only occurs if the embedding product actually decodes externally-influenced images - a product that only renders trusted, build-time image assets is not realistically exposed; confidentiality impact of the over-read is low (C:L), and the dominant real-world outcome is an availability/DoS device hang. |
| Impact | This is a moderate-severity, locally-triggered memory-safety flaw in the GUIX software JPEG decoder, best treated as a robustness/availability bug rather than a top-tier priority. The vendor CVSS 3.1 vector (AV:L/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:H, 6.1) is internally consistent with the description: exploitation requires the application to decode an attacker-supplied JPEG (UI:R), yields only a low-confidentiality out-of-bounds read (C:L, matching CWE-125) and a high-availability denial of service from the non-terminating block-decode loop (A:H). No EPSS score, KEV listing, or POC was provided in the input, so there is no public exploit identified at time of analysis and no evidence of active or widespread exploitation - the signals do not conflict, they are simply absent, which is consistent with a newly-disclosed embedded-RTOS parser bug. The main caveat is the attack vector: CVSS asserts AV:L, but in practice the real exposure depends entirely on how the embedding product feeds images to GUIX (local resource vs. image received over a network/Bluetooth/USB channel); if a product decodes remotely-sourced JPEGs, the practical reach is broader than AV:L implies - verify the data path per deployment. Overall, remediate on a normal patch cadence; the A:H device-hang is the more realistic impact than the low-value memory disclosure. |
| Exploit ScenarioDerived | An attacker crafts a malformed JPEG - either with a truncated marker segment (APP/DQT/DHT/SOF-class) shorter than the fields the decoder reads, or with a chroma sampling factor of zero - and gets it in front of a GUIX-based application, e.g. as a firmware resource, a file on removable media, or an image received over a product's own channel. When the device decodes it with the default GX_SOFTWARE_DECODER_SUPPORT path, the truncated segment causes a read past the end of the image buffer (leaking adjacent memory or faulting) or the zero sampling factor sends the block-decode loop into a permanent hang. No public exploit code was provided in the input. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 20, 2026
Truncated JPEG marker segments and a zero chroma sampling factor in Eclipse ThreadX GUIX's software JPEG decoder can trigger an out-of-bounds read and a non-terminating block-decode loop, letting a local, unauthenticated attacker who can get a crafted JPEG opened or rendered crash or hang the device and potentially disclose a small amount of adjacent memory. Both triggers reproduce in the default configuration with GX_SOFTWARE_DECODER_SUPPORT enabled; the CVSS 3.1 score is 6.1 (AV:L/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:H), so the dominant outcome is availability loss rather than large-scale data theft. No public exploit code or CISA KEV entry was identified at time of analysis, and no EPSS score was provided.
RemediationAI
Apply the vendor fix referenced in the Eclipse ThreadX GUIX security advisory GHSA-pppm-h3g4-986x; the supplied data does not include an exact fixed version and the version-wildcarded CPE does not identify one, so the advisory is the authoritative source for the patched release. If an immediate upgrade is not possible, build with GX_SOFTWARE_DECODER_SUPPORT disabled where software JPEG decoding is not required - trade-off: the product loses GUIX software JPEG decode and must rely on a hardware or external decoder. For products that must decode untrusted images, add an application-side JPEG validation step that rejects marker segments shorter than the fields the decoder reads and rejects images declaring a zero chroma sampling factor - trade-off: extra parsing code and possible rejection of malformed-but-tolerated files - and run decoding in a supervised task with a watchdog so the non-terminating loop cannot permanently hang the device (trade-off: watchdog resets can discard other GUI state). Where the device only renders trusted, build-time assets, restrict the decoder to those sources rather than accepting arbitrary images.
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 an embedded GUI stack; its software JPEG decoder, enabled by default through GX_SOFTWARE_DECODER_SUPPORT, parses JPEG marker segments before decoding blocks. The decoder reads fields from four marker-segment types without first confirming the segment is long enough, so a truncated segment causes a read past the end of the caller-provided image buffer - the CWE-125 out-of-bounds read class assigned to this CVE. Separately, a JPEG declaring a zero chroma sampling factor makes the block decode loop non-terminating, producing a device hang rather than a memory-safety violation. The CPE cpe:2.3:a:eclipse_foundation:eclipse_threadx_-_guix:*:*:*:*:*:*:*:* is version-wildcarded and therefore does not pin a specific release range; real exposure depends on whether the embedding product actually feeds attacker-influenced JPEG images to this decoder. The assessed vector is local (AV:L) with user interaction (UI:R) and no privileges required (PR:N); the over-read's confidentiality impact is low (C:L) while availability impact is high (A:H).
Know when Eclipse Threadx 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:N/PR:N/UI:A/VC:L/VI:N/VA:H/SC:N/SI:N/SA:N
Malicious JPEG must be supplied to and decoded by the app (AV:L, UI:R, PR:N); CWE-125 over-read gives limited leakage (C:L), no integrity impact, and the infinite loop causes a device hang (A:H).
Primary rating from Vendor (eclipse).
CVSS VectorVendor: eclipse
Lifecycle Timeline
1DescriptionCVE.org
The GUIX software JPEG decoder reads four kinds of marker segment without checking that each is long enough to hold what it reads. A truncated segment is therefore read past the end of the caller's image buffer. Separately, a zero chroma sampling factor makes the block decode loop non-terminating. Both reproduce in the default configuration, in which GX_SOFTWARE_DECODER_SUPPORT is enabled.
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.
More in Eclipse Threadx Guix
View allThe Eclipse ThreadX GUIX PNG decoder can be driven out of bounds by a crafted PNG that places a second IHDR chunk after
Heap-based out-of-bounds write in the Eclipse ThreadX GUIX binary resource (font) loader: a font page header declaring f
An out-of-bounds read in the Eclipse ThreadX GUIX JPEG software decoder lets a crafted JPEG file expose memory beyond an
Out-of-bounds reads in Eclipse ThreadX GUIX can expose adjacent memory or terminate the application when gx_binres_theme
Out-of-bounds write in the Eclipse ThreadX GUIX binary resource theme loader lets an attacker who supplies a crafted GUI
Eclipse GUIX multi-line text view rendering can read one byte past the end of an application text buffer when the displa
EUVD-2026-105046
NVD
CVE.org
EPSS
Vulnrichment
GitHub
VulDB
Exploit-DB