Summary
GLPI versions 11.0.0 through 11.0.5 contain an unauthenticated time-based blind SQL injection vulnerability in the application's search engine.
An attacker can abuse crafted search requests to infer database contents and manipulate queries without valid credentials, becoming particularly dangerous on internet-exposed or shared GLPI instances.
Affected context
This vulnerability occurs in GLPI's search engine functionality when deployed with versions 11.0.0 to before 11.0.6.
It is relevant in contexts where the search interface is accessible without authentication, such as default or overly permissive configurations, and where the application has direct or high-privilege connectivity to its backend database.
The issue is more impactful when GLPI is reachable from untrusted networks and the database contains sensitive IT asset, user, or ticketing data.
Exploit preconditions
- Attack surface: Public or internal web interface exposing the GLPI search functionality.
- Required access: No authentication required; attacker only needs network access to the GLPI web UI.
- Trigger point: Submission of specially crafted search parameters that are incorporated into backend SQL queries.
- Why exploitation is possible: User-controlled search input is not safely parameterized or validated, allowing the attacker to influence SQL query structure and observe timing differences in responses to infer database information.
Why this happens
The underlying bug belongs to CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection').
Within the GLPI search engine, user-supplied data is incorporated into SQL statements in a way that allows control over query logic.
Instead of using strictly parameterized statements or a safe query builder for search conditions, the implementation permits certain search parameters to alter the database query, enabling time-based blind probing (e.g., via deliberate delays or heavy operations) to leak information through response times.
Conceptually, this reflects a failure to clearly separate data from control in SQL construction and to consistently treat search inputs as untrusted.
Potential impact
- Unauthenticated attackers could read or infer sensitive data stored in the GLPI database (assets, tickets, credentials metadata, configuration).
- Attackers may enumerate database structure such as table names, column names, and schema details.
- Depending on database permissions, attackers could modify or delete data, leading to integrity and availability issues.
- Chained with other weaknesses, attackers might escalate to full system compromise or leverage information for further lateral movement.
General mitigation guidance
Effective mitigation centers on reducing the ability of user input to affect SQL query structure and limiting database blast radius:
- Enforce parameterized queries or a vetted ORM/query builder for all search-related database access, ensuring user input is only ever treated as data, not executable SQL fragments.
- Normalize and validate search parameters against a strict allowlist of permitted columns, operators, and values, rejecting or sanitizing anything that falls outside supported patterns.
- Encapsulate complex search logic behind server-side abstractions (e.g., pre-defined filters or views) rather than concatenating conditions directly into SQL strings.
- Apply least-privilege to the database account used by GLPI so that, even if some injection path exists, the account cannot perform high-risk operations like dropping tables or accessing unrelated schemas.
- Where possible, shield the GLPI interface from direct internet exposure (e.g., VPN, reverse proxies, or additional access controls), reducing unauthenticated attack surface.
How teams detect issues like this
Detection generally combines code-centric and behavior-centric approaches:
- Static analysis: Configure SAST or linters to flag dynamic SQL construction, string concatenation involving request parameters, and non-parameterized query APIs in search-related code paths.
- Code review: During manual review, look for search features that build WHERE clauses or ORDER BY segments using raw user input, especially where logic is assembled in strings or templates.
- Logging and monitoring: Enable detailed application and database logging to detect anomalous patterns such as repeated similar search requests with unusual parameters and consistent time-delayed behavior indicative of blind SQL probing.
- Runtime protections: Use a web application firewall (WAF) or API gateway with SQL injection signatures or anomaly detection, tuned specifically for GLPI search endpoints to catch suspicious query-like input.

