/

CVE-2026-73612

Severity:

HIGH RISK

(8.1)

Path Access Bypass (CWE-639) in File Browser Operations

CVE-2026-73612

Deferred

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-639

Impact:

Unauthorized file access and modification

Severity:

HIGH RISK

(8.1)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

File Browser fails to revalidate access rules for descendant files during recursive copy, rename, and delete operations. An authenticated user who can access a parent directory may use these operations to act on files that should be denied, undermining confidentiality and integrity controls.

Affected context

The issue occurs in File Browser deployments that use path-based access rules to isolate files or directories. It becomes risky when an authenticated user is permitted to operate on a parent directory while descendant objects have more restrictive rules, and recursive copy, rename, or delete operations do not independently enforce those descendant restrictions.

Exploit preconditions

  • Attack surface: File management operations exposed by the File Browser application
  • Required access: An authenticated account with permission to operate on an allowed parent directory
  • Trigger point: Recursive copy, rename, or delete functionality
  • Why exploitation is possible: The application authorizes the parent operation without consistently validating access rules for every affected descendant

Why this happens

The underlying bug is an authorization decision that is applied to an allowed parent path but not re-evaluated for each descendant affected by a recursive operation. This creates an authorization bypass through an insufficiently validated resource identifier, matching CWE-639, where access control decisions fail to account for the actual object being accessed or modified.

Potential impact

  • An attacker may copy denied files into an accessible location
  • An attacker may rename protected files or move them across policy boundaries
  • An attacker may delete files that should be inaccessible
  • Confidential data could be exposed or integrity of stored content could be affected
  • Rule-based tenant or directory isolation could be weakened

General mitigation guidance

Mitigation generally focuses on enforcing authorization at the resource level

for every object affected by a bulk operation.

Common defensive patterns include:

  • Revalidating access rules for each source and destination descendant
  • Treating recursive operations as a set of individual authorization decisions
  • Denying an operation when any affected object fails policy evaluation
  • Canonicalizing paths before authorization checks and preventing boundary confusion
  • Applying least-privilege permissions to users and service accounts
  • Using secure-by-default policies that do not infer descendant access solely from parent access
  • Logging authorization decisions and rejected descendant operations

How teams detect issues like this

Organizations can identify similar issues through:

  • Static analysis and code review checks for recursive filesystem operations lacking per-object authorization
  • Tests that place denied files beneath allowed directories and exercise copy, rename, and delete workflows
  • Policy tests covering path canonicalization, parent-child rule inheritance, and cross-boundary destinations
  • Runtime monitoring for bulk operations affecting objects outside the initiating user's allowed scope
  • Automated review tools that flag authorization checks performed only before recursive traversal

Sources

SourceLink
github.comgithub.com/filebrowser/filebrowser/commit/72faf6dd3c85628e332d3e567124b86708ce2695
github.comgithub.com/filebrowser/filebrowser/security/advisories/GHSA-77x8-73f4-5485
vulncheck.comvulncheck.com/advisories/file-browser-before-authorization-bypass-via-recursive-operations

Frequently asked

questions

It can be exploitable through the File Browser application interface when the

affected file operations are exposed to an authenticated user.

The attacker generally needs valid credentials and permission to operate on

an allowed parent directory. Separate permission to the denied descendants

should not be required.

Enforce authorization independently for every source and destination object

involved in recursive copy, rename, and delete operations, rejecting the

complete operation if any object is unauthorized.

Use canonical path handling, explicit deny-by-default policies, comprehensive

parent-and-descendant authorization tests, least-privilege accounts, and

monitoring for unexpected bulk file operations.

Find out what's already
exploitable in your codebase.