/

CVE-2026-23492

Severity:

HIGH RISK

(8.8)

SQL Injection in Pimcore Admin Search Find API

CVE-2026-23492

Analyzed

Vulnerability type

Category:

SQL Injection

CWE:

CWE-89

Impact:

Database Information Disclosure and Potential Data Compromise

Severity:

HIGH RISK

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

Pimcore's Admin Search Find API contains a blind SQL injection flaw that allows an authenticated user of the admin interface to inject crafted SQL fragments into backend queries.

Because the previous fix only removed SQL comments and caught syntax errors, attackers can still send syntactically valid payloads and infer database information through timing or boolean-based responses.

Affected context

This vulnerability occurs in Pimcore's administrative interface, specifically within the Admin Search Find API used to search and filter data.

It manifests when user-controlled search or filter parameters are incorporated into SQL queries without robust parameterization and validation.

The risk is present in deployments where administrators or other authenticated users can submit arbitrary search input and where the application directly builds SQL statements from that input.

Exploit preconditions

  • Attack surface: Pimcore admin interface (Admin Search Find API endpoint)
  • Required access: Valid, authenticated user account with access to the admin search functionality
  • Trigger point: Submission of crafted search or filter values that are concatenated into SQL queries
  • Why exploitation is possible: The query-building logic relies on string manipulation and partial filtering (e.g., stripping comments and catching syntax errors) instead of fully parameterized queries, allowing syntactically valid SQL fragments to alter the query logic without raising errors.

Why this happens

The root cause is the construction of SQL queries using untrusted input without strict parameterization, falling under CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection').

The earlier patch focused on blocking certain patterns such as SQL comments and trapping obvious syntax errors, but it did not change the underlying pattern of concatenating user input into SQL strings.

As a result, attackers can craft payloads that remain syntactically valid while still modifying WHERE clauses, conditions, or expressions in ways that leak information through blind SQL techniques.

Potential impact

  • Attackers may infer table structure, column names, and other schema details via blind SQL injection.
  • Attackers could determine the presence or absence of specific records in the database.
  • Under some configurations, attackers may escalate to reading sensitive data fields indirectly.
  • The compromised search functionality can be used as a foothold to map and profile the database for further attacks.

General mitigation guidance

Effective mitigation focuses on eliminating ad-hoc SQL string construction and treating all search parameters as data, not as query fragments.

Recommended patterns include:

  • Using prepared statements or query builders that bind all parameters, including dynamically constructed filters, through placeholders rather than string concatenation.
  • Centralizing query construction logic so that search fields and operators are mapped from a fixed, whitelisted set rather than being taken directly from user input.
  • Applying strict validation and canonicalization to search parameters, limiting them to expected data types, ranges, and enumerated values.
  • Separating application-level search logic from raw SQL by leveraging ORM abstractions or dedicated search services where possible.
  • Applying least-privilege database roles so that the account used by the admin search has only the minimum required permissions.

How teams detect issues like this

Detection commonly combines code-level and behavioral approaches:

  • Static analysis: Define rules that flag dynamic SQL built from request parameters, especially concatenation of search terms into WHERE, ORDER BY, or LIMIT clauses without parameter binding.
  • Code review: Examine the Admin Search Find API and similar endpoints for patterns like string-based query assembly, manual escaping, or partial filters (e.g., stripping comments) that indicate compensating controls instead of proper parameterization.
  • Runtime monitoring: Use application and database logs to identify unusual query patterns, long-running queries, or repetitive timing-based requests coming from the admin interface.
  • Security testing: Incorporate automated and manual SQL injection tests, including blind/time-based vectors, into QA and CI pipelines to validate that fixes actually remove injection paths rather than blocking narrow payload classes.

Sources

SourceLink
github.comgithub.com/pimcore/pimcore/commit/25ad8674886f2b938243cbe13e33e204a2e35cc3
github.comgithub.com/pimcore/pimcore/security/advisories/GHSA-qvr7-7g55-69xj

Frequently asked

questions

It is exploitable over the network but only through the authenticated admin interface; an attacker must be able to access and interact with the Admin Search Find API.

The attacker needs valid credentials with permission to use the Pimcore admin search functionality. Anonymous or public users cannot directly exploit this specific issue.

Replace all dynamic SQL concatenation in the affected API with parameterized queries or a robust query builder/ORM, ensuring that every user-supplied value is bound as a parameter and that fields/operators come from controlled, whitelisted sets.

Adopt a development standard that forbids ad-hoc SQL string building, enforce secure query construction patterns in code review and static analysis, and include comprehensive SQL injection testing (including blind variants) in the regular security testing process.

Find out what's already
exploitable in your codebase.