Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAttach or emulate malicious virtio PCIe device
-
DeliverySystem boot triggers virtio PCI driver probe
-
ExploitDriver reads attacker-crafted cap_len from PCI config space
-
ExecutionUnvalidated cap_len drives unbounded or oversized copy loop
-
PersistKernel stack corrupted with device-controlled data
-
ImpactKernel crash or arbitrary code execution in kernel mode
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 the virtio device backend - specifically, to supply a crafted cap_len byte via the PCI configuration space of a virtio PCIe device. This condition is met in two concrete scenarios: (1) a bare-metal Zephyr system where a physical or PCIe passthrough virtio device is untrusted or attacker-supplied, or (2) a confidential computing deployment where the Zephyr guest is explicitly defending against a potentially malicious hypervisor acting as the virtio device backend. The vulnerability is NOT exploitable for privilege escalation in the standard case where Zephyr runs as a guest under a trusted hypervisor, because the host backend already has full control over the guest. Triggering occurs during boot-time driver initialization (device probe), not during runtime I/O operations. The CVSS Physical attack vector (AV:P) confirms no network-based exploitation path exists. No kernel-side privileges are required (PR:N) - the constraint lies entirely on the attacker's need for device-level access, not on kernel authentication. |
| Impact | The CVSS 3.1 vector (AV:P/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:H, score 6.1) is the dominant framing signal: the Physical attack vector accurately reflects that exploitation requires controlling the virtio device backend itself, not a network path. In the most common Zephyr deployment - running as a hypervisor guest against a trusted host - the host already fully outranks the guest, so kernel stack corruption yields no practical escalation and the CVE description explicitly confirms this. The exploitable threat model is narrow: bare-metal systems with untrusted physical or PCIe passthrough hardware, or confidential computing environments. No EPSS score was supplied in the intelligence; no CISA KEV listing exists; no public exploit or POC has been identified. The integrity and availability impacts are correctly marked High because unbounded or large stack writes during kernel probe can produce code execution or a hard crash. Given the physical attack vector, the 6.1 Medium score is well-calibrated - this is not a network-exploitable mass-exploitation risk, and most Zephyr deployments in typical embedded or guest-VM postures are not exposed to the triggering condition. |
| Exploit ScenarioDerived | An attacker who controls a virtio PCIe device - either malicious physical hardware attached to a bare-metal Zephyr system, or a compromised hypervisor in a confidential computing environment - crafts a PCI capability structure with a malformed cap_len value (either below 24 bytes to trigger unsigned underflow or above the stack buffer ceiling to write up to ~228 bytes of controlled data). When Zephyr boots and the virtio PCI driver probes the device, it reads the attacker-supplied cap_len without runtime validation and executes the copy loop, corrupting the kernel stack with device-controlled content in kernel mode. Depending on stack layout, the result is a kernel crash or potential arbitrary code execution within the Zephyr kernel context. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 25, 2026
Stack buffer overflow in Zephyr RTOS's virtio PCI driver (drivers/virtio/virtio_pci.c) allows a malicious virtio device to corrupt the kernel stack with up to ~228 bytes of device-controlled data, or trigger a near-unbounded write via unsigned underflow, during boot-time device probe. All Zephyr versions are potentially affected (CPE: cpe:2.3:a:zephyrproject:zephyr:*:*:*:*:*:*:*:*) when compiled with CONFIG_ASSERT disabled, which is the production default. Exploitable scenarios are limited to bare-metal systems with untrusted physical or passthrough virtio PCIe devices, or confidential computing deployments where the Zephyr guest must be defended against a potentially malicious hypervisor. No public exploit identified at time of analysis; upstream patch is available at commit d98dacee.
RemediationAI
Apply the upstream fix at commit d98dacee24ad10c972d3b7281c9009d82ed351c9 (https://github.com/zephyrproject-rtos/zephyr/commit/d98dacee24ad10c972d3b7281c9009d82ed351c9), which introduces a runtime range check in virtio_pci_read_cap() replacing the compiled-out assert. A specific tagged Zephyr release incorporating this commit has not been independently confirmed from the available data - monitor the security advisory at https://github.com/zephyrproject-rtos/zephyr/security/advisories/GHSA-qrh3-4mvv-w667 for release version details. As a compensating control where patching is not immediately possible, prohibit attachment of untrusted virtio PCIe devices or disable virtio PCIe passthrough - this eliminates the attack vector entirely but also removes virtio device functionality. Enabling CONFIG_ASSERT in production builds is a partial mitigation that converts silent corruption into an explicit assertion failure and crash, but introduces runtime overhead and instability risk and is not a substitute for the patch.
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 vulnerability resides in virtio_pci_read_cap() within Zephyr's virtio PCI subsystem (drivers/virtio/virtio_pci.c). During driver initialization, the function reads a device-supplied cap_len byte from PCI configuration space via pcie_conf_read(). This value was validated only by assert(tmp.cap_len == cap_struct_size), which resolves to __ASSERT_NO_MSG() - a macro gated by CONFIG_ASSERT, disabled by default in production builds. Without runtime enforcement, cap_len drives a loop copying extra capability dwords into a fixed-size caller-supplied stack buffer. CWE-787 (Out-of-Bounds Write) manifests in two ways: a cap_len below the 24-byte struct virtio_pci_cap underflows the unsigned extra_data_words counter to near-SIZE_MAX, producing a practically unbounded write; a cap_len above the caller's buffer but within the 255-byte PCI cap ceiling writes up to approximately 228 bytes of attacker-controlled data past the buffer end. Both paths execute in kernel mode during boot. The commit diff confirms the fix replaces the no-op assert with an explicit runtime range check rejecting any cap_len outside [sizeof(struct virtio_pci_cap), cap_struct_size], returning false on violation.
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
AV:P/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:H
Attacker must control the virtio PCIe device backend (physical or hypervisor-level), giving AV:P; no kernel-side privileges or user interaction required; no confidentiality impact confirmed in the description.
Primary rating from Vendor (zephyr).
CVSS VectorVendor: zephyr
DescriptionCVE.org
The virtio PCI driver (drivers/virtio/virtio_pci.c) parses a device's PCI capability list during driver initialization. In virtio_pci_read_cap() the device-supplied capability length byte cap_len (read from PCI config space via pcie_conf_read()) was only checked with assert(tmp.cap_len == cap_struct_size). That assert resolves to __ASSERT_NO_MSG(), gated by CONFIG_ASSERT, which defaults off in production builds, so the value reached the copy logic completely unvalidated.
The length then drives a loop that copies extra capability dwords into a fixed-size stack buffer supplied by the caller. A cap_len below the 24-byte base struct virtio_pci_cap underflows the unsigned extra_data_words count to a near-SIZE_MAX value, producing an effectively unbounded stack write; a cap_len above the caller's buffer (up to 255) writes up to roughly 228 bytes of device-controlled data past the buffer. Both are out-of-bounds writes of attacker-controlled content executed in kernel mode during boot-time device probe.
The input originates from the virtio device. In the common deployment where Zephyr runs as a guest under a hypervisor, the device backend is the host, which already fully outranks the guest, so the bug yields no privilege escalation. The exploitable case is a virtio device that is untrusted relative to the Zephyr kernel - an untrusted or physical/passthrough virtio PCIe device on a bare-metal system, or a confidential-computing posture where the guest must defend against the host - where a malicious device can corrupt the kernel stack and potentially achieve code execution or a crash.
The fix replaces the compiled-out assert with a runtime range check rejecting cap_len outside [sizeof(struct virtio_pci_cap), cap_struct_size] before any arithmetic or copy.
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
Privilege escalation occurs when an attacker leverages flaws in access control mechanisms to gain permissions beyond what they were originally granted.
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.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
Potential off-by-one buffer overflow vulnerability in the Zephyr fuse file system. Rated critical severity (CVSS 10.0),
An out-of-bounds write in the Zephyr RTOS DNS resolver (dns_unpack_name()) lets a crafted DNS response corrupt memory on
Possible variant of CVE-2021-3434 in function le_ecred_reconf_req. Rated critical severity (CVSS 9.8), this vulnerabilit
Unchecked user input length in /subsys/net/l2/wifi/wifi_shell.c can cause buffer overflows. Rated critical severity (CVS
Potential buffer overflow vulnerability in the Zephyr CAN bus subsystem. Rated critical severity (CVSS 9.8), this vulner
Integer Underflow in 6LoWPAN IPHC Header Uncompression in Zephyr. Rated critical severity (CVSS 9.8), this vulnerability
Buffer overflow in Zephyr USB DFU DNLOAD. Rated critical severity (CVSS 9.8), this vulnerability is remotely exploitable
DOS: Incorrect 802154 Frame Validation for Omitted Source / Dest Addresses. Rated critical severity (CVSS 9.8), this vul
zephyr-rtos version 1.12.0 contains a NULL base pointer reference vulnerability in sys_ring_buf_put(), sys_ring_buf_get(
Potential buffer overflow vulnerabilities n the Zephyr Bluetooth subsystem. Rated critical severity (CVSS 9.6), this vul
The documentation specifies that the BT_GATT_PERM_READ_LESC and BT_GATT_PERM_WRITE_LESC defines for a Bluetooth characte
Potential buffer overflows in the Bluetooth subsystem due to asserts being disabled in /subsys/bluetooth/host/hci_core.c
EUVD-2026-65597
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB