/

CVE-2026-44556

Severity:

HIGH RISK

(7.1)

Broken Access Control in Open WebUI

CVE-2026-44556

Analyzed

Vulnerability type

Category:

Broken Access Control

CWE:

CWE-284, CWE-862

Impact:

Unauthorized Access to Protected Models and Data

Severity:

HIGH RISK

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

Open WebUI's OpenAI router exposes a /responses endpoint that forwards requests to upstream LLM providers without enforcing per-model access control.

Any authenticated user with a valid session can invoke arbitrary configured models by calling this proxy endpoint, bypassing the stricter checks applied to the primary chat completion API.

Affected context

This issue appears in Open WebUI deployments where multiple models are configured behind the OpenAI router, including models restricted to specific users, groups, or access grants.

The vulnerability is present when the /api/openai/responses endpoint is exposed to authenticated users and is used as a generic proxy to upstream LLM providers, but does not replicate the ownership, group membership, or AccessGrant checks applied by generate_chat_completion.

Any environment that relies on per-model authorization to separate tenants, teams, or sensitivity levels may be affected if users can reach this endpoint.

Exploit preconditions

  • Attack surface: HTTP(S) API endpoint /api/openai/responses exposed by Open WebUI.
  • Required access: Any authenticated user account with a valid session (no special roles or model permissions needed).
  • Trigger point: Sending a POST request to /api/openai/responses with a chosen model identifier in the request body.
  • Why exploitation is possible: The /responses proxy verifies only session validity via get_verified_user and omits the per-model ownership, group membership, and AccessGrant checks enforced by the primary chat completion path, enabling direct invocation of models regardless of configured access rules.

Why this happens

The root cause is inconsistent authorization enforcement between two code paths that reach the same upstream LLM infrastructure.

The primary generate_chat_completion handler enforces per-model access control by checking model ownership, group membership, and AccessGrants, while the /responses proxy path only validates session authenticity.

This divergence maps to CWE-284: Improper Access Control and CWE-862: Missing Authorization, where an endpoint exposes sensitive operations without applying the same authorization logic as other, better-protected entry points.

Conceptually, the proxy endpoint treats any authenticated user as authorized for all configured models, effectively collapsing model-level access boundaries.

Potential impact

  • Authenticated users may interact with models they are not intended to access, including restricted, paid, or tenant-specific models.
  • Users could indirectly access data or capabilities exposed only through certain models (for example, models fine-tuned on sensitive or proprietary datasets).
  • Cross-tenant or cross-group isolation may be weakened, enabling one group's users to leverage another group's models.
  • Operational costs may increase if high-cost models can be invoked by a wider audience than anticipated.
  • Security and compliance controls based on model segmentation may be undermined.

General mitigation guidance

Effective mitigation focuses on aligning authorization across all pathways that reach upstream LLM providers.

Common defensive patterns include:

  • Enforcing a single, shared authorization layer that all model invocation endpoints must call, ensuring consistent checks for ownership, group membership, and access grants.
  • Treating any "proxy" or "passthrough" endpoints as high risk and requiring them to reuse the same access control routines as primary business APIs.
  • Designing model configurations with explicit access policies, and failing closed when policy data is missing or cannot be evaluated.
  • Applying least-privilege principles so that authenticated sessions are not implicitly authorized for all models, and introducing clear separation of duties for administrative model management.
  • Centralizing policy configuration and avoiding ad hoc authorization checks dispersed across handlers or routes.

How teams detect issues like this

Detection efforts can center on both code-level and operational signals:

  • Static analysis / code review: Flag routes that invoke upstream LLM providers or sensitive operations without calling the standard authorization utilities used elsewhere in the codebase.
  • Policy checks: Enforce rules that all external-facing endpoints must explicitly reference a shared authorization function or middleware before forwarding requests.
  • Logging and monitoring: Instrument endpoints like /api/openai/responses with structured logs capturing user identity, model identifier, and authorization decisions, then alert on unexpected cross-model access patterns.
  • Automated security testing: Use integration tests to simulate users with differing model entitlements and validate that they cannot invoke models outside their assigned scope.

Sources

SourceLink
github.comgithub.com/open-webui/open-webui/security/advisories/GHSA-hp5m-24vp-vq2q

Frequently asked

questions

Yes, if the Open WebUI instance is exposed over the network and accessible to users who can authenticate. Any such user can send HTTP requests to the /api/openai/responses endpoint to exploit the missing per-model access control.

The attacker needs a valid authenticated session in Open WebUI. No special role, administrative access, or prior permission for a specific model is required; possession of any standard user account is sufficient to invoke arbitrary models via the vulnerable endpoint.

The safest pattern is to centralize authorization and require all model invocation paths—including proxy or "responses" endpoints—to call the same per-model authorization logic. This ensures that ownership, group membership, and access grants are evaluated uniformly, and that requests are denied by default when policy checks fail.

Future prevention involves adopting a policy of "authorize once, reuse everywhere" for sensitive operations. This includes implementing shared authorization middleware, conducting design reviews to identify alternate code paths to the same resources, and adding automated tests and static checks that verify every route touching models or other sensitive resources invokes the standardized authorization layer.

Find out what's already
exploitable in your codebase.