/

CVE-2025-61028

Severity:

HIGH RISK

(7.5)

SQL Injection (CWE-89) in Virtuoso time_t_to_dt

CVE-2025-61028

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-89, CWE-770

Impact:

Denial of Service via 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

The time_t_to_dt component in Virtuoso Open-Source 7.2.11 is vulnerable to SQL injection, allowing crafted SQL statements to disrupt normal database processing.

When untrusted input is incorporated into SQL queries without proper validation or parameterization, attackers can trigger conditions that lead to Denial of Service (DoS).

Affected context

This vulnerability manifests in deployments of Virtuoso Open-Source that expose query interfaces or application endpoints which pass user-controlled data into the time_t_to_dt component.

It is relevant where SQL statements are dynamically constructed and executed by Virtuoso, and where input is not consistently sanitized or bound as parameters.

Environments that allow complex or nested SQL expressions, especially those involving date and time conversion, are more likely to trigger the issue.

Exploit preconditions

  • Attack surface: Any API, query endpoint, or application layer that forwards client-supplied parameters to Virtuoso SQL processing.
  • Required access: Ability to submit or influence SQL queries, typically through application inputs, web forms, or direct query consoles.
  • Trigger point: Execution of crafted SQL statements that exercise the time_t_to_dt conversion logic.
  • Why exploitation is possible: User input is incorporated into SQL commands without strict parameterization or validation, allowing malformed or hostile queries to reach vulnerable code paths.

Why this happens

The underlying bug maps to CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection').

In abstract terms, the system constructs SQL statements by concatenating or embedding externally supplied data, rather than treating that data as parameters.

When the time_t_to_dt component receives such input, it may process unexpected values that stress internal conversion routines, leading to resource exhaustion or error states.

The insecure pattern is trusting structured input as part of executable SQL logic instead of enforcing separation between code and data.

Potential impact

  • Attackers may cause the Virtuoso database service to become temporarily unavailable.
  • Crafted queries could trigger excessive resource consumption, leading to degraded performance.
  • Application features depending on Virtuoso may fail or return errors during an attack.
  • DoS conditions can be used as a smokescreen for other malicious activities in the environment.

General mitigation guidance

Effective mitigation centers on reducing trust in external input and enforcing strict boundaries between data and SQL logic.

Common defensive patterns include:

  • Using prepared statements or parameterized queries instead of dynamic SQL concatenation.
  • Applying rigorous input validation and normalization for any data used in SQL expressions, especially date and time values.
  • Implementing query-level controls, such as limits on complexity, recursion, and resource usage.
  • Applying least-privilege principles to database accounts so that even if hostile queries run, their ability to affect availability is minimized.
  • Designing interfaces so that clients cannot directly shape low-level SQL syntax, but instead operate through constrained, higher-level operations.

How teams detect issues like this

Detection typically involves a combination of preventive and reactive measures:

  • Static analysis rules that flag dynamic SQL construction and direct concatenation of user input.
  • Code review checklists that require parameterized queries and explicit validation for all database-bound data.
  • Monitoring and alerting on unusual query patterns, spikes in error rates, or resource usage anomalies within Virtuoso.
  • Policy enforcement in CI/CD pipelines to block deployments containing high-risk SQL injection patterns.
  • Optional use of database firewalls or query filters that can recognize and throttle abusive or malformed SQL statements.

Sources

SourceLink
github.comgithub.com/openlink/virtuoso-opensource/issues/1233
access.redhat.comaccess.redhat.com/security/cve/CVE-2025-61028
bugzilla.redhat.combugzilla.redhat.com/show_bug.cgi?id=2491830
security.access.redhat.comsecurity.access.redhat.com/data/csaf/v2/vex/2025/cve-2025-61028.json

Frequently asked

questions

Exploitability depends on exposure of SQL-driven interfaces. If untrusted users can influence queries that reach the time_t_to_dt component, they may be able to trigger DoS conditions; tightly controlled environments with no such exposure are at lower risk.

An attacker generally needs the ability to submit or modify SQL statements, either directly through a query console or indirectly via application inputs that are translated into SQL by the backend.

The most robust fix is to eliminate dynamic SQL that embeds user input and replace it with parameterized queries, combined with strict validation of data used in date/time conversions and other sensitive expressions.

Adopt secure coding practices that treat all external input as untrusted, enforce parameterization for database interactions, establish automated checks for injection patterns, and perform regular security-focused code reviews of database access layers.

Find out what's already
exploitable in your codebase.