/

CVE-2026-44555

Severity:

HIGH RISK

(7.6)

Missing Authorization in Open WebUI Model Composition

CVE-2026-44555

Analyzed

Vulnerability type

Category:

Missing Authorization

CWE:

CWE-862

Impact:

Privilege Escalation via Unauthorized Access to Restricted Models

Severity:

HIGH RISK

(7.6)

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 model composition feature allows users to define custom models that delegate inference to a base model, but prior to version 0.9.0 it failed to re-check authorization on the referenced base model.

As a result, any user permitted to create models could chain their custom model to a restricted base model and invoke it, causing the server to run requests against that restricted model using the platform's privileged API key.

Affected context

This vulnerability appears in Open WebUI deployments where:

  • Model composition is enabled via base_model_id
  • Users are allowed to create or import custom models by default
  • Certain base models are intended to be restricted (e.g., premium, safety-hardened, or admin-only models)
  • Access control checks are implemented at the "composed model" level but not consistently enforced on the underlying base model

The issue specifically affects environments that rely on Open WebUI's role- or permission-based access control to prevent regular users from invoking certain base models while still letting them register new composed models.

Exploit preconditions

  • Attack surface: Open WebUI HTTP API / web interface for model creation/import and model invocation.
  • Required access: A regular user account with:
  • Permission to create or import custom models, and
  • Permission to invoke their own models.
  • Trigger point: Creating a new model that references a restricted base model via base_model_id, then sending inference requests to the newly created composed model.
  • Why exploitation is possible:
  • The model creation/import endpoints accept arbitrary base_model_id values without verifying the caller's authorization on the referenced base model.
  • The access control pipeline validates access only on the composed model, and never re-verifies that the caller is allowed to use the base model.
  • The server subsequently dispatches the request to the restricted base model using admin-configured credentials, effectively proxying the attacker's request with elevated privileges.

Why this happens

The underlying bug falls under CWE-862: Missing Authorization and stems from incomplete enforcement of access control across a chained resource relationship.

In Open WebUI's design, a composed model is a logical wrapper that delegates inference to a base model identified by base_model_id. The authorization layer correctly enforces whether the caller may use the composed model, but it fails to:

  • Validate that the caller has permission to reference a given base_model_id during model creation/import.
  • Re-check authorization on the base model when a composed model is invoked.

This creates a "secondary resource" gap: access to a wrapper entity (the composed model) implicitly confers use of another, more sensitive resource (the base model) without a corresponding authorization decision. The pattern is typical of systems where:

  • Permissions are checked only at the outermost object, and
  • Inner dependencies or chained resources are assumed to be safe because they were configured by an administrator, but are in fact user-controlled through fields like base_model_id.

Potential impact

  • Unauthorized invocation of restricted base models that were intended to be admin-only or limited to specific user groups.
  • Abuse of premium or costlier models at the expense of the organization's API quota or billing account.
  • Bypass of content, safety, or policy filters if restricted base models enforce stricter controls than general-purpose models.
  • Expansion of an attacker's effective permissions in the AI platform, enabling them to perform higher-sensitivity inference tasks.
  • Indirect exposure of capabilities tied to the admin's API key, depending on how the downstream model provider enforces access scope.

General mitigation guidance

Effective mitigation focuses on enforcing authorization consistently across all layers of model composition and preventing users from escalating privileges through chained resources.

Pattern-level mitigations include:

  • Enforce authorization on secondary resources: Treat base_model_id as a protected resource identifier. During model creation/import and invocation, verify that the caller is authorized to use the referenced base model, not just the composed model.
  • Constrain user-controlled references: Avoid letting regular users supply arbitrary identifiers for sensitive resources. Provide a curated list of allowed base models per role or tenant and enforce that base_model_id values are drawn from this list.
  • Separate admin and user configuration spaces: Keep administrative model configurations (including restricted base models) in an isolated configuration domain that regular users cannot reference or import into their own definitions.
  • Implement defense-in-depth in access control: Apply checks at multiple stages (model definition, persistence, and runtime dispatch) so that a single missed validation does not grant unauthorized access.
  • Use least privilege for outbound credentials: Where possible, configure downstream API keys with the minimum scope needed, and avoid using a single highly privileged credential for all requests.

How teams detect issues like this

Detection primarily involves identifying inconsistent authorization patterns and suspicious model compositions.

High-level approaches include:

  • Static and configuration review:
  • Inspect model creation/import endpoints to ensure they enforce per-resource authorization on base_model_id.
  • Look for code paths where composed models are invoked and verify that base model permissions are re-checked.
  • Flag patterns where user-controlled identifiers are passed directly into routing logic without permission validation.
  • Policy-based access control checks:
  • Implement automated tests or policy engines that assert "no user may indirectly access a resource they cannot directly access," especially for chained model relationships.
  • Enforce rules that prevent regular users from binding to admin-only model identifiers.
  • Runtime logging and anomaly detection:
  • Log the caller identity, composed model ID, and base model ID for each inference request.
  • Monitor for regular users invoking composed models that reference base models outside their normal permission set.
  • Automated tooling:
  • Use security linters or application security scanners that can model role-permission matrices and identify missing authorization checks around secondary resources.

Sources

SourceLink
github.comgithub.com/open-webui/open-webui/security/advisories/GHSA-9vvh-qmjx-p4q8

Frequently asked

questions

Yes, if Open WebUI is exposed over a network and users can authenticate and create models. An attacker only needs network access to the interface and a valid user account with model-creation permission to exploit the issue.

The attacker needs a standard user account with:

  • Permission to create or import custom models, and
  • Permission to invoke their own models.

They do not need administrator privileges or direct access to restricted base models.

The safest approach is to enforce authorization checks on the base model whenever it is referenced:

  • Validate base_model_id against the caller's permissions during model creation/import.
  • Re-check base model access at invocation time to ensure that calling a composed model never bypasses restrictions on underlying resources.

Additionally, limit which base models can be used by which roles and ensure that administrative models cannot be referenced by regular users.

Design access control around clear resource boundaries and apply checks wherever resources are linked:

  • Treat every referenced resource (like a base model) as requiring its own authorization decision.
  • Use centralized authorization middleware that consistently enforces policies on both primary and secondary objects.
  • Perform regular security reviews focusing on composition features (wrappers, proxies, and chains), and add automated tests that verify users cannot gain access to restricted resources via indirection.
Find out what's already
exploitable in your codebase.