/

CVE-2026-55460

Severity:

HIGH RISK

(7.1)

Authorization Bypass (CWE-863) in Snipe-IT Bulk User Delete

CVE-2026-55460

Modified

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-863

Impact:

Privilege Abuse / Unauthorized User Deletion

Severity:

HIGH RISK

(7.1)

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 authorization bypass in Snipe-IT allows authenticated non-admin users with view and edit permissions to soft-delete other non-admin users via the bulk save endpoint.

The issue becomes risky in deployments where fine-grained permission models are relied upon to prevent non-admins from performing delete operations on user accounts.

Affected context

This vulnerability occurs in Snipe-IT installations that expose the /users/bulksave endpoint and rely on role-based permissions to separate view, edit, and delete capabilities.

It affects scenarios where non-admin users are granted users.view and users.edit privileges but explicitly denied users.delete, yet can still issue bulk operations against other non-admin user accounts.

Exploit preconditions

  • Attack surface: Web application interface and HTTP API (the /users/bulksave endpoint)
  • Required access: Authenticated non-admin account with users.view and users.edit permissions but not users.delete
  • Trigger point: Sending a crafted POST request to /users/bulksave with delete_user=1 targeting another non-admin user
  • Why exploitation is possible: The BulkUsersController::destroy() path authorizes only update capability, failing to enforce the distinct delete permission, which allows soft-deletion operations under insufficient authorization.

Why this happens

The underlying bug is an authorization logic flaw where permission checks do not properly differentiate between update and delete actions on user records.

By authorizing the bulk delete pathway using only update privileges, the controller violates the intended access control policy that separates editing from deletion rights.

This maps to CWE-863: Incorrect Authorization, in which a resource operation (soft-deleting users) is allowed based on incomplete or inappropriate permission checks, enabling users to perform actions outside their intended privilege scope.

Potential impact

  • Non-admin users may soft-delete other non-admin user accounts without having delete permissions.
  • Asset management and audit trails could be disrupted by unauthorized removal of user records.
  • User access workflows can be undermined, leading to account deactivation or confusion about legitimate user status.
  • Administrative overhead may increase due to unexpected user deletions requiring manual recovery or investigation.

General mitigation guidance

Mitigation strategies focus on tightening authorization boundaries and ensuring that each sensitive operation is guarded by the correct permission checks.

Recommended patterns include:

  • Separating update and delete operations at the controller level, with explicit checks for both actions.
  • Centralizing authorization logic so that bulk actions reuse the same permission checks as single-record operations.
  • Modeling permissions in a way that delete operations require a distinct, higher-privilege capability than edit operations.
  • Applying least-privilege principles when assigning roles, ensuring non-admin users receive only the minimum capabilities required for their tasks.
  • Regularly reviewing authorization mappings to confirm that business rules about who can delete accounts are accurately reflected in code.

How teams detect issues like this

Effective detection can combine code-level and behavior-level analysis:

  • Static analysis and code review: Look for controller methods handling bulk operations that authorize based on generic update permissions but perform delete-like actions. Flag endpoints that modify deleted or status fields without explicit delete permission checks.
  • Policy enforcement: Maintain a security policy requiring that any operation altering account lifecycle states (such as soft-delete) must invoke dedicated authorization checks tied to delete permissions.
  • Logging and monitoring: Instrument user-management endpoints to log who initiates deletion-like actions and compare those activities against assigned roles and permissions to identify anomalies.
  • Automated review tools: Use application security scanners or authorization-focused linters to detect inconsistent permission application across CRUD operations.

Sources

SourceLink
github.comgithub.com/grokability/snipe-it/commit/374f426f0c6bb7a4f129f7b85051cc1da753a0f5
github.comgithub.com/grokability/snipe-it/releases/tag/v8.6.2
github.comgithub.com/grokability/snipe-it/security/advisories/GHSA-vgx7-c78r-69w9

Frequently asked

questions

Exploitation is limited to authenticated non-admin users who already possess view and edit permissions for user records. Those users can leverage the bulk save endpoint to soft-delete other non-admin accounts, but they cannot typically affect admin accounts if the application restricts such operations.

The attacker must have a valid non-admin login and be granted users.view and users.edit permissions while lacking users.delete. With this combination of rights, they can send crafted POST requests to the /users/bulksave endpoint to trigger unauthorized soft deletions.

The safest pattern is to enforce strict, operation-specific authorization checks. Any action that changes account lifecycle state—such as soft-delete, deactivate, or remove—should require explicit delete or equivalent high-privilege permissions, and bulk operations must reuse these same checks rather than relying only on update privileges.

Prevention typically involves designing a clear, consistent permission model, centralizing authorization logic, and implementing automated tests that verify each controller action requires the correct permission. Periodic security reviews of access control paths, combined with logging and monitoring for unusual delete activity, help catch regressions early.

Find out what's already
exploitable in your codebase.