Skip to main content

Zephyr RTOS CVE-2026-19676

| EUVDEUVD-2026-107481 HIGH
Untrusted Pointer Dereference (CWE-822)
2026-10-21 zephyr
7.8
CVSS 3.1 · Vendor: zephyr
View

Attack ChainAIDerived

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

  1. Access
    Obtain user-mode thread granted PECI device
  2. Delivery
    Craft peci_msg with kernel pointer in rx/tx buffer
  3. Exploit
    Call peci_transfer() past weak verifier
  4. Execution
    Driver dereferences buffer in supervisor mode
  5. Persist
    Arbitrary kernel read/write primitive
  6. Impact
    Code execution at supervisor privilege

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Untrusted pointer prevention
Exploitation Conditions

Exploitation requires ALL of: CONFIG_USERSPACE=y; exactly one of the PECI drivers enabled (CONFIG_PECI_NPCX, CONFIG_PECI_XEC, or CONFIG_PECI_ITE_IT8XXX2); and local code execution in a user-mode thread that has been granted the PECI device object via the standard device-granting mechanism. The concrete trigger is a peci_transfer() call whose embedded struct peci_buf members (tx_buffer/rx_buffer) carry caller-controlled buf pointers and len values that, pre-patch, were passed unchecked into the driver. Limiting factors that reduce realistic risk: the attack is local only (no network reachability), the attacker must already possess a granted PECI device handle (not default for arbitrary user threads), and the target build must enable USERSPACE together with a vulnerable PECI driver - platforms without PECI hardware/driver are unaffected.

Impact

All signals point to a genuine, high-integrity local privilege-escalation flaw rather than a mass-exploitable internet threat. The CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, base 7.8) is internally consistent with the description: exploitation is LOCAL (AV:L), of LOW complexity (AC:L - no race or special timing, just crafted pointers), and requires LOW privileges (PR:L) because the attacker must already run as a user-mode thread that has been granted the PECI device object. The C:H/I:H/A:H triad is well justified - the description gives an arbitrary kernel READ (confidentiality, disclosed to a PECI bus observer), an arbitrary kernel WRITE leading to supervisor code execution (integrity), and a trivially reachable supervisor fault (availability). No EPSS score, KEV listing, or SSVC decision data was supplied, and there is no indication of public exploit code, so exploitation-probability signals are ABSENT rather than low - read this as 'likelihood unknown,' not 'safe.' This is a real priority for anyone shipping Zephyr with CONFIG_USERSPACE and a PECI driver, since it defeats the userspace sandbox that is the entire security promise of CONFIG_USERSPACE; but it is NOT remotely wormable - the local-only vector and the prerequisite of already holding the PECI device object sharply bound the realistic attacker population. One conflict to flag explicitly: the 'RCE' tag implies remote code execution, yet the CVSS vector is AV:L and the description describes LOCAL code execution escalating to supervisor privilege - treat this as a local sandbox escape / privilege escalation, not network RCE.

Exploit ScenarioDerived

A low-privileged user-mode Zephyr application that has legitimately been granted the PECI device object (the normal way CONFIG_USERSPACE exposes a device) invokes peci_transfer() with a crafted struct peci_msg whose rx_buffer.buf points at kernel memory and whose len is attacker-chosen. Because the pre-patch z_vrfy_peci_transfer() validated only the device handle and the outer struct, the driver dereferences those pointers in supervisor mode, yielding an arbitrary kernel write (hardware bytes written into kernel memory) and an arbitrary kernel read (kernel memory pushed onto the PECI/eSPI out-of-band bus). No public exploit identified at time of analysis, though the primitive is straightforward given the low attack complexity.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.1% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 21, 2026

User-mode-to-kernel escape in Zephyr RTOS lets a local thread that holds a granted PECI device object turn peci_transfer() into arbitrary supervisor-mode read and write primitives. The syscall verifier z_vrfy_peci_transfer() validated only the outer struct peci_msg and then handed the caller-controlled tx_buffer/rx_buffer pointers and lengths to in-tree drivers (NPCX, IT8xxx2, MCHP XEC), which dereference them in supervisor mode - allowing kernel memory to be overwritten with hardware-supplied bytes, kernel contents to be pushed onto the PECI/eSPI bus, or a supervisor fault via an unmapped address. Scoring is CVSS 3.1 7.8 (AV:L/PR:L, C:H/I:H/A:H) and exploitation is gated on CONFIG_USERSPACE=y, an enabled vulnerable PECI driver, and local code execution in a thread already granted the PECI device; no public exploit code exists at time of analysis and there is no confirmed active exploitation (CISA KEV).

RemediationAI

Vendor-released fix: apply commit d7faf323d52b7e8845a63b1f854a82bdda44c261 in drivers/peci/peci_handlers.c, tracked by advisory GHSA-g66q-frxm-3hfg; upstream fix is available as a commit, and a tagged release containing it was not independently confirmed from the supplied data, so verify the commit is present in your Zephyr tree or vendor SDK before assuming you are patched. The fix is small enough to backport: it adds K_SYSCALL_MEMORY_READ over tx_buffer.buf with length len - 1 and a size_add_overflow()-guarded K_SYSCALL_MEMORY_WRITE over rx_buffer.buf, so any fork of the driver must carry both checks, not just one. Compensating controls where patching is not yet possible: remove the user-mode grant on the PECI device (drop the DT_/device-grant entry or the userspace device-granting call) so no user thread can reach peci_transfer() - trade-off is that the PECI consumer must move into supervisor mode or into a privileged helper; disable the PECI driver entirely (CONFIG_PECI_NPCX, CONFIG_PECI_XEC, CONFIG_PECI_ITE_IT8XXX2) if out-of-band telemetry is not required - trade-off is loss of PECI/eSPI platform telemetry; or build without CONFIG_USERSPACE so the verifier path is not a security boundary - trade-off is loss of all userspace isolation across the product, so this is only viable for deeply constrained images. Do not rely on limiting PECI bus peer access as a mitigation: the vulnerability is the kernel-side pointer dereference, not the bus transaction.

