Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
ReconShare one net_buf across contexts
-
DeliveryTwo holders unref concurrently
-
ExploitBoth read same refcount value
-
InstallBoth perform final free
-
C2Double free of block
-
ExecuteHeap metadata corruption and UAF
-
ImpactDevice crash or memory corruption
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Double free prevention
|
| Exploitation Conditions | Exploitation requires two concrete prerequisites drawn from the description: (1) genuine concurrency - either a CONFIG_SMP build with buffer holders on different CPUs, or a single-core build where preemption lands between the non-atomic refcount load and store while another context unrefs the same buffer; and (2) an application architecture that shares one net_buf among multiple independent unref'ers (e.g. buffers passed via k_fifo, zbus multi-subscriber delivery, or the IP stack RX/TX path with CONFIG_NET_BUF_FIXED_DATA_SIZE=n). The double-free of the underlying data block additionally requires a heap/variable-data pool (mem_pool_data_unref/heap_data_unref) as used by zbus, capture, WireGuard, ISO-TP and usbip; fixed-data pools (Bluetooth, default networking) instead suffer free-list corruption via the per-header refcount. Limiting factors that reduce realistic risk: the trigger is a refcount/timing race, not attacker-controlled packet content, so an external attacker has at most weak indirect influence over the race window; single-owner or lock-serialized unref designs are not affected; and the window demands precise timing (reflected in AC:H). |
| Impact | This is a genuine memory-safety defect but a lower operational priority than its 8.1 base score suggests. The published CVSS vector is AV:N/AC:H/PR:N/UI:N with C:H/I:H/A:H, yet the description is explicit that the trigger is a refcount/timing race, not packet content, and that an external attacker has 'at most weak indirect influence over the race window' - so AV:N (network) overstates attacker reachability, and a local/architecture-gated assessment (AV:L) is more faithful. Corroborating signals agree: EPSS is 0.16% (6th percentile), SSVC records Exploitation: none, Automatable: no, Technical Impact: partial, there is no CISA KEV listing and no public PoC. Exploitation is doubly gated - it requires (1) genuine concurrency (SMP, or single-core preemption at the exact non-atomic window) and (2) an application architecture that shares one buffer among multiple independent unref'ers. The high AC:H correctly reflects the required timing precision. Conflict to verify with the vendor: CVSS advertises a network vector while the description indicates the race is not attacker-content-controlled - treat this as an internal reliability/robustness hazard (crashes, heap corruption) more than a remotely weaponizable RCE primitive. |
| Exploit ScenarioDerived | On an SMP-enabled Zephyr device, two threads each hold a reference to the same net_buf received via k_fifo (for example a zbus message delivered to multiple subscribers); both call net_buf_unref() at nearly the same instant, read the same prior refcount, and both perform the final free, double-freeing the heap data block and corrupting heap metadata. The resulting use-after-free/heap corruption can crash the device or, with careful heap grooming, be steered toward memory disclosure or control-flow corruption. No public PoC is identified, and because the race is timing-driven rather than packet-content-driven (AV network but AC high), an external party has only weak, indirect influence over when the window occurs. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv5 – Jul 06, 2026
Non-atomic reference-count manipulation in the Zephyr RTOS net_buf library (lib/net_buf/buf.c) allows a double-free/use-after-free when a single buffer is shared and independently unref'd across concurrent contexts. Because buf->ref and the per-data-block ref_count were incremented/decremented with plain C operators despite the API being documented as self-synchronizing, two holders racing net_buf_unref() under SMP or single-core preemption can each conclude they hold the last reference, causing a double k_heap_free()/k_free() (heap-metadata corruption and UAF on heap-hardening poison) for heap/variable-data pools, or a double return to the pool free list for any pool type. All Zephyr releases through v4.4.0 are affected; no public exploit is identified at time of analysis and EPSS risk is low (0.16%, 6th percentile).
Earlier versions of this analysis (4)
Memory corruption in the Zephyr RTOS net_buf library (through v4.4.0) arises because both the per-header reference count (buf->ref) and the per-data-block ref_count were manipulated with non-atomic C increment/decrement operators, despite the API being documented as self-synchronizing for buffers shared across threads. Under genuine concurrency (SMP or single-core preemption), two independent holders can each observe the same reference value and both free the same buffer, causing a double k_heap_free()/k_free() with heap-metadata corruption and use-after-free, or double return of a fixed-data buffer to the pool free list. This is CWE-415 (double free); it has no public exploit identified at time of analysis, EPSS is low (0.16%, 6th percentile), and CISA SSVC records exploitation status as none.
Double-free and use-after-free in the Zephyr RTOS net_buf library (lib/net_buf/buf.c, all releases through v4.4.0) arise because both the per-header buffer reference count and the per-data-block ref_count were manipulated with non-atomic C operators despite the API being documented as self-synchronizing across threads. Under genuine concurrency - SMP or single-core preemption - two holders of the same shared buffer can each conclude they hold the last reference, causing a double k_heap_free()/k_free() (heap corruption plus UAF on heap-hardening poison for variable/heap-data pools) or a double return to the pool free list (later handing one buffer to two owners) for any pool type including the fixed-data pools used by Bluetooth and networking. There is no public exploit identified at time of analysis and EPSS is low (0.16%); exploitation is gated on internal concurrency and application architecture rather than attacker-controlled packet content, so an external attacker has at most weak indirect influence over the race window.
Double-free memory corruption in the Zephyr RTOS net_buf library (lib/net_buf/buf.c) lets concurrent buffer holders both release the same allocation, corrupting the heap and pool free lists. Any Zephyr release through v4.4.0 is affected when an application shares a single net_buf across threads (e.g. via k_fifo) and multiple contexts independently call net_buf_unref() under SMP or single-core preemption. The flaw is a non-atomic reference-count race rather than a packet-content bug, so no public exploit identified at time of analysis, EPSS is low (0.16%), and CISA SSVC records exploitation as none - but successful triggering yields heap-metadata corruption and use-after-free suitable for code execution.
Heap corruption and double-free in Zephyr's net_buf library (all releases through v4.4.0) arise from non-atomic reference count manipulation across concurrent execution contexts, enabling heap metadata corruption and use-after-free conditions on systems using SMP or preemptible scheduling. The net_buf API is documented as safe for cross-thread sharing via k_fifo, but non-atomic increments and decrements on both the per-header buf->ref and the per-data-block ref_count allow two concurrent unref'ers to both observe the same prior value and both conclude they hold the last reference. No confirmed active exploitation (no CISA KEV listing), and no public exploit code was identified at time of analysis; however, the CVSS score of 6.4 with AV:A and AC:H reflects genuine but constrained real-world risk, particularly for networked or Bluetooth-enabled IoT devices running on SMP hardware.
RemediationAI
Vendor-released patch: upgrade to Zephyr v4.5.0, which contains the fix (per EUVD the fixed version is 4.5.0); the change converts both reference counts to atomic operations in commit 9bb2878319d5f46c29ab5fe855a378d87cd75fc3 (https://github.com/zephyrproject-rtos/zephyr/commit/9bb2878319d5f46c29ab5fe855a378d87cd75fc3) and is documented in advisory GHSA-284j-5jm9-55hh (https://github.com/zephyrproject-rtos/zephyr/security/advisories/GHSA-284j-5jm9-55hh). If you cannot upgrade the whole tree, backport that single self-contained commit (net_buf.h union plus the buf.c atomic_inc/atomic_dec conversion) to your Zephyr version. As compensating controls until patched: avoid application designs where one net_buf is shared and independently net_buf_unref'd by multiple concurrent contexts - have a single owner perform the final unref, or serialize unref calls behind your own lock (trade-off: added latency and code changes); on single-core builds you can shrink the preemption window by not preempting between paired ref/unref sequences, and where feasible prefer fixed-data pools with a single-consumer handoff model, accepting that this does not eliminate the header-refcount race and is risk-reduction only, not a fix.
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
Zephyr is a widely-used real-time operating system for resource-constrained embedded and IoT devices. Its net_buf library provides reference-counted buffers passed between subsystems and threads (e.g. handed off through a k_fifo), and the public contract states each holder may independently call net_buf_unref() with no surrounding lock. Two counters exist: the per-header buf->ref inside struct net_buf, and a per-data-block ref_count at the start of each variable/heap data allocation. Both were mutated with non-atomic read-modify-write sequences (buf->ref++, if (--buf->ref > 0), if (--(*ref_count))), which is the root cause captured by CWE-415 (Double Free). Under genuine concurrency the load and store are not indivisible, so two contexts can read the same prior value and both drive the counter to the 'last reference' state. The fix overlays buf->ref in an atomic_t-sized union (packed with the write-once flags/pool_id/user_data_size bytes) and converts the data-block ref_count from uint8_t to atomic_t, replacing operations with atomic_inc/atomic_dec. Affected consumers include zbus message subscribers, the IP stack RX/TX buffers when CONFIG_NET_BUF_FIXED_DATA_SIZE=n, packet capture, WireGuard, ISO-TP, usbip, and (for the header refcount) Bluetooth and networking fixed-data pools.
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:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H
The trigger is a non-attacker-controlled timing race, so AV:L and AC:H; no privileges or user interaction are needed to reach the code path, but memory corruption yields full C/I/A impact.
Primary rating from Vendor (zephyr).
CVSS VectorNVD
Lifecycle Timeline
6DescriptionNVD
The Zephyr net_buf library (lib/net_buf/buf.c) manipulated both of its reference counts -- the per-header buf->ref and the per-data-block ref_count at the start of each variable/heap data allocation -- with plain non-atomic C operators (buf->ref++, if (--buf->ref > 0), if (--(*ref_count))). The API is documented as self-synchronizing: callers may share one buffer across threads (e.g. via k_fifo) and each holder independently calls net_buf_unref() with no surrounding lock. Under true concurrency (SMP, or single-core preemption between the non-atomic load and store while another context unrefs the same buffer), two holders can both observe the same prior reference value and both conclude they are the last reference. For heap/variable-data pools (mem_pool_data_unref/heap_data_unref, used by zbus message subscribers, the IP stack RX/TX buffers when CONFIG_NET_BUF_FIXED_DATA_SIZE=n, capture, wireguard, ISO-TP and usbip) this produces a double k_heap_free()/k_free() of the same block -- heap-metadata corruption and a use-after-free on the heap-hardening poison pattern. For the per-header refcount the buffer is returned to the pool free LIFO twice for any pool type (including fixed-data pools used by Bluetooth and networking), corrupting the free list so a later allocation hands the same buffer to two owners. The fix converts both refcounts to atomic_inc/atomic_dec (overlaying buf->ref in an atomic_t-sized union and changing the data-block refcount from uint8_t to atomic_t). Impact is gated on genuine concurrency and on an application architecture that shares one buffer among multiple independent unref'ers; the trigger is a refcount/timing race rather than packet content, so an external attacker has at most weak indirect influence over the race window. Affects all Zephyr releases through v4.4.0.
Executive ViewAI
Zephyr RTOS, deployed across IoT and embedded systems, contains a memory-safety vulnerability (CVE-2026-10653, CVSS 8.1) in buffer management that can cause system crashes, memory corruption, and potential code execution when buffers are concurrently shared between processes. Organizations operating Zephyr-based devices face risk of system instability and infrastructure failure, particularly in production IoT and embedded deployments. A patch is available; exploitation probability is currently low (0.2%), but the critical nature of buffer handling makes urgent remediation essential.
Apply vendor patch.
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
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
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-40367
NVD
CVE.org
EPSS
Vulnrichment
GitHub
VulDB
Exploit-DB