/

CVE-2026-36720

Severity:

HIGH RISK

(8.1)

Privilege Misconfiguration (CWE-284) in Bookcars v8.3

CVE-2026-36720

Deferred

Vulnerability type

Category:

Authorization / Access Control

CWE:

CWE-284

Impact:

Privilege Escalation to Administrator

Severity:

HIGH RISK

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

Bookcars v8.3 contains an authorization weakness that allows a logged-in user to change their own account type from regular user to administrator.

If an attacker can exploit this insecure permission model, they may gain full administrative capabilities within the application.

Affected context

The issue appears in the authorization and role management layer of Bookcars v8.3, where user accounts have a mutable "user type" or role attribute.

In deployments where the backend trusts client-controlled parameters or lacks strict server-side checks on role changes, authenticated users may be able to modify their own user type.

This typically arises when the same update pathway is used for both self-service profile edits and administrative role assignments without proper separation of duties.

Exploit preconditions

  • Attack surface: Application endpoints that update user profiles or account attributes, including user type or role fields.
  • Required access: Valid authenticated user account (non-admin).
  • Trigger point: Sending a crafted request that alters the user type value (e.g., from standard user to admin) using available account update functionality or exposed APIs.
  • Why exploitation is possible: The backend enforces insufficient authorization on role-changing operations, allowing users to update security-sensitive attributes that should be restricted to administrative workflows.

Why this happens

This vulnerability stems from an access control misconfiguration where authorization is not enforced on security-sensitive fields, specifically the user type or role attribute.

Rather than having the server derive and tightly control roles based on privileged workflows, the implementation appears to accept and persist user type changes from any authenticated context.

This maps to CWE-284: Improper Access Control, where the system fails to restrict access and modification of privileged state, enabling horizontal-to-vertical privilege escalation.

Conceptually, the same update mechanism is reused for both benign profile data and critical authorization attributes, without separate permission checks or context-aware enforcement.

Potential impact

  • An attacker can escalate privileges from a normal user to an administrator.
  • Compromised accounts could manage or modify other users, including locking them out or changing their roles.
  • Sensitive data accessible only to administrators could be viewed, modified, or exfiltrated.
  • Application configuration, business rules, or content governed by admin interfaces could be altered.
  • Subsequent abuse might facilitate broader compromise of connected systems or data stores.

General mitigation guidance

Effective mitigation focuses on strict server-side authorization for any operation that touches roles, permissions, or other security-sensitive attributes.

General defensive patterns include:

  • Separating profile-update logic from administrative user management APIs to avoid shared, overly permissive endpoints.
  • Ensuring the server completely ignores client-provided role or user-type fields in self-service contexts, deriving such values only from privileged actions.
  • Implementing explicit permission checks before any change to a role, group, or privilege flag, tied to administrative capabilities rather than general authentication.
  • Treating role fields as immutable for regular users, using dedicated admin-only paths and workflows for any permission changes.
  • Applying least-privilege principles in the data model so that the default and most common account types have minimal permissions.

How teams detect issues like this

Detection efforts can target both the codebase and runtime behavior:

  • Static analysis / code review:
  • Identify endpoints or handlers that update user records and examine whether role/user-type fields are writable from general user contexts.
  • Look for direct binding of client-supplied JSON/form parameters into entire user objects, especially where role attributes are not filtered out server-side.
  • Flag any missing or generic authorization checks (e.g., "authenticated" only) on methods that alter user roles or permission sets.
  • Policy and testing:
  • Define security policies that prohibit client-driven role changes and enforce them via automated linting or review checklists.
  • Include abuse-case tests in QA, such as attempting to modify roles using standard user accounts and validating that the server rejects such requests.
  • Use application security testing tools or custom scripts to fuzz user-update endpoints, checking for unexpected privilege changes.

Sources

SourceLink
github.comgithub.com/CC-T-454455/Vulnerabilities/tree/master/bookcars/vulnerability-3

Frequently asked

questions

Yes, it can typically be exploited remotely by any authenticated user who can access the affected account update or role-related endpoints, assuming no additional network-layer restrictions.

The attacker generally needs a valid non-administrative user account. Once logged in, they can attempt to modify their user type or role to obtain administrative privileges.

The most robust fix is to enforce strict server-side authorization on all role and permission changes, ensuring that only dedicated administrative contexts can modify user types, and that client input cannot directly set or override these attributes.

Adopting a defense-in-depth approach helps: treat roles as strictly server-controlled, segregate admin and user functionality, perform threat modeling around access control decisions, and incorporate automated checks and tests that verify unauthorized users cannot alter their privileges.

Find out what's already
exploitable in your codebase.