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/bulksaveendpoint) - Required access: Authenticated non-admin account with
users.viewandusers.editpermissions but notusers.delete - Trigger point: Sending a crafted POST request to
/users/bulksavewithdelete_user=1targeting 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
deletedorstatusfields 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.

