/

CVE-2026-53448

Severity:

HIGH RISK

(7.2)

SQL Injection (CWE-89) in Coturn HTTPS Admin Panel

CVE-2026-53448

Analyzed

Vulnerability type

Category:

SQL Injection

CWE:

CWE-89

Impact:

Arbitrary SQL Execution and Potential RCE

Severity:

HIGH RISK

(7.2)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

The Coturn HTTPS admin panel contains a SQL injection flaw where HTTP query parameters are interpolated directly into SQL statements without sanitization.

An authenticated administrator can inject arbitrary SQL via specific admin operations, leading to full database compromise and possible OS-level code execution in certain deployments.

Affected context

This vulnerability affects deployments of the Coturn HTTPS admin panel where administrators interact with delete-related operations such as delete-user, delete-secret, and delete-IP.

It becomes relevant when the server relies on a relational database backend and the admin interface is exposed to authenticated operators, particularly in environments where database privileges allow filesystem interaction or command execution (e.g., PostgreSQL COPY TO PROGRAM).

Exploit preconditions

  • Attack surface: HTTPS admin panel endpoints handling delete operations (e.g., du, ds, dip parameters).
  • Required access: Valid authenticated administrator access to the Coturn web administration interface.
  • Trigger point: Submission of crafted HTTP query parameters that are directly formatted into SQL queries via snprintf.
  • Why exploitation is possible: Input from HTTP query parameters is used in SQL string construction without proper sanitization or parameterization, and the existing is_secure_string filter is not applied to these admin operations.

Why this happens

The underlying issue is the construction of SQL queries by concatenating or interpolating user-supplied data into query strings, rather than using parameterized statements or robust escaping.

In the vulnerable code path, snprintf is used to embed HTTP query parameters directly into SQL, bypassing the is_secure_string filter applied elsewhere in the application.

This aligns with CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection'), where special characters and control tokens in untrusted input can alter the structure and behavior of SQL statements.

Potential impact

  • Authenticated administrators may execute arbitrary SQL commands against the Coturn database.
  • Attackers could read, modify, or delete TURN user credentials, secrets, and configuration data.
  • Database integrity and availability can be compromised, including dropping tables or altering schemas.
  • In environments where the database supports shell interaction (such as PostgreSQL COPY TO PROGRAM), attackers could potentially gain OS-level code execution under the database service account.
  • Pivoting to other systems that trust the compromised database may become possible.

General mitigation guidance

Mitigation generally focuses on eliminating direct string-based SQL construction and reducing trust in administrative inputs.

Recommended patterns include:

  • Adopting parameterized queries or prepared statements for all database interactions, especially in administrative endpoints.
  • Applying consistent input validation and normalization filters across all paths, including admin-only operations, rather than assuming admin input is inherently safe.
  • Enforcing least-privilege roles for the database account used by the application, limiting its ability to perform filesystem or OS-level actions.
  • Segregating administrative interfaces on dedicated network segments and protecting them with strong authentication and access control.
  • Implementing defense-in-depth controls, such as database-level query auditing and restrictions on dangerous features like COPY TO PROGRAM where not strictly needed.

How teams detect issues like this

Detection efforts can focus on both code and runtime behavior:

  • Static analysis rules to flag string interpolation into SQL queries, especially uses of snprintf, sprintf, or manual concatenation in database-related code.
  • Code review checklists that explicitly require verification of parameterized queries and consistent use of validation filters for all admin endpoints.
  • Application-level logging of admin actions and anomalous query patterns, such as unexpected use of SQL meta-commands or multi-statement submissions.
  • Database security monitoring and auditing to detect suspicious queries, privilege escalations, or use of advanced features like COPY TO PROGRAM.
  • Integration of automated security scanners or linters in CI pipelines to detect SQL injection patterns early in the development lifecycle.

Sources

SourceLink
github.comgithub.com/coturn/coturn/commit/b84dbab1d1aa6e2bf0211a1cdbb250d6de2a0d09
github.comgithub.com/coturn/coturn/pull/1924
github.comgithub.com/coturn/coturn/releases/tag/4.12.0
github.comgithub.com/coturn/coturn/security/advisories/GHSA-v8hj-2xx7-xmp5

Frequently asked

questions

Exploitation is limited to authenticated administrators with access to the HTTPS admin panel, but within that scope it can provide extensive control over the database and, in some environments, the underlying OS.

No. The attacker only needs authenticated access to the admin interface; the vulnerable code path sends crafted SQL via the application's existing database connection.

The safest pattern is to replace all string-constructed SQL with parameterized queries and ensure uniform input validation for all parameters, including those in admin-only functions, combined with restrictive database privileges.

Establish coding standards that forbid raw SQL string concatenation, enforce secure database access patterns through shared libraries or ORM layers, mandate security-focused code reviews for admin interfaces, and continuously use automated tooling to detect SQL injection patterns during development and testing.

Find out what's already
exploitable in your codebase.