Summary
Open WebUI versions prior to 0.1.124 contain an authorization flaw where the API does not correctly enforce that a user has an authorized role of user before granting access.
In deployments that allow open sign-ups, newly registered accounts with a default pending role may still be able to interact with application APIs that should be restricted to fully approved users.
Affected context
This issue arises in Open WebUI instances that:
- Are configured with new sign-ups enabled
- Assign new accounts a default
pendingrole until an admin approves them - Expose API endpoints that assume role checks are enforced server-side
In these setups, the API layer may fail to reliably distinguish between a pending user and a fully approved user, allowing operations that should only be permitted after administrative approval.
Exploit preconditions
- Attack surface: Open WebUI HTTP API endpoints.
- Required access: Ability to create or control a user account in
pendingstate (e.g., via open sign-up). - Trigger point: Issuing API requests that are intended for users with the
userrole while the account is stillpending. - Why exploitation is possible: The backend does not consistently enforce role-based access control and may rely on client-side assumptions or incomplete server-side validation, allowing
pendingusers to access protected functionality.
Why this happens
The vulnerability is rooted in incomplete server-side access control, where role checks are either missing, inconsistently applied, or rely on client-provided information.
This maps to CWE-863 (Incorrect Authorization), because the application fails to validate that a given request is associated with a subject authorized for the user role.
It is also related to CWE-602 (Client-Side Enforcement of Server-Side Security), as any reliance on the frontend to gate features by role allows an attacker to bypass controls by directly invoking backend APIs.
Abstractly, the insecure pattern is treating role transitions (from pending to user) as a UI concern rather than a strict server-side gate that must be checked for every sensitive operation.
Potential impact
- Pending users could gain access to features intended only for approved
useraccounts. - Attackers may be able to interact with AI models or data that should be restricted to authorized users.
- Expanded attack surface for further misuse of the platform's capabilities (e.g., large-scale automated interactions).
- Potential breach of administrative expectations around manual approval workflows.
General mitigation guidance
Effective mitigation centers on enforcing robust, server-side role-based access control:
- Treat the
pendingrole as a hard-deny state for any operation beyond registration and basic profile setup. - Implement centralized authorization checks that validate the authenticated user's role on every protected endpoint.
- Avoid relying on client-side role indicators or UI state to control access; the backend should be the single source of truth.
- Design roles and permissions explicitly, ensuring that default roles (like
pending) have minimal capabilities. - Apply the principle of least privilege so that newly created accounts cannot perform sensitive actions until an explicit promotion occurs.
How teams detect issues like this
Organizations can detect similar authorization weaknesses through:
- Static analysis rules that flag endpoints lacking explicit authorization or role checks.
- Code review checklists that require verifying role enforcement for all non-public APIs.
- Logging and monitoring for abnormal access patterns, such as
pendingor low-privilege accounts invoking high-privilege actions. - Automated security testing that attempts operations with accounts in different roles to validate least-privilege behavior.
- Policy enforcement in CI/CD pipelines to ensure new endpoints integrate with a central authorization framework.

