Skip to main content

Zephyr RTOS EUVDEUVD-2026-97112

| CVE-2026-19576 MEDIUM
Out-of-bounds Write (CWE-787)
2026-10-11 zephyr
6.8
CVSS 3.1 · Vendor: zephyr
View

Attack ChainAIDerived

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

  1. Recon
    Gain physical access to target board
  2. Delivery
    Substitute or spoof GT9xx I2C controller
  3. Exploit
    Pass init probe with valid product ID and config
  4. Install
    Report touch count above configured maximum
  5. C2
    Overflow point_reg[] via 8-byte I2C reads
  6. Execute
    Overwrite gt911_process() stack with chosen data
  7. Impact
    Hijack control flow at kernel privilege

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, write limits
MITRE ATT&CK

2 techniques across 2 tactics: Execution, Privilege Escalation

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 attacker to control, substitute, or spoof the I2C touch controller that the Zephyr GT9xx driver talks to; the spoofed device must answer the driver's init probes with a supported product ID and a checksum-valid config blob, then report a touch-point count greater than CONFIG_INPUT_GT911_MAX_TOUCH_POINTS (Kconfig range 1..5, default 1) in the status register's low nibble (masked by GT911_TOUCH_POINTS_MSK 0x0F to 0..15). The practical limiting factors are: physical/local hardware access is mandatory (AV:P) with no network, USB, or syscall path; the vulnerable boards are those where the GT9xx panel is a pluggable display module or shield rather than an on-PCB part; and the condition can also be met non-adversarially by a GT9271-class panel that ignores the driver's touch-count programming and reports up to ten points, or by bus corruption of the single status byte - meaning no attacker is strictly required to trigger the overflow.

Impact

All signals point to a genuinely high technical impact but a sharply constrained real-world risk. The provided CVSS:3.1 vector (6.8, Medium) encodes the critical limiter: AV:P means physical/local hardware access is required - the description explicitly states there is no network, USB, or syscall path to the defect, which is consistent with AV:P. With AC:L/PR:N/UI:N the attack is easy and needs no authentication once physical hardware access is achieved, and C:H/I:H/A:H reflects a stack out-of-bounds write of fully attacker-chosen content at kernel privilege (control-flow hijack potential). SSVC-style reasoning: technical impact is total, but exploitation is NOT automatable - it requires physically substituting or spoofing the I2C touch controller. EPSS is not provided, there is no CISA KEV listing, and no public exploit is identified in the input, so there is no evidence of active or at-scale exploitation. This is therefore a real but targeted/physical-access priority rather than a widespread remote threat - worth patching on affected embedded devices but not an emergency for fleets lacking the vulnerable touch hardware. One notable nuance the vendor flags: the overflow can also occur NON-adversarially with a GT9271-class panel that reports up to ten points or via bus corruption of the single status byte, raising reliability/robustness risk even absent an attacker. EPSS score is missing, so widespread-exploitation probability cannot be independently confirmed.

Exploit ScenarioDerived

An attacker with physical access to an embedded board that uses a pluggable GT9xx touch panel or shield swaps in a malicious or spoofed I2C device that passes the driver's init probes with a supported product ID and a checksum-valid config blob. The spoofed controller then reports more touch points than CONFIG_INPUT_GT911_MAX_TOUCH_POINTS allows, so each per-point 8-byte I2C read writes attacker-chosen data past the end of point_reg[] on the gt911_process() stack frame, enabling control-flow hijack at kernel privilege. No public exploit code is identified at time of analysis, and the physical attack vector (AV:P) with low complexity means the practical barrier is hardware access, not technical skill.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 11, 2026

An out-of-bounds stack write in the Zephyr RTOS Goodix GT9xx touch driver (drivers/input/input_gt911.c) lets a malicious or misbehaving I2C touch controller overwrite up to 112 bytes of the gt911_process() stack frame with attacker-chosen data running at kernel privilege, potentially hijacking control flow on the host microcontroller. Only systems built with the GT9xx driver are affected, and reaching the defect requires physical/local access to the I2C bus (AV:P) - there is no network, USB, or syscall path - most plausibly on boards where the panel is a pluggable display module or shield rather than a soldered part. No public exploit code has been identified at time of analysis and the issue is not in CISA KEV, though the fix is a small one-line clamp and the same overflow can occur non-adversarially with a GT9271-class panel or a single corrupted status byte.

