Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach CoAP device on network
-
DeliverySend GET /.well-known/core?href=/<prefix>
-
ExploitPrefix matches longer registered resource path
-
ExecutionInner loop reads uri[len] past option-value copy
-
ImpactOut-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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
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'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
AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:L
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).
Primary rating from Vendor (zephyr).
CVSS VectorVendor: zephyr
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
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 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.
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-88474
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB