Open-Webui (<= 0.8.12) — CraftedSignal Threat Feed

Open WebUI /responses Endpoint Authentication Bypass Vulnerability

hello@craftedsignal.io — Fri, 08 May 2026 19:45:53 +0000

Open WebUI versions 0.8.12 and earlier contain an authentication bypass vulnerability in the /responses endpoint of the OpenAI router. This endpoint, intended as a proxy to upstream LLM providers, fails to enforce per-model access controls. While the primary chat completion endpoint (generate_chat_completion) correctly validates model ownership, group membership, and AccessGrants, the /responses endpoint only verifies a valid user session. Consequently, any authenticated user can interact with any model configured on the Open WebUI instance, regardless of their assigned roles or group memberships, by sending a crafted POST request to /api/openai/responses with an arbitrary model ID. This circumvents intended access restrictions and poses risks to service availability, model security, and policy enforcement.

Attack Chain

An attacker obtains valid user credentials for the Open WebUI instance. This could be through credential stuffing, phishing, or other common methods.
The attacker authenticates to the Open WebUI instance using the obtained credentials.
The attacker crafts a POST request to the /api/openai/responses endpoint.
The attacker includes an arbitrary model ID in the POST request body, specifying a model they do not have explicit access to under normal access control policies.
The Open WebUI instance, upon receiving the request at /api/openai/responses, only verifies the user’s session.
Due to the missing access control checks, the request is forwarded to the upstream LLM provider, effectively bypassing the intended access restrictions.
The upstream LLM provider processes the request using the specified model, even though the user lacks authorization.
The attacker receives the response from the LLM, successfully interacting with a restricted model.

Impact

Successful exploitation of this vulnerability can have significant consequences. Unauthorized users can submit resource-intensive requests to expensive models, leading to Model Denial of Service (OWASP LLM04) by exhausting API budgets or rate limits, potentially causing total service disruption for legitimate users. Furthermore, if the instance proxies access to fine-tuned or self-hosted models, unauthorized interaction can lead to Model Theft (OWASP LLM10), enabling capability extraction or model distillation. Finally, the vulnerability undermines existing access control systems, preventing administrators from enforcing cost-tier restrictions, team-based model assignments, or compliance boundaries.

Recommendation

Upgrade to Open WebUI version 0.8.13 or later to patch CVE-2026-44556 and address the authentication bypass vulnerability.
Deploy the Sigma rule “Detect Open WebUI Unauthorized Model Access via Responses Endpoint” to identify potential exploitation attempts by monitoring POST requests to /api/openai/responses with potentially malicious model IDs.
Review Open WebUI access logs for any suspicious activity related to the /api/openai/responses endpoint, particularly requests from users who should not have access to specific models.

Open WebUI LDAP Empty Password Authentication Bypass

hello@craftedsignal.io — Fri, 08 May 2026 19:38:31 +0000

Open WebUI is vulnerable to an LDAP authentication bypass. The LDAP authentication endpoint does not validate that the submitted password is non-empty before performing a Simple Bind against the LDAP server. This vulnerability exists because the LdapForm Pydantic model accepts an empty string for the password field without any minimum length constraint. Subsequently, the Connection.bind() call succeeds on vulnerable LDAP servers, and the application issues a full session token for the target user. The issue affects the current main branch (commit 6fdd19bf1) and likely all versions with LDAP authentication support. Exploitation requires that LDAP is enabled and the underlying LDAP server accepts unauthenticated simple binds with empty passwords, which is the default configuration for OpenLDAP and some Active Directory setups.

Attack Chain

LDAP authentication is enabled on the Open WebUI instance (ENABLE_LDAP=True).
The attacker identifies a valid LDAP username.
The underlying LDAP server accepts unauthenticated simple binds (OpenLDAP default, some AD configs).
Attacker sends a POST request to /api/v1/auths/ldap with the target username and an empty password.
The application’s DN bind succeeds, finding the target user via LDAP search.
The application attempts a user bind using the provided (empty) password.
The LDAP server returns success for the unauthenticated bind due to the empty password.
authenticate_user_by_email issues a full session token for the target user, granting complete account access.

Impact

Successful exploitation allows a complete authentication bypass, enabling attackers to take over any LDAP user account without knowing the password, including admin accounts if they authenticate via LDAP. The vulnerability can be exploited with zero interaction from the victim and without rate limiting on the LDAP endpoint.

Recommendation

Apply the mitigations recommended in GHSA-2r4p-jpmg-48f4 to prevent empty passwords from being used in LDAP authentication.
Deploy the Sigma rule “Detect Open WebUI LDAP Authentication Bypass Attempt” to monitor for POST requests to the /api/v1/auths/ldap endpoint with an empty password field, indicating a potential exploit attempt.
Ensure the LDAP server is configured to reject unauthenticated simple binds with empty passwords.
Monitor web server logs for POST requests to /api/v1/auths/ldap (webserver log source) and correlate with other authentication-related events.

Open WebUI Cross-Instance Cache Poisoning Vulnerability

hello@craftedsignal.io — Thu, 09 May 2024 12:00:00 +0000

Open WebUI, a web interface for LLMs, is susceptible to a cross-instance cache poisoning vulnerability (CVE-2026-44552) when multiple instances share a Redis backend. This issue stems from missing REDIS_KEY_PREFIX usage for the tool_servers and terminal_servers keys in utils/tools.py. Specifically, lines 841, 850, 976, and 986 do not utilize the key prefix. As a result, an attacker with admin privileges on one instance can overwrite the cache values used by other instances. This vulnerability affects the current main branch (commit 6fdd19bf1) and likely all versions since the tool server/terminal server Redis cache was introduced. This is a critical issue because it undermines the multi-instance isolation that REDIS_KEY_PREFIX aims to provide, potentially impacting blue-green deployments, multi-region setups, and cluster topologies.

Attack Chain

An attacker gains admin access to Open WebUI Instance A, either through legitimate means or by exploiting vulnerabilities like LDAP empty-password or stale-admin-role issues.
The attacker configures a malicious tool server on Instance A, pointing to https://attacker-controlled.example.com/openapi.json. This configuration triggers a write to the tool_servers Redis key without the REDIS_KEY_PREFIX (line 841 in utils/tools.py).
Users on Open WebUI Instance B attempt to query available tools. This action triggers a read from the same unprefixed tool_servers Redis key (line 850 in utils/tools.py).
Instance B retrieves the attacker’s poisoned tool server list from Instance A, which now includes the attacker’s server, possibly replacing legitimate tool servers.
A user on Instance B invokes a tool. The tool call payload, including chat content, user identity, and OAuth tokens, is sent to the attacker-controlled server.
The attacker’s server responds with arbitrary tool outputs, which are then fed back into Instance B’s LLM context.
The malicious tool output is treated as trusted data within Instance B’s LLM, enabling prompt injection and misinformation delivery.
The attacker leverages prompt injection and misinformation delivery to further compromise Instance B and exfiltrate sensitive data.

Impact

Successful exploitation of this vulnerability leads to cross-instance cache poisoning, where one instance’s admin can affect all users of another instance sharing the same Redis backend. Sensitive data, including chat content and user identity, can be exfiltrated to an attacker-controlled server. Furthermore, the attacker can inject malicious content into the victim instance’s LLM context, leading to prompt injection attacks. This undermines the intended isolation between Open WebUI instances and can lead to significant data breaches and system compromise. The vulnerability’s silent failure mode makes detection difficult for victim instances.

Recommendation

Deploy the Sigma rule “Detect Open WebUI Tool Server Configuration Change” to monitor for unauthorized changes to the tool_servers key (rule below).
Deploy the Sigma rule “Detect Open WebUI Terminal Server Configuration Change” to monitor for unauthorized changes to the terminal_servers key (rule below).
Apply available patches or upgrades to Open WebUI to versions beyond 0.8.12 as soon as they are released to address CVE-2026-44552.
Restrict admin access to Open WebUI instances and enforce strong password policies.
Review and audit existing Open WebUI deployments to ensure proper configuration and security best practices.

