/

CVE-2026-25890

Severity:

HIGH RISK

(8.1)

Authorization Bypass via Path Normalization Error

CVE-2026-25890

Analyzed

Vulnerability type

Category:

Authorization Bypass via Path Normalization Error

CWE:

CWE-706, CWE-863

Impact:

Unauthorized File and Directory Access

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 versions prior to 2.57.1 contain a path normalization flaw in their authorization logic that allows authenticated users to bypass "Disallow" rules by manipulating the URL path (for example, using //private/).

Because the access control check operates on the unnormalized path while the underlying filesystem resolves it correctly, users may gain unauthorized access to files and directories that should be restricted.

Affected context

This vulnerability appears in File Browser deployments that:

  • Rely on "Disallow" path rules to restrict access to sensitive directories or files, and
  • Perform authorization checks on raw URL paths without consistent normalization, while
  • Using a filesystem layer that normalizes redundant path separators (such as multiple slashes).

Any environment where authenticated users can supply or manipulate path segments via the web interface can be affected, especially when access to private or administrative directories depends on these path-based rules.

Exploit preconditions

  • Attack surface: HTTP(S) interface exposed by File Browser.
  • Required access: Valid, authenticated user account with general access to the File Browser UI.
  • Trigger point: File or directory operations (e.g., list, read, upload, delete) targeting paths covered by "Disallow" rules, but requested using modified URL paths containing redundant separators (such as //).
  • Why exploitation is possible: The authorization layer compares the requested path to the configured "Disallow" entries using the unnormalized URL string. The filesystem subsequently resolves the path with normalization (collapsing repeated slashes), so a path that should match a disallowed rule appears allowed to the access control logic yet still maps to the protected location on disk.

Why this happens

The core issue is an inconsistent handling of path normalization between authorization checks and actual filesystem resolution.

The access control implementation evaluates "Disallow" rules against the raw URL path, without normalizing it to a canonical form first. This mismatch lets attackers craft logically equivalent but syntactically different paths (e.g., //private/ instead of /private/) that evade string-based rule matching.

This behavior aligns with:

  • CWE-706: Use of Incorrectly-Resolved Name or Reference — the system relies on a non-canonical representation of a resource name when making security decisions.
  • CWE-863: Incorrect Authorization — the authorization mechanism fails to correctly enforce intended restrictions due to flawed comparison logic between requested and protected resources.

Potential impact

  • Unauthorized listing and viewing of files in directories intended to be disallowed.
  • Access to sensitive configuration data, logs, or user files stored under restricted paths.
  • Potential modification, deletion, or upload of files within protected areas, depending on the user's granted capabilities.
  • Expansion of a low-privileged account's reach, enabling lateral movement or data exfiltration within the managed directory tree.
  • Undermining of security assumptions that rely solely on path-based "Disallow" rules for segregation of sensitive content.

General mitigation guidance

Effective mitigation focuses on making access control decisions using canonical, consistently-normalized paths and not relying solely on raw string comparisons:

  • Normalize all incoming paths to a canonical form (e.g., collapse redundant separators, resolve dot segments) before applying "Disallow" checks or other authorization logic.
  • Centralize path resolution so that the same canonicalization logic is used both for authorization decisions and for filesystem access.
  • Prefer policy models that combine path-based rules with additional context (e.g., role- or owner-based checks) to avoid overreliance on string paths for security boundaries.
  • Treat all user-controlled path segments as untrusted, validating them against allowed roots and ensuring they cannot escape designated base directories.
  • Apply least-privilege principles to user roles so that a bypass of one rule does not grant broader administrative capabilities than necessary.

How teams detect issues like this

Detection typically involves identifying inconsistent path handling and authorization flows:

  • Static analysis and code review:
  • Look for authorization checks that compare user-supplied paths directly against configuration entries without normalization or canonicalization.
  • Flag patterns where the path passed to the filesystem API may differ from the path used in access control logic.
  • Review middleware and routing layers for path rewriting or normalization that is not mirrored in security checks.
  • Configuration and policy review:
  • Examine "Disallow" rules and ensure they are enforced at a single, canonicalization-aware control point.
  • Runtime monitoring and logging:
  • Log access to restricted directories and include both the raw request path and the resolved filesystem path for comparison.
  • Set alerts on repeated access to protected paths using unusual patterns (e.g., multiple slashes, encoded separators).
  • Automated security testing tools and DAST scanners can be configured to fuzz path segments (e.g., extra slashes, dot segments) to identify inconsistencies between expected and actual authorization behavior.

Sources

SourceLink
github.comgithub.com/filebrowser/filebrowser/commit/489af403a19057f6b6b4b1dc0e48cbb26a202ef9
github.comgithub.com/filebrowser/filebrowser/releases/tag/v2.57.1
github.comgithub.com/filebrowser/filebrowser/security/advisories/GHSA-4mh3-h929-w968

Frequently asked

questions

Yes. Any user who can authenticate to the File Browser web interface and send crafted HTTP requests can attempt to exploit this issue remotely, provided network access to the service is available.

No administrative privileges are required beyond having a valid user account. The vulnerability specifically allows lower-privileged authenticated users to reach files and directories that should be blocked by "Disallow" rules.

The most robust fix is to normalize all user-supplied paths to a canonical form before performing any authorization or policy checks, and to ensure that the same canonical path is used for both security decisions and filesystem operations. Additionally, review and harden path-based policies so they do not rely solely on raw string matching.

Future designs should establish a single, well-tested path canonicalization routine and mandate its use before any access control decision. Combine canonical path checks with additional contextual controls (such as role-based permissions and strict root directories), and include automated tests and code review checklists that explicitly verify consistent path handling in security-sensitive components.

Find out what's already
exploitable in your codebase.