Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSupply text ending in carriage return
-
DeliveryWidget renders in multi-line text view
-
ExploitTrigger out-of-bounds read in display_info_get
-
ExecutionIndex advances past buffer, second over-read
-
ImpactDisclose adjacent memory as spurious extra row
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 | Exploitation requires the application to display a string that terminates with a carriage return ( |
| Impact | This is a genuinely low-to-moderate priority issue despite being a memory-safety bug. The CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:A/VC:L/VI:N/VA:L, score 4.6 Medium) tells a consistent story: exploitation is LOCAL (not network-reachable), requires active user interaction (a user must render/view the affected text view), and yields only LOW confidentiality impact (a single out-of-bounds byte / spurious row) and LOW availability impact (minor display corruption), with no integrity impact. There is no EPSS score, no CISA KEV listing, and no public exploit code referenced in the input - no public exploit identified at time of analysis. The signals do not conflict: a local, UI-gated, one-byte over-read in an embedded GUI library is a correctness/robustness defect more than a weaponizable vulnerability. The classification tag 'Buffer Overflow' is somewhat loose - CWE-125 (out-of-bounds READ) is the accurate characterization, and there is no write primitive, so code execution is not indicated by the data. Realistic risk is bounded by the embedded, local, user-interaction-dependent nature of the flaw; it merits patching during normal maintenance rather than emergency response. |
| Exploit ScenarioDerived | An application built on Eclipse ThreadX GUIX renders attacker-influenced text - ending in a carriage return ( |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 20, 2026
Eclipse GUIX multi-line text view rendering can read one byte past the end of an application text buffer when the displayed string ends with a carriage return, and that over-read can cascade into an index overrun and a spurious text row. The issue is local and requires user interaction: an attacker must influence text rendered in a GUIX multi-line text view and a user must view that widget; impact is limited to low confidentiality and availability effects, with no public exploit identified at time of analysis. It is a low-to-moderate priority memory-safety bug in Eclipse ThreadX GUIX rather than a remotely triggerable or code-execution issue.
RemediationAI
No vendor-released patch version is identified in the supplied data; check the Eclipse ThreadX GUIX advisory at https://github.com/eclipse-threadx/guix/security/advisories/GHSA-4qjc-2g93-36m2 for the fixed release and upgrade to that version once identified. Until then, sanitize or normalize application-supplied strings before rendering them in GUIX multi-line text views, specifically stripping a trailing carriage return and enforcing buffer length/NUL-termination checks; this may alter display semantics for text that legitimately ends in \r. Avoid displaying untrusted or attacker-influenced text in multi-line text view widgets, or restrict such widgets to trusted content, accepting reduced functionality. If multi-line text views are not required, disable their use in affected builds, with the trade-off of losing that UI feature.
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
The affected component is Eclipse Foundation Eclipse ThreadX GUIX, identified by CPE cpe:2.3:a:eclipse_foundation:eclipse_threadx_-_guix:*:*:*:*:*:*:*:*; the wildcard version means the supplied data does not enumerate exact releases. The bug is CWE-125 (out-of-bounds read) in _gx_multi_line_text_view_display_info_get(), which processes a string for a GUIX multi-line text view. If that string ends with a carriage return (\r), the routine reads one byte beyond the application's text buffer; callers can then advance an index past the string end, causing a second over-read in _gx_multi_line_text_view_string_total_rows_compute() and producing a row of text not present in the source. The assessed vector is local with UI interaction and low confidentiality/availability impact; the data does not indicate an integrity or code-execution primitive.
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:L/SC:N/SI:N/SA:N
Local library over-read requires the app to render attacker-influenced text and a user to view it (AV:L/UI:R); only one disclosed byte (C:L) and minor display corruption (A:L), no write primitive so I:N.
Primary rating from Vendor (eclipse).
CVSS VectorVendor: eclipse
DescriptionCVE.org
_gx_multi_line_text_view_display_info_get() reads one byte past the end of the application's text buffer when the string it is given ends with a carriage return (\r). The over-read can also cause callers to advance their index past the end of the string, producing a second over-read in _gx_multi_line_text_view_string_total_rows_compute() and a row of text that is not in the source.
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
Truncated JPEG marker segments and a zero chroma sampling factor in Eclipse ThreadX GUIX's software JPEG decoder can tri
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
EUVD-2026-105126
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB