NewApp Monitoring is liveSign up free
AgentbeamBeta
AI agent vulnerability · Open WebUI

CVE-2026-44555: Open WebUI's Base Model Routing Bypasses Access Control via Model Chaining

highCVSS 3.1 7.6GHSA-9vvh-qmjx-p4q8

Open WebUI up to 0.8.12 checks access only on the model a user calls, not on the base model it chains to. Any user can create a wrapper model whose base_model_id points at a restricted model, then call it. The server forwards the request with the admin's API key. Access grants on paid or internal models stop working. Fixed in 0.9.0.

Published May 8, 2026 · Updated May 15, 2026 · Analysis Oct 28, 2026

What an attacker can do

Open WebUI lets a user define a model that sits on top of another one through base_model_id. check_model_access() in utils/models.py runs only against the user-facing model. When the chat pipeline in main.py resolves the base model, it rewrites payload["model"] to the base ID and the openai.py and ollama.py routers dispatch it, with no second access check. The create (create_new_model) and import (import_models) endpoints also accept any base_model_id without asking whether the caller may use it.

The attacker needs an account with model creation permission. That is the default workspace.models permission, granted to all users. They POST /api/v1/models/create with an id of their choice and base_model_id set to the restricted model, then POST /api/chat/completions against their own wrapper. They own it, so the check passes, and the upstream call goes out under the admin-configured key. The import endpoint gives the same bypass and can also overwrite existing models.

The result is that group restrictions on premium, tiered or internal models are silently ineffective. The admin sees the restriction work in the normal model selector, so the control looks sound. The direct cost falls on pay-per-token backends such as OpenAI, Anthropic or Azure, billed to the admin's key for requests the admin meant to forbid.

Who is affected

Affected: open-webui <= 0.8.12, on pip and as the openwebui/open-webui Docker image. The report was made against main at commit 6fdd19bf1 and says likely all versions with model chaining. Exposure needs a restricted base model on the instance and users who hold the workspace.models permission, which is the default.

Check the version:

pip show open-webui

For Docker, check the image tag.

open-webui

Ecosystem
PyPI
Affected
<= 0.8.12
Fixed in
0.9.0
Check
pip show open-webui

How to fix it

Upgrade to open-webui 0.9.0 or later:

pip install --upgrade open-webui

For Docker, pull a 0.9.0 or newer image and recreate the container. The advisory lists no workaround. It does note that the attack depends on the default workspace.models permission, so removing that permission from users who do not need to build models reduces exposure until you upgrade. The advisory does not present that as a fix.

How to tell if you were hit

List the models in your workspace and look for user-created models whose base_model_id points at a model that user is not allowed to use. Check the models table or the admin model list for wrappers made by ordinary accounts.

Compare upstream provider billing with who should have access. Spikes in usage of a restricted model, with no matching requests under that model's own name in the Open WebUI logs, point to chaining. Look for POST /api/v1/models/create and import calls that set base_model_id to a restricted model.

Original advisory

From the GitHub Advisory Database (CC BY 4.0).

Base Model Routing Bypasses Access Control via Model Chaining

Affected Component

Model chaining via base_model_id:

  • backend/open_webui/routers/models.py (lines 170-214, create_new_model)
  • backend/open_webui/routers/models.py (lines 254-308, import_models)
  • backend/open_webui/main.py (lines 1696-1711, base model resolution in chat completion)
  • backend/open_webui/routers/openai.py (lines 1032-1037, base model payload rewrite)
  • backend/open_webui/routers/ollama.py (lines 1086-1090, base model payload rewrite)
  • backend/open_webui/utils/models.py (line 380, check_model_access — checks user-facing model only)

Affected Versions

Current main branch (commit 6fdd19bf1) and likely all versions with the model chaining (base_model_id) feature.

Description

Open WebUI supports model composition via base_model_id: a user-defined model (e.g., "Cheap Assistant") can reference an existing base model (e.g., "gpt-4-turbo-restricted") that provides the actual inference capability. When a user queries the composed model, the access control pipeline verifies the user has access to the composed model but never re-verifies access to the chained base model.

Additionally, the model creation and import endpoints accept arbitrary base_model_id values without checking that the caller has access to that base model. Combined, this allows any user with the default model creation permission to create a model that chains to a restricted base model — and then invoke it, causing the server to dispatch the request to the restricted base model using the admin-configured API key.

# utils/models.py:380 — access check runs against the user-facing model only
def check_model_access(user, model):
    if user.role == 'user':
        ...check access grants on `model`...

# main.py:1696-1711 — base model resolved without access check
base_model = request.app.state.MODELS.get(model.info.base_model_id)
if base_model:
    # payload["model"] is rewritten to base_model.id
    # but no check_model_access(user, base_model) is performed

# openai.py:1032-1037 / ollama.py:1086-1090 — the rewritten payload is dispatched
payload['model'] = base_model_id

Attack Scenario

  1. Admin provisions a premium/restricted model gpt-4-turbo-restricted and configures access grants so only the "ML Engineers" group can use it.
  2. Attacker (a regular user not in that group) calls: `` POST /api/v1/models/create { "id": "cheap-assistant", "name": "Cheap Assistant", "base_model_id": "gpt-4-turbo-restricted", "params": {}, "meta": {} } ` The creation endpoint does not validate the attacker's access to gpt-4-turbo-restricted`.
  3. Attacker now owns cheap-assistant. check_model_access(attacker, cheap-assistant) passes trivially because they are the owner.
  4. Attacker sends: `` POST /api/chat/completions {"model": "cheap-assistant", "messages": [...]} ``
  5. At main.py:1696, the pipeline resolves cheap-assistant.base_model_id to gpt-4-turbo-restricted, rewrites payload["model"] to the base model ID, and dispatches the upstream request with the admin-configured API key for the backend.
  6. The attacker receives responses from the restricted model, bypassing the access grant policy.

The same bypass is available via the import endpoint, which additionally allows overwriting existing models (see related finding on model import ownership).

Impact

  • Regular users can query restricted models by chaining through a self-owned wrapper model
  • Access control on gpt-4-turbo-restricted (or equivalent paid/tiered/internal models) becomes silently ineffective
  • Direct cost impact on pay-per-token backends (OpenAI, Anthropic, Azure) — the admin's API key is used for requests the admin intended to forbid
  • Creates a false sense of security — the admin sees access restrictions work through the standard model selector but not through user-created chains

Preconditions

  • Attacker must have model creation permission (default workspace.models permission, granted to all users by default)
  • A restricted base model must exist on the instance (the target of the chain)

Credited to Classic298.

Questions

Who can exploit the Open WebUI model chaining bypass?

Any authenticated user with the workspace.models permission, which all users have by default. They also need a restricted model to exist on the instance.

Which key is used for the bypassed requests?

The admin-configured API key for the backend. The cost lands on the pay-per-token account the admin set up.

Is there a workaround besides upgrading?

The advisory lists none. Removing the workspace.models permission from users who do not need it narrows the attack, but it is not offered as a fix.

Is it exploited in the wild?

No source reports exploitation. It is not in CISA's KEV catalog, and its EPSS score is low (0.0035).

References

How this page is made: the data panel comes from the GitHub Advisory Database, CISA’s KEV catalog, the NVD and FIRST EPSS, and updates twice a day. The analysis is written by an AI model from the sources listed above and checked by automated rules before it is published. Check versions against the vendor's advisory before you act. Methodology

More Open WebUI vulnerabilities

All Open WebUI entries