/

CVE-2026-47102

Severity:

HIGH RISK

(8.8)

Improper Authorization in LiteLLM update Endpoint

CVE-2026-47102

Modified

Vulnerability type

Category:

Improper Authorization

CWE:

CWE-863, CWE-915

Impact:

Privilege Escalation to Full Administrative Control

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

LiteLLM prior to version 1.83.10 allows authenticated users to arbitrarily change their own user_role via the /user/update endpoint.

Because the API does not restrict which fields may be modified, a user can escalate their privileges to proxy_admin and gain full administrative control over LiteLLM, including access to all users, teams, keys, models, and prompt history.

Affected context

This vulnerability arises in LiteLLM deployments where the /user/update endpoint is exposed to authenticated users for self-service account management.

The endpoint correctly limits updates to the caller's own account but does not enforce field-level authorization on the user_role attribute.

In environments where regular or org_admin users can reach this endpoint, they can modify their own role to proxy_admin, effectively bypassing intended admin boundaries and central access controls.

Exploit preconditions

  • Attack surface: HTTP API, specifically the /user/update endpoint.
  • Required access: Valid LiteLLM user session; users with org_admin role inherently have access and can exploit it without additional flaws.
  • Trigger point: Sending an update request that includes the user_role field set to a higher-privileged value such as proxy_admin for the caller's own account.
  • Why exploitation is possible: Authorization is enforced only at the resource level (own account) and not at the field level, so sensitive attributes like user_role are not protected by role-based checks or whitelisting.

Why this happens

The core issue is a lack of fine-grained authorization on sensitive fields within an otherwise correctly scoped update operation.

While the /user/update endpoint validates that a user may only modify their own account, it does not differentiate between benign profile attributes and powerful authorization attributes such as user_role.

This matches CWE-863: Improper Authorization, where the system fails to enforce appropriate access controls for a security-sensitive operation, in this case role management, allowing users to elevate their privileges by modifying fields that should be restricted to administrators.

Potential impact

  • A regular user may escalate to proxy_admin and gain full administrative privileges.
  • Org_admin users may bypass intended separation of duties and become proxy_admin without additional approval.
  • Access to all users, teams, API keys, models, and prompt history can be obtained or manipulated.
  • Creation, modification, or deletion of configuration and resources across the LiteLLM deployment.
  • Potential exposure or destruction of sensitive prompts, responses, and operational logs.

General mitigation guidance

Effective mitigation focuses on enforcing field-level authorization and principle of least privilege for account updates:

  • Treat role- and permission-related attributes (e.g., user_role) as security-sensitive and restrict their modification to trusted administrative paths only.
  • Implement an explicit allowlist of fields that ordinary users are permitted to update through self-service endpoints, excluding any authorization or ownership attributes.
  • Introduce server-side authorization checks that verify the caller's current role before allowing changes to privileged fields.
  • Centralize role management behind dedicated administrative workflows or services that require stronger authentication, auditing, and, where appropriate, multi-party approval.
  • Apply least-privilege design for non-admin roles, ensuring they do not inherently require broad account modification capabilities.

How teams detect issues like this

Detection can combine API-layer monitoring, code analysis, and policy enforcement:

  • Static analysis and code review: Look for update endpoints that accept arbitrary JSON payloads for user objects without explicit checks on role, permission, or ownership fields. Flag any controller or handler where user_role (or equivalent) is mapped directly from client input.
  • API contract and schema validation: Enforce schemas that restrict which fields clients can send on self-service user update routes; highlight deviations in automated tests or CI.
  • Logging and monitoring: Record role changes with old and new values, initiator identity, and source IP. Set alerts for unexpected transitions, such as non-admin users becoming proxy_admin or frequent role changes from the same actor.
  • Security tooling: Use automated API security scanners or policy-as-code frameworks to identify endpoints where authorization logic does not differentiate between benign and privileged fields.

Sources

SourceLink
gist.github.comgist.github.com/13ph03nix/9ec616e1fdc77b3673509c60206e827f
github.comgithub.com/BerriAI/litellm/commit/128d32d2494b759c5d15da3452452af4c6a34c01
github.comgithub.com/BerriAI/litellm/commit/e6f18ce75b111c9b93dc15c72894cbdeb53177ce
github.comgithub.com/BerriAI/litellm/pull/25541
github.comgithub.com/BerriAI/litellm/releases/tag/v1.83.10-stable
huntr.comhuntr.com/bounties/8e75edfb-ff05-4e63-bfca-2d93d03fb3b9
obsidiansecurity.comobsidiansecurity.com/blog/litellm-privilege-escalation-rce
vulncheck.comvulncheck.com/advisories/litellm-privilege-escalation-via-user-update
access.redhat.comaccess.redhat.com/security/cve/CVE-2026-47102
bugzilla.redhat.combugzilla.redhat.com/show_bug.cgi?id=2480634
security.access.redhat.comsecurity.access.redhat.com/data/csaf/v2/vex/2026/cve-2026-47102.json

Frequently asked

questions

Yes. Any user who can authenticate to LiteLLM and reach the /user/update endpoint over the network can exploit this issue, subject to whatever external network and authentication controls are in place.

An attacker must have a valid LiteLLM user account. Users with the org_admin role already have legitimate access to the endpoint and can exploit the vulnerability directly. Regular authenticated users may also be able to exploit it if they can call /user/update.

Implement strict field-level authorization for user updates. Only allow non-privileged users to modify a minimal, explicit set of non-security-sensitive fields, and restrict role or permission changes to dedicated administrative operations that require an already-privileged account.

Design user management APIs with clear separation between self-service and administrative capabilities, adopt explicit allowlists for updatable fields, treat role and permission attributes as privileged data, and enforce access control policies that are verified through code review, tests, and automated security checks.

Find out what's already
exploitable in your codebase.