Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain valid TURN credentials
-
DeliveryCraft USERNAME/REALM with printf specifiers
-
ExploitSend TURN Allocate to coturn
-
ExecutionAttacker key embedded in Redis command format string
-
PersistredisvFormatCommand reads past va_list
-
ImpactProcess crash drops all sessions or leaks stack memory to Redis
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Format string safety
|
| Exploitation Conditions | The attacker must hold valid TURN long-term credentials (username and password) for the targeted Coturn instance, corresponding to PR:L in the CVSS vector; unauthenticated exploitation is not possible. Coturn must have Redis integration enabled via configuration options such as --redis-userdb or --redis-statsdb - deployments backed by file-based, SQLite, PostgreSQL, or MySQL user databases do not reach the vulnerable send_message_to_redis() code path. The TURN/STUN service port (typically UDP/TCP 3478 or TLS 5349) must be network-reachable by the attacker. There is no requirement for elevated TURN privileges beyond standard user-level credentials, and no special client software is needed beyond a TURN-compliant client capable of crafting USERNAME or REALM attribute values containing percent signs. Exploitation is constrained by the need for valid credentials and the Redis dependency; environments that issue TURN credentials to untrusted or anonymous users (common in WebRTC signaling services) face materially higher risk. |
| Impact | The NVD CVSS 7.1 (High) vector AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:H is well-calibrated for this vulnerability: the attack is network-accessible and requires no special complexity beyond holding valid TURN credentials, the availability impact is High because a single crafted request can crash the coturn process and terminate all active TURN sessions, and confidentiality is Low due to stack memory potentially surfacing in Redis. No EPSS score was provided in the available intelligence, and no CISA KEV listing exists, so real-world exploitation frequency is unconfirmed. The practical risk is bounded by the PR:L requirement - attackers need valid TURN credentials - and by the further constraint that Redis integration must be enabled; deployments using file-based or SQL-backed user databases are not exposed by this code path. Despite the lack of a known public exploit, the vulnerability is straightforward to trigger with a minimal crafted TURN Allocate request once credentials are available, making it a meaningful availability risk for any public-facing WebRTC infrastructure that uses Redis-backed Coturn. |
| Exploit ScenarioDerived | An attacker with valid TURN credentials - obtained legitimately, stolen, or through credential stuffing - sends a TURN Allocate request whose USERNAME attribute contains a printf format string such as user%s%x%n%s. Coturn embeds this value into a Redis key and passes the concatenated command-plus-key as the format argument to redisAsyncCommand() with only one variadic argument; redisvFormatCommand() reads past the va_list, either crashing the coturn process and dropping all concurrent WebRTC sessions or reading stack memory that may contain sensitive data into Redis. No public proof-of-concept code has been identified, but the exploit technique maps directly to the described code path and requires only a standard TURN client. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 19, 2026
Format string injection in Coturn prior to 4.13.0 lets an authenticated TURN user crash the relay server or leak stack memory into Redis by embedding printf-style specifiers in STUN USERNAME or REALM attributes. At nine call sites in ns_ioalib_engine_impl.c, attacker-controlled values pass is_secure_string() validation and are embedded into Redis keys; send_message_to_redis() then passes the composite key as the format argument to redisAsyncCommand(), causing redisvFormatCommand() to read past the va_list. No public exploit identified at time of analysis and no CISA KEV listing; however, the attack surface is reachable by any valid TURN credential holder, including guest or externally-provisioned users in many WebRTC deployments.
RemediationAI
Upgrade to Coturn 4.13.0 or later, available at https://github.com/coturn/coturn/releases/tag/4.13.0; this is the vendor-released patch confirmed by commit 8fa38032bb4751e11e072d65a8eca3c06c950979 and security advisory GHSA-4g7c-p5wg-j4hp. If immediate upgrade is not feasible, disabling Redis integration (removing --redis-userdb, --redis-statsdb, and related Redis configuration directives) eliminates the vulnerable send_message_to_redis() code path entirely, at the cost of losing Redis-backed session persistence, quota enforcement, and distributed credential lookups. A narrower compensating control is to restrict TURN credential issuance to fully trusted internal users, reducing the probability that an attacker holds valid credentials; however, this does not eliminate the vulnerability and is not a substitute for patching. No vendor-documented workaround preserves full functionality without the patch.
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
Coturn is an open-source TURN and STUN server (CPE: cpe:2.3:a:coturn:coturn:*:*:*:*:*:*:*:*) widely deployed as a WebRTC media relay. The vulnerability is CWE-134 (Use of Externally-Controlled Format String). In src/apps/relay/ns_ioalib_engine_impl.c, STUN USERNAME and REALM attribute values are incorporated verbatim into Redis key strings after passing is_secure_string() - a check that does not strip printf conversion specifiers. The function send_message_to_redis() in src/apps/relay/hiredis_libevent2.c historically constructed a format string by snprintf-concatenating the Redis command with the attacker-controlled key, then supplied that composite string as the format argument to hiredis redisAsyncCommand() with only a single variadic value (the Redis value field). Because redisvFormatCommand() walks the format string consuming va_list entries per specifier, any additional %s/%x/%n tokens in the key cause it to read past the end of the va_list - producing a crash or exposing stack memory. The fix, confirmed in commit 8fa38032, replaces the dynamic format construction with a constant "%s %s %s" literal and passes command, key, and value strictly as data arguments.
Know when Coturn 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:L/UI:N/S:U/C:L/I:N/A:H
Requires valid TURN credentials (PR:L); Redis integration is common enough that AC:L holds; stack leak is Low confidentiality; process crash is High availability with no scope change.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
Coturn is a free open source implementation of TURN and STUN Server. Prior to 4.13.0, an authenticated TURN user can place printf-style format specifiers in the STUN USERNAME or REALM attribute, which passes is_secure_string() validation and is embedded into Redis keys at nine call sites in src/apps/relay/ns_ioalib_engine_impl.c. send_message_to_redis() in src/apps/relay/hiredis_libevent2.c then passes the attacker-controlled key as the format argument to redisAsyncCommand() while supplying only one variadic value, causing hiredis redisvFormatCommand() to read past the va_list. Exploitation can crash the coturn process and terminate active TURN sessions or disclose stack memory into Redis. This issue is fixed in version 4.13.0.
Executive ViewAI
Coturn TURN relay servers prior to version 4.13.0 are vulnerable to format string injection via crafted STUN authentication attributes, allowing authenticated users to crash the relay service or exfiltrate sensitive stack memory. This directly impacts organizations operating WebRTC platforms (video conferencing, peer-to-peer communication) where TURN servers are essential infrastructure; widespread guest or federated user bases amplifies the attack surface.
No vendor-released patch identified at time of analysis. Interim mitigations: restrict TURN access to trusted, authenticated users only; implement input validation or filtering to block printf-style format specifiers (%, $) in STUN USERNAME and REALM attributes; enable Redis access controls and monitoring for anomalous key patterns; configure rate limiting on TURN authentication attempts; establish monitoring alerts for unexpected server crashes or memory-related Redis errors; evaluate network segmentation to isolate TURN infrastructure from sensitive systems.
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.
An exploitable heap out-of-bounds read vulnerability exists in the way CoTURN 4.5.1.1 web server parses POST requests. R
An exploitable denial-of-service vulnerability exists in the way CoTURN 4.5.1.1 web server parses POST requests. Rated h
Coturn TURN/STUN server contains an access control bypass that allows remote attackers to reach blocked internal address
Stack buffer overflow in Coturn's OAuth token decoder (decode_oauth_token_gcm()) lets remote unauthenticated attackers c
Remote denial of service in Coturn TURN/STUN server allows unauthenticated attackers to crash ARM64 deployments with a s
In coturn before version 4.5.1.3, there is an issue whereby STUN/TURN response buffer is not initialized properly. Rated
Server-side request forgery in coturn TURN/STUN server before 4.13.0 lets an authenticated TURN client bypass the defaul
SQL injection in the Coturn TURN/STUN server's HTTPS admin panel (versions prior to 4.12.0) allows an authenticated admi
Unauthenticated remote attackers can leak residual stack memory from Coturn 4.10.0 by sending a TURN Allocate request wi
Memory exhaustion in Coturn 4.15.0 allows an authenticated TURN user to crash or degrade server availability by abusing
Arbitrary file overwrite in Coturn prior to 4.13.0 is possible through the CLI management interface's `psd` (print sessi
Stored XSS in Coturn's web-admin HTTPS interface (all versions prior to 4.11.0) allows a TURN-level attacker to inject p
EUVD-2026-63077
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB