Skip to main content

Zephyr RTOS EUVDEUVD-2026-88474

| CVE-2026-18416 LOW
Out-of-bounds Read (CWE-125)
2026-09-28 zephyr
3.7
CVSS 3.1 · Vendor: zephyr
View

Attack ChainAIDerived

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

  1. Access
    Reach CoAP device on network
  2. Delivery
    Send GET /.well-known/core?href=/<prefix>
  3. Exploit
    Prefix matches longer registered resource path
  4. Execution
    Inner loop reads uri[len] past option-value copy
  5. Impact
    Out-of-bounds read triggers undefined behaviour

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, read limits
MITRE ATT&CK

1 technique across 1 tactic: Collection

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Requires the target to run the Zephyr CoAP server subsystem with CONFIG_COAP_SERVER_WELL_KNOWN_CORE enabled (default y) so that /.well-known/core is served, AND at least one registered resource must declare struct coap_core_metadata attributes so match_queries_resource() reaches the vulnerable path. The attacker must also supply a Uri-Query href= value that is a strict prefix of a longer registered resource path segment for the inner loop to over-read. No authentication or user interaction is needed (PR:N/UI:N), but AC:H reflects that the over-read is probabilistic (each extra byte is read only if it equals the next path character) and produces no observable output - it cannot influence the response or disclose data, which severely limits practical exploitation.

Impact

This is a genuinely low-risk issue despite a network attack vector. The CVSS 3.1 base score of 3.7 (AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:L) is consistent with the description: reachable remotely and unauthenticated (PR:N), but with high complexity (AC:H) and only a marginal availability impact (A:L), no confidentiality or integrity impact. There is no EPSS score, no CISA KEV listing, and no public exploit code identified, so all severity/exploitation signals align on low priority. Critically, the description itself limits impact more strongly than the vector might suggest: the CWE-125 out-of-bounds read stays within a stack-local copy (struct coap_option.value[12]), NOT the receive buffer, reads only the uninitialized tail (in practice a single byte), cannot influence the CoAP response, and produces undefined behaviour rather than information disclosure. This is a real defensive-hygiene fix but not an operational priority. Note the CWE-125 (out-of-bounds READ) contradicts the 'Buffer Overflow' tag (which implies a write), and the 'Information Disclosure' tag directly contradicts the description, which explicitly states the flaw is 'not information disclosure.'

Exploit ScenarioDerived

An unauthenticated attacker who can reach a Zephyr-based CoAP device sends GET /.well-known/core?href=/<prefix> where <prefix> is a prefix of a longer registered resource path that declares coap_core_metadata attributes. The match_path_uri() inner loop then reads one or a few bytes past the end of the option-value copy on the stack, causing undefined behaviour. No public exploit code exists, and the read neither discloses data to the attacker nor alters the response, so the practical outcome is limited to potential undefined behaviour.

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

An out-of-bounds read in the Zephyr RTOS CoAP link-format helper match_path_uri() (subsys/net/lib/coap/coap_link_format.c) allows an unauthenticated remote attacker to drive the URI comparison loop one or more bytes past the end of a Uri-Query href= option value by sending a GET /.well-known/core?href=/<prefix> request whose value is a strict prefix of a longer registered resource path. Only devices running the Zephyr CoAP server subsystem with CONFIG_COAP_SERVER_WELL_KNOWN_CORE enabled (the default) and at least one resource declaring struct coap_core_metadata attributes reach the vulnerable code path. The over-read is bounded - in practice a single byte, limited by the compared path length - reads only uninitialized stack tail rather than receive-buffer or attacker-controlled data, cannot influence the response, and yields undefined behaviour rather than information disclosure or a matching error; no public exploit code was identified at time of analysis, and the assessed severity is Low (CVSS 3.7).

RemediationAI

