/

CVE-2026-37709

Severity:

CRITICAL RISK

(9.8)

Insecure Access Control / Authorization in Snipe-IT

CVE-2026-37709

Analyzed

Vulnerability type

Category:

Insecure Access Control / Authorization

CWE:

CWE-284

Impact:

Remote Code Execution

Severity:

CRITICAL RISK

(9.8)

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

An insecure permissions issue in Snipe-IT up to version 8.4.0 allows remote attackers to trigger arbitrary code execution through the app/Http/Controllers/Api/UploadedFilesController.php API component.

When access controls around uploaded file handling and execution are misconfigured, attackers can abuse the upload or file-processing flow to run server-side code under the web application's privileges.

Affected context

This vulnerability exists in Snipe-IT deployments that expose the Uploaded Files API and rely on its internal permission checks to protect file upload and processing paths.

It typically manifests where uploaded content can be stored in web-accessible or interpreter-reachable locations, and where permissions around who can upload or influence executed content are insufficiently constrained.

Multi-tenant or internet-facing instances with broad API access or weak authentication boundaries are especially exposed.

Exploit preconditions

  • Attack surface: HTTP(S) API endpoints associated with UploadedFilesController in Snipe-IT.
  • Required access: Ability to reach the affected API; depending on configuration, this may be unauthenticated or require low-privileged credentials.
  • Trigger point: File upload, file association, or subsequent processing route that interacts with uploaded content.
  • Why exploitation is possible: Authorization and permission checks around uploaded files are insufficient, allowing an attacker to influence how server-side code interprets or executes uploaded content, ultimately leading to arbitrary code execution under the application context.

Why this happens

The core issue maps to CWE-284: Improper Access Control, where the application fails to enforce strict permissions on sensitive operations.

In this case, the upload and processing logic in UploadedFilesController does not adequately restrict who can perform dangerous actions or how uploaded files can be used.

This can manifest as overly broad roles, missing authorization checks on critical controller methods, or trusting client-controlled parameters that influence code execution paths, leaving a gap where attacker-controlled inputs intersect with server-side execution capabilities.

Potential impact

  • Remote execution of arbitrary code on the Snipe-IT application server
  • Full compromise of the Snipe-IT instance, including asset and user data
  • Use of the compromised server as a pivot point into the surrounding network
  • Data theft, modification, or destruction within the asset management system
  • Installation of web shells or persistent backdoors in the hosting environment

General mitigation guidance

Effective mitigation focuses on tightening access control and reducing the power of file-handling paths:

  • Enforce strict authentication and role-based authorization on all file upload and related API endpoints, allowing only necessary roles to access them.
  • Treat uploaded files as untrusted data: store them outside of web roots and interpreter search paths, and avoid any dynamic execution or direct interpretation of uploaded content.
  • Apply strong server-side validation on file metadata and types, and decouple file storage from any logic that could result in code execution.
  • Run the application and associated services under least-privilege OS accounts with minimal file system and process execution rights.
  • Introduce defense-in-depth controls such as application-level feature flags for risky operations and centralized authorization policies reviewed by security teams.

How teams detect issues like this

Detection typically combines code-centric and operational approaches:

  • Use static analysis or manual review to find controller actions that perform sensitive operations without explicit, centralized authorization checks or policy enforcement.
  • Review framework middleware and route definitions to verify that all UploadedFilesController endpoints are protected by appropriate authentication and authorization layers.
  • Monitor logs for anomalous file upload patterns, unusual file types, or access to uploaded content from unexpected users, IP ranges, or automation.
  • Employ web application firewalls or API gateways with rules that restrict dangerous file types and enforce stricter access patterns on upload-related endpoints.

Sources

SourceLink
github.comgithub.com/grokability/snipe-it/commit/676a9958895a77de340565e7a0b17ae744664904
github.comgithub.com/grokability/snipe-it/security/advisories/GHSA-xg82-2hrv-hf64

Frequently asked

questions

Yes. As described, a remote attacker who can reach the affected API endpoints may be able to trigger arbitrary code execution if access controls are weak enough.

The required access depends on deployment configuration. In some setups, low-privileged or misconfigured accounts may be sufficient; in others, exposure could occur through overly permissive or unauthenticated API access.

Centralize and harden authorization around the uploaded files API, ensure that only necessary roles can use these endpoints, and remove any execution paths that allow uploaded content to influence server-side code execution.

Apply a defense-in-depth access control strategy: enforce strict role-based permissions on sensitive controllers, treat all uploaded content as untrusted, avoid executing or directly interpreting user-controlled files, and regularly review authorization logic through code review and automated checks.

Find out what's already
exploitable in your codebase.