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.

