/

CVE-2026-55208

Severity:

HIGH RISK

(7.7)

Time-Based SQL Injection (CWE-89) in Pimcore Studio

CVE-2026-55208

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-89

Impact:

Authenticated data exfiltration via time-based SQL injection

Severity:

HIGH RISK

(7.7)

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 time-based blind SQL injection vulnerability in Pimcore Studio Backend Bundle allows an authenticated user to manipulate SQL queries through the DateFilter column key parameter.

By injecting crafted values into the columnFilters key field, an attacker can exfiltrate sensitive database content such as admin password hashes via timing-based responses.

Affected context

This vulnerability occurs in Pimcore Studio Backend Bundle when backend listing endpoints accept a columnFilters array and interpolate the key field directly into SQL.

Installations where authenticated users can access endpoints like POST /pimcore-studio/api/website-settings and related listing APIs, and where the server constructs SQL using manually backticked identifiers without strict validation or parameterization, are exposed.

The risk is higher in environments where backend users are numerous or semi-trusted, and where the database contains highly sensitive records such as password hashes or application secrets.

Exploit preconditions

  • Attack surface: Pimcore Studio backend listing endpoints (e.g., /pimcore-studio/api/website-settings) that accept columnFilters.
  • Required access: Valid authenticated user account with permission to reach the affected endpoints.
  • Trigger point: Submission of a crafted columnFilters payload where the key field includes a backtick and appended SQL expressions (e.g., time-based subqueries).
  • Why exploitation is possible: The key value is concatenated into the SQL statement with only manual backtick quoting and no proper identifier validation or parameter binding, allowing a backtick to terminate the identifier context and inject arbitrary SQL that the database executes.

Why this happens

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

The application constructs SQL fragments for column filters by interpolating the key parameter directly into the query string, relying on naive backtick wrapping rather than treating it as an untrusted identifier.

Because no strict whitelist, schema-based validation, or safe identifier construction is applied, an attacker can include a backtick and additional SQL syntax in the key value.

The database then interprets the injected fragment as part of the query, enabling time-based blind injection through functions like SLEEP() and conditional expressions without returning visible error messages.

Potential impact

  • Extraction of admin password hashes and other sensitive credential material via timing-based inference.
  • Exfiltration of arbitrary database records accessible to the application's database account.
  • Enumeration of database structure (tables, columns, relationships) using blind SQL techniques.
  • Potential pivot to broader account compromise if password hashes are cracked offline.
  • Increased risk of targeted privilege escalation within the application's user base.

General mitigation guidance

Effective mitigation focuses on eliminating dynamic SQL construction that incorporates untrusted identifier or filter fields.

Recommended defensive patterns include:

  • Enforcing strict whitelists for sortable/filterable column keys, mapping client-supplied identifiers to a fixed set of server-side constants.
  • Using parameterized queries or ORM query builders for all variable parts of conditions and avoiding manual string concatenation of SQL fragments.
  • Applying robust validation for any input that influences query structure (e.g., column names, sort fields), rejecting values that do not match expected patterns.
  • Isolating database privileges so the application account has only the minimum permissions required, reducing impact if injection occurs.
  • Implementing secure-by-default backend APIs that expose only necessary filtering options instead of reflecting raw client-provided SQL semantics.

How teams detect issues like this

Detection commonly relies on both code-centric and behavior-centric approaches:

  • Static analysis rules scanning for dynamic SQL building patterns that concatenate request parameters (e.g., key, columnFilters) into query strings, especially around identifier quoting with backticks or quotes.
  • Manual code review focusing on backend listing and filter APIs, looking for any place where client-supplied field names determine SQL identifiers or fragments without strict mapping.
  • Runtime monitoring and database activity logging to flag anomalous queries containing functions like SLEEP(), IF(), or unusual conditional expressions originating from backend endpoints.
  • Integrating application security testing (SAST/DAST) into CI/CD to probe filter and listing endpoints for time-based behavior when invalid or malformed column keys are supplied.

Sources

SourceLink
github.comgithub.com/pimcore/pimcore/security/advisories/GHSA-79cw-hfcc-7mw9
github.comgithub.com/pimcore/studio-backend-bundle/commit/f532428cfbf4f5d6e299a13cedd5c29541802552
github.comgithub.com/pimcore/studio-backend-bundle/pull/1883
github.comgithub.com/pimcore/studio-backend-bundle/releases/tag/v2025.4.6
github.comgithub.com/pimcore/studio-backend-bundle/releases/tag/v2026.1.6

Frequently asked

questions

Yes, if the Pimcore Studio backend is exposed over the network and an attacker can obtain valid credentials, they can exploit the vulnerable endpoints remotely through crafted HTTP requests.

No. The vulnerability requires an authenticated account with access to the affected listing endpoints, but not necessarily administrative privileges. Any user role that can invoke those endpoints may be able to perform time-based SQL injection.

The safest pattern is to remove dynamic SQL string concatenation for column keys and instead map allowed client-visible fields to a static whitelist of server-side identifiers, using parameterized queries or ORM APIs for all variable conditions.

Adopt a development standard that forbids direct concatenation of request data into SQL, requires parameterization for values, mandates whitelisting for any user-controlled identifiers, and enforces security-focused code review or static analysis on all data access layers.

Find out what's already
exploitable in your codebase.