CVE-2026-44555: Open WebUI's Base Model Routing Bypasses Access Control via Model Chaining
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-webuiFor 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-webuiFor 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_idAttack Scenario
- Admin provisions a premium/restricted model
gpt-4-turbo-restrictedand configures access grants so only the "ML Engineers" group can use it. - 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 togpt-4-turbo-restricted`. - Attacker now owns
cheap-assistant.check_model_access(attacker, cheap-assistant)passes trivially because they are the owner. - Attacker sends: ``
POST /api/chat/completions {"model": "cheap-assistant", "messages": [...]}`` - At
main.py:1696, the pipeline resolvescheap-assistant.base_model_idtogpt-4-turbo-restricted, rewritespayload["model"]to the base model ID, and dispatches the upstream request with the admin-configured API key for the backend. - 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.modelspermission, 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 entriesCVE-2026-87011
Open WebUI: Unauthenticated requests can stall the server via uncached OIDC fetches in back-channel logout
high7.5Sep 10, 2026CVE-2026-87012
Open WebUI: Any authenticated user can suppress calendar alerts instance-wide via a non-numeric alert value
medium4.3Sep 10, 2026CVE-2026-87013
Open WebUI: Any authenticated user can start a non-terminating request via a folder parent cycle
medium4.3Sep 10, 2026CVE-2026-87014
Open WebUI: Admin demoted through SSO role sync keeps read and write access to all users' notes
medium6.5Sep 10, 2026CVE-2026-87015
Open WebUI: A user's session cookies are sent to tool servers configured for bearer authentication
medium6.8Sep 10, 2026CVE-2026-87016
Open WebUI: Sign-in as another user via wildcard characters in the OAuth subject claim on SQLite
high8.1Sep 10, 2026
