/

CVE-2026-22248

Severity:

HIGH RISK

(8.0)

Unsafe Deserialization in GLPI Technician File Handling

CVE-2026-22248

Analyzed

Vulnerability type

Category:

Unsafe Deserialization

CWE:

CWE-502

Impact:

Remote Code Execution by Authenticated User

Severity:

HIGH RISK

(8.0)

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 before 11.0.5 contain an unsafe PHP instantiation flaw that allows an authenticated technician to upload a malicious file and have it executed by the application.

Under specific conditions where uploaded content is later instantiated or processed as PHP objects, this can lead to arbitrary code execution within the GLPI server context.

Affected context

The vulnerability occurs in GLPI deployments where technician-level users can upload files that are later processed by PHP code in a way that instantiates classes or objects based on file content or metadata.

It is relevant in environments where technicians have legitimate access to the GLPI interface and where the server executes PHP code with sufficient privileges to impact configuration, data, or underlying infrastructure.

Exploit preconditions

  • Attack surface: Web application (GLPI HTTP interface).
  • Required access: Valid, authenticated GLPI account with technician-level permissions and access to the affected upload functionality.
  • Trigger point: Server-side processing of the uploaded file, where PHP performs unsafe object instantiation or similar logic tied to file content.
  • Why exploitation is possible: The code path trusts data associated with an uploaded file and instantiates PHP objects without adequately constraining what can be loaded or executed, aligning with CWE-502 (unsafe deserialization/instantiation).

Why this happens

The core issue is the use of unsafe PHP instantiation patterns that treat user-influenced data as a source for object creation or dynamic behavior.

When a technician uploads a file, parts of its content, name, or metadata are later interpreted in a way that allows controlled object instantiation or method invocation.

This behavior corresponds to CWE-502: Deserialization of Untrusted Data, generalized here as unsafe object instantiation, where the application fails to restrict which classes or behaviors can be activated from data controlled by a non-admin user.

Potential impact

  • Arbitrary PHP code execution in the GLPI application context.
  • Complete compromise of the GLPI instance, including configuration, assets, and ticket data.
  • Theft or tampering of IT asset inventories, service desk records, and credentials stored in the system.
  • Lateral movement within the infrastructure if GLPI has access to other internal systems or services.
  • Use of the GLPI server as a foothold for further attacks or as a platform for persistence.

General mitigation guidance

Mitigation typically focuses on constraining how file uploads are processed and eliminating unsafe dynamic instantiation paths:

  • Treat all uploaded content as untrusted and avoid using file content or user-controlled metadata to determine classes, handlers, or executable logic.
  • Replace dynamic object instantiation from data with explicit, whitelist-based mappings where only known-safe classes and operations are permitted.
  • Enforce strict validation and sanitization on file uploads, including type checks, size limits, and storage in non-executable locations.
  • Apply least-privilege principles to the PHP execution environment and the GLPI application, limiting the impact of a successful exploit.
  • Separate upload processing from sensitive operations, ensuring that uploaded files cannot influence configuration or high-privilege code paths.

How teams detect issues like this

Effective detection revolves around surfacing unsafe object handling and suspicious upload behavior:

  • Use static analysis or code scanning rules targeting PHP patterns such as dynamic class instantiation, unserialize-like behaviors, or reflection driven by user-controlled input.
  • During code review, flag any logic that:
  • Instantiates objects based on file content or user-supplied parameters.
  • Dynamically loads classes or handlers from values derived from uploads or request parameters.
  • Monitor application logs for anomalous upload behavior, such as unexpected file types, repeated upload attempts, or access patterns followed immediately by unusual server-side errors or spikes.
  • Employ web application firewalls or application-layer monitoring capable of flagging suspicious file uploads and subsequent execution paths.

Sources

SourceLink
github.comgithub.com/glpi-project/glpi/security/advisories/GHSA-c9q3-mcxq-9vr4

Frequently asked

questions

Yes, but only by authenticated users. An attacker must be able to access GLPI over the network and authenticate as a technician (or another role with equivalent upload capabilities) to exploit the issue.

Exploitation requires a valid GLPI account with technician-level permissions that allow uploading files through the affected functionality. Anonymous or unauthenticated users cannot directly trigger this flaw under normal configurations.

The safest pattern is to remove any dynamic object instantiation or deserialization driven by user-controlled data and replace it with explicit, whitelist-based logic. Uploaded files should be treated as passive data only, stored in non-executable locations, and never used as a source for class names, methods, or configuration directives.

Adopt a defensive design approach where uploaded content and other user input are never trusted to control program flow:

  • Establish secure coding guidelines for avoiding unsafe deserialization and dynamic instantiation.
  • Integrate static analysis and security review into the development lifecycle to flag high-risk patterns early.
  • Regularly audit file upload paths and ensure that they only perform strictly necessary, non-executable processing on user-supplied data.
Find out what's already
exploitable in your codebase.