/

CVE-2026-29047

Severity:

HIGH RISK

(7.2)

SQL Injection in GLPI Logs Export Feature

CVE-2026-29047

Analyzed

Vulnerability type

Category:

SQL Injection

CWE:

CWE-89

Impact:

Authenticated SQL Injection Leading to Data Exposure and Modification

Severity:

HIGH RISK

(7.2)

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's logs export feature contains a SQL injection vulnerability that allows an authenticated user to manipulate database queries.

Under specific conditions, crafted input in the export parameters can alter the underlying SQL, potentially exposing or modifying sensitive data stored in the GLPI database.

Affected context

The vulnerability affects GLPI instances running versions from 10.0.0 up to (but not including) 10.0.24 and 11.0.6.

It occurs in the logs export functionality, where user-controlled input is incorporated into SQL statements used to build export queries.

The issue is only reachable by authenticated users with access to the logs export feature, and is more impactful in environments where those accounts have broad visibility across assets, tickets, or administrative data.

Exploit preconditions

  • Attack surface: GLPI web application, specifically the logs export interface.
  • Required access: Valid authenticated GLPI account with permission to access and use log export features.
  • Trigger point: Submission of specially crafted parameters or filters within the export/logs query flow.
  • Why exploitation is possible: User-supplied values are concatenated or directly embedded into SQL statements without robust parameterization or sufficient server-side validation, enabling manipulation of the query structure.

Why this happens

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

Within the logs export feature, the application appears to treat user-supplied export or filter parameters as trusted, incorporating them into SQL queries without consistently using prepared statements or strong server-side sanitization.

This pattern allows control characters and SQL syntax from user input to influence the execution path of the database query, turning data input into query logic and enabling injection.

Potential impact

  • May allow retrieval of data beyond what the authenticated user should normally access.
  • Could enable modification or deletion of records if the constructed query interacts with write-capable operations.
  • Can expose sensitive configuration or user-related information stored in the database.
  • May assist an attacker in mapping database structure and identifying additional weaknesses.

General mitigation guidance

Defensive strategies for this class of issue focus on strict separation between data and query logic:

  • Use parameterized queries or prepared statements for all database interactions, especially those involving dynamic filters or export criteria.
  • Centralize query construction in a data access layer that enforces parameter binding and forbids string-concatenated SQL.
  • Apply strict server-side validation and canonicalization to export and filter parameters, whitelisting expected formats and values.
  • Implement least-privilege database accounts so the application's DB user can only perform the minimum required operations, reducing impact if injection occurs.
  • Design logging and export features to reference pre-defined query templates instead of allowing arbitrary, user-driven SQL-like expressions.

How teams detect issues like this

High-level detection typically combines code-centric and behavior-centric approaches:

  • Static analysis rules that flag SQL query construction using string concatenation or interpolation with user-controllable variables.
  • Code review checklists specifically calling out export, reporting, and search features as high-risk for injection, verifying use of prepared statements.
  • Database activity monitoring or query logging to detect anomalous patterns such as unexpected UNIONs, subqueries, or tautological conditions coming from web sessions.
  • Security testing (including automated DAST or manual penetration testing) focused on log/export parameters to identify inputs that alter query structure.

Sources

SourceLink
github.comgithub.com/glpi-project/glpi/security/advisories/GHSA-3m49-qf92-vccr

Frequently asked

questions

No. Exploitation requires an authenticated GLPI user account with access to the logs export feature; anonymous users cannot directly trigger the vulnerable functionality.

An attacker needs valid credentials and sufficient permissions to access the logs export functionality. The more permissions and visibility the account has, the more impactful the injected queries may become.

The most robust fix is to ensure all queries used by the logs export feature are built using parameterized queries or prepared statements and that any dynamic components are constrained to vetted, whitelisted values or pre-defined query fragments. Avoid any string-based SQL construction that directly incorporates user input.

Adopt a secure data access layer that mandates parameterization, enforce strict input validation for filters and export options, and incorporate automated security checks (static analysis and security-focused code review) into the development pipeline, especially for reporting and export functionality.

Find out what's already
exploitable in your codebase.