/

CVE-2026-26263

Severity:

HIGH RISK

(8.1)

SQL Injection in GLPI Search Engine

CVE-2026-26263

Analyzed

Vulnerability type

Category:

SQL Injection

CWE:

CWE-89

Impact:

Unauthenticated SQL Injection leading to data exfiltration and potential data manipulation

Severity:

HIGH RISK

(8.1)

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

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.

Sources

SourceLink
github.comgithub.com/glpi-project/glpi/security/advisories/GHSA-346p-qj3v-9rxj

Frequently asked

questions

Yes. As long as an attacker can reach the GLPI web interface where the search engine is exposed, they can attempt to exploit the vulnerability without local access to the server.

No. The issue is described as an unauthenticated SQL injection, meaning an attacker does not need valid GLPI credentials if the vulnerable search functionality is publicly accessible.

The safest pattern is to remove any direct string-based SQL construction influenced by user input and replace it with parameterized queries or a safe query abstraction that enforces strict separation between query structure and data, combined with strong validation and allowlisting of search parameters.

Adopt a secure coding standard that mandates parameterized database access, integrate static analysis for injection patterns into the CI pipeline, require security-focused code reviews for features that build dynamic queries (such as search), and regularly test key endpoints with automated and manual security testing focusing on injection risks.

Find out what's already
exploitable in your codebase.