Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach CoAP fileserver over network
-
DeliverySend request with oversized extended token
-
Exploitcoap_build_reply/_resp_init fails silently
-
ExecutionCode continues on stale response state
-
Persist_calc_szx2 assertion aborts task
-
ImpactService/device denial of service
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A10:2025 - Mishandling of Exceptional Conditions
ASVS 5.0
V16 - Security Logging and Error Handling Return value checking
|
| Exploitation Conditions | Requires the target to run the nanocoap_fileserver (sys/net/application_layer/nanocoap/fileserver.c) AND have the nanocoap_token_ext (CoAP extended token) feature enabled - a non-default build-time option; the attacker then sends a CoAP request with an extended token large enough that coap_build_reply() cannot fit the response header, making _resp_init() fail. LIMITING FACTORS: exploitation is gated on that non-default token-ext configuration, on the fileserver being network-reachable, and practically on RIOT assertions being compiled in (typically under DEVELHELP; NDEBUG builds may suppress the abort). No authentication is required (PR:N) and no user interaction is needed (UI:N) once those conditions hold; affected versions are 2023.07 through 2026.07 with no fixed release available. |
| Impact | The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, 7.5 HIGH) is internally consistent with the description: a remote, unauthenticated client can crash the service over the network with low complexity, and the impact is availability-only (no confidentiality or integrity loss), matching a pure denial-of-service via a reachable assertion failure (CWE-252, unchecked return value of _resp_init()). No EPSS score, KEV listing, or public POC is present in the provided data, so there is no public exploit identified at time of analysis - the vulnerability is confirmed by a RIOT-OS GitHub Security Advisory (GHSA-39j3-3v73-5mj2) and a fix PR/commit, but no SSVC decision data was supplied. Two factors materially lower real-world risk below what the 7.5 score suggests: (1) exploitation requires the nanocoap_fileserver to be running AND the non-default nanocoap_token_ext (CoAP extended-token) feature to be enabled, and (2) the crash depends on the assertion being compiled in (RIOT assertions are typically active under DEVELHELP; production images built with NDEBUG may not abort, though stale response state could still cause undefined behavior) - these configuration dependencies are not reflected in the base CVSS and should be weighed by defenders. CONFLICTING/MISSING SIGNAL TO NOTE: the base vector marks PR:N and AC:L as if universally exploitable, but the description explicitly gates exploitation on a non-default build-time feature, so the effective attack surface is narrower than the score implies; verify whether nanocoap_token_ext is enabled in your firmware before treating this as a default-config network DoS. |
| Exploit ScenarioDerived | An attacker with network reachability to a RIOT-based IoT device exposing the nanocoap fileserver (with nanocoap_token_ext enabled) sends a single CoAP request carrying an extended token large enough that coap_build_reply() cannot fit the response header into the buffer. _resp_init() fails but its return value is ignored, so _get_file()/_get_directory() continue with stale response state and reach the _calc_szx2() payload_len > reserve assertion, terminating the service or device task. No public exploit code is identified at time of analysis, but the trigger is a trivially crafted single packet. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 09, 2026
Remote, unauthenticated denial of service in RIOT OS 2023.07 through 2026.07: the nanocoap_fileserver in sys/net/application_layer/nanocoap/fileserver.c ignores the failure returned by _resp_init() when coap_build_reply() cannot fit a response header into the response buffer. On builds with the non-default nanocoap_token_ext option enabled, a client can send a CoAP request carrying a sufficiently large extended token so that response initialization fails while _get_file()/_get_directory() proceeds with stale response state, eventually hitting the _calc_szx2() assertion (pdu->payload_len > reserve) and aborting the affected service or device task. Exploitation is gated on the token-ext configuration, network reachability of the fileserver, and assertions being compiled in; there is no confidentiality or integrity impact, no public exploit identified at time of analysis, and no fixed release was available as of this review.
RemediationAI
No fixed release was available at time of analysis; the status is upstream fix available (PR/commit) with a released patched version not independently confirmed, so the practical route is to track or backport https://github.com/RIOT-OS/RIOT/pull/22745 (commit d3a47289c58d108575a19e623e4d3f647659e743), which makes every nanocoap fileserver handler verify the _resp_init() return value and return -1 while closing the vfs file/directory handles. Until that is integrated, the most effective control is to build without the nanocoap_token_ext option: this removes the extended-token path the attack depends on, at the cost of losing extended CoAP token support for clients that need tokens longer than the base 8 bytes. If extended tokens are required, the next best option is to disable or remove the nanocoap fileserver module from the firmware image, since the vulnerable code exists only in that component - the trade-off being loss of over-the-air file and directory access, which may break provisioning or update workflows that depend on it. Where the fileserver must remain, restrict network exposure of the CoAP endpoint (block UDP/TCP 5683 and DTLS 5684 from untrusted networks, or place it behind a gateway that enforces request-size and token-length limits) so that only authorized clients can reach it. Note that compiling with assertions disabled (e.g. NDEBUG) may suppress the abort in some builds, but this is not a reliable mitigation because it leaves the underlying unchecked-return-value defect and stale response state in place and merely changes the failure mode. Refer to the vendor advisory https://github.com/RIOT-OS/RIOT/security/advisories/GHSA-39j3-3v73-5mj2 for the definitive patch guidance.
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
RIOT is an open-source microcontroller operating system for IoT and embedded systems, and nanocoap is its lightweight CoAP (RFC 7252) implementation. The affected component is the nanocoap file server (sys/net/application_layer/nanocoap/fileserver.c), which serves GET/PUT/DELETE over CoAP through _get_file, _put_file, _delete_file, _get_directory, _put_directory and _delete_directory handlers. The root cause class is CWE-252, unchecked return value: every one of these handlers called _resp_init() - which wraps coap_build_reply() and fails when the response header cannot be encoded into the supplied buffer - without testing the return code. When the CoAP extended token option (nanocoap_token_ext, a non-default build-time feature) is enabled, an attacker can send a request with a token large enough to consume the buffer headroom so that _resp_init() fails, yet the handler continues operating on stale/inconsistent pdu state. That path reaches _calc_szx2(), whose assertion pdu->payload_len > reserve fires and terminates the task or device. The corresponding upstream fix (PR 22745, commit d3a47289c58d108575a19e623e4d3f647659e743) converts each unchecked _resp_init() call into a checked one that returns -1 on failure, closing file descriptors (vfs_close) and directory handles (vfs_closedir) before bailing out so that no stale state is used. The affected CPE is cpe:2.3:a:riot-os:riot:*:*:*:*:*:*:*:*, with versions 2023.07 through 2026.07 in scope.
Know when Riot 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:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Remote single-packet trigger with no auth or interaction gives AV:N/AC:L/PR:N/UI:N; impact is a service/task crash only, so C:N/I:N/A:H, scope unchanged.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
DescriptionCVE.org
RIOT is an open-source microcontroller operating system designed for Internet of Things devices and other embedded systems. From version 2023.07 through version 2026.07, nanocoap_fileserver callers in sys/net/application_layer/nanocoap/fileserver.c ignore a failure returned by _resp_init() when coap_build_reply() cannot fit a response header into the response buffer. A remote client can send a CoAP request with a sufficiently large extended token when nanocoap_token_ext is enabled, causing response initialization to fail while _get_file() or _get_directory() continues with stale response state. The path then reaches _calc_szx2() and its pdu->payload_len > reserve assertion, terminating the affected service or device task. No fixed release is available as of this review.
Technical POC Analysis
CWE-252 (Unchecked Return Value), with the consequence being a reachable assertion (advisory lists CWE-617 as a secondary candidate).
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
RIOT OS versions 2023.07 through 2026.07 contain a high-severity remote denial-of-service vulnerability in the nanocoap fileserver that can abort affected services or device tasks when the non-default nanocoap_token_ext option is enabled and a crafted CoAP request is processed. This creates an availability risk for IoT and edge deployments using affected RIOT OS builds with the fileserver exposed to untrusted networks. No vendor-released patch identified at time of analysis and no public exploit identified at time of analysis, so leadership should prioritize inventory, network exposure reduction, and build-time configuration changes for affected devices.
No vendor-released patch identified at time of analysis. Interim mitigations: disable the nanocoap_token_ext build option; remove or disable nanocoap_fileserver where not required; restrict network access to the CoAP fileserver via firewall, ACLs, or segmentation; enable watchdog monitoring and auto-restart for affected tasks; and apply a vendor patch when released.
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
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
RIOT-OS, an operating system for Internet of Things (IoT) devices, contains a network stack with the ability to process
RIOT RIOT-OS version after commit 7af03ab624db0412c727eed9ab7630a5282e2fd3 contains a Buffer Overflow vulnerability in s
RIOT IoT operating system has an out-of-bounds read vulnerability (CVSS 9.1) that could lead to information disclosure o
RIOT is a real-time multi-threading operating system that supports a range of devices that are typically 8-bit, 16-bit a
RIOT is a real-time multi-threading operating system that supports a range of devices that are typically 8-bit, 16-bit a
RIOT is a real-time multi-threading operating system that supports a range of devices that are typically 8-bit, 16-bit a
RIOT is an operating system for internet of things (IoT) devices. Rated high severity (CVSS 7.5), this vulnerability is
RIOT-OS, an operating system that supports Internet of Things devices, contains a network stack with the ability to proc
RIOT 2019.07 contains a NULL pointer dereference in the MQTT-SN implementation (asymcute), potentially allowing an attac
In the TCP implementation (gnrc_tcp) in RIOT through 2019.07, the parser for TCP options does not terminate on all input
RIOT through 2019.07 contains a memory leak in the TCP implementation (gnrc_tcp), allowing an attacker to consume all me
RIOT is an open-source microcontroller operating system, designed to match the requirements of Internet of Things (IoT)
EUVD-2026-95933
NVD
CVE.org
EPSS
GitHub
Exploit-DB