/

CVE-2026-25932

Severity:

HIGH RISK

(7.2)

Cross-Site Scripting (XSS) in GLPI Supplier Fields

CVE-2026-25932

Analyzed

Vulnerability type

Category:

Cross-Site Scripting (XSS)

CWE:

CWE-79, CWE-116

Impact:

Stored Cross-Site Scripting leading to session hijacking, data theft, and UI compromise

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, an IT asset and service management platform, contains a stored cross-site scripting vulnerability that allows an authenticated technician to inject malicious JavaScript into supplier fields.

When other users view the affected supplier data in the web interface, the injected script can execute in their browser, potentially compromising their session and data.

Affected context

The vulnerability occurs in GLPI deployments where technician-level users can create or modify supplier records and those records are later rendered in the web UI without sufficient output encoding.

It primarily affects views or components that display supplier fields in a browser context, especially where HTML is interpreted and script execution is possible.

The risk is higher in environments where technicians have broad access and other, more privileged users routinely view supplier information through the GLPI interface.

Exploit preconditions

  • Attack surface: GLPI web application, specifically pages that display supplier fields.
  • Required access: Valid, authenticated GLPI account with at least technician-level permissions capable of editing or creating supplier entries.
  • Trigger point: Any view or page render where stored supplier fields containing the payload are displayed to a user's browser.
  • Why exploitation is possible: User-controlled input in supplier fields is stored and later rendered without consistent, context-aware HTML/JavaScript output encoding, allowing injected scripts to execute in the victim's browser.

Why this happens

The root cause aligns with CWE-79: Improper Neutralization of Input During Web Page Generation (Cross-Site Scripting).

User-supplied content in supplier fields is accepted, stored, and then incorporated into HTML responses without proper output encoding for the specific browser context (e.g., HTML body, attribute, or JavaScript context).

This lack of robust, context-aware escaping means that special characters and script constructs are not neutralized, enabling injected JavaScript to run when another user views the compromised supplier data.

CWE-116 (Improper Encoding or Escaping of Output) is also relevant, as the application does not reliably encode stored content before rendering it in the browser.

Potential impact

  • Malicious scripts may execute in the browser of any user who views the affected supplier entries.
  • Attackers could steal session cookies or tokens, potentially leading to account takeover.
  • Sensitive data visible in the GLPI UI, such as asset details or tickets, could be exfiltrated.
  • The attacker could perform actions on behalf of the victim (e.g., modifying tickets, assets, or configurations) via forged requests.
  • Browser-based payloads could be used to spread the attack further within the application interface.

General mitigation guidance

Effective mitigation focuses on defensive output encoding and strict handling of user-controlled content:

  • Apply context-aware output encoding to all supplier fields before rendering them in HTML, attributes, or JavaScript blocks.
  • Centralize templating and rendering logic to ensure that all dynamic content passes through encoding helpers rather than being directly concatenated into HTML.
  • Enforce server-side validation rules to restrict supplier fields to expected character sets and formats, reducing the risk of script-like input being stored.
  • Consider applying a Content Security Policy (CSP) that disallows inline scripts and restricts script sources, reducing the impact of stored XSS if it occurs.
  • Use a "safe-by-default" templating framework where variables are escaped automatically, and unescaped output requires explicit developer opt-in.

How teams detect issues like this

Organizations can identify and monitor this class of issue through a combination of review and testing:

  • Use static analysis or security linters to flag unescaped variables rendered into HTML templates, especially for fields that originate from user input such as supplier data.
  • Conduct focused code reviews around form handling, persistence, and rendering of supplier entities, paying attention to any raw HTML output or manual concatenation of strings into responses.
  • Employ dynamic application security testing (DAST) tools configured to probe for stored XSS by injecting harmless markers and verifying whether they execute when re-displayed.
  • Integrate security checks into CI/CD to block changes that introduce new unescaped browser contexts or bypass existing encoding utilities.

Sources

SourceLink
github.comgithub.com/glpi-project/glpi/security/advisories/GHSA-m627-945g-x7xh

Frequently asked

questions

Exploitation requires an authenticated GLPI user with at least technician-level permissions who can create or edit supplier records. Unauthenticated attackers cannot directly exploit this issue without first obtaining valid credentials.

Yes, it can be exploited remotely over the network through the GLPI web interface, as long as the attacker can log in with a suitable account and another user subsequently views the manipulated supplier data.

The most robust fix pattern is to ensure all supplier fields are rendered using context-aware output encoding in the server-side templates or view layer, combined with validation to restrict unexpected characters and enforcing a secure-by-default templating approach.

Standardize on frameworks and template engines that escape output by default, mandate security-focused code reviews for any UI changes, add automated tests or scanners for XSS, and consider deploying restrictive content security policies to reduce the impact of any residual issues.

Find out what's already
exploitable in your codebase.