Affected VersionsENISA

Zephyr 2.3.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

Zephyr's user-mode syscall layer splits each syscall into an implementation and a z_vrfy_* verifier that runs in supervisor mode to validate user-supplied arguments before the driver touches them. In drivers/peci/peci_handlers.c, z_vrfy_peci_transfer() copied the caller's struct peci_msg with k_usermode_from_copy(), which validates only the outer structure - the buf pointers and len values inside the embedded struct peci_buf members tx_buffer and rx_buffer stayed fully caller-controlled. That is CWE-822 (untrusted pointer offset / untrusted pointer dereference): a pointer value from an untrusted domain is dereferenced without an address-space or bounds check. Every in-tree PECI driver then dereferences those pointers from supervisor context - peci_npcx_transfer() in drivers/peci/peci_npcx.c and peci_it8xxx2_transfer() in drivers/peci/peci_ite_it8xxx2.c write hardware-supplied bytes into rx_buffer.buf[i] and read command bytes from tx_buffer.buf[i], and peci_xec_read()/peci_xec_write() in drivers/peci/peci_mchp_xec.c do the same with no bound on rx_buffer.len at all. Because the verifier is the security boundary between unprivileged threads and kernel memory under CONFIG_USERSPACE, the missing K_SYSCALL_MEMORY_READ()/K_SYSCALL_MEMORY_WRITE() checks convert a routine hardware transaction into an arbitrary kernel read/write primitive. The upstream fix is the verification logic itself: it checks the TX buffer with K_SYSCALL_MEMORY_READ (len - 1, since the frame-check-sequence byte is appended), and checks the RX buffer with size_add_overflow() to account for the added FCS byte before K_SYSCALL_MEMORY_WRITE - the overflow guard matters because a len of SIZE_MAX would otherwise wrap to zero and pass a naive size check.

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 7.8 HIGH
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 7.8 HIGH

Local syscall abuse (AV:L), no special timing (AC:L), requires a granted PECI device handle so PR:L not PR:N; arbitrary kernel read/write/fault gives C:H/I:H/A:H.

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

Primary rating from Vendor (zephyr).

CVSS VectorVendor: zephyr

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

DescriptionCVE.org

The user-mode verifier for the peci_transfer() system call, z_vrfy_peci_transfer() in drivers/peci/peci_handlers.c, checked only the device object permission and copied the caller-supplied struct peci_msg with k_usermode_from_copy(). That copy validates the outer structure only; the buf pointers and len values inside the embedded struct peci_buf members tx_buffer and rx_buffer remained fully caller-controlled and were passed unchecked to the driver.

Every in-tree PECI driver dereferences those pointers in supervisor mode: peci_npcx_transfer() in drivers/peci/peci_npcx.c and peci_it8xxx2_transfer() in drivers/peci/peci_ite_it8xxx2.c copy hardware bytes into rx_buffer.buf[i] and read command bytes out of tx_buffer.buf[i], and peci_xec_read()/peci_xec_write() in drivers/peci/peci_mchp_xec.c do the same with no bound on rx_buffer.len at all. A user-mode thread that has been granted the PECI device object - the normal way an application exposes a device under CONFIG_USERSPACE - could therefore point rx_buffer.buf at kernel data structures and have the driver write hardware-supplied bytes there, or point tx_buffer.buf at kernel memory and have its contents pushed onto the PECI/eSPI out-of-band bus.

The impact is a full user-mode-to-kernel escape: an arbitrary kernel write primitive (integrity and, through it, code execution at supervisor privilege), an arbitrary kernel read disclosed to a PECI bus observer, and a trivially reachable supervisor-mode fault if an unmapped address is supplied. Exploitation requires CONFIG_USERSPACE=y, one of the PECI drivers enabled (CONFIG_PECI_NPCX, CONFIG_PECI_XEC or CONFIG_PECI_ITE_IT8XXX2), and local code execution in a user-mode thread holding the PECI device.

The fix adds K_SYSCALL_MEMORY_READ() and K_SYSCALL_MEMORY_WRITE() checks over the two embedded buffers, with a size_add_overflow() guard on the frame-check-sequence byte accounted for in the RX length.

Technical POC Analysis

CWE-822 (Untrusted Pointer Dereference).

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Executive ViewAI

Why It Matters

Zephyr RTOS products that grant user-mode threads access to PECI hardware can be driven from a local compromise into full kernel-level control, putting device confidentiality and integrity at risk. Exposure is limited to builds that enable userspace and one of the affected PECI drivers, but for those products a local foothold can become a platform-wide compromise. No public exploit has been identified at time of analysis, so priority should be driven by affected fleet exposure and patchability rather than observed attacks.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.1%
Top 99% exploitable
Prevalence
Low
embedded RTOS; vulnerable surface needs niche USERSPACE+PECI driver config
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 HIGH
CISA KEV No
Public POC No
EPSS 0.1%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.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
Scheduled
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact
High

Priority Score

39
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +39
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

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