Summary
File Browser's TUS protocol DELETE endpoint contains a broken access control flaw that lets users with only Create permission delete files and directories within their assigned scope.
In multi-user deployments where deletion is intentionally restricted, an authenticated user can bypass the missing Delete permission and perform unauthorized removals of content they should only be able to create or upload.
Affected context
This vulnerability appears in File Browser deployments that:
- Use the TUS protocol for file upload and management
- Define granular per-user or per-role permissions (Create vs Delete)
- Intend to prevent some users from deleting files or directories while still allowing uploads
The issue manifests when the TUS DELETE endpoint enforces only partial or incorrect permission checks, allowing users with Create but without Delete permissions to remove arbitrary items within their assigned directory scope.
Exploit preconditions
- Attack surface: File Browser HTTP API, specifically the TUS DELETE endpoint.
- Required access: Valid authenticated account with Create permission, but explicitly lacking Delete permission within a given directory scope.
- Trigger point: Issuing TUS DELETE requests targeting files or directories under the user's accessible path.
- Why exploitation is possible: The authorization logic for the DELETE operation does not fully verify the dedicated Delete permission, relying instead on weaker or incomplete checks (e.g., only verifying scope or existence), thereby violating the intended permission model.
Why this happens
The core issue is a mismatch between the documented permission model and the actual authorization checks applied to the TUS DELETE endpoint.
Instead of strictly validating that a user holds explicit Delete privileges, the endpoint allows deletion based on broader criteria, such as the ability to create or access files within a path.
This aligns with CWE-284 (Improper Access Control) and CWE-732 (Incorrect Permission Assignment for Critical Resource), where sensitive actions are guarded by inadequate or incorrect authorization rules, resulting in users performing operations outside their intended permission set.
Potential impact
- Unauthorized deletion of files uploaded by the user within their scope.
- Deletion of shared project assets or content relied upon by other users in the same workspace or directory.
- Disruption of services or workflows that depend on files managed by File Browser.
- Data loss and potential integrity issues if backup or recovery mechanisms are not in place.
- Erosion of administrative trust in permission boundaries and multi-tenant isolation.
General mitigation guidance
Mitigation generally focuses on enforcing strict, explicit authorization for each file operation and aligning runtime checks with the documented permission model.
Useful defensive patterns include:
- Implementing per-action authorization checks that require a distinct Delete permission for any DELETE operation, independent of Create or Read permissions.
- Centralizing access control logic so that all file operations (upload, rename, delete, edit) use a single, well-reviewed permission evaluation module.
- Treating file deletion as a higher-risk operation and using explicit capability flags rather than inferred permissions based on other actions.
- Applying the principle of least privilege by default, ensuring new roles or users are not granted deletion capabilities unless explicitly required.
- Introducing soft deletion or recycle-bin patterns for sensitive environments, so accidental or unauthorized deletion can be reversed.
How teams detect issues like this
Detection strategies typically combine API-level monitoring with code-level analysis:
- Static analysis and code review:
- Search for HTTP handlers or routes implementing DELETE functionality and verify they invoke robust, explicit authorization checks.
- Look for permission checks that reuse "create" or "write" permissions for delete operations, or that rely solely on path ownership rather than distinct Delete flags.
- Enforce coding standards requiring per-action permission constants or enums and prohibit implicit permission inference.
- Runtime monitoring and logging:
- Log all delete operations with user identity, scope, resource path, and evaluated permissions.
- Alert on delete requests performed by roles that are not supposed to have Delete permission, as defined in configuration or policy.
- Policy enforcement and testing:
- Use automated tests or security scanning tools to exercise file operations under different permission sets and verify that delete-only tests fail for non-privileged users.
- Integrate access-control test cases into CI/CD pipelines to prevent regressions in authorization logic.

