Skip to main content

RIOT OS EUVDEUVD-2026-95933

| CVE-2026-107838 HIGH
Unchecked Return Value (CWE-252)
2026-10-09 GitHub_M
7.5
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Reach CoAP fileserver over network
  2. Delivery
    Send request with oversized extended token
  3. Exploit
    coap_build_reply/_resp_init fails silently
  4. Execution
    Code continues on stale response state
  5. Persist
    _calc_szx2 assertion aborts task
  6. Impact
    Service/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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet 0.3% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – 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

RIOT 2023.07, ≤ 2026.07

Affected Packages

euvd riot_2023_07 no fix

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

Vendor (GitHub_M) PRIMARY 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
vuln.today AI 7.5 HIGH

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.

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

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

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

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

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.3%
Top 75% exploitable
Prevalence
Low
niche open-source IoT/embedded RTOS, limited production deployment footprint
Social Media
2
Sightings
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 HIGH
CISA KEV No
Public POC No
EPSS 0.3%
Patch available No
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.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· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
High

Priority Score

38
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +38
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

More in Riot

View all
CVE-2023-33975 CRITICAL POC
9.8 May 30

RIOT-OS, an operating system for Internet of Things (IoT) devices, contains a network stack with the ability to process

CVE-2019-1000006 CRITICAL POC
9.8 Feb 04

RIOT RIOT-OS version after commit 7af03ab624db0412c727eed9ab7630a5282e2fd3 contains a Buffer Overflow vulnerability in s

CVE-2026-25139 CRITICAL POC
9.1 Feb 04

RIOT IoT operating system has an out-of-bounds read vulnerability (CVSS 9.1) that could lead to information disclosure o

CVE-2024-32018 CRITICAL POC
9.0 May 01

RIOT is a real-time multi-threading operating system that supports a range of devices that are typically 8-bit, 16-bit a

CVE-2024-32017 CRITICAL POC
9.0 May 01

RIOT is a real-time multi-threading operating system that supports a range of devices that are typically 8-bit, 16-bit a

CVE-2024-31225 CRITICAL POC
9.0 May 01

RIOT is a real-time multi-threading operating system that supports a range of devices that are typically 8-bit, 16-bit a

CVE-2024-52802 HIGH POC
7.5 Nov 22

RIOT is an operating system for internet of things (IoT) devices. Rated high severity (CVSS 7.5), this vulnerability is

CVE-2023-24818 HIGH POC
7.5 Apr 24

RIOT-OS, an operating system that supports Internet of Things devices, contains a network stack with the ability to proc

CVE-2019-16754 HIGH POC
7.5 Sep 24

RIOT 2019.07 contains a NULL pointer dereference in the MQTT-SN implementation (asymcute), potentially allowing an attac

CVE-2019-15702 HIGH POC
7.5 Aug 27

In the TCP implementation (gnrc_tcp) in RIOT through 2019.07, the parser for TCP options does not terminate on all input

CVE-2019-15134 HIGH POC
7.5 Aug 17

RIOT through 2019.07 contains a memory leak in the TCP implementation (gnrc_tcp), allowing an attacker to consume all me

CVE-2024-53980 MEDIUM POC
6.9 Nov 29

RIOT is an open-source microcontroller operating system, designed to match the requirements of Internet of Things (IoT)

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy