Skip to main content

Zephyr RTOS EUVDEUVD-2026-68723

| CVE-2026-14368 MEDIUM
Out-of-bounds Write (CWE-787)
2026-08-31 zephyr
5.4
CVSS 3.1 · Vendor: zephyr
View

Attack ChainAIDerived

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

  1. Recon
    Establish DTLS session as authorized LwM2M server
  2. Delivery
    Target a STRING-type resource on the client
  3. Exploit
    Craft CoAP WRITE with JSON string length == resource buflen
  4. Install
    Trigger get_string() off-by-one overflow
  5. C2
    Write NUL byte past buffer boundary
  6. Execute
    Corrupt adjacent memory field
  7. Impact
    Cause crash or silent data corruption

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

The attacker must control or impersonate a LwM2M server with an active DTLS session to the target Zephyr client (CVSS PR:L reflects this authorized-peer requirement - unauthenticated or anonymous network access alone is not sufficient). The device must be compiled with Zephyr's LwM2M subsystem enabled (CONFIG_LWM2M) and must expose at least one LWM2M_RES_TYPE_STRING resource. Exploitation is only possible when the LwM2M WRITE uses JSON content format; the other formatters (TLV, plain text, CBOR, SenML CBOR, SenML JSON) are not affected. The exact crash or corruption outcome depends on runtime memory layout adjacent to the target buffer, which the attacker cannot control. Limiting factors: requires an authorized LwM2M server role with an established DTLS session; requires a STRING-typed resource target; and impact is constrained to a single deterministic NUL-byte write with layout-dependent consequences.

Impact

The CVSS 5.4 base score (AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:L) accurately reflects a network-reachable, low-complexity flaw requiring low-privilege access - specifically, an established LwM2M server role over a DTLS session. EPSS data is absent from the provided intelligence set, so exploitation probability cannot be quantified. KEV status is not confirmed and this CVE does not appear as actively exploited. No public exploit code has been identified, though the publicly visible commit diff and GHSA advisory substantially lower the barrier for an attacker to reproduce the flaw. Real-world risk is constrained by two factors: the overflow writes exactly one fixed byte (0x00) at a deterministic offset, and the actual damage depends on the platform's memory layout at runtime, which the attacker cannot control. This limits the primitive to a reliability/DoS concern or silent data corruption rather than a reliable code-execution path in most configurations; however, on safety-critical or resource-constrained embedded devices typical of Zephyr deployments, even a controllable crash or state corruption carries operational consequences beyond what the CVSS score alone suggests, and operators managing fleets of LwM2M-connected devices should treat patch deployment as a near-term priority.

Exploit ScenarioDerived

A malicious or compromised LwM2M management server with an active DTLS session to a Zephyr client sends a CoAP WRITE request targeting a STRING-type resource, encoding a JSON string payload whose byte length exactly equals the resource's configured maximum buffer size. The client's do_write_op_json() parses the payload, invokes get_string(), which copies the string into the buffer and writes a NUL byte one position past the end, silently corrupting an adjacent memory field - potentially a length field, counter, flag, or neighboring resource value - resulting in a subsequent crash or undetected data mishandling.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.2% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Aug 31, 2026

Off-by-one out-of-bounds write in Zephyr RTOS's LwM2M JSON formatter allows a LwM2M server peer to corrupt one byte of memory adjacent to a STRING resource buffer by sending a WRITE payload whose string length exactly equals the buffer size. Affected devices are Zephyr LwM2M clients with the JSON content formatter enabled (cpe:2.3:a:zephyrproject:zephyr:*:*:*:*:*:*:*:*). The overflow deterministically writes a NUL byte past the buffer boundary, enabling potential crash or silent data corruption depending on memory layout; no public exploit has been identified at time of analysis, but the fix commit and security advisory are publicly visible.

RemediationAI

