Skip to main content

Eclipse GUIX CVE-2026-91057

| EUVDEUVD-2026-105126 MEDIUM
Out-of-bounds Read (CWE-125)
2026-10-20 eclipse
4.6
CVSS 4.0 · Vendor: eclipse
View

Attack ChainAIDerived

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

  1. Access
    Supply text ending in carriage return
  2. Delivery
    Widget renders in multi-line text view
  3. Exploit
    Trigger out-of-bounds read in display_info_get
  4. Execution
    Index advances past buffer, second over-read
  5. Impact
    Disclose 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 (\r) inside a GUIX multi-line text view widget (the _gx_multi_line_text_view_* code path). The attacker must be able to control or influence the text content rendered in that widget, and - per UI:A - a user must actually render/view the widget for the over-read to trigger. Limiting factors: the vector is LOCAL (AV:L), so there is no remote/network trigger; the device must use GUIX multi-line text views; and impact is confined to a single-byte over-read plus a spurious display row (low confidentiality, low availability), with no integrity or code-execution primitive indicated by the data.

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 (\r) - inside a multi-line text view widget. When the widget computes display info, GUIX reads one byte past the end of the string buffer and may advance its index, over-reading again and rendering an extra row sourced from adjacent memory, potentially disclosing a byte of neighboring data on the device. No public proof-of-concept exists; exploitation requires local control over the displayed string and a user viewing the widget.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
No patch listed yet 0.2% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

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

Eclipse ThreadX - GUIX 0 ≤6.5.1.202602a

Affected Packages

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

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

Vendor (eclipse) PRIMARY 4.6 MEDIUM
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
vuln.today AI 4.4 MEDIUM

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.

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

Primary rating from Vendor (eclipse).

CVSS VectorVendor: eclipse

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

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

EPSS Score
0.2%
Top 95% exploitable
Prevalence
Low
niche embedded RTOS GUI library, graphics-only subset of ThreadX deployments
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.2%
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

23
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +23
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