/

CVE-2025-61025

Severity:

HIGH RISK

(7.5)

SQL Injection DoS (CWE-89) in Virtuoso sslr_qst_get

CVE-2025-61025

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-89, CWE-400

Impact:

Denial of Service via Malicious SQL Injection

Severity:

HIGH RISK

(7.5)

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 vulnerability in the sslr_qst_get component of Virtuoso Open-Source 7.2.11 allows crafted SQL statements to trigger abnormal resource consumption and service instability.

When an attacker can inject or manipulate SQL reaching this component, the database process may hang or crash, resulting in denial of service.

Affected context

This vulnerability occurs within deployments of Virtuoso Open-Source that expose SQL execution paths tied to the sslr_qst_get component, such as database endpoints, query interfaces, or application backends using Virtuoso as a data store.

It becomes relevant when user-controlled input is incorporated into SQL queries without robust validation or parameterization, allowing attackers to craft statements that stress parser logic or engine resources.

Exploit preconditions

  • Attack surface: Any SQL execution interface backed by Virtuoso (web application, API endpoint, admin console, or direct SQL clients).
  • Required access: Ability to submit or influence SQL queries processed by the sslr_qst_get logic, typically through application input fields or query endpoints.
  • Trigger point: Execution of specially crafted SQL that interacts with the vulnerable query handling path.
  • Why exploitation is possible: The component does not adequately constrain or defensively handle certain SQL structures, allowing untrusted input to drive excessive resource usage or error states.

Why this happens

The underlying bug aligns with CWE-89 (Improper Neutralization of Special Elements used in an SQL Command) and CWE-400 (Uncontrolled Resource Consumption).

SQL construction appears to rely on input that is not rigorously sanitized or parameterized, enabling attackers to introduce patterns that cause heavy computation, large result sets, or pathological query plans.

Abstractly, this reflects an insecure pattern where dynamic SQL built from untrusted data is executed without safeguards on complexity, recursion, or resource limits, allowing a single query to overwhelm the engine.

Potential impact

  • The Virtuoso database service may become unresponsive or crash.
  • Applications relying on Virtuoso can experience downtime or degraded performance.
  • Critical data services and APIs may be temporarily unavailable.
  • Operational monitoring and maintenance processes can be disrupted by repeated DoS conditions.

General mitigation guidance

Mitigation generally focuses on reducing trust in SQL inputs and constraining engine resource usage.

Recommended patterns include:

  • Using parameterized queries and avoiding string concatenation of user input into SQL commands.
  • Applying strict input validation and query shape constraints before execution (e.g., whitelisting allowed operations).
  • Enforcing query timeouts, resource quotas, and limits on recursion, joins, or result size at the database layer.
  • Isolating public-facing query interfaces from administrative or high-impact operations and applying least-privilege roles for execution.

How teams detect issues like this

High-level detection approaches include:

  • Static analysis rules that flag dynamic SQL construction and highlight unparameterized concatenation patterns in application code using Virtuoso.
  • Code review practices that look for direct insertion of user-controlled data into SQL strings and lack of resource-limiting safeguards.
  • Runtime monitoring for anomalous query patterns, spikes in CPU, memory, or connection usage, and repeated long-running or failing statements.
  • Policy enforcement in CI/CD pipelines that require parameterized access layers and prohibit direct ad hoc SQL in user-facing components.

Sources

SourceLink
github.comgithub.com/openlink/virtuoso-opensource/issues/1229

Frequently asked

questions

The described behavior is focused on denial of service through crafted SQL, though improper query handling can sometimes be a stepping stone to broader SQL injection risks depending on surrounding logic.

An attacker generally needs the ability to submit or influence SQL queries processed by Virtuoso, typically via application input fields, query APIs, or less protected administrative endpoints.

The safest pattern is to enforce parameterized SQL access, validate and constrain user input, and apply strict limits on query complexity and resource consumption so untrusted input cannot drive pathological workloads.

Adopt a standard data access layer that abstracts query construction, mandate parameterization by policy, regularly review SQL-related code for injection patterns, and configure database-level guards such as timeouts, quotas, and query whitelisting where appropriate.

Find out what's already
exploitable in your codebase.