RemediationAI

Upstream fix available (PR/commit); released patched version not independently confirmed - the canonical remediation is to apply the Zephyr fix commit 42b52d571eb2113012c135276693042fd372fdea, which clamps the reported touch-point count with min(status & GT911_TOUCH_POINTS_MSK, CONFIG_INPUT_GT911_MAX_TOUCH_POINTS) before it is used as a loop bound, or to update to a downstream release that includes it; see advisory GHSA-p7qh-fvwx-f7vr for vendor guidance. Where patching is not immediately possible, raise CONFIG_INPUT_GT911_MAX_TOUCH_POINTS to its maximum of 5, which shrinks the maximum overrun from roughly 112 bytes to about 80 bytes but does not eliminate the defect, and note it increases per-call stack usage with no functional benefit for genuine GT911 panels that report at most five points. Because the attack requires controlling or substituting the I2C controller, harden the physical layer: prefer soldering the panel or use a locked/glued connector instead of pluggable modules and shields, and isolate or filter the GT9xx I2C bus where feasible. Bus-integrity measures (proper pull-ups, shorter traces, lower bus speed) reduce the non-adversarial trigger from corruption of the single status byte. If the touch panel is not required, disabling the GT9xx driver entirely removes the attack surface; this trades away touch input functionality.

Affected VersionsENISA

Zephyr 4.0.0 ≤4.4.2

Affected Packages

euvd zephyr 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 Zephyr GT9xx input driver (input_gt911.c) communicates with the Goodix touch controller over I2C. During gt911_process(), the driver reads a status register, masks the low nibble with GT911_TOUCH_POINTS_MSK (0x0F) to obtain a reported touch-point count in the range 0..15, and uses that value directly as the loop bound for filling point_reg[], a stack array sized by CONFIG_INPUT_GT911_MAX_TOUCH_POINTS. That Kconfig symbol is constrained to 1..5 with a default of 1, so a count above the configured maximum writes past the end of the array: every iteration performs an I2C read of eight bytes directly into point_reg[i], so up to 112 bytes of peer-supplied data can be written over the gt911_process() stack frame in the system workqueue thread, followed by two further loops that read out of bounds from the same array. The root cause is CWE-787 (out-of-bounds write) - a classic missing bounds check where the driver relied solely on a comment asserting the controller was programmed at init to never report more points than configured. The upstream fix adds an include of <zephyr/sys/minmax.h> and clamps the value with min(status & GT911_TOUCH_POINTS_MSK, CONFIG_INPUT_GT911_MAX_TOUCH_POINTS) before any array indexing.

Know when Zephyr 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 (zephyr) PRIMARY 6.8 MEDIUM
AV:P/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 6.8 MEDIUM

Physical access to the I2C bus/controller (AV:P), low complexity with no auth or user interaction once connected, and a kernel-privilege stack overwrite yielding full C/I/A impact.

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

Primary rating from Vendor (zephyr).

CVSS VectorVendor: zephyr

Attack Vector
Physical
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
High

DescriptionCVE.org

The Goodix GT9xx input driver in drivers/input/input_gt911.c reads the touch point count from the controller's status register and masks it with GT911_TOUCH_POINTS_MSK (0x0F), yielding a value of 0..15. In gt911_process() that value is used directly as the loop bound for filling point_reg[], a stack array sized to CONFIG_INPUT_GT911_MAX_TOUCH_POINTS, whose Kconfig range is 1..5 with a default of 1. No other check constrains the count; the driver relied only on a comment asserting that the controller had been programmed at init to report no more points than configured.

