/

CVE-2026-44567

Severity:

HIGH RISK

(7.3)

Authorization Bypass / Access Control in Open WebUI Role

CVE-2026-44567

Analyzed

Vulnerability type

Category:

Authorization Bypass / Access Control

CWE:

CWE-602, CWE-863

Impact:

Privilege Escalation / Unauthorized Access

Severity:

HIGH RISK

(7.3)

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

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 pending role 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 pending state (e.g., via open sign-up).
  • Trigger point: Issuing API requests that are intended for users with the user role while the account is still pending.
  • 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 pending users 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 user accounts.
  • 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 pending role 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 pending or 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.

Sources

SourceLink
github.comgithub.com/open-webui/open-webui/security/advisories/GHSA-4vg5-rp28-gvjf

Frequently asked

questions

Yes, in typical deployments where Open WebUI is exposed over a network. An attacker with the ability to register a new account can attempt to exploit weak role enforcement remotely.

The attacker generally needs only the ability to create or control a pending user account, which is possible when open sign-ups are enabled or when registration workflows are loosely controlled.

Implement centralized, server-side role checks for all protected resources, ensuring that pending users are explicitly denied access to operations intended for user or admin roles, regardless of client behavior.

Adopt a consistent access control architecture where every endpoint consults a trusted authorization layer, minimize default privileges for new accounts, and incorporate authorization-focused tests and reviews into the development lifecycle.

Find out what's already
exploitable in your codebase.