Open WebUI Stale Admin Role Enables Post-Demotion Cross-User Note Access

hello@craftedsignal.io — Thu, 25 Jan 2024 12:00:00 +0000

Open WebUI, a web interface for large language models, is susceptible to a privilege escalation vulnerability stemming from how it manages user sessions via Socket.IO. Specifically, when a user establishes a connection, their role (e.g., ‘admin’) is cached in an in-memory SESSION_POOL. Crucially, subsequent administrative actions like role revocation or user deletion, performed through HTTP endpoints, do not invalidate existing Socket.IO sessions. As a result, a user who has been demoted or deleted can retain their previous admin privileges within the active Socket.IO session indefinitely, so long as they maintain the connection via heartbeats. This vulnerability impacts current main branch (commit 6fdd19bf1) and likely all versions with the collaborative document (Yjs) Socket.IO handlers.

Attack Chain

User B authenticates as an administrator and establishes a Socket.IO connection, which stores their role as admin in the SESSION_POOL.
Administrator A demotes User B to a regular user via the POST /api/v1/users/{B_id}/update endpoint, modifying the user’s role in the database.
The Socket.IO session remains active, and User B’s SESSION_POOL entry retains the stale admin role.
User B’s client continues sending heartbeat events to maintain the Socket.IO connection, refreshing only the last_seen_at timestamp in the SESSION_POOL.
User B sends a ydoc:document:join event with the document_id of a note belonging to another user (e.g., note:).
The server-side handler at socket/main.py:538 checks the cached role from the SESSION_POOL, incorrectly granting access due to the stale admin role.
User B now gains read access to the victim’s note, receives the full document state, and gets live updates.
User B sends a ydoc:document:update event, and the handler at socket/main.py:611 bypasses authorization using the cached role, allowing User B to modify the victim’s note’s content.

Impact

Successful exploitation of this vulnerability allows unauthorized read and write access to any user’s notes. This occurs even after admin privileges have been legitimately revoked. The attacker only needs to maintain an active Socket.IO connection established while they had administrative rights, which is trivial as heartbeats keep the session alive indefinitely. This grants a false sense of security to administrators who revoke privileges, as the revocation only affects HTTP access but not real-time collaborative access.

Recommendation

Apply available patches or upgrade Open WebUI to a version that addresses CVE-2026-44553.
Implement a mechanism to invalidate Socket.IO sessions upon user role changes or deletions to prevent the use of stale privileges. Specifically, invalidate or update SESSION_POOL entries when user roles are modified via the /api/v1/users/{B_id}/update endpoint.
Deploy the Sigma rule “Detect Open WebUI Note Access Attempt with Stale Admin Session” to identify potential attempts to access notes using stale admin sessions.
Review and audit the implementation of the Socket.IO session management, particularly the connect and heartbeat handlers in backend/open_webui/socket/main.py, to ensure proper role validation.

Open WebUI Knowledge Base Destruction and RAG Poisoning via Unauthorized Collection Overwrite

hello@craftedsignal.io — Thu, 18 Jan 2024 12:00:00 +0000

Open WebUI, a retrieval-augmented generation (RAG) application, is susceptible to unauthorized knowledge base modification. The vulnerability lies in the process_web endpoint within backend/open_webui/routers/retrieval.py. Specifically, the POST /api/v1/retrieval/process/web endpoint lacks authorization checks, which allows any authenticated user with knowledge of a target knowledge base UUID to overwrite it with arbitrary content. This is possible due to the overwrite parameter, which defaults to True and triggers the deletion of the existing vector collection before new content is written via the save_docs_to_vector_db function. The issue affects the current main branch (commit 6fdd19bf1) and likely all versions with RAG functionality. An attacker can leverage this vulnerability to poison the RAG system by injecting malicious content into the knowledge base.

Attack Chain

