CVE-2026-68554 in Coturn
Summary
by MITRE • 08/20/2026
Coturn is a free open source implementation of TURN and STUN Server. Prior to 4.15.0, an on-path attacker can append attributes after MESSAGE-INTEGRITY to an authenticated STUN request on plain UDP or TCP, adjust the STUN header length, and recompute the unkeyed FINGERPRINT while the original HMAC remains valid because it covers only the message prefix. Server-side parsing in src/server/ns_turn_server.c continues past MESSAGE-INTEGRITY through handle_turn_allocate(), handle_turn_create_permission(), handle_turn_refresh(), and handle_turn_command(), allowing trailing LIFETIME, XOR-PEER-ADDRESS, or ORIGIN attributes to override allocation lifetime, inject a permission, or bypass the origin check. TLS and DTLS deployments prevent this in-transit modification. This issue is fixed in version 4.15.0.
If you want to get the best quality for vulnerability data then you always have to consider VulDB.
Analysis
by VulDB Data Team • 08/20/2026
The vulnerability identified in Coturn versions prior to 4.15.0 represents a critical authentication bypass mechanism within the Session Traversal Utilities for NAT (STUN) and TURN protocol implementations. As an open-source server widely deployed to facilitate real-time communication by helping peers discover their public IP addresses and establish direct connections, Coturn relies heavily on message integrity checks to ensure that requests originate from authorized clients. The core technical flaw lies in how the server processes authenticated STUN messages transmitted over unencrypted transports such as plain UDP or TCP. Specifically, an attacker positioned on the network path can intercept a valid, authenticated STUN request and append additional attributes after the MESSAGE-INTEGRITY attribute. Because the HMAC signature computed by the client covers only the message prefix up to but not including the MESSAGE-INTEGRITY field itself, these trailing modifications do invalidate the existing cryptographic hash. However, due to a parsing logic error in the server-side implementation located in src/server/ns_turn_server.c, the application continues processing the message despite this discrepancy, effectively ignoring the tampering that occurred after the integrity check point.
This architectural weakness allows an on-path attacker to manipulate critical control attributes such as LIFETIME, XOR-PEER-ADDRESS, or ORIGIN without triggering a rejection of the request. By adjusting the STUN header length and recomputing the unkeyed FINGERPRINT attribute, which is not protected by HMAC, the attacker can craft a maliciously modified packet that appears structurally valid to the parser while retaining the original client-generated signature for the initial portion of the message. The server's handling functions, including handle_turn_allocate(), handle_turn_create_permission(), and handle_turn_refresh(), proceed with these altered parameters as if they were part of the originally authenticated payload. This leads to severe operational impacts where an attacker can override allocation lifetimes to extend session duration indefinitely, inject unauthorized peer permissions to redirect traffic through compromised nodes, or bypass origin checks that are designed to prevent cross-origin attacks. Such manipulations compromise the integrity and confidentiality of VoIP and WebRTC sessions, potentially enabling eavesdropping, man-in-the-middle attacks, or denial of service conditions by exhausting server resources with invalid allocations.
The risk is strictly limited to deployments using unencrypted transport protocols; TLS and DTLS implementations are immune to this specific vector because they provide end-to-end encryption that prevents any on-path modification of the message content after authentication occurs. To mitigate this vulnerability in affected versions, administrators must upgrade Coturn to version 4.15.0 or later where the parsing logic has been corrected to strictly validate the entire message structure against the integrity check. In environments where upgrading is not immediately feasible, enforcing TLS or DTLS for all STUN and TURN traffic effectively neutralizes this attack by ensuring that any tampering with the message body would break the transport layer encryption before it reaches the application parser. This incident highlights a common class of vulnerabilities in network protocol implementations known as truncation attacks or partial authentication bypasses, which are categorized under CWE-347 Improper Verification of Cryptographic Signature when the signature verification does not cover all relevant data fields. Furthermore, this exploitation technique aligns with MITRE ATT&CK techniques related to Protocol Manipulation and Defense Evasion, specifically involving the modification of network packets to bypass security controls such as origin checks or access permissions within real-time communication infrastructure.