Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAttacker authenticates with low-privilege Snipe-IT account
-
DeliveryCrafts XHTML or XML file with embedded JavaScript payload
-
ExploitUploads file as asset attachment, bypassing finfo SVG sanitization gate
-
ExecutionVictim administrator opens attachment inline via UploadedFilesController
-
PersistBrowser executes JavaScript same-origin in victim's session
-
ImpactAttacker captures session token or performs privileged CSRF action
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Output encoding, context-aware escaping
MITRE ATT&CK
2 techniques across 2 tactics: Initial Access, Execution The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | The attacker must hold a valid Snipe-IT account with file upload permissions - the CVSS PR:L metric confirms authentication at the low-privilege level is required; unauthenticated exploitation is not possible. The target instance must be running a version prior to 8.6.2. A second prerequisite is victim interaction (UI:A): a separate user, typically an administrator, must actively open the malicious attachment inline in their browser - the exploit does not trigger on upload alone. The MIME-type bypass is specifically conditional on the uploaded file being XHTML or XML rather than SVG, since PHP's finfo reports a non-SVG type and skips sanitization. No non-default Snipe-IT configuration setting is required; any deployment that permits low-privilege file uploads - the default posture for many installations - is vulnerable. Exploitation is bounded by the need for both an attacker-controlled account and an identifiable victim who will open the attachment. |
| Impact | The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:L/UI:A/SC:H/SI:H/SA:N) scores 6.2, placing this in the medium band. The SC:H/SI:H metrics are the critical signal: successful exploitation yields same-origin JavaScript execution within the victim's active session, enabling session-token theft, CSRF-driven privileged actions, or exfiltration of asset data visible to the victim - impacts typical of stored XSS against an administrative user. The constraining factors are PR:L (attacker must hold a valid account with upload permissions) and UI:A (a second user must actively open the attachment inline). These prerequisites meaningfully reduce opportunistic mass exploitation risk. No CISA KEV listing exists and no EPSS data was provided in the source intelligence; combined, this indicates no observed widespread exploitation at time of analysis. Despite the modest score, the privilege-escalation dynamic - a low-privilege user targeting an administrator via a plausible workflow artifact - makes this a real operational risk in multi-user Snipe-IT deployments. The attack complexity is low once an account is obtained, and the finfo MIME-type bypass technique is well understood in the PHP security community. |
| Exploit ScenarioDerived | An attacker with a low-privilege Snipe-IT account crafts an XHTML file embedding a JavaScript payload - such as a script that exfiltrates document.cookie to an attacker-controlled endpoint - and uploads it as an attachment to an asset record. When an administrator later opens the attachment inline through the Snipe-IT interface to review it, UploadedFilesController serves the XHTML same-origin without sanitization, the browser executes the embedded script in the administrator's session, and the attacker receives the stolen session token. No public proof-of-concept has been identified at time of analysis, though the finfo MIME-bypass technique requires no specialized tooling. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jul 10, 2026
Stored cross-site scripting in Snipe-IT prior to 8.6.2 enables a low-privilege authenticated user to upload malicious XHTML or XML files that bypass the SVG sanitization gate and execute arbitrary JavaScript in any viewer's browser when the attachment is opened inline. The bypass works because UploadFileRequest only sanitizes SVG content when PHP's finfo extension reports image/svg+xml - uploading XHTML or generic XML evades this check - while UploadedFilesController serves the file same-origin without invoking StorageHelper::allowSafeInline(), completing the injection path. No public exploit code or CISA KEV listing has been identified at time of analysis; the vendor released a confirmed fix in version 8.6.2.
RemediationAI
Upgrade Snipe-IT to version 8.6.2 or later, the vendor-confirmed fix released via commit 000cea0a622d586366cf60d2240c7c2a4b17c955 (https://github.com/grokability/snipe-it/commit/000cea0a622d586366cf60d2240c7c2a4b17c955) and documented in the security advisory GHSA-jhph-5q74-pmfx. As a compensating control prior to patching, restrict file upload permissions to the smallest set of trusted roles - eliminating the low-privilege upload vector removes the attacker's entry point entirely; the trade-off is reduced self-service capability for end users. A second compensating measure is to configure the web server or reverse proxy to force Content-Disposition: attachment on all files served from the uploads path, preventing inline rendering; note this will break any existing inline preview functionality for PDFs and images. Deploying a strict Content-Security-Policy header that blocks inline scripts on the Snipe-IT origin can also limit same-origin JavaScript execution as a defense-in-depth measure, though CSP misconfiguration can introduce false assurance. Patch deployment is the only complete remediation.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 packages in composer, euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Snipe-IT is a PHP-based open-source IT asset and license management platform. The vulnerability spans two components: UploadFileRequest (the upload validator) and UploadedFilesController (the attachment-serving controller). Sanitization in UploadFileRequest is gated on PHP's finfo extension detecting the MIME type image/svg+xml; XHTML and XML files carrying embedded script elements report different MIME types and pass through unsanitized. UploadedFilesController then serves these files as inline attachments without calling StorageHelper::allowSafeInline(), meaning the browser receives the content with its original MIME type and renders it in-page, executing any embedded JavaScript in the application's same-origin context. CWE-79 (Improper Neutralization of Input During Web Page Generation) is the root cause class: user-supplied active content is not neutralized before it reaches a victim's rendering context. The fix is implemented in commit 000cea0a622d586366cf60d2240c7c2a4b17c955 and shipped as release v8.6.2.
Know when PHP gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:A/VC:N/VI:N/VA:N/SC:H/SI:H/SA:N
PR:L for authenticated low-privilege upload; UI:R for victim opening attachment; S:C and limited C/I reflect same-origin session JavaScript access.
Primary rating from Vendor (github).
CVSS VectorVendor: github
Lifecycle Timeline
1DescriptionCVE.org
Snipe-IT is an IT asset/license management system. Prior to 8.6.2, UploadFileRequest sanitizes SVG content only when PHP finfo reports image/svg+xml and UploadedFilesController serves attachments inline without using StorageHelper::allowSafeInline(), allowing a low-privilege user to upload active XHTML or XML content that is later served same-origin and executes JavaScript in a viewer’s browser. This issue is fixed in version 8.6.2.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Cross-Site Scripting occurs when an application accepts untrusted data and sends it to a web browser without proper validation or encoding.
In PHP versions 7.1.x below 7.1.33, 7.2.x below 7.2.24 and 7.3.x below 7.3.11 in certain configurations of FPM setup it
sapi/cgi/cgi_main.c in PHP before 5.3.12 and 5.4.x before 5.4.2, when configured as a CGI script (aka php-cgi), does not
(1) boardData102.php, (2) boardData103.php, (3) boardDataJP.php, (4) boardDataNA.php, and (5) boardDataWW.php in Netgear
The '/common/download_agent_installer.php' script in the Quest KACE System Management Appliance 8.0.318 is accessible by
ProjectSend versions prior to r1720 are affected by an improper authentication vulnerability. Rated critical severity (C
Roundcube Webmail contains a critical PHP object deserialization vulnerability (CVE-2025-49113, CVSS 9.9) that allows au
Util/PHP/eval-stdin.php in PHPUnit before 4.8.28 and 5.x before 5.6.3 allows remote attackers to execute arbitrary PHP c
Palo Alto Networks PAN-OS management web interface contains an authentication bypass allowing unauthenticated attackers
Nagios XI version xi-5.7.5 is affected by OS command injection. Rated high severity (CVSS 8.8), this vulnerability is re
Nagios XI version xi-5.7.5 is affected by OS command injection. Rated high severity (CVSS 8.8), this vulnerability is re
The get_referers function in /opt/ws/bin/sblistpack in Sophos Web Appliance before 3.7.9.1 and 3.8 before 3.8.1.1 allows
The Backup Migration plugin for WordPress is vulnerable to Remote Code Execution in all versions up to, and including, 1
EUVD-2026-42996
GHSA-jhph-5q74-pmfx
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB