Summary
Pimcore's Admin Classic Bundle contains a SQL injection vulnerability in the translation grid date filter because a user-controlled property value is inserted into a SQL expression without parameterization or allowlist validation. An attacker who can submit affected backend filter requests may be able to alter database queries, potentially exposing or modifying data.
Affected context
The issue occurs in Pimcore's Admin Classic Bundle translation grid when processing date-filter JSON. It becomes risky where users can reach the backend interface and provide filter input that is incorporated into the generated SQL query without being constrained to an approved set of properties.
Exploit preconditions
- Attack surface: Pimcore backend translation grid filtering
- Required access: Access to submit requests to the affected backend functionality; deployment-specific authentication and authorization controls may apply
- Trigger point: Processing a translation grid date filter containing a user-controlled
propertyfield - Why exploitation is possible: The property value is interpolated directly into a SQL expression instead of being parameterized or checked against a strict allowlist
Why this happens
The underlying bug is an unsafe construction of SQL statements from user-controlled structural input. The translation filter incorporates the property field into a UNIX_TIMESTAMP(DATE(FROM_UNIXTIME(...))) expression without separating data from SQL syntax or validating the field against permitted column mappings. This behavior maps to CWE-89, SQL Injection, because attacker-influenced input can affect database query interpretation.
Potential impact
- An attacker may read data that the database account can access.
- An attacker could alter query behavior and bypass intended filtering.
- An attacker may modify or delete database records if the database privileges permit it.
- The vulnerability could expose sensitive application or administrative information.
General mitigation guidance
Mitigation generally focuses on eliminating dynamic SQL construction from
untrusted input and reducing the trust placed in filter fields.
Common defensive patterns include:
- Use parameterized queries for values and trusted server-side mappings for column or property names.
- Enforce a strict allowlist for filter properties before query generation.
- Separate structural query composition from user-supplied values.
- Apply least-privilege permissions to the database account used by the application.
- Validate filter schemas and reject unexpected fields, types, and operators by default.
- Treat backend users and client-generated filter JSON as untrusted input.
How teams detect issues like this
Detection approaches may include:
- Static analysis rules for string interpolation, concatenation, or formatting inside SQL statements.
- Code review checks for user-controlled JSON fields used as table, column, expression, or clause components.
- Searches for dynamic SQL near request handlers and filter-processing code.
- Runtime monitoring for anomalous translation-grid queries, unexpected database errors, and unusual query patterns.
- CI policy checks requiring parameterized database APIs and approved query-builder abstractions.
Automated application-security review tools may help identify unsafe query construction, but findings should be validated against the actual data flow and authorization model.

