/

CVE-2026-54089

Severity:

CRITICAL RISK

(9.1)

Auth Bypass via Proxy Headers (CWE-290) in FileBrowser

CVE-2026-54089

Deferred

Vulnerability type

Category:

Authentication Bypass

CWE:

CWE-287, CWE-290

Impact:

Account Takeover and Unauthorized Account Creation

Severity:

CRITICAL RISK

(9.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

FileBrowser's proxy authentication mode allows unauthenticated attackers to impersonate arbitrary users, including administrators, by sending a forged HTTP header.

Because non-existent usernames are automatically provisioned, attackers can also create new accounts without any authorization whenever they can directly reach a vulnerable FileBrowser instance.

Affected context

This vulnerability arises when FileBrowser is deployed with auth.method=proxy and is reachable directly by clients that are not reliably authenticated by an upstream proxy.

In such configurations, the application implicitly trusts a specific HTTP header as proof of identity and does not verify that the request actually originated from the designated proxy.

Environments where FileBrowser is exposed to the internet, internal networks with untrusted clients, or misconfigured reverse proxies are particularly susceptible to this issue.

Exploit preconditions

  • Attack surface: HTTP interface of a FileBrowser instance configured with auth.method=proxy
  • Required access: Network reachability to the FileBrowser server without enforced upstream authentication
  • Trigger point: Submission of a single crafted HTTP request containing the trusted proxy-authentication header with an arbitrary username value
  • Why exploitation is possible: The application fully trusts the proxy-provided identity header without verifying source authenticity, and automatically creates user records for unknown usernames, eliminating any credential or authorization checks.

Why this happens

The root cause is a flawed authentication design that equates the presence of a specific HTTP header with a fully authenticated identity.

By delegating authentication to a proxy but failing to enforce that all requests actually traverse that proxy, FileBrowser treats user-controllable header values as authoritative credentials.

This maps to CWE-290: Authentication Bypass by Spoofing and CWE-287: Improper Authentication, where identity information is accepted without robust verification of its origin or binding to a trusted authentication flow.

Potential impact

  • Attackers can impersonate any existing user, including administrative accounts.
  • Attackers may gain full control over FileBrowser configuration and file management operations.
  • Unauthorized creation of new user accounts with arbitrary roles and permissions may occur.
  • Stored data can be read, modified, deleted, or exfiltrated without legitimate credentials.
  • Downstream systems integrated with FileBrowser (e.g., storage backends) can be indirectly impacted through misused privileges.

General mitigation guidance

Long-term mitigation focuses on eliminating trust in unauthenticated headers and tightening the boundary between proxy and application authentication.

Common patterns include:

  • Ensuring FileBrowser is only reachable behind a properly configured reverse proxy that enforces authentication and strips or controls identity-related headers from client requests.
  • Adding application-level checks to reject or ignore proxy-authentication headers when the request did not come from a known, trusted network path or IP range.
  • Treating upstream identity assertions as hints that must be bound to a secure channel (e.g., mutual TLS, private network, or other strong trust mechanisms).
  • Disabling or avoiding proxy-based authentication in deployments where strict control of client routing and header injection cannot be guaranteed.
  • Applying least-privilege account roles and minimizing the number of administrator accounts to reduce blast radius if spoofing occurs.

How teams detect issues like this

Detection involves both configuration review and behavioral monitoring:

  • Reviewing deployments for auth.method=proxy and verifying that the FileBrowser endpoint is not directly exposed to untrusted clients.
  • Examining HTTP access logs for suspicious patterns such as frequent changes in the proxy-identity header, unexpected usernames, or account creation events without corresponding upstream authentication.
  • Using static or configuration analysis to flag services that rely solely on unverified headers for authentication.
  • Establishing security policies or automated checks in infrastructure-as-code and CI pipelines to ensure that header-based authentication is only used behind trusted, authenticated proxies.

Sources

SourceLink
github.comgithub.com/filebrowser/filebrowser/blob/main/auth/proxy.go
github.comgithub.com/filebrowser/filebrowser/blob/main/http/auth.go#L121-L137
github.comgithub.com/filebrowser/filebrowser/security/advisories/GHSA-xqp3-jq6g-x3qm

Frequently asked

questions

Yes. If FileBrowser with proxy authentication enabled is reachable over the network without a strictly enforced upstream proxy, a remote attacker can exploit it using crafted HTTP headers.

No. The attacker does not need any credentials. They can impersonate existing users or create new accounts simply by specifying arbitrary usernames in the trusted header.

Restrict direct access to FileBrowser so that all traffic must pass through a trusted proxy that performs real authentication, and ensure the application only accepts identity headers from that proxy-controlled context. Where that cannot be guaranteed, avoid using proxy-based authentication.

Design authentication schemes so that identity assertions from upstream components are cryptographically or contextually bound to trusted channels, validate that all requests traverse the intended authentication path, and treat client-supplied headers as untrusted unless explicitly sanitized and controlled by infrastructure policies.

Find out what's already
exploitable in your codebase.