/

CVE-2025-61027

Severity:

HIGH RISK

(7.5)

SQL Injection (CWE-89) causing DoS in Virtuoso engine

CVE-2025-61027

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-89

Impact:

Denial of Service

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 SQL injection issue in the t_set_push component of OpenLink Virtuoso Open-Source 7.2.11 allows crafted SQL statements to disrupt normal database processing.

When an attacker can submit specially formed queries to the Virtuoso engine, they may trigger resource exhaustion or engine faults, resulting in denial of service conditions.

Affected context

This vulnerability arises in deployments of the Virtuoso Open-Source engine that expose SQL query interfaces to clients or applications.

It becomes relevant where user-controlled or externally sourced query fragments reach the t_set_push component without sufficient validation or parameterization.

Environments with shared or public-facing query endpoints, such as SPARQL or SQL gateways, are more likely to experience this issue under load or malicious traffic.

Exploit preconditions

  • Attack surface: SQL or query endpoints backed by the Virtuoso Open-Source 7.2.11 engine.
  • Required access: Ability to send or influence SQL statements processed by the t_set_push component (e.g., through application inputs, APIs, or query consoles).
  • Trigger point: Submission of crafted SQL queries that manipulate expression sets or internal state handled by t_set_push.
  • Why exploitation is possible: Input is treated as part of executable SQL without robust parameterization or structural controls, allowing attackers to drive the engine into error states or resource-heavy operations.

Why this happens

The underlying issue aligns with CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection').

In abstract terms, the t_set_push component accepts data that can alter the shape and behavior of SQL expressions without enforcing strict boundaries between data and control.

This insecure pattern allows attackers to inject or amplify query constructs that stress internal processing, leading to crashes, hangs, or excessive resource consumption rather than simple query failures.

Potential impact

  • Service disruption or temporary unavailability of the Virtuoso database instance.
  • Saturation of CPU, memory, or I/O resources, affecting co-located services.
  • Forced restarts or crashes of the database engine under malicious or malformed loads.
  • Degradation of performance for legitimate queries and downstream applications.

General mitigation guidance

Effective mitigation focuses on limiting how untrusted data can influence SQL structure and resource usage.

Common patterns include:

  • Using parameterized queries or prepared statements so that input is treated strictly as data.
  • Introducing query validation and allowlists to constrain supported operations and expression complexity.
  • Applying throttling and resource limits per client or session to reduce the impact of abusive query patterns.
  • Separating public-facing endpoints from privileged query interfaces and running the engine with least-privilege OS and network permissions.
  • Implementing input normalization and rejecting anomalous or overly complex queries at the application or gateway layer.

How teams detect issues like this

Detection typically combines static and operational signals:

  • Static analysis rules to identify dynamic SQL construction paths where user input is concatenated or interpolated directly.
  • Code review practices that flag complex query-building logic and ensure parameterization in all data access layers.
  • Database monitoring for repeated error patterns, long-running queries, or sudden spikes in resource utilization tied to specific statements.
  • Policy-based controls that log and optionally block queries violating complexity or length thresholds.
  • Integration of automated security testing tools that fuzz query inputs and detect unexpected DoS behavior.

Sources

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

Frequently asked

questions

The reported behavior centers on denial of service through crafted SQL, but SQL injection as a class can also lead to data exposure or tampering. The practical impact depends on how the affected queries are used and what privileges they carry.

An attacker must be able to submit or influence SQL statements processed by the Virtuoso engine, typically via application forms, APIs, query consoles, or integrated data access layers.

The most robust approach is to eliminate dynamic SQL built from untrusted input by adopting parameterized queries, strict query schemas, and defensive validation at all entry points.

Consistently separate data from query logic, apply centralized query-building utilities that enforce parameterization, incorporate static analysis and security reviews into development workflows, and enforce operational safeguards such as rate limiting and query complexity controls.

Find out what's already
exploitable in your codebase.