/

CVE-2026-54329

Severity:

HIGH RISK

(8.5)

Authorization Bypass (CWE-862) in Snipe-IT Accessories API

CVE-2026-54329

Analyzed

Vulnerability type

Category:

Authorization Bypass / Access Control

CWE:

CWE-862

Impact:

Cross-tenant Data Tampering

Severity:

HIGH RISK

(8.5)

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

A missing authorization control in the Snipe-IT Accessories API allows low-privileged users to create accessory records under companies they do not belong to when Full Multiple Companies Support is enabled.

By mass-assigning the company_id attribute, an attacker can bypass tenant isolation and inject data into other companies' asset inventories.

Affected context

This vulnerability appears in deployments of Snipe-IT where:

  • Full Multiple Companies Support is enabled to support multi-tenant use,
  • The Accessories API create endpoint is exposed to authenticated users with limited roles,
  • The company_id field on the Accessory model is mass-assignable and not constrained by per-request authorization checks.

In such environments, accessory creation requests can be crafted to associate new records with a different company than the one the user is legitimately assigned to.

Exploit preconditions

  • Attack surface: Snipe-IT Accessories API create endpoint.
  • Required access: Authenticated, low-privileged account belonging to at least one company in a multi-company deployment.
  • Trigger point: Submission of an accessory creation request that includes a company_id value for a company the user should not control.
  • Why exploitation is possible: The server-side logic relies on mass assignment of request parameters into the Accessory model without enforcing that company_id aligns with the authenticated user's allowed companies, effectively omitting a critical authorization check (CWE-862).

Why this happens

The underlying issue is a missing authorization validation on a sensitive, tenant-scoping field (company_id) during mass assignment.

The Accessories API directly maps incoming request parameters to model attributes, trusting the client to supply a legitimate company_id value.

Because the application does not verify that this value belongs to a company the user is authorized to act for, attackers can cross company boundaries and create data in other tenants' scopes.

This aligns with CWE-862: Missing Authorization, where operations are allowed based solely on authentication without enforcing resource-level access control.

Potential impact

  • Attackers could create accessory records under other companies' inventories.
  • Cross-tenant data pollution may occur, complicating asset tracking and reporting.
  • Malicious or misleading records can be introduced into another company's asset management workflows.
  • Indirect integrity issues may arise if downstream processes or integrations trust accessory data to be tenant-isolated.

General mitigation guidance

Effective mitigation focuses on enforcing strict, server-side authorization around tenant-scoping fields and limiting mass assignment:

  • Treat fields such as company_id as server-controlled, deriving their values from the authenticated user's context rather than trusting client input.
  • Introduce explicit authorization checks that validate whether the user is allowed to operate on a specific company before persisting any record.
  • Constrain mass assignment so that only non-sensitive attributes are bindable from request parameters, using explicit whitelists or dedicated DTOs.
  • Apply a consistent multi-tenant access control pattern, ensuring every create, update, and delete operation is scoped to the user's permitted companies by default.

How teams detect issues like this

Organizations can detect similar issues by:

  • Reviewing API controllers and services for operations where client-supplied identifiers (such as company_id, tenant_id, or organization IDs) are directly assigned to models without authorization checks.
  • Using static analysis or linters configured to flag mass-assignment on fields marked as tenant- or ownership-scoping.
  • Implementing code review checklists that explicitly call out the need to verify tenant isolation and resource-level authorization for all multi-tenant operations.
  • Adding automated tests that attempt to perform cross-company operations with low-privileged accounts to validate isolation guarantees.

Sources

SourceLink
github.comgithub.com/grokability/snipe-it/commit/6a0ec6945126a79fc25c0990c99abe632db370c3
github.comgithub.com/grokability/snipe-it/commit/dc8cbf4786bb38b260b4ae1723ec9e7f81d82fe5
github.comgithub.com/grokability/snipe-it/commit/e2bea57146eb3a3781b5eb21b69d7e04cc87c268
github.comgithub.com/grokability/snipe-it/releases/tag/v8.6.2
github.comgithub.com/grokability/snipe-it/security/advisories/GHSA-pwpj-p52h-q484

Frequently asked

questions

Yes. Any authenticated user with network access to the Snipe-IT API can exploit the issue by calling the Accessories create endpoint, provided Full Multiple Companies Support is enabled.

The attacker needs a valid, low-privileged account in at least one company. No elevated administrative rights are required; the weakness lies in missing authorization checks during accessory creation.

The safest pattern is to remove client control over tenant-scoping fields like company_id and derive them from the authenticated session, while enforcing explicit authorization checks before creating or modifying records. Additionally, limit mass assignment to non-sensitive attributes and handle sensitive fields separately in trusted server-side code.

Adopt a consistent access control design where every request is checked against both authentication and resource-level authorization, especially in multi-tenant environments. Combine this with strict mass-assignment controls, security-focused code reviews, and automated tests that verify that users cannot act outside their assigned companies or tenants.

Find out what's already
exploitable in your codebase.