/

CVE-2026-36670

Severity:

HIGH RISK

(8.8)

Time-Based SQL Injection (CWE-89) in OpenSIPS Panel

CVE-2026-36670

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-89

Impact:

Arbitrary SQL Command Execution

Severity:

HIGH RISK

(8.8)

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

A time-based blind SQL injection flaw in the alias_management module of the OpenSIPS Control Panel allows crafted values in a GET parameter to alter backend SQL queries.

When an authenticated user can control the table parameter in alias_management.php, they may execute arbitrary SQL statements against the application database.

Affected context

This vulnerability appears in OpenSIPS Control Panel deployments using the alias_management module, where HTTP GET parameters are interpolated into SQL queries without robust validation.

It is relevant when authenticated users can reach alias_management.php and the backend database account has privileges beyond strictly read-only operations.

The risk increases in environments where the same database stores sensitive user, routing, or configuration data used by OpenSIPS and related services.

Exploit preconditions

  • Attack surface: Web interface of the OpenSIPS Control Panel, specifically the alias_management module.
  • Required access: Valid authenticated session with permission to access alias_management.php.
  • Trigger point: Supplying a crafted value in the table GET parameter that is later concatenated or interpolated into an SQL statement.
  • Why exploitation is possible: The application constructs SQL queries dynamically using user-controlled input without adequate parameterization, whitelisting, or escaping, making database behavior observable via timing differences (time-based blind technique).

Why this happens

At its core, this issue reflects CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection').

The alias_management logic appears to treat the table GET parameter as trusted and interpolates it into SQL without strict validation or parameter binding.

Dynamic query construction using untrusted input allows attackers to inject additional SQL fragments and influence execution flow, even when no direct error messages are shown, enabling time-based blind exploitation through response delays.

Potential impact

  • Arbitrary SQL queries may be executed against the control panel database.
  • Attackers could read or infer sensitive data such as user records, routing information, or credentials stored in the database.
  • Database contents could be modified or deleted, impacting SIP routing behavior or control panel integrity.
  • In certain deployments, database-level compromise could facilitate broader system or account takeover if reused credentials or elevated DB privileges exist.

General mitigation guidance

Effective mitigation typically focuses on eliminating dynamic query construction from untrusted inputs and constraining what can be referenced from the application layer.

General defensive patterns include:

  • Using parameterized queries or prepared statements for all database operations, including those involving table or column identifiers where feasible.
  • Applying strict server-side whitelisting for any parameter that selects tables or objects; only known, pre-approved identifiers should be accepted.
  • Normalizing and validating input early, rejecting unexpected values instead of attempting to sanitize arbitrary SQL fragments.
  • Segregating database privileges so that the application account has only the minimal permissions required for its operations.
  • Implementing secure-by-default frameworks or data access layers that make unsafe query construction harder or impossible for developers.

How teams detect issues like this

Detection efforts can combine static analysis, code review, and runtime monitoring:

  • Static analysis rules targeting string concatenation with SQL keywords or variables sourced from HTTP parameters, especially in PHP data access code.
  • Code review checklists that flag any direct inclusion of user-controlled values (like GET or POST parameters) into query strings, with special attention to identifiers such as table names.
  • Centralized data-access layers enforced by policy, where queries outside these layers trigger alerts or additional review.
  • Application and database logging tuned to highlight anomalous or complex queries, repeated long-running queries, or patterns consistent with time-based probing.
  • Use of automated security testing tools (DAST) configured to probe parameters like table for timing-based SQL injection behavior.

Sources

SourceLink
github.comgithub.com/Gabriel-Lacorte/CVE-2026-36670/blob/main/ADVISORY.md

Frequently asked

questions

Exploitation is remote in the sense that it occurs over HTTP, but it typically requires authenticated access to the OpenSIPS Control Panel interface rather than unauthenticated public access.

An attacker generally needs a valid user account or compromised credentials that allow access to the alias_management module and the ability to supply crafted values to the table GET parameter.

The safest fix pattern is to remove direct string interpolation of user input into SQL and replace it with parameterized queries plus strict whitelisting of allowed tables or identifiers, ensuring only predefined, trusted values are ever used to construct queries.

Adopt a consistent data access layer that enforces parameterization by default, apply strong input validation and whitelisting for any identifier-like parameters, minimize database privileges, and integrate security-focused code reviews and automated analysis into the development lifecycle.

Find out what's already
exploitable in your codebase.