Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessLocal workload co-resident with sensor streaming
-
DeliveryInduce RTIO block-pool starvation/fragmentation
-
ExploitAllocator returns buffer smaller than 204-byte FIFO batch
-
ExecutionDriver queues per-entry reads past clamp
-
PersistDMA/bus backend writes ~186 bytes out of bounds
-
ImpactCorrupt neighbouring RTIO buffers or crash
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 | Requires a board with an interrupt-wired ADXL345 accelerometer, firmware built with CONFIG_ADXL345_STREAM, and an RTIO streaming configuration whose mempool block granularity is smaller than a full 204-byte FIFO batch - explicitly the sensor shell's RTIO_DEFINE_WITH_MEMPOOL(sensor_read_rtio, 8, 8, 32, 64, 4) (64-byte blocks) driven by 'sensor stream <dev> on fifo_wm incl', or the documented 16-byte-block streaming example. The out-of-bounds write is then triggered by RTIO block-pool starvation or fragmentation (the allocator returning a truncated buffer), which a co-resident local workload can induce and which also occurs spontaneously under load; a companion bug (fifo_total_bytes un-reset at batch start) can carry a stale offset after an aborted/errored chain. Limiting factors: strictly local - there is no network, USB or radio path; low local privileges are needed (PR:L); it is confined to specific ADXL345 streaming hardware/build configurations; and the corruption is uncontrollable (sample data at the allocation tail), so it yields no reliable exploitation primitive, only corruption or crashes. |
| Impact | All signals point to a low-priority, locally-scoped memory-safety defect. The CVSS 3.1 vector (AV:L/AC:H/PR:L/UI:N/S:U/C:N/I:L/A:L, base 3.6 Low) describes a local-only, high-complexity flaw requiring low privileges, with no confidentiality impact and only limited integrity/availability impact - and the description independently confirms there is 'no network, USB or radio path to this code.' The vuln.today Decision label is 'monitor,' the lowest urgency tier, which is consistent with the low CVSS. No EPSS score was supplied and the CVE is NOT in CISA KEV, so there is no exploitation-probability or active-exploitation signal; no PoC or exploit reference is present either, so this is no public exploit identified at time of analysis. The complexity driver (AC:H) is grounded in evidence: exploitation needs RTIO block-pool starvation/fragmentation, a condition a co-resident workload can induce but that also 'occurs spontaneously under load' - i.e. largely outside precise attacker control. Critically, the advisory states 'there is no controllable corruption primitive': the overwritten bytes are accelerometer samples written at the allocation's tail, so this cannot be steered into a reliable code-execution or privilege-escalation primitive; the realistic impact is silent corruption of other RTIO consumers' buffers or a crash. Net: a genuine out-of-bounds write (CWE-787) worth patching in affected embedded builds, but not an emergency - the low real-world risk is coherent across CVSS, the 'monitor' decision, absence of KEV/EPSS/PoC, and the uncontrollable nature of the corruption. |
| Exploit ScenarioDerived | On a board with an interrupt-wired ADXL345 built with CONFIG_ADXL345_STREAM, a co-resident local workload (or ordinary load) starves/fragments the shared RTIO block pool so the allocator returns a buffer smaller than a full 204-byte FIFO batch. The driver still queues one 6-byte bus read per hardware FIFO entry, and the I2C/SPI RTIO backend (often DMA) writes up to 186 bytes past the allocation, corrupting neighbouring live buffers or memory beyond the pool and causing silent data corruption or a crash. No public exploit code is identified, and because the written bytes are just accelerometer samples at the tail of the allocation there is no controllable corruption primitive. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 23, 2026
Out-of-bounds write in the Zephyr ADXL345 RTIO streaming path (drivers/sensor/adi/adxl345/adxl345_stream.c) affects builds from 4.0.0 through 4.4.2 that enable CONFIG_ADXL345_STREAM on a board with an interrupt-wired ADXL345. The completion callback clamps the reported read length to the buffer actually granted by rtio_sqe_rx_buf(), but then queues one 6-byte bus read per hardware FIFO entry at consecutive offsets bounded by the device-reported entry count, so a truncated allocation causes up to 186 bytes written past the end of the block-pool buffer; a companion defect that failed to reset fifo_total_bytes at batch start can carry a stale offset into the next batch. Exposure is strictly local with high attack complexity and low privileges (CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:N/I:L/A:L, score 3.6); the written data is accelerometer sample content at the allocation tail, so the realistic outcome is corruption of neighbouring RTIO consumers' buffers or a crash rather than a controllable primitive. No public exploit code has been identified at time of analysis, the issue is not in CISA KEV, and vendor fixes are merged on main and both release branches with a projected fixed release of 4.5.0.
RemediationAI
Apply the upstream fix or upgrade: the correcting commit is 3451bb1e1e9165844060551164adb8a756e7b6b7 (PR #116003 on main), backported via PR #117498 to v4.4-branch and PR #117497 to v4.3-branch, with version 4.5.0 projected as the first release containing the change - confirm against the actual release notes, since the vendor advisory describes that version as a forecast. The patch bounds the read loop and the completion-callback attachment by read_samples = read_len / sample_set_size and resets fifo_total_bytes at batch start, so total bytes written never exceed read_len <= buf_avail. Where updating is not immediately possible, the advisory's own analysis identifies the precondition to remove: avoid RTIO streaming configurations whose mempool block granularity is below the 204-byte full FIFO batch. Concretely, either enlarge the mempool block size so a full batch fits in one contiguous run (at the cost of more RAM per block and fewer usable blocks), or stop driving the streaming path through small-block pools such as the sensor shell's 64-byte-block RTIO_DEFINE_WITH_MEMPOOL(sensor_read_rtio, 8, 8, 32, 64, 4) configuration and the 16-byte-block documentation example, which removes the truncated-allocation path at the cost of losing that low-memory streaming arrangement. Builds without CONFIG_ADXL345_STREAM, or boards without an interrupt-wired ADXL345, do not reach the vulnerable code. Note that a truncated allocation is a designed behaviour of rtio_block_pool_alloc(), so pool fragmentation and consumer back-pressure cannot be relied on as a safeguard; the vendor's complete fix is the code change above. Full details: https://github.com/zephyrproject-rtos/zephyr/security/advisories/GHSA-4v56-r4qm-v964.
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 ADXL345 driver uses Zephyr's RTIO subsystem for streaming FIFO reads. rtio_sqe_rx_buf() hands the driver either a caller-supplied buffer or a mempool block, and rtio_block_pool_alloc() intentionally degrades the request one block at a time until a contiguous run is available, so a short buffer is a normal, first-class outcome under fragmentation. The driver's minimum requirement is only sizeof(struct adxl345_fifo_data) + 6 bytes (min_read_size 18), while a full FIFO batch is 204 bytes; fifo_samples is a 6-bit device register field (SAMPLE_MASK 0x3F, SAMPLE_SIZE 6), so the device can report 192-378 bytes of pending data. The pre-fix loop iterated over the device-reported fifo_samples rather than over read_len / sample_set_size, issuing one 6-byte I2C/SPI RTIO read per entry at read_buf + fifo_total_bytes, which the I2C/SPI backend (DMA on many SoCs) executes directly into the shared RTIO block pool - corrupting neighbouring live buffers, or memory beyond the pool for pools smaller than one batch. The unrelated companion bug left fifo_total_bytes un-reset when a new batch started, so an aborted or errored chain could leave a stale write offset that pushes the following batch out of bounds too. The root cause class is CWE-787 (out-of-bounds write), a mismatch between the clamped length and the loop bound. The fix computes read_samples = read_len / sample_set_size, uses it to bound both the read loop and the completion-callback attachment, and resets fifo_total_bytes at batch start. Sibling drivers adxl362, adxl372 and adxl355 issue a single read bounded by read_len, confirming the adxl345 loop was the outlier. The corruption is not a controllable primitive: the bytes written are sensor samples and the destination follows the allocation, and because the block pool lives in K_APP_BMEM(rtio_partition) under CONFIG_USERSPACE, there is no clean user-to-kernel escalation path.
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:L/AC:H/PR:L/UI:N/S:U/C:N/I:L/A:L
Local-only path (AV:L), no attacker control over pool starvation so AC:H, low local privilege to run a co-resident workload (PR:L); no confidentiality (C:N), only limited data corruption/crash (I:L/A:L).
Primary rating from Vendor (zephyr).
CVSS VectorVendor: zephyr
DescriptionCVE.org
The RTIO streaming completion callback adxl345_process_fifo_samples_cb() in drivers/sensor/adi/adxl345/adxl345_stream.c clamps the amount of FIFO data it will report (read_len = MIN(fifo_bytes, buf_avail)) to the space actually returned by rtio_sqe_rx_buf(), but then queues one 6-byte bus read per hardware FIFO entry at consecutive offsets from read_buf, bounded by the device-reported entry count rather than by the clamp. When the allocated buffer is smaller than a full batch, the driver writes up to 186 bytes past the end of the allocation; a companion defect left data->fifo_total_bytes un-reset at batch start, so an aborted or errored chain could leave a stale write offset that pushes the next batch's writes out of bounds as well.
A short buffer is an expected, first-class outcome of the RTIO allocator: rtio_block_pool_alloc() walks the requested size down one block at a time until a contiguous run is available, and the driver only demands sizeof(struct adxl345_fifo_data) + 6 bytes as its minimum. Any streaming configuration whose mempool block granularity is smaller than a full FIFO batch (204 bytes) - for example the sensor shell's RTIO_DEFINE_WITH_MEMPOOL(sensor_read_rtio, 8, 8, 32, 64, 4) used by sensor stream <dev> on fifo_wm incl, or the 16-byte-block streaming example in the documentation - takes this path whenever the pool is fragmented or the consuming thread falls behind.
The out-of-bounds writes are performed by the I2C/SPI RTIO backend (DMA on many SoCs) into the shared RTIO block pool, corrupting neighbouring live buffers or, for a pool smaller than one batch, memory beyond the pool itself. The written bytes are accelerometer samples and the destination follows the allocation, so there is no controllable corruption primitive: the realistic impact is silent corruption of other RTIO consumers' data or a crash. Reaching it requires a board with an interrupt-wired ADXL345 built with CONFIG_ADXL345_STREAM, plus buffer-pool starvation, which a co-resident local workload can induce but which also occurs spontaneously under load; there is no network, USB or radio path to this code.
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.
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.
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-109141
NVD
CVE.org
EPSS
GitHub
Exploit-DB