Zephyr RTOS
CVE-2026-18746
MEDIUM
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach client LwM2M UDP socket (NoSec)
-
DeliveryOpen 3 incomplete Block1 writes
-
ExploitExhaust block1_contexts pool
-
ExecutionSend first block of 4th write
-
PersistTrigger NULL-pointer dereference
-
ImpactDevice crashes or resets
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A10:2025 - Mishandling of Exceptional Conditions
ASVS 5.0
V16 - Security Logging and Error Handling Null pointer safety, defensive checks
MITRE ATT&CK
1 technique across 1 tactic: Impact The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Requires a Zephyr device running the LwM2M client with CoAP block-wise transfer handling, deployed in NoSec mode (CONFIG_LWM2M_DTLS_SUPPORT disabled - which has no default, so this is a common deployment). The attacker must reach the connected UDP socket and pass its source-address filter (as an on-path or address-spoofing peer, or a bootstrap/lower-trust server); no credentials are needed when DTLS is off. The core prerequisite is exhausting the static Block1 context pool (CONFIG_LWM2M_NUM_BLOCK1_CONTEXT, default 3) by opening that many concurrent incomplete block-wise writes on distinct object paths and keeping them uncompleted (entries only reclaim on completion, failure, or 30-second aging), then sending a fourth first-block write. Limiting factors: enabling DTLS (CONFIG_LWM2M_DTLS_SUPPORT) forces authentication and blocks the unauthenticated path; the multi-request pool-exhaustion sequence raises attack complexity; impact is confined to a crash/reset with no confidentiality or integrity effect. |
| Impact | This is a real but bounded availability issue, not a critical one. The CVSS 3.1 vector (AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H, base 5.9) is internally consistent with the description: network-reachable and unauthenticated in a NoSec deployment (PR:N), but with high attack complexity (AC:H) because the attacker must first exhaust the small static Block1 context pool by opening three concurrent incomplete block-wise transfers before the fourth request reaches the unguarded NULL dereference. Impact is purely availability (A:H) - a fatal memory fault causing crash/reset; the write is a fixed low address with a value of 0-7 and is explicitly NOT a usable memory-corruption primitive, so C:N/I:N are correct. Exploitation status is 'no public exploit identified at time of analysis': there is no EPSS score, no CISA KEV listing, and no POC in the provided intelligence - the only references are the vendor commit and GHSA advisory. There are no conflicting signals between CVSS and description. The main risk nuance is that the same condition can be triggered ACCIDENTALLY by a legitimate LwM2M server running four concurrent block transfers, and the flaw is also reachable from a bootstrap or lower-trust server, which raises real-world likelihood of unintentional denial of service beyond deliberate attack. Overall: legitimate priority for embedded fleets running LwM2M in NoSec mode, but the crash-only impact and AC:H keep it at low-to-medium urgency. |
| Exploit ScenarioDerived | In a NoSec LwM2M deployment (DTLS not enabled, which is not a default), an on-path or address-spoofing attacker who can reach the client's UDP socket sends three CoAP block-wise WRITE/CREATE requests with the More bit set on three distinct object paths and leaves them incomplete, filling the default 3-entry block1_contexts pool. A fourth first-block WRITE on a new path then hits init_block_ctx()'s NULL-return path, and the unguarded store dereferences NULL, faulting the device into a crash or reset. No public exploit code is available, and the same sequence can also be triggered inadvertently by a legitimate server running four concurrent block transfers. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 29, 2026
Denial of service in the Zephyr RTOS LwM2M client: the CoAP Block1 write handler can be driven into a NULL pointer dereference that crashes or resets the device. Affected are Zephyr builds using the LwM2M engine with block-wise transfer handling, particularly NoSec deployments where CONFIG_LWM2M_DTLS_SUPPORT is disabled (it has no default, so this is a common configuration); an unauthenticated remote peer that can reach the LwM2M UDP socket - an on-path or address-spoofing attacker, or a bootstrap/lower-trust server - first exhausts the static Block1 context pool (CONFIG_LWM2M_NUM_BLOCK1_CONTEXT, default 3) with three incomplete block-wise writes, then sends a fourth first-block write to hit the unguarded store. The assessed impact is availability only (AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H, CVSS 5.9), and no public exploit code was identified at time of analysis; the multi-request pool-exhaustion sequence is the main factor keeping complexity high.
RemediationAI
Upstream fix available (PR/commit); released patched version not independently confirmed - apply Zephyr commit e61790f776863032925e96819f84cafc9a958b8a (or backport its guard) so that block_ctx is null-checked before block_ctx->ctx.block_size is stored, as detailed in advisory GHSA-4q9g-2mhh-m7w7. Where firmware updates cannot be deployed immediately, the most effective mitigation is enabling CONFIG_LWM2M_DTLS_SUPPORT, which enforces authentication and removes the unauthenticated path - at the cost of provisioning credentials, extra handshake/flash/RAM overhead, and possible unsuitability on the most constrained parts. Increasing CONFIG_LWM2M_NUM_BLOCK1_CONTEXT above the default of 3 raises the number of concurrent incomplete transfers required to exhaust the pool, but it only shifts the threshold and consumes additional static RAM per entry. Restricting network reachability to the LwM2M socket (ACL/firewall or placing the client on a segmented network) reduces exposure to off-path attackers but does not defeat an on-path or address-spoofing peer, since the connected UDP socket's source-address filter is the only barrier in NoSec mode. As a resilience rather than a fix measure, ensure a watchdog is configured to reboot promptly after the inevitable fault, accepting that the crash itself still constitutes the denial of service.
Affected ProductsAI
Zephyr RTOS builds that include the LwM2M library and block-wise transfer handling - specifically subsys/net/lib/lwm2m/lwm2m_message_handling.c prior to the upstream fix commit e61790f776863032925e96819f84cafc9a958b8a. Risk is highest for devices configured with CONFIG_LWM2M_DTLS_SUPPORT disabled (the option has no default, making NoSec deployments common) and with the default small Block1 pool of CONFIG_LWM2M_NUM_BLOCK1_CONTEXT=3; the same code path is reachable from a bootstrap or lower-trust LwM2M server and can also be triggered accidentally by a legitimate server running four concurrent block transfers. No CPE strings were supplied with the available intelligence, so exact affected release tags and version ranges should be confirmed against the upstream advisory GHSA-4q9g-2mhh-m7w7 and the Zephyr release notes.
Affects your stack
Find out whether the stacks and servers you run are on an affected version.
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Zephyr's LwM2M implementation runs over CoAP and supports block-wise transfers via the Block1 option (RFC 7959). Block-wise state is kept in the static array block1_contexts[], sized by CONFIG_LWM2M_NUM_BLOCK1_CONTEXT (default 3), with entries reclaimed only when a transfer completes, fails, or ages out after roughly 30 seconds. In parse_write_op() in subsys/net/lib/lwm2m/lwm2m_message_handling.c, the first block of an inbound WRITE/CREATE called init_block_ctx() and then unconditionally executed block_ctx->ctx.block_size = block_size before checking the return value. init_block_ctx() sets the caller's pointer to NULL and returns -ENOMEM when no pool entry is free or the entry is stale, so the store dereferences NULL - the classic CWE-476 NULL pointer dereference root cause. The vulnerable write lands at a fixed low address with a small value (0-7), which produces a fatal BusFault or corrupted low-memory fault rather than a controllable corruption primitive: the outcome is a device crash/reset with no confidentiality or integrity impact. The upstream fix restructures the logic so the peer-selected block size is stored only after the context is validated, and it checks block_ctx == NULL directly rather than relying on the return code.
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:N/I:N/A:H
Network-reachable and unauthenticated in default NoSec mode (PR:N); AC:H because the 3-entry context pool must be exhausted first; crash-only, so C:N/I:N and A:H.
Primary rating from Vendor (zephyrproject).
CVSS VectorVendor: zephyrproject
DescriptionCVE.org
parse_write_op() in subsys/net/lib/lwm2m/lwm2m_message_handling.c handles inbound CoAP WRITE/CREATE requests that carry a Block1 option. For the first block of a transfer it called init_block_ctx() and then immediately stored the peer-selected block size with block_ctx->ctx.block_size = block_size before inspecting the return code. init_block_ctx() sets the caller's pointer to NULL and returns -ENOMEM when no entry of the static block1_contexts[] pool is free or timed out, so that store dereferences a NULL pointer.
The pool holds CONFIG_LWM2M_NUM_BLOCK1_CONTEXT entries (default 3) and an entry is only reclaimed once its transfer completes, fails, or ages past 30 seconds. A peer that reaches the client's LwM2M socket can therefore start three block-wise writes on three distinct object paths with the CoAP More bit set and leave them incomplete, then send the first block of a fourth write on a new path to reach the unguarded dereference. Reachability is gated only by the connected UDP socket's source-address filter unless CONFIG_LWM2M_DTLS_SUPPORT is enabled - which has no default - so in a NoSec deployment an on-path or address-spoofing attacker needs no credentials; the same sequence is also reachable from a bootstrap or lower-trust server, and can be hit accidentally by a legitimate server running four concurrent block transfers.
The write targets a fixed low address with a value between 0 and 7, so the consequence is a fatal memory fault (BusFault or corrupted low memory leading to a fault) rather than a usable memory-corruption primitive: the device crashes or resets. Confidentiality and integrity are not affected. The fix moves the store below the guard and validates the context pointer itself instead of the return code, so the context is only touched once it is known to be valid.
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 null pointer dereference occurs when a program attempts to access memory through a pointer that has been set to NULL (address 0x0).
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
Related Vulnerabilities in Zephyr RTOS Memory Safety and DoS Vulnerabilities
View all 3Potential 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
NVD
CVE.org
EPSS
Vulnrichment
GitHub
VulDB
Exploit-DB