Apply upstream commit ba38f4b94337cc2c2446277ac181bdb5fec8f2b2, which changes the off-by-one guard in get_string() from string_length > buflen to string_length >= buflen, aligning the JSON formatter with all other LwM2M content formatters. The fix and advisory are available at https://github.com/zephyrproject-rtos/zephyr/security/advisories/GHSA-vg53-h6qq-xx7h and https://github.com/zephyrproject-rtos/zephyr/commit/ba38f4b94337cc2c2446277ac181bdb5fec8f2b2. No specific fixed release version is confirmed from the provided data; consumers should cherry-pick the commit onto their target Zephyr branch. As a compensating control pending patching, restrict LwM2M server access to explicitly trusted peers using DTLS certificate-based or PSK authentication to reduce the population of entities that can send WRITE operations - note this does not eliminate the vulnerability but raises the exploitation bar. Alternatively, reconfiguring devices to use TLV, CBOR, or plain-text content formats instead of JSON (if deployment permits) avoids the vulnerable code path entirely, though this may require server-side changes and could affect interoperability.

Affected VersionsENISA

Zephyr 3.2.0 <4.4.2

Affected Packages

euvd zephyr fix: 4.4.2

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 RTOS is an open-source real-time operating system for constrained IoT and embedded devices. The affected component is its LwM2M (Lightweight Machine-to-Machine) protocol stack, which operates over CoAP (Constrained Application Protocol) and is typically secured with DTLS. The root cause (CWE-787, Out-of-bounds Write) is an off-by-one boundary check in get_string() at subsys/net/lib/lwm2m/lwm2m_rw_json.c: the guard if (string_length > buflen) permits the case where string_length == buflen, causing memcpy() to fill the entire buffer and the subsequent NUL-terminator assignment buf[string_length] = '\0' to write one byte past the allocation. The destination is either a resource instance's fixed data buffer (res_inst->data_ptr/max_data_len) or the engine validation buffer, both on the heap or BSS. All other Zephyr LwM2M content formatters (plain text, OMA-TLV, SenML JSON, CBOR, SenML CBOR) already used the correct >= boundary check; the JSON formatter was the sole outlier. CPE cpe:2.3:a:zephyrproject:zephyr:*:*:*:*:*:*:*:* indicates the entire Zephyr version history prior to the fix is in scope.

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 5.4 MEDIUM
AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:L
vuln.today AI 5.4 MEDIUM

Attacker must hold an authorized LwM2M server role over DTLS (PR:L); network-triggered with no complexity (AV:N/AC:L); no confidentiality impact; limited, layout-dependent integrity and availability effects.

3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:L
4.0 AV:N/AC:L/AT:N/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
Network
Attack Complexity
Low
Privileges Required
Low
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
Low
Availability
Low

DescriptionCVE.org

The LwM2M JSON content formatter's get_string() in subsys/net/lib/lwm2m/lwm2m_rw_json.c copies a parsed JSON string into a caller-supplied buffer and NUL-terminates it. The length guard used if (string_length > buflen), which accepts a string whose length is exactly buflen. After memcpy() fills the whole buffer, buf[string_length] = '\0' then writes one byte past the end of the buffer (CWE-787).

The string value and its length are taken directly from the incoming CoAP payload during a LwM2M WRITE: do_write_op_json() parses the payload obtained from coap_packet_get_payload(), and get_string() is invoked from lwm2m_write_handler() (engine_get_string() in subsys/net/lib/lwm2m/lwm2m_message_handling.c) for a LWM2M_RES_TYPE_STRING resource. The destination buf/buflen is either the resource instance's fixed data buffer (res_inst->data_ptr/max_data_len) or the engine validation buffer (msg->ctx->validate_buf). A LwM2M server (the client's DTLS peer) can therefore write a string resource with a value whose length equals the target buffer size and force a one-byte overflow.

The overflow is a single out-of-bounds write of the constant byte 0x00 immediately past the resource or validation buffer, corrupting the adjacent byte in memory. It is not an information leak and the written value is fixed, so it is not a direct code-execution primitive, but it can corrupt adjacent state (an adjacent resource value, a length/flag field, or a struct field) and cause data corruption or a crash. Triggering the write is deterministic; the resulting impact depends on memory layout.

The fix changes the guard to string_length >= buflen, rejecting the exact-length case and aligning the JSON formatter with the other content formatters (lwm2m_rw_plain_text.c, lwm2m_rw_oma_tlv.c, lwm2m_rw_senml_json.c, lwm2m_rw_cbor.c, lwm2m_rw_senml_cbor.c), which already used the correct boundary check.

Threat Intelligence Overview

EPSS Score
0.2%
Top 87% exploitable
Prevalence
Medium
widely used RTOS in IoT and embedded device firmware
Data Quality
6 sources
Confidence: High

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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
No
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

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