Skip to main content

Eclipse tinydtls CVE-2026-9267

| EUVDEUVD-2026-40054 MEDIUM
Out-of-bounds Read (CWE-125)
2026-06-29 eclipse GHSA-qqgj-g5f7-jqhm
6.9
CVSS 4.0 · Vendor: eclipse
View

Attack ChainAIDerived

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

  1. Access
    Reach target DTLS UDP port
  2. Delivery
    Initiate epoch 0 DTLS handshake
  3. Exploit
    Send Certificate message with oversized fragment_length
  4. Execution
    check_server_certificate() skips buffer length check
  5. Persist
    Out-of-bounds read in uint24/memcmp/memcpy
  6. Impact
    Crash or memory exposure on constrained device

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

No authentication is required - the vulnerability is triggered during DTLS epoch 0, the unencrypted pre-authentication handshake phase, before any session credentials are established. No user interaction is required. No special non-default configuration is needed; any tinydtls deployment that accepts inbound DTLS connections and processes Certificate handshake messages is affected. Both client and server code paths are vulnerable, meaning a malicious server can also exploit a tinydtls client during handshake. Exploitation is limited by: (1) the attacker must have UDP network access to the target's DTLS port; (2) the target must be running an unpatched tinydtls version; (3) impact is availability-only per the CVSS 4.0 vector (VA:L, VC:N, VI:N), though the Information Disclosure tag suggests potential memory exposure that may not be fully captured in the current CVSS assessment.

Impact

The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N, score 6.9) reflects a network-reachable, zero-interaction, unauthenticated path with low availability impact and no confidentiality or integrity impact on the vulnerable system. However, the 'Information Disclosure' tag conflicts with VC:N - CWE-125 OOB reads on constrained devices can expose adjacent heap or stack memory to an attacker, suggesting confidentiality impact may have been underweighted or was deliberately scoped out; this discrepancy should be verified against the fix commit diff. EPSS data was not provided, so exploitation probability cannot be quantified numerically. No CISA KEV listing and no POC code have been identified, placing this in the low-urgency tier despite its clean attack vector. On memory-constrained embedded targets (the tinydtls deployment context), even a 'low' availability impact may mean a full device crash or reboot rather than merely degraded performance, which amplifies real-world operational risk in IoT deployments. No SSVC data was provided; inferred SSVC exploitation status is 'none' given absence of KEV and POC.

Exploit ScenarioDerived

An attacker with network access to a DTLS-enabled tinydtls endpoint initiates a DTLS handshake during epoch 0 and sends a crafted Certificate handshake message in which the fragment_length field is set to a value exceeding the actual buffer size. The check_server_certificate() function reads the uint24 value and proceeds to memcmp or memcpy operations without validating buffer bounds, triggering an out-of-bounds read that corrupts or reads adjacent memory, causing the memory-constrained target device to crash or become unresponsive. No exploit code is publicly known, but the attack requires only standard DTLS socket access and a single crafted packet, making it low-effort to reproduce from the description alone.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
No patch listed yet 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Jun 29, 2026

Out-of-bounds read in Eclipse tinydtls prior to commit b3efd41ad111a4920f599f51ffa4f5e9f1e72221 allows unauthenticated network attackers to crash memory-constrained IoT devices by sending a specially crafted Certificate handshake message during DTLS epoch 0. The vulnerable check_server_certificate() function omits buffer length validation before uint24 reads, memcmp, and memcpy operations, enabling reads beyond valid buffer boundaries on both client and server code paths. No public exploit code or active exploitation has been identified at time of analysis; however, the unauthenticated, network-reachable nature makes this straightforward to trigger against any exposed tinydtls endpoint.

RemediationAI

The primary fix is to update Eclipse tinydtls to a version that includes commit b3efd41ad111a4920f599f51ffa4f5e9f1e72221, which adds buffer length validation before the uint24 reads, memcmp, and memcpy operations in check_server_certificate(). A released tagged version number containing this fix has not been independently confirmed from available data - verify against the upstream repository at the Eclipse security advisory (https://gitlab.eclipse.org/security/cve-assignment/-/work_items/112) before deploying. If patching is not immediately possible, deployments that do not require DTLS certificate-based handshakes can disable or restrict Certificate message processing as a compensating control, though this may break mutual TLS authentication flows. Network-level filtering to restrict DTLS traffic (UDP) to trusted peers only reduces the attack surface but does not eliminate the vulnerability for threat models involving untrusted network participants.

Affected VersionsENISA

Eclipse TinyDTLS 0 <b3efd41ad111a4920f599f51ffa4f5e9f1e72221

Affects your stack

Find out whether the stacks and servers you run are on an affected version.

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

Eclipse tinydtls is a lightweight Datagram Transport Layer Security (DTLS) implementation designed for resource-constrained devices in IoT and embedded environments. The vulnerability is rooted in CWE-125 (Out-of-bounds Read): the check_server_certificate() function does not validate that the buffer is sufficiently large before reading a 3-byte unsigned integer (uint24), passing buffer regions to memcmp, or copying data with memcpy. This occurs during DTLS epoch 0, which is the unencrypted pre-authentication handshake phase, meaning no session establishment or credential check gatekeeps the attack. The affected CPE is cpe:2.3:a:eclipse_foundation:eclipse_tinydtls:*:*:*:*:*:*:*:* - the wildcard version range indicates all releases prior to the fix commit are affected. The tags list 'Information Disclosure' alongside Denial of Service, consistent with CWE-125 behavior where OOB reads may expose adjacent memory content in addition to causing crashes.

Know when Eclipse Tinydtls 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 (eclipse) PRIMARY 6.9 MEDIUM
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N
vuln.today AI 5.3 MEDIUM

Network-reachable, unauthenticated DTLS epoch-0 handshake path; no privileges or interaction required; only availability impact confirmed, no integrity or confidentiality effect established.

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

Primary rating from Vendor (eclipse).

CVSS VectorVendor: eclipse

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
None
Vulnerable system: Availability
Low
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

Eclipse tinydtls before commit b3efd41ad111a4920f599f51ffa4f5e9f1e72221 contains an out-of-bounds read vulnerability in the check_server_certificate() function that allows unauthenticated attackers to trigger reads beyond valid buffer boundaries by crafting a Certificate handshake message with a specific fragment_length value. Attackers can exploit missing buffer length validation before uint24 reads, memcmp, and memcpy operations during DTLS epoch 0 on both client and server paths to cause denial of service on memory-constrained devices.

Threat Intelligence Overview

EPSS Score
0.2%
Top 93% exploitable
Prevalence
Low
niche DTLS library for constrained IoT/embedded devices only
Social Media
1
Sightings
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 No
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
None
System Exposure· derived
Open
Automatable
Yes
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

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

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

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

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