Summary
A missing permission check in Open WebUI's file-related API endpoints allows any authenticated user to list, access, and delete files uploaded by other users.
When multi-user deployments reuse the same Open WebUI instance, this flaw can expose or destroy other users' uploaded content and disrupt workflows.
Affected context
This vulnerability appears in Open WebUI deployments that:
- Enable user uploads through the platform's file interfaces
- Operate in a multi-user or shared environment where different users expect isolated file spaces
- Rely on Open WebUI's built-in authentication without additional file-layer access control
In such setups, file management APIs treat all authenticated users as equally privileged for file listing, retrieval, and deletion operations.
Exploit preconditions
- Attack surface: Open WebUI HTTP(S) API endpoints handling file listing, retrieval, and deletion
- Required access: Any authenticated user account; no special roles or administrative privileges needed
- Trigger point: Invoking file-related API endpoints without enforcing per-user ownership or access checks
- Why exploitation is possible: The back-end logic omits authorization checks, so file operations are performed based solely on authentication, not on file ownership or user role
Why this happens
The root cause is a classic broken access control pattern where the system assumes that authentication alone is sufficient for file operations.
File-related API routes fail to verify whether the requesting user owns the target file or is authorized to manage it.
This maps to CWE-284: Improper Access Control, where resources—in this case uploaded files—are exposed to any authenticated user due to missing or incomplete authorization logic in the file management endpoints.
Potential impact
- Unauthorized users may view or download files uploaded by other users
- Attackers could delete other users' files, causing data loss and workflow disruption
- Sensitive or proprietary content stored in uploaded files can be exposed to unintended parties
- Platform trust may be eroded if users cannot rely on isolation of their data
General mitigation guidance
Effective mitigation focuses on enforcing strong, consistent authorization checks around file operations:
- Design file ownership models where each uploaded file is tied to a specific user or group context
- Apply per-request authorization verification in file list, read, and delete handlers to ensure the caller is allowed to access the resource
- Use role-based or attribute-based access control policies to define which users can manage shared or system-level files
- Minimize privileges for general user accounts so they cannot act as global file administrators
- Clearly separate administrative file management paths from regular user operations, with distinct authorization gates
How teams detect issues like this
Detection typically involves examining both code and runtime behavior:
- Static analysis and code review:
- Look for file-related API handlers that rely only on authentication (e.g., session or token presence) without explicit authorization checks
- Identify endpoints where user identifiers from the session are not compared with file ownership metadata
- Flag shared resource access patterns where there is no policy evaluation before performing actions
- Runtime and policy-based checks:
- Implement logging of file access operations, including requesting user and file owner, and analyze for cross-user access patterns
- Configure automated tests that simulate multiple users and verify that users cannot access each other's files
- Automated review tools can help spot missing authorization decorators, middleware, or policy checks around file management routes.