Apply the upstream fix commit ef5b303dc88fb5159850623a2b51b590c36fa5bc, which adds a k >= len bound check inside the inner loop of match_path_uri() so every uri[k] dereference remains within the Uri-Query option value while still permitting a trailing '*' wildcard to match a longer path; this is an upstream fix available as a commit/PR, and a tagged Zephyr release carrying it is not independently confirmed in the provided data, so verify the fix is present in your chosen release before deploying (advisory: https://github.com/zephyrproject-rtos/zephyr/security/advisories/GHSA-m3mv-vvm4-h58g). If an immediate upgrade is not possible, the exposure can be removed by disabling CONFIG_COAP_SERVER_WELL_KNOWN_CORE, which stops the device from serving /.well-known/core at all and therefore breaks CoAP resource discovery and any client that relies on it - an acceptable trade-off for constrained deployments that do not need discovery. A less disruptive alternative is to stop declaring struct coap_core_metadata attributes on registered resources, so match_queries_resource() never reaches the vulnerable comparison; the side effect is loss of href filtering in well-known-core discovery responses, though basic /.well-known/core listing continues to work. Network-level filtering that blocks or strips Uri-Query href= parameters on requests to /.well-known/core would also suppress the trigger, but risks rejecting legitimate filtered-discovery requests and is fragile against parameter-encoding variations. Given that the flaw is a bounded stack over-read of at most a few uninitialized bytes with no demonstrated information disclosure and no public exploit code identified, these compensating controls are adequate interim measures rather than urgent mitigations.

Affected VersionsENISA

Zephyr 1.8.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's CoAP server exposes resource discovery through /.well-known/core, implemented in subsys/net/lib/coap/coap_link_format.c. When a discovery request carries a Uri-Query href= option, coap_well_known_core_get_len() and coap_well_known_core_get() call match_queries_resource(), which parses the option into a stack-local struct coap_option whose value is a fixed-size array (value[12], or CONFIG_COAP_EXTENDED_OPTIONS_LEN_VALUE bytes when extended options are enabled) and copies the option bytes into it, so the uri argument points into that on-stack copy, not into the received packet. match_path_uri() iterates the option value with an index k while comparing against the registered resource path, but the inner character loop advanced k once per path character without ever comparing k against the option length len, so when a registered path segment is longer than the supplied URI and the URI is a prefix of it, the loop dereferences uri[len] and beyond - the classic CWE-125 out-of-bounds read. In Zephyr's historical ZoAP library (v1.8.0 through v1.9.x) the same option value was a pointer into the received packet, so the over-read extended into the packet buffer; in current Zephyr it is confined to the unused tail of the stack-local array and the adjacent stack frame. Because returning a match still requires the final compared index to be len - 1 or len (both in bounds), out-of-bounds bytes can only steer the loop toward the next candidate resource, so the fault is undefined behaviour with no confidentiality or integrity consequence. The upstream patch adds an explicit if (k >= len) goto next; guard at the top of the inner loop, preserving the trailing '*' wildcard semantics while ensuring every uri[k] dereference stays within the option value.

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

Remotely reachable unauthenticated (AV:N/PR:N) but AC:H due to required metadata resources and probabilistic prefix match; over-read stays in stack copy with no info leak (C:N/I:N) and only possible undefined-behaviour instability (A:L).

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

Primary rating from Vendor (zephyr).

CVSS VectorVendor: zephyr

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

DescriptionCVE.org

The CoAP link-format helper match_path_uri() in subsys/net/lib/coap/coap_link_format.c compares a registered resource path against the URI carried in a Uri-Query href= option. That URI is not NUL terminated, but the inner character loop advanced its index k once per path character without ever testing it against the option length len. When a registered path segment is longer than the supplied URI and the URI is a prefix of it, the loop reads uri[len] and beyond, past the end of the option value.

The path is reached from coap_well_known_core_get_len() and coap_well_known_core_get() via match_queries_resource(), i.e. by any unauthenticated GET /.well-known/core?href=/<prefix> request to a device that serves /.well-known/core (for the CoAP server subsystem, CONFIG_COAP_SERVER_WELL_KNOWN_CORE, default y) and has at least one resource that declares struct coap_core_metadata attributes.

The over-read does not reach the receive buffer. The well-known-core builders parse the query into a stack-local struct coap_option, whose value is a fixed array (value[12], or CONFIG_COAP_EXTENDED_OPTIONS_LEN_VALUE bytes) that the option bytes are copied into, so uri points into that copy. Reading past len therefore reads the unused, uninitialized tail of the array and, when the option fills it, the bytes just past it in the same stack frame. (In the ZoAP library of v1.8.0 to v1.9.x the option value was instead a pointer into the received packet, and the over-read ran past the option inside the packet buffer.)

The impact is bounded. The number of bytes read past the end is limited by the length of the resource path segment, and each additional byte is only read if it happens to equal the next path character, so in practice the over-read is one byte. It also cannot influence the response: returning a match requires the final compared index to be len - 1 or len, both in bounds, so out-of-bounds bytes only ever steer the loop to the next candidate resource. The consequence is undefined behaviour, not information disclosure and not a matching error.

The fix adds a k >= len guard at the top of the inner loop, so every uri[k] dereference is within the option value while still allowing a trailing * wildcard to match a longer path.

Threat Intelligence Overview

EPSS Score
0.2%
Top 89% exploitable
Prevalence
High
Zephyr is a widely-deployed open-source embedded RTOS across IoT/embedded devices
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.2%
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
None
System Exposure· derived
Open
Automatable
No
Human Impact· derived
Low
Technical Impact
Partial

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.

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