Each loop iteration issues an I2C read of eight bytes straight into point_reg[i], so a controller that reports more points than the array holds causes up to 112 bytes of peer-supplied data to be written past the end of the array, over the stack frame of gt911_process() in the system workqueue thread. Two further loops then read out of bounds from the same array. Triggering it requires control of, or the ability to substitute, the I2C touch controller - plausible on the many supported boards where the GT9xx panel is a pluggable display module or shield rather than an on-PCB part; a spoofed device need only answer the init probes with a supported product ID and a checksum-valid config blob. The same overflow can also occur non-adversarially, with a GT9271-class panel that ignores the driver's touch-count programming and reports up to ten points, or with bus corruption of the single status byte.

The impact is an out-of-bounds stack write with fully attacker-chosen content executing at kernel privilege, i.e. potential control-flow hijack on the host MCU, in addition to out-of-bounds reads and crashes. The attack vector is physical/local hardware access only; there is no network, USB, or syscall path to the defect. The fix clamps the reported count with min() against CONFIG_INPUT_GT911_MAX_TOUCH_POINTS before any array indexing.

Threat Intelligence Overview

EPSS Score
0.2%
Top 94% exploitable
Prevalence
Low
niche embedded touch-controller driver in Zephyr RTOS; requires specific GT9xx hardware
Social Media
1
Sightings
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 Yes
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· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact· derived
Medium

Priority Score

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

Memory corruption occurs when a program writes data beyond the boundaries of allocated memory regions or accesses memory in unintended ways, violating the integrity of the process's address space.

More in Zephyr

View all
CVE-2023-4260 CRITICAL POC
10.0 Sep 27

Potential off-by-one buffer overflow vulnerability in the Zephyr fuse file system. Rated critical severity (CVSS 10.0),

CVE-2026-1678 CRITICAL POC
9.8 Mar 05

An out-of-bounds write in the Zephyr RTOS DNS resolver (dns_unpack_name()) lets a crafted DNS response corrupt memory on

CVE-2023-5055 CRITICAL POC
9.8 Nov 21

Possible variant of CVE-2021-3434 in function le_ecred_reconf_req. Rated critical severity (CVSS 9.8), this vulnerabilit

CVE-2023-4257 CRITICAL POC
9.8 Oct 13

Unchecked user input length in /subsys/net/l2/wifi/wifi_shell.c can cause buffer overflows. Rated critical severity (CVS

CVE-2023-3725 CRITICAL POC
9.8 Oct 06

Potential buffer overflow vulnerability in the Zephyr CAN bus subsystem. Rated critical severity (CVSS 9.8), this vulner

CVE-2021-3323 CRITICAL POC
9.8 Oct 12

Integer Underflow in 6LoWPAN IPHC Header Uncompression in Zephyr. Rated critical severity (CVSS 9.8), this vulnerability

CVE-2021-3625 CRITICAL POC
9.8 Oct 05

Buffer overflow in Zephyr USB DFU DNLOAD. Rated critical severity (CVSS 9.8), this vulnerability is remotely exploitable

CVE-2021-3319 CRITICAL POC
9.8 Oct 05

DOS: Incorrect 802154 Frame Validation for Omitted Source / Dest Addresses. Rated critical severity (CVSS 9.8), this vul

CVE-2018-1000800 CRITICAL POC
9.8 Sep 06

zephyr-rtos version 1.12.0 contains a NULL base pointer reference vulnerability in sys_ring_buf_put(), sys_ring_buf_get(

CVE-2023-4264 CRITICAL POC
9.6 Sep 27

Potential buffer overflow vulnerabilities n the Zephyr Bluetooth subsystem. Rated critical severity (CVSS 9.6), this vul

CVE-2024-1638 CRITICAL POC
9.1 Feb 19

The documentation specifies that the BT_GATT_PERM_READ_LESC and BT_GATT_PERM_WRITE_LESC defines for a Bluetooth characte

CVE-2023-5753 HIGH POC
8.8 Oct 25

Potential buffer overflows in the Bluetooth subsystem due to asserts being disabled in /subsys/bluetooth/host/hci_core.c

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