/

CVE-2026-48507

Severity:

HIGH RISK

(7.1)

Access Control Flaw (CWE-863) in Snipe-IT User Edit Flow

CVE-2026-48507

Analyzed

Vulnerability type

Category:

Missing Authorization / Access Control

CWE:

CWE-863

Impact:

Privilege Abuse and Admin Account Lockout

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

Snipe-IT contains an access control flaw that allows a non-admin user with only the granular users.edit permission to modify critical account status fields for any user.

By editing the activated and ldap_import flags, such a user can lock all administrators out of the instance and block password reset flows, effectively causing a denial of service for legitimate admins.

Affected context

This issue occurs in Snipe-IT deployments where granular permissions are used and non-admin users are granted the users.edit capability.

The vulnerability manifests in the user management functionality when the same edit permission that is intended for routine profile changes also allows modification of high-impact fields, such as login activation and LDAP import flags, without additional privilege checks.

Environments that delegate user management to helpdesk or support roles are more exposed, as those roles may not be expected to perform security-sensitive account control operations.

Exploit preconditions

  • Attack surface: Snipe-IT web interface, specifically the user edit functionality.
  • Required access: Authenticated, non-admin account with the users.edit permission.
  • Trigger point: Submitting updates to user records, including administrator accounts, via the edit form or corresponding API endpoints.
  • Why exploitation is possible: The system performs insufficient authorization checks on critical account-control fields (activated, ldap_import), treating them as editable by any user who has generic user-edit privileges instead of restricting them to privileged administrators or dedicated account-control operations.

Why this happens

The core issue aligns with CWE-863: Incorrect Authorization, where permissions are checked too broadly or at the wrong granularity.

The application grants users.edit permission holders the ability to modify entire user records, including fields that directly govern login eligibility and password reset behavior.

Instead of enforcing field-level or operation-specific authorization for security-sensitive attributes, the implementation relies on a coarse-grained permission that does not distinguish between benign profile edits and actions that can disable or lock out administrative accounts.

This design leads to excessive authority being bundled into a single permission and exposes critical control paths to lower-privileged users.

Potential impact

  • Non-admin users with users.edit may disable all administrator accounts by toggling the activated flag.
  • Helpdesk or delegated roles could unintentionally or maliciously create a denial of service for Snipe-IT administration.
  • Administrators may be prevented from using standard password reset mechanisms due to manipulation of the ldap_import flag.
  • Incident response and recovery processes can be delayed if the last remaining admin-capable accounts are locked out.
  • Audit trails and accountability may be weakened if unauthorized changes to admin accounts are not clearly distinguished.

General mitigation guidance

Mitigation should focus on strengthening authorization boundaries around security-sensitive user attributes and minimizing the authority granted to non-admin roles.

Common patterns include:

  • Applying field-level authorization so that only highly privileged roles can toggle login, activation, and identity-source flags, even if less-privileged users can edit non-critical profile information.
  • Separating routine user profile management from account control operations (activation, deactivation, reset eligibility), and protecting these operations with stricter permissions and possibly stronger authentication or workflow approval.
  • Designing permissions to be least-privilege by default, avoiding broad edit rights that cover both harmless and high-impact fields.
  • Implementing configuration options to constrain who can manage administrator or elevated accounts, such as disallowing lower-privileged users from editing users above their own role level.
  • Ensuring administrative access recovery mechanisms (e.g., out-of-band admin creation or emergency access) exist so that misconfigurations or abuse cannot permanently lock out legitimate owners.

How teams detect issues like this

Detection efforts can center on both code-level analysis and runtime monitoring:

  • Static analysis and code review: Examine controller or service logic that handles user updates to ensure that sensitive fields (e.g., activation, authentication source, role, group membership) enforce stricter authorization checks than generic user-edit operations.
  • Policy and test enforcement: Introduce automated tests or security policies that assert only specific roles can modify critical account fields, and that non-admin roles are restricted to low-risk attributes.
  • Logging and alerting: Capture detailed audit logs whenever account status or authentication-related attributes change, especially for admin accounts; configure alerts on unusual patterns such as multiple admins being deactivated in a short time.
  • Automated tooling: Utilize application security testing tools or custom linters to flag endpoints where high-impact account changes share the same permission as ordinary edits, prompting manual review.

Sources

SourceLink
github.comgithub.com/grokability/snipe-it/commit/403f9c848b05274642f64450696bdcdc242a352a
github.comgithub.com/grokability/snipe-it/security/advisories/GHSA-6f75-x745-xcpr

Frequently asked

questions

Yes, if the Snipe-IT instance is exposed over the network and a remote user can authenticate with an account that has the users.edit permission, they can exploit this issue through normal web or API access.

No. Exploitation only requires a non-admin account with the granular users.edit permission. The flaw is that this permission also allows editing critical admin account flags without additional checks.

The safest fix is to introduce stricter, field-level authorization for sensitive user attributes and separate permissions for high-risk account-control actions, ensuring only designated admin roles can change them. Reducing the scope of generic edit permissions and enforcing role hierarchy checks further strengthens protection.

Prevention involves designing a clear authorization model from the outset, treating account status and role-related fields as privileged operations, and systematically enforcing least privilege. Regular security-focused code reviews, automated tests around permission boundaries, and explicit documentation of which fields are security-sensitive help catch similar flaws before release.

Find out what's already
exploitable in your codebase.