Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessGain physical access to I3C bus
-
DeliveryAttach or emulate malicious I3C peripheral
-
ExploitInitiate rapid high-frequency IBI/hot-join requests
-
ExecutionRace ISR sys_slist_get() against workqueue sys_slist_append()
-
PersistCorrupt free-list linkage (double-hand-out or stale pointer)
-
ImpactTrigger out-of-bounds memcpy or kernel crash
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V15 - Secure Coding and Architecture Concurrency control, locking
MITRE ATT&CK
1 technique across 1 tactic: Privilege Escalation The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Physical access to the I3C bus is mandatory - the attack vector is AV:P per the CVSS vector. The attacker must control or emulate an I3C target device capable of generating high-frequency IBIs, hot-join events, or controller-role requests. The target system must be compiled with I3C support enabled (CONFIG_I3C). The race window is narrow, requiring AC:H (high complexity) timing alignment between an incoming IBI interrupt and the workqueue thread's sys_slist_append() operation; under CONFIG_SMP this window widens slightly due to true parallelism. No authentication or user interaction is required on the bus itself (PR:N, UI:N). Exploitation is limited by: physical bus access requirement, need to win a narrow timing race, and the non-deterministic nature of corruption making reliable controlled code execution unlikely. |
| Impact | The CVSS 3.1 vector CVSS:3.1/AV:P/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:L yields a score of 3.1, accurately reflecting the substantial exploitation barriers: physical access to the I3C bus and winning a narrow timing race. There is no CISA KEV listing and no public exploit code, consistent with the difficulty of achieving reliable memory corruption via a race condition on a constrained embedded bus. The most realistic impact is a crash or hang (denial of service) rather than controlled code execution, as the description itself acknowledges that memory corruption is 'possible but hard to control.' EPSS data is not provided but would be expected to be very low given the physical access requirement and target platform specificity. The Integrity:Low and Availability:Low ratings are accurate - a double-hand-out overwrites a node in flight (integrity), while a garbage-pointer dereference crashes the system (availability). Confidentiality is correctly scored at None. This is a real but low-priority issue except for systems where Zephyr-based I3C hardware is directly accessible by untrusted parties. |
| Exploit ScenarioDerived | An attacker with physical access to the target board attaches a malicious or compromised I3C peripheral device to the bus and programs it to emit rapid, precisely-timed IBIs - targeting the window when the workqueue thread is mid-way through returning a node via sys_slist_append(). If the race is won, the same work node pointer is returned to two concurrent callers; the subsequent memcpy overwrites a node still being processed, most likely crashing the Zephyr kernel. No public exploit code exists; exploitation requires hardware access and iterative timing calibration. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 31, 2026
Race condition in Zephyr RTOS's I3C IBI workqueue subsystem allows a physically-present attacker controlling an I3C peripheral to corrupt kernel memory structures, most realistically causing denial of service. The unsynchronized free-list (sys_slist_t) shared between ISR context and the workqueue handler thread creates a window where a work node can be handed to two consumers simultaneously or a garbage pointer can be dereferenced in a memcpy, producing an out-of-bounds write. No public exploit code has been identified and no CISA KEV listing exists; the patch wrapping all free-list operations in a k_spinlock is confirmed in upstream commit e87e7e2.
RemediationAI
The upstream fix is confirmed in Zephyr commit e87e7e2ac7c5ded0af3fb5934518cc5688e458cc (https://github.com/zephyrproject-rtos/zephyr/commit/e87e7e2ac7c5ded0af3fb5934518cc5688e458cc), which introduces ibi_work_alloc() and ibi_work_free() helpers each protected by a k_spinlock (ibi_work_lock), replacing all bare sys_slist_get() and sys_slist_append() calls on the free-list. A specific patched release version is not independently confirmed from available data - consult the GitHub Security Advisory GHSA-gfj5-gcxv-9jqm for the first tagged release incorporating this fix. As a compensating control where patching is not immediately possible, operators can restrict physical access to I3C bus headers and disable I3C support at build time (CONFIG_I3C=n) if the bus is not required; disabling I3C entirely eliminates the attack surface with the trade-off of losing I3C peripheral functionality.
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
I3C (Improved Inter-Integrated Circuit) is a MIPI-standardized multi-master serial bus protocol designed as an evolution of I2C for chip-to-chip communication in embedded systems. The In-Band Interrupt (IBI) mechanism allows target devices to asynchronously interrupt the bus controller. Zephyr's IBI subsystem (drivers/i3c/i3c_ibi_workq.c) pools statically allocated work nodes in a singly-linked list (sys_slist_t) to avoid heap allocation in ISR context. The root cause is CWE-362 (Race Condition due to Concurrent Access on Shared Resource): sys_slist_get() and sys_slist_append() are non-atomic, non-reentrant list operations; calling them from both ISR context (interrupt-driven enqueue helpers) and thread context (workqueue handler) with no mutual exclusion corrupts the list's head/tail/next linkage. Under CONFIG_SMP, true parallelism amplifies the window. The affected CPE cpe:2.3:a:zephyrproject:zephyr:*:*:*:*:*:*:*:* indicates all tracked Zephyr versions are considered affected.
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:H/PR:N/UI:N/S:U/C:N/I:L/A:L
Physical I3C bus access required (AV:P); narrow timing race to win (AC:H); no auth needed on bus (PR:N); no confidentiality impact from list corruption.
Primary rating from Vendor (zephyr).
CVSS VectorVendor: zephyr
DescriptionCVE.org
The I3C IBI subsystem in drivers/i3c/i3c_ibi_workq.c hands out statically-allocated work nodes through a free-list i3c_ibi_work_nodes_free implemented as a plain sys_slist_t, which provides no synchronization. The allocation helpers (i3c_ibi_work_enqueue, i3c_ibi_work_enqueue_target_irq, i3c_ibi_work_enqueue_hotjoin, i3c_ibi_work_enqueue_controller_request, i3c_ibi_work_enqueue_cb) called sys_slist_get() directly from ISR context, while the workqueue handler i3c_ibi_work_handler() returned nodes with sys_slist_append() from the workqueue thread, with no lock on either side.
Because sys_slist_get() and sys_slist_append() are neither atomic nor interrupt-safe, an IBI interrupt that fires while the workqueue thread is mid-append (or a truly parallel access under CONFIG_SMP) races on the shared list. This corrupts the list linkage: a node may be handed to two consumers, a node may be lost, or the head/tail pointers may be left inconsistent so sys_slist_get() returns a stale or garbage pointer. In the double-hand-out case the subsequent memcpy(ibi_node, ibi_work, sizeof(*ibi_node)) overwrites a node still in flight; a garbage pointer turns the same memcpy into an out-of-bounds write.
The race is driven by I3C bus traffic - IBIs, hot-joins, and controller-role requests originate from target devices on the bus, and I3C supports hot-joining devices. An attacker controlling an I3C peripheral on the board's chip-to-chip bus can generate high-frequency interrupts timed to collide with the free operation. Exploitation requires physical access to the bus and winning a narrow timing window; the most realistic impact is a crash or hang (denial of service), with memory corruption possible but hard to control.
The fix wraps all free-list sys_slist_get()/sys_slist_append() operations in the new ibi_work_alloc()/ibi_work_free() helpers, each guarded by a k_spinlock (ibi_work_lock), closing the race across ISR and thread contexts.
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.
Race conditions occur when multiple concurrent requests exploit the brief time gap between checking a condition and acting upon it (TOCTOU - Time of Check, Time of Use).
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
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-68718
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB