CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-61807

CVE-2026-61807: Stored DOM-Based Cross-Site Scripting in Snipe-IT

Alon Barad
Alon Barad
Software Engineer

Aug 20, 2026·6 min read·19 visits

Executive Summary (TL;DR)

Authenticated low-privilege users can execute arbitrary JavaScript in the browsers of administrators by creating or renaming a manufacturer or supplier with a crafted malicious payload, exploiting unsafe client-side DOM construction via jQuery.

A Stored DOM-based Cross-Site Scripting (DOM XSS) vulnerability exists in Snipe-IT versions prior to 8.6.2. The vulnerability occurs when a stored manufacturer or supplier name is converted to CamelCase and rendered within the 'data-selected-count-id' attribute of a table. Client-side JavaScript retrieves this decoded attribute and performs unsafe string concatenation, passing it directly into jQuery's '.after()' method, enabling authenticated attackers to execute arbitrary JavaScript in the victim's session.

Vulnerability Overview

Snipe-IT is an open-source asset management platform built on the Laravel framework. The application relies on client-side components to manage dynamic data visualization, specifically utilizing jQuery and Bootstrap Table. These table structures render elements with dynamic attributes derived from user-defined metadata, such as manufacturer and supplier names. This architecture presents an attack surface when user inputs are processed through client-side scripting sinks.\n\nThe vulnerability classified as CVE-2026-61807 represents a Stored DOM-based Cross-Site Scripting (DOM XSS) flaw. An authenticated attacker with permissions to create or update manufacturer or supplier resources can insert HTML metacharacters into the name fields. Because the backend does not sanitize or strip these characters during CamelCase transformation, the payload remains intact. When other users view these pages, the client-side JavaScript reads the decoded attribute and executes the injected script.\n\nThe impact is localized primarily to the browser session of the victim, which can be an administrator. This execution context allows session hijacking, token theft, and administrative actions performed on behalf of the victim. This analysis investigates the root cause, exploitation methodology, and remediation actions required to eliminate the vulnerability.

Root Cause Analysis

The root cause of CVE-2026-61807 is located in the sequence of template rendering and subsequent DOM manipulation. In the Laravel Blade template, the data-selected-count-id attribute is assigned a value that represents a camel-cased version of the manufacturer or supplier name. The application utilizes the Illuminate\\Support\\Str::camel() helper function to format the string. While this helper converts word spacing and case structures, it does not neutralize or escape HTML metacharacters.\n\nWhen rendering the page, Laravel Blade escapes HTML special characters inside the attribute to prevent direct server-side HTML injection. However, once the document object model is fully initialized, the web browser automatically decodes these entities. When client-side scripts query the attribute, they receive the decoded, raw text representation. This is where the transition from server-side security to client-side risk occurs.\n\nThe client-side script uses jQuery's .data('selected-count-id') method to extract the formatted identifier. In jQuery, .data() automatically parses and decodes the requested attribute, preserving the dangerous payload. The application then performs a substring operation to strip the leading symbol and concatenates this value into a raw HTML template. This concatenated string is passed directly to jQuery's .after() method, which functions as an active DOM sink.

Code Analysis

To understand the exact mechanics of the vulnerability, we must examine the difference between the vulnerable codebase and the patched implementation. The vulnerable code constructs an HTML string by directly concatenating the user-controlled countId value. This pattern is risky because it allows arbitrary HTML elements and script handlers to be parsed by jQuery.\n\njavascript\n// Vulnerable implementation in resources/views/partials/bootstrap-table.blade.php\nvar countId = $(this).data('selected-count-id');\nif (!countId) return;\nvar $paginationDetail = $(this).closest('.bootstrap-table')\n .find('.fixed-table-pagination').first()\n .find('.pagination-detail');\nif ($paginationDetail.length && $(countId).length === 0) {\n // Dangerous HTML construction via string concatenation\n $paginationDetail.after('<span id="' + countId.substring(1) + '" style="display:none; float:left; margin-top:10px; margin-bottom:10px; margin-left:10px; line-height:34px;">&mdash; <span class="badge">0</span> {{ trans(\'general.selected\') }}</span>');\n}\n\n\nThe patched version resolves this vulnerability by completely removing the raw HTML string concatenation pattern. Instead, it utilizes secure jQuery element constructors where attributes are defined as key-value pairs, preventing syntax-level injection. Furthermore, the patch utilizes document.createTextNode() to append the delimiter and label text. This forces the browser to treat the input strictly as plain-text data rather than executable markup.\n\njavascript\n// Patched implementation utilizing programmatic DOM element construction\nif ($paginationDetail.length && !document.getElementById(rawCountId)) {\n var $selectedCount = $('<span/>', {\n id: rawCountId,\n style: 'display:none; float:left; margin-top:10px; margin-bottom:10px; margin-left:10px; line-height:34px;'\n });\n // Text nodes prevent the parsing of HTML tags and script elements\n $selectedCount.append(document.createTextNode('— '));\n $selectedCount.append($('<span/>', { 'class': 'badge', text: '0' }));\n $selectedCount.append(document.createTextNode(' {{ trans(\'general.selected\') }}'));\n $paginationDetail.after($selectedCount);\n}\n

Exploitation & Attack Methodology

Exploitation of this vulnerability requires the attacker to have privileges to create or edit manufacturers or suppliers. An attacker with asset manager credentials can navigate to the creation interface and insert a specially crafted payload into the "Name" field. The payload must bypass the CamelCase transformation while retaining valid HTML metacharacters. A payload structure such as x[foo=\'><svg/onload=alert(document.cookie)>\'] achieves this.\n\nWhen an administrative user or any other operator accesses the detail page for the affected manufacturer, the server generates the page containing the bootstrap table. The table element is rendered with the malicious payload nested inside the data-selected-count-id attribute. Because the browser parses the attribute context, it decodes the entities. The client-side Bootstrap Table script then executes on the post-body.bs.table event.\n\nThe client-side code retrieves the attribute value, extracts the payload, and performs unsafe string concatenation. When jQuery's .after() method parses the output, the injected <svg> block is integrated into the DOM. The browser immediately processes the SVG element and executes the nested JavaScript handler. This executing payload operates within the security context of the victim's session, enabling actions such as session hijacking or API manipulation.

Impact Assessment

The impact of this vulnerability is assessed as Medium severity, with a CVSS v4.0 base score of 6.3. The attack requires low-privileged credentials and relies on passive user interaction. However, the subsequent impact on the confidentiality and integrity of the victim's session is high. If the victim has administrative privileges, the attacker can hijack the session completely.\n\nAn administrative session hijack within Snipe-IT allows the attacker to read, modify, or delete sensitive IT assets, licenses, and user directories. The attacker can execute arbitrary API calls, manipulate hardware allocations, or potentially configure backdoors in the system. Because Snipe-IT acts as a central repository for an enterprise's IT hardware and software assets, access to this platform poses a risk to overall infrastructure integrity.\n\nCurrently, this vulnerability is not listed in CISA's Known Exploited Vulnerabilities catalog, and there are no active weaponized exploits publicly available. The Exploit Prediction Scoring System score is low, reflecting the localized nature of the flaw. However, security teams must treat this with priority because the barrier to entry for exploitation is low once credentials are acquired.

Remediation & Mitigation

The definitive remediation for CVE-2026-61807 is upgrading the Snipe-IT installation to version 8.6.2 or higher. This version integrates the secure DOM construction methods described in the code analysis, resolving the underlying vulnerability. Administrators should apply the update during a standard maintenance window. No additional database migrations are required to implement this fix.\n\nFor environments where an immediate upgrade is not feasible, temporary mitigation strategies can be implemented. Configuring a robust Content Security Policy (CSP) that prohibits inline scripts provides significant defense against this vector. Snipe-IT includes native support for CSP, which can be activated by setting ENABLE_CSP=true in the environment configuration file. This stops the execution of injected script tags even if the DOM is successfully modified.\n\nAdditionally, administrators can restrict write access to the manufacturer and supplier creation interfaces to reduce the attack surface. Implementing network segregation and monitoring application access logs for unexpected metacharacters in input parameters are also recommended. These defense-in-depth measures provide temporary protection until the application is fully patched.

Official Patches

GrokabilityFix commit addressing unsafe DOM element construction in bootstrap-table.blade.php
GrokabilityGitHub Security Advisory

Fix Analysis (1)

Technical Appendix

CVSS Score
6.3/ 10
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:P/VC:L/VI:L/VA:N/SC:H/SI:H/SA:N

Affected Systems

Snipe-IT

Affected Versions Detail

Product
Affected Versions
Fixed Version
Snipe-IT
Grokability
< 8.6.28.6.2
AttributeDetail
CWE IDCWE-79
Attack VectorNetwork (AV:N)
CVSS v4.0 Score6.3
Exploit StatusProof of Concept / Theoretical
CISA KEV StatusNot Listed
ImpactStored DOM-Based Cross-Site Scripting (DOM XSS)

MITRE ATT&CK Mapping

T1189Drive-by Compromise
Initial Access
T1185Browser Session Hijacking
Collection
CWE-79
Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')

Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')

Vulnerability Timeline

Initial codebase commits refactoring table row selection
2026-05-22
Final patch commit introducing safe element constructors
2026-06-12
Official release of Snipe-IT v8.6.2 containing the fix
2026-08-19
Publication of NVD entry and CVE record
2026-08-19

References & Sources

  • [1]GitHub Security Advisory GHSA-c8qc-wf67-342w
  • [2]Snipe-IT Patch Commit
  • [3]Snipe-IT v8.6.2 Release Notes
  • [4]CVE.org Record
  • [5]NVD Entry

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•14 minutes ago•GHSA-QX75-2P3R-PWM5
7.7

CVE-2026-55622: Cross-Project Instance Copy Authorization Bypass in Canonical LXD and LXC Incus

CVE-2026-55622 (GHSA-qx75-2p3r-pwm5) is an improper access control vulnerability (CWE-284) in Canonical LXD and LXC Incus (tracked as GHSA-c9f5-j9c3-mhrg). In multi-tenant deployments utilizing project-based isolation, the REST API handler for instance creation via POST /1.0/instances verifies that the authenticated user has authorization in the destination project specified by the query parameter, but fails to verify whether the user holds read or view permissions for the source instance when executing a copy operation across projects. Consequently, an authenticated client restricted to a single project can clone instances or snapshots from unauthorized projects into their own project, resulting in complete disclosure of the target instance filesystem and embedded credentials.

Amit Schendel
Amit Schendel
1 views•11 min read
•about 1 hour ago•GHSA-7MR3-28H5-M5VX
7.7

GHSA-7mr3-28h5-m5vx: Authorization Bypass and Cross-Project Volume Copy in Canonical LXD

An authorization bypass vulnerability in Canonical LXD (tracked as GHSA-7mr3-28h5-m5vx and CVE-2026-55621, and as GHSA-64f3-v33m-w89f in Linux Containers Incus) allows an authenticated user with restricted project access to copy custom storage volumes and volume snapshots from unauthorized projects. The flaw resides in the storagePoolVolumesPost REST API handler, which verifies permissions on the destination project but fails to check whether the caller holds view entitlements on the source project or volume specified in the request body.

Alon Barad
Alon Barad
2 views•10 min read
•about 2 hours ago•GHSA-47W9-6R3F-938G
9.9

GHSA-47w9-6r3f-938g: Authorization Bypass and Host Root Command Execution in Canonical LXD and Incus

A missing authorization and configuration validation vulnerability in Canonical LXD and LXC Incus allows authenticated users within restricted projects to bypass project security boundaries. By smuggling prohibited low-level configuration directives (such as raw.lxc or raw.qemu) inside instance snapshots or backup archives, an attacker can restore these configurations within a restricted project and execute arbitrary commands with root privileges on the underlying host operating system.

Alon Barad
Alon Barad
4 views•11 min read
•about 3 hours ago•GHSA-JPF8-86F3-WP38
9.9

CVE-2026-48752: Arbitrary Host File Read and Write via Templates Symlink in Canonical LXD and Incus

A symbolic link traversal vulnerability (CWE-59) in Canonical LXD and Linux Containers Incus allows an authenticated user with image import permissions to read and write arbitrary files on the host filesystem. During image archive unpacking, the daemon fails to reject top-level symbolic links for the instance `templates` directory. Subsequent requests to the instance template API endpoints follow this symbolic link outside the instance storage directory with root privileges, enabling complete host compromise.

Amit Schendel
Amit Schendel
4 views•10 min read
•1 day ago•CVE-2026-12411
8.4

CVE-2026-12411: Cross-Guest Volume Hijack via DevLXD Device PATCH in Canonical LXD

CVE-2026-12411 is a broken access control vulnerability in the DevLXD interface of Canonical LXD versions 6.6 through 6.8. The flaw resides in the devLXDInstancePatchHandler component, which fails to verify storage volume ownership when an instance attaches a new disk device via the /dev/lxd guest socket. When the security.devlxd.management.volumes configuration option is enabled, an untrusted guest or DevLXD identity can issue a crafted HTTP PATCH request referencing another tenant's custom storage volume. The LXD host daemon subsequently mounts the target volume into the requesting guest, permitting unauthorized cross-tenant read and write operations.

Amit Schendel
Amit Schendel
7 views•10 min read
•1 day ago•CVE-2026-105769
9.3

CVE-2026-105769: Azure Entra ID Token Exfiltration in Kaniko via Unanchored ACR Hostname Regex

CVE-2026-105769 (GHSA-5q7h-w9jf-cx97, GO-2026-6225) is an origin validation error and credential exfiltration vulnerability affecting Kaniko prior to version 1.25.20. The flaw stems from an unanchored regular expression in the integrated Azure Container Registry (ACR) credential helper (github.com/chrismellard/docker-credential-acr-env). When Kaniko processes a Dockerfile containing an image reference hosted on a lookalike domain containing an ACR suffix as a substring (e.g., x.azurecr.io.attacker.com), the credential helper acquires a Microsoft Entra ID access token for Azure Resource Manager and transmits it via HTTP POST to the attacker-controlled host.

Amit Schendel
Amit Schendel
11 views•11 min read