/

CVE-2026-52785

Severity:

CRITICAL RISK

(9.9)

SQL Injection (CWE-89) in OpenProject Timestamps API

CVE-2026-52785

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-89

Impact:

Arbitrary SQL query execution against the application database, potentially leading to data exfiltration, modification, or deletion.

Severity:

CRITICAL RISK

(9.9)

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 vulnerability in OpenProject's timestamps functionality allows crafted parameter values to manipulate backend database queries.

When historic work-package attributes are requested via the timestamps parameter without proper sanitization, an attacker can potentially run arbitrary SQL, threatening data confidentiality and integrity.

Affected context

The vulnerability occurs in OpenProject's web-based project management interface where historic work-package attributes are retrieved using the timestamps parameter.

It is relevant in deployments where user-controlled input is passed into database queries for baseline comparisons without adequate parameterization or validation.

The issue is exposed through HTTP requests that invoke the timestamps functionality and rely on dynamic query construction tied to user-provided values.

Exploit preconditions

  • Attack surface: HTTP endpoints that support baseline comparison and accept the timestamps parameter for work-package history retrieval.
  • Required access: Ability to send crafted requests to the affected OpenProject instance (typically authenticated user, but can vary with project permissions and endpoint exposure).
  • Trigger point: Submission of malicious timestamps values that are incorporated into SQL statements for fetching historical attributes.
  • Why exploitation is possible: The backend builds or augments SQL queries using untrusted timestamps input without strict parameter binding, allowing attacker-controlled syntax to alter query structure.

Why this happens

The underlying bug aligns with CWE-89: improper neutralization of special elements used in an SQL command.

Application code handling timestamps-based baseline comparison appears to embed user-supplied values directly into SQL or fails to use robust parameterization, enabling input to be interpreted as part of the query rather than data.

This pattern emerges when query construction logic trusts the format of client-provided parameters and does not enforce strict typing, whitelisting, or prepared statements, leaving the database interpreter exposed to injected fragments.

Potential impact

  • An attacker may read arbitrary data from the OpenProject database, including project, user, and work-package information.
  • They could modify or delete work-package records, baselines, or related project metadata.
  • They may create or alter accounts or permissions if those are stored and managed through database-backed tables.
  • Attackers could impact application stability by issuing costly or invalid queries, leading to performance degradation or outages.
  • They may leverage the database server for further lateral movement depending on configuration and integrations.

General mitigation guidance

Effective mitigation centers on eliminating direct use of untrusted input in SQL query construction.

Typical defensive patterns include:

  • Using parameterized queries or ORM methods that strictly separate query structure from data values for timestamps and related parameters.
  • Constraining timestamps inputs to well-defined formats (e.g., strict date/time, integer identifiers) combined with server-side validation and type checking.
  • Applying allowlists for acceptable fields or historical attributes, avoiding dynamic column or table selection based on client input.
  • Reducing database privileges of the application account so that even if injection occurs, destructive operations are limited.
  • Centralizing query-building logic behind safe abstractions, discouraging ad-hoc concatenation of request parameters into SQL.

How teams detect issues like this

Detection often involves reviewing both code and runtime behavior for signs of unsafe query construction.

Useful approaches include:

  • Static analysis rules that flag string concatenation, interpolation, or dynamic SQL building paths involving request parameters like timestamps.
  • Targeted code reviews of database access layers handling historical work-package queries, verifying consistent use of prepared statements and strict input validation.
  • Database activity monitoring configured to alert on unusual query patterns, such as union-based queries, stacked statements, or access to unexpected tables originating from the application.
  • CI/CD checks and security linters that enforce organization-wide policies against non-parameterized queries and risky ORM escapes.

Sources

SourceLink
github.comgithub.com/opf/openproject/security/advisories/GHSA-98vw-2r87-fx2r

Frequently asked

questions

Yes. If the affected endpoints are reachable over the network, an attacker can remotely send crafted HTTP requests with malicious timestamps parameters to attempt SQL injection.

Typically, the attacker needs the ability to interact with the timestamps functionality, which may require an authenticated OpenProject account depending on project and API access configuration.

The most robust fix is to enforce strict parameterization for all database queries, validate timestamps against a narrow, expected format, and ensure no dynamic SQL is built from raw request values.

Adopting secure coding standards around database access, using ORM or query builder abstractions that prevent direct concatenation, integrating static analysis for injection patterns, and performing regular security-focused code reviews on data-access layers can significantly reduce recurrence.

Find out what's already
exploitable in your codebase.