/

CVE-2026-45779

Severity:

CRITICAL RISK

(9.8)

SQL Injection (CWE-89) in Open XDMoD Metrics Platform

CVE-2026-45779

Analyzed

Vulnerability type

Category:

SQL Injection

CWE:

CWE-89

Impact:

Database Compromise and Remote Data Manipulation

Severity:

CRITICAL RISK

(9.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

An SQL injection flaw in Open XDMoD prior to version 10.0.3 allows remote, unauthenticated attackers to execute arbitrary SQL statements against the application's database.

Because no authentication or user interaction is required, any exposed deployment may be subject to full database compromise and data manipulation.

Affected context

This vulnerability arises in Open XDMoD installations that expose web-facing endpoints backed by a relational database.

It is present when user-controlled input, such as HTTP query parameters or request bodies, is incorporated into SQL queries without proper parameterization or robust sanitization.

Environments where the Open XDMoD web interface is reachable from untrusted networks are at particular risk, especially if the application connects with a highly privileged database account.

Exploit preconditions

  • Attack surface: Public or internal web endpoints of the Open XDMoD interface.
  • Required access: None; the vulnerability can be reached without authentication.
  • Trigger point: Submission of crafted input that is concatenated directly into SQL queries.
  • Why exploitation is possible: The query construction logic fails to consistently use prepared statements or safe parameter binding, allowing attacker-controlled input to alter the intended SQL structure.

Why this happens

The root cause aligns with CWE-89, where application code dynamically constructs SQL queries by concatenating raw user input instead of using parameterized queries.

When user data is embedded directly into SQL strings, the database engine interprets parts of that input as executable SQL syntax rather than as data.

This insecure pattern breaks the separation between data and commands, enabling an attacker to inject additional clauses, union queries, or entirely new statements within a single request.

Potential impact

  • Attackers may read sensitive data from any table the database user can access.
  • Data within the Open XDMoD database can be modified, corrupted, or deleted.
  • User accounts and API credentials stored in the database may be exposed or altered.
  • Database-level privileges could be abused to create new accounts or escalate access in the wider environment.
  • Application integrity and reporting accuracy can be undermined through silent data tampering.

General mitigation guidance

Long-term mitigation should focus on adopting defensive query construction practices and reducing implicit trust in inputs.

Recommended patterns include:

  • Using parameterized queries or prepared statements for all database interactions, avoiding string concatenation with user input.
  • Applying strict server-side validation and normalization of request parameters before they reach the data access layer.
  • Implementing a data access abstraction layer that enforces safe query APIs and prevents direct construction of raw SQL in business logic.
  • Running the application with minimally privileged database accounts limited to the operations strictly required.
  • Segregating sensitive tables or schemas and applying additional access controls where possible.

How teams detect issues like this

Detection efforts can combine code-centric and behavior-centric approaches:

  • Static analysis rules that flag dynamic SQL construction, string concatenation involving request parameters, or bypass of query parameter binding.
  • Targeted code review of database access modules, focusing on endpoints reachable without authentication.
  • Use of application security testing (DAST) tools configured to probe query parameters and request bodies for injection behavior.
  • Runtime monitoring of database logs for anomalous queries, such as unexpected UNION operations, stacked statements, or sudden access to atypical tables.
  • CI/CD policy checks that prevent merging code introducing new raw SQL execution paths without parameterization.

Sources

SourceLink
github.comgithub.com/ubccr/xdmod/releases/tag/v10.0.3
github.comgithub.com/ubccr/xdmod/security/advisories/GHSA-r33r-6g3c-r992
open.xdmod.orgopen.xdmod.org/security_patches/GHSA-r33r-6g3c-r992-0_0_0-8_6_0.patch
open.xdmod.orgopen.xdmod.org/security_patches/GHSA-r33r-6g3c-r992-9_0_0-10_0_2.patch

Frequently asked

questions

The issue is broadly exploitable on any affected Open XDMoD instance exposed over the network, because it does not require authentication or user interaction. Attackers only need network reachability to the vulnerable interface.

No prior access is required beyond the ability to send HTTP requests to the Open XDMoD application. The attack can be performed by an unauthenticated remote user.

The most robust fix is to remove all dynamic SQL string concatenation and enforce parameterized queries or prepared statements across the codebase, combined with strict validation of every input that influences database queries.

Adopt a database access layer that only exposes safe query-building primitives, enforce secure coding guidelines around input handling, and integrate automated security checks—such as SAST and security-focused code review—into the development lifecycle to catch unsafe patterns early.

Find out what's already
exploitable in your codebase.