Attacker gains a valid user account on the Open WebUI instance.
Attacker discovers the victim’s knowledge base UUID, potentially through the knowledge-bases meta-collection (as mentioned in the report).
Attacker crafts a POST request to the /api/v1/retrieval/process/web endpoint, setting the collection_name parameter to the victim’s KB UUID and ensures overwrite=true.
The POST request includes a url parameter pointing to an attacker-controlled URL containing malicious content.
The Open WebUI server fetches the content from the attacker-controlled URL.
The save_docs_to_vector_db function is called, which first deletes the existing vector collection associated with the victim’s knowledge base.
The fetched content from the attacker’s URL is then embedded and stored as the new content for the knowledge base.
When the victim queries their knowledge base, the RAG system returns the attacker-controlled content, leading to potential misinformation or malicious actions.

Impact

Successful exploitation leads to data destruction, where the victim’s original knowledge base embeddings are permanently deleted from the vector store. Furthermore, the RAG system is poisoned with attacker-controlled content, causing the LLM to return misleading or malicious responses. This can enable indirect prompt injection and manipulation of the victim’s LLM behavior. The poisoned content persists until the knowledge base is rebuilt from the original source files, creating a persistent vulnerability. Versions of open-webui up to and including 0.8.12 are affected.

Recommendation

Apply authorization checks to the /api/v1/retrieval/process/web endpoint to verify that the user has write access to the target collection, mitigating CVE-2026-44554.
Monitor webserver logs for POST requests to /api/v1/retrieval/process/web with suspicious collection_name parameters, using the Sigma rule “Detect Open WebUI Unauthorized Collection Overwrite Attempt” to identify potential exploitation attempts.
Inspect network traffic for connections to suspicious URLs used in the url parameter of the /api/v1/retrieval/process/web endpoint, such as the IOC https://attacker.com/poison.

Open WebUI Model Chaining Access Control Bypass

hello@craftedsignal.io — Tue, 02 Jan 2024 12:00:00 +0000

Open WebUI, a web interface for Large Language Models, is susceptible to an access control vulnerability via its model chaining feature. This feature allows users to create custom models that reference existing base models for inference. The vulnerability arises because access controls are only applied to the user-facing model, not the chained base model. An attacker with default model creation permissions can exploit this flaw to create a model that chains to a restricted or premium base model, effectively bypassing intended access restrictions and querying the restricted model using the admin-configured API key. This issue affects the current main branch (commit 6fdd19bf1) and likely all versions with the model chaining feature.

Attack Chain

Admin provisions a restricted model, such as gpt-4-turbo-restricted, and configures access control policies.
Attacker, without access to the restricted model, crafts a POST request to /api/v1/models/create with a payload defining a new model (e.g., cheap-assistant) and setting its base_model_id to the restricted model’s ID.
The create endpoint lacks validation to ensure the attacker has access to the specified base_model_id.
The attacker now owns the cheap-assistant model, which will pass the initial check_model_access check.
The attacker sends a POST request to /api/chat/completions, specifying the newly created cheap-assistant model.
The application resolves the base_model_id of cheap-assistant to gpt-4-turbo-restricted within main.py:1696.
The application rewrites the payload["model"] to the base model ID, and dispatches the upstream request using the admin-configured API key.
The attacker receives responses from the restricted model, successfully circumventing the intended access restrictions.

Impact

This vulnerability allows unauthorized access to restricted models, potentially leading to increased costs on pay-per-token backends such as OpenAI or Azure, as the admin’s API key is used for unauthorized requests. It also creates a false sense of security, as access restrictions appear to work through the standard model selector but are ineffective against user-created chains. The vulnerability can lead to direct cost impact on pay-per-token backends and erode trust in the configured access controls.

Recommendation

Deploy the Sigma rule Detect Open WebUI Model Creation with External BaseModelID to detect attempts to create models with base_model_id pointing to existing models, and tune the false positives for your environment.
Deploy the Sigma rule Detect Open WebUI Chat Completion Request Using Custom Model with BaseModelID to detect chat completion requests using a custom model with a base_model_id set.
Upgrade to a patched version of Open WebUI that includes proper access control validation for base_model_id during model creation to remediate CVE-2026-44555.