/

CVE-2026-44832

Severity:

HIGH RISK

(8.8)

Broken Access Control / Authorization in Snipe-IT User API

CVE-2026-44832

Modified

Vulnerability type

Category:

Broken Access Control / Authorization

CWE:

CWE-281, CWE-863

Impact:

Privilege Escalation to Administrator

Severity:

HIGH RISK

(8.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

Snipe-IT contains an authorization flaw where an authenticated user with only the users.edit permission can escalate their own privileges to admin via the user update API.

By abusing insufficient permission checks on the /api/v1/users/{id} PATCH endpoint, a non-admin user can modify their permission set and gain full administrative capabilities.

Affected context

This vulnerability occurs in Snipe-IT deployments where:

  • Role and permission management is handled via the REST API
  • Users with limited roles are granted the ability to edit user records (users.edit)
  • The backend controller for /api/v1/users/{id} trusts client-supplied permission arrays, stripping only the superuser key while allowing other permission flags (including admin) to be set

The issue is exposed when user accounts are managed programmatically or via clients that call the API directly, not just through the web UI.

Exploit preconditions

  • Attack surface: Authenticated Snipe-IT REST API (/api/v1/users/{id}) for user management
  • Required access: A valid account with users.edit capability or equivalent permission to update user records via PATCH
  • Trigger point: Sending a crafted PATCH request that includes permissions[admin]=1 (and potentially other permission keys) for the attacker's own user ID
  • Why exploitation is possible: The authorization logic only strips the superuser key from the permission payload and does not enforce server-side checks to prevent non-admin users from assigning themselves admin or additional permissions

Why this happens

The underlying issue is a broken access control pattern where authorization decisions are made too coarsely and rely on client-controlled data.

Specifically, the API endpoint responsible for updating user records accepts a permissions array from the client and only removes the superuser entry before saving the remainder.

This maps to CWE-863: Incorrect Authorization, because the system fails to ensure that only appropriately privileged actors can assign or modify high-privilege roles like admin.

It is also related to CWE-281: Improper Preservation of Permissions, as the design does not safeguard the integrity of permission assignments when updates are processed.

Instead of deriving effective roles solely from trusted server-side logic, the API trusts the user's submitted permission flags, allowing privilege escalation via crafted requests.

Potential impact

  • A regular user can escalate their account to an admin role
  • Attackers may gain full control over Snipe-IT configuration, assets, and license data
  • Unauthorized creation, modification, or deletion of users, assets, and audit records
  • Potential exposure or tampering of sensitive inventory and license information managed in Snipe-IT
  • Indirect impact on connected systems through misconfigured assets or altered integrations

General mitigation guidance

Risk reduction centers on enforcing strict, server-side authorization for role and permission changes and minimizing trust in client-supplied permission structures.

Common defensive patterns include:

  • Defining a clear separation between "edit user details" and "manage roles/permissions," with the latter restricted to highly privileged roles only
  • Enforcing server-side checks that prevent any user from assigning roles or permissions that exceed their own effective privilege level
  • Treating permissions and roles as server-managed attributes, ignoring or strictly validating any client-supplied permission arrays
  • Implementing whitelists of editable fields per role or per endpoint, and rejecting updates to fields outside that whitelist
  • Applying least-privilege principles when assigning management capabilities such as users.edit, ensuring they are only granted where strictly necessary

These patterns help ensure that even if users can edit certain account details, they cannot independently elevate their privileges.

How teams detect issues like this

Detection typically focuses on identifying both insecure patterns in code and anomalous permission changes in runtime logs:

  • Static analysis and code review:
  • Flag endpoints that accept and persist permission or role data directly from client input
  • Look for controllers that modify authorization-related fields without explicit, role-based guard checks
  • Review any logic that filters or strips specific permission flags while leaving others unchecked
  • Policy and configuration checks:
  • Enforce secure coding guidelines that prohibit trusting client-supplied role or permission arrays
  • Implement mandatory reviews for API endpoints that change user roles, groups, or permission sets
  • Operational monitoring:
  • Log all changes to user roles and permissions, including who made the change and from where
  • Set alerts for unusual patterns, such as non-admin users gaining admin privileges or multiple rapid permission changes for a single account
  • Automated tooling:
  • Use application security testing tools (DAST/IAST) configured to probe for privilege escalation by modifying permission-related parameters
  • Integrate automated checks into CI/CD pipelines to detect regressions in access control logic

Sources

SourceLink
github.comgithub.com/grokability/snipe-it/commit/ce18ff669ceb0f0349749fd5d11c1d3d40b10569
github.comgithub.com/grokability/snipe-it/security/advisories/GHSA-hq28-crg7-95pr

Frequently asked

questions

Yes, it can be exploited remotely by any authenticated user with network access to the Snipe-IT API, provided they have the users.edit capability or similar rights to update user records.

The attacker must have a legitimate Snipe-IT account with permission to edit users.

No prior admin access is required; the flaw allows escalation from a lower-privilege account to an admin role through crafted API requests.

The safest pattern is to centralize and strictly control all changes to roles and permissions on the server side.

Only designated high-privilege roles should be able to modify authorization-related attributes, and the server should ignore or reject client attempts to set roles or permission flags beyond what their current role allows.

Prevention relies on explicit, defense-in-depth authorization design:

  • Treat any field related to roles, permissions, or access levels as sensitive and subject to robust server-side checks
  • Apply least privilege when designing roles and capabilities, ensuring that users cannot manage permissions beyond their scope
  • Incorporate systematic access control reviews into code review, threat modeling, and automated testing
  • Maintain detailed logging and regular audits of role and permission changes to quickly detect misconfigurations or abuses.
Find out what's already
exploitable in your codebase.