CVE-2026-73214: Coturn DTLS Fragment DoS Vulnerability

CVE-2026-73214 Overview

Coturn, a widely deployed open source implementation of TURN and STUN servers, contains a resource exhaustion vulnerability in its DTLS listener. Versions prior to 4.16.0 allocate per-peer OpenSSL reassembly state before validating the RFC 6347 cookie challenge. An unauthenticated remote attacker can send 35-byte fragmented ClientHello messages declaring a 650,000-byte handshake from fresh UDP source tuples, forcing the server to retain reassembly buffers without completing a handshake, presenting valid credentials, or spoofing source addresses. The flaw is tracked as [CWE-400] and resolved in Coturn 4.16.0.

Critical Impact
Unauthenticated remote attackers can exhaust server memory on Coturn TURN/STUN deployments by flooding the DTLS listener with small fragmented ClientHello packets, degrading or terminating real-time media relay services.

Affected Products

Coturn TURN/STUN Server versions prior to 4.16.0
Deployments exposing the DTLS listener (dtls_listener.c) to untrusted networks
WebRTC and VoIP infrastructures relying on Coturn for media relay

Discovery Timeline

2026-08-11 - CVE-2026-73214 published to NVD
2026-08-12 - Last updated in NVD database

Technical Details for CVE-2026-73214

Vulnerability Analysis

The vulnerability resides in dtls_server_input_handler() and create_new_connected_udp_socket() within src/apps/relay/dtls_listener.c. These functions instantiate a per-peer SSL object, an ioa_socket, and a ts_ur_super_session upon receiving the first fragment of a DTLS ClientHello, before the RFC 6347 stateless cookie exchange completes. OpenSSL's dtls1_reassemble_fragment() then retains buffer state sized against the attacker-declared handshake length. Because these allocations occur pre-cookie, no source-address validation gates the memory commitment.

Root Cause

Coturn allocated handshake-tracking state on the very first inbound datagram without capping the number of concurrent half-open sessions. A 35-byte fragmented ClientHello advertising a 650,000-byte handshake message is sufficient to force the reassembly path to keep buffers alive. The design assumed the cookie exchange would filter unattested peers, but state was committed before cookie validation.

Attack Vector

An unauthenticated remote sender iterates through fresh UDP 4-tuples, transmitting one small fragmented ClientHello per tuple. Each packet causes the listener to allocate an SSL context and session tracking structures. Because source spoofing is not required, the flood proceeds directly from the attacker's IP, and completion of the handshake or presentation of TURN credentials is unnecessary. Memory consumption grows linearly with packet volume until the process is out-of-memory killed or service quality collapses.

The upstream patch introduces a global atomic counter, turn_dtls_half_open, and caps concurrent half-open handshakes per relay thread:

/* Cap on concurrent half-open (handshake-incomplete) DTLS sockets, summed
 * across all relay threads. A DTLS ClientHello from a new source makes the
 * listener allocate a per-peer SSL + ioa_socket + ts_ur_super_session before
 * the source has answered the RFC 6347 cookie challenge...
 */
#define TURN_DTLS_HALF_OPEN_PER_THREAD 16

bool turn_dtls_half_open_try_inc(uint32_t cap) {
  for (;;) {
    const uint32_t cur = turn_atomic_load_u32(&turn_dtls_half_open);
    if (cur >= cap) {
      return false;
    }
    if (turn_atomic_cas_u32(&turn_dtls_half_open, cur, cur + 1)) {
      return true;
    }
  }
}

Source: GitHub Commit 37e13d1

Detection Methods for CVE-2026-73214

Indicators of Compromise

High volume of DTLS ClientHello packets originating from many distinct UDP source ports against the Coturn listener
Growing resident memory (RSS) of the turnserver process without a proportional increase in completed TURN allocations
Elevated counts of SSL objects and ioa_socket structures that never transition past the cookie exchange

Detection Strategies

Baseline the ratio of DTLS handshake starts to handshake completions and alert on divergence
Inspect UDP flow telemetry for many short-lived, single-packet flows targeting the Coturn DTLS port (typically 3478 or 5349)
Correlate turnserver memory growth with concurrent unique remote endpoint counts

Monitoring Recommendations

Ship turnserver process metrics (RSS, file descriptors, session counts) to the SIEM for trend analysis
Enable verbose DTLS logging temporarily to capture per-source ClientHello volumes during suspected floods
Monitor upstream network devices for asymmetric UDP traffic patterns indicative of state-exhaustion attempts

How to Mitigate CVE-2026-73214

Immediate Actions Required

Upgrade Coturn to version 4.16.0 or later, which enforces a cap on concurrent half-open DTLS handshakes
Restrict the DTLS listener to trusted network segments where operationally feasible
Apply UDP rate limits at the network edge to blunt high-rate ClientHello floods

Patch Information

The fix is delivered in Coturn 4.16.0. Two upstream commits address the issue: GitHub Commit 37e13d1 caps concurrent half-open handshakes, and GitHub Commit beb4de9d corrects the handshake buffer bound. Full details are available in the GitHub Security Advisory GHSA-5x2p-4vqj-f6m4 and GitHub Release 4.16.0.

Workarounds

Front the Coturn DTLS port with a firewall rule that rate-limits new UDP flows per source prefix
Reduce the allocate timeout so half-open sessions are reaped faster when running an unpatched build
Scale relay threads only after patching, since the per-thread cap of 16 half-open handshakes scales linearly with general_relay_servers_number

bash

# Example iptables UDP rate limit for the Coturn DTLS listener
iptables -A INPUT -p udp --dport 3478 -m hashlimit \
  --hashlimit-name coturn_dtls \
  --hashlimit-mode srcip \
  --hashlimit-above 50/sec \
  --hashlimit-burst 100 \
  -j DROP