Skip to main content

Zephyr ADXL345 Driver CVE-2026-79978

| EUVDEUVD-2026-109141 LOW
Out-of-bounds Write (CWE-787)
2026-10-23 zephyr
3.6
CVSS 3.1 · Vendor: zephyr
View

Attack ChainAIDerived

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

  1. Access
    Local workload co-resident with sensor streaming
  2. Delivery
    Induce RTIO block-pool starvation/fragmentation
  3. Exploit
    Allocator returns buffer smaller than 204-byte FIFO batch
  4. Execution
    Driver queues per-entry reads past clamp
  5. Persist
    DMA/bus backend writes ~186 bytes out of bounds
  6. Impact
    Corrupt 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.

Monitor Track and reassess. Why: LOW severity (CVSS 0.1-3.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 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

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 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

Vendor (zephyr) PRIMARY 3.6 LOW
AV:L/AC:H/PR:L/UI:N/S:U/C:N/I:L/A:L
vuln.today AI 3.6 LOW

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).

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

Primary rating from Vendor (zephyr).

CVSS VectorVendor: zephyr

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

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

EPSS Score
0.1%
Top 98% exploitable
Prevalence
Low
niche ADXL345 streaming driver config on specific embedded Zephyr boards
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 LOW
CISA KEV No
Public POC No
EPSS 0.1%
Patch available Yes
Active threat No
Deciding rule
LOW severity (CVSS 0.1-3.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
Low

Priority Score

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