/

CVE-2026-34528

Severity:

HIGH RISK

(8.1)

Privilege Management / Authorization Misconfiguration

CVE-2026-34528

Analyzed

Vulnerability type

Category:

Privilege Management / Authorization Misconfiguration

CWE:

CWE-269

Impact:

Remote Command Execution via Over-Privileged Self-Registered Accounts

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's signup flow previously applied default user permissions and only stripped the Admin flag, leaving the Execute permission and command list intact.

When signup and server-side execution are enabled and the default user template allows execution, any unauthenticated user who self-registers may gain the ability to run arbitrary commands on the server.

Affected context

This vulnerability arises in File Browser deployments that:

  • Have user self-signup enabled
  • Have server-side command execution enabled
  • Configure the default user template with Execute=true and a non-empty command list
  • Rely on the signup handler to safely restrict new user privileges

In this context, newly created accounts inherit execution capabilities that should typically be reserved for trusted or administrative users.

Exploit preconditions

  • Attack surface: Public or internal HTTP interface exposing the File Browser signup endpoint.
  • Required access: No prior authentication; the attacker only needs network access to reach the File Browser instance and create an account.
  • Configuration requirements:
  • Signup feature enabled by an administrator.
  • Server-side execution functionality enabled.
  • Default user template configured with Execute=true and at least one allowed command.
  • Trigger point: Attacker completes the standard self-registration workflow, after which the created account possesses execute privileges.
  • Why exploitation is possible: The signup handler applies the full default permission template and only removes the Admin flag, failing to clear or constrain the Execute permission and associated command list for untrusted, newly registered users.

Why this happens

The underlying issue is a privilege management error consistent with CWE-269, where authorization boundaries between trusted and untrusted users are not robustly enforced.

The signup handler (signupHandler) applies a default permission template (d.settings.Defaults.Apply(user)) to new accounts, then strips only the Admin role.

This model assumes that non-admin defaults are safe for all users, but in practice the template also contains high-privilege capabilities such as Execute=true and a list of shell commands.

Because the design does not differentiate between "trusted default users" and "self-registered untrusted users," the code path that creates accounts via signup unintentionally bestows powerful server-side execution rights.

Potential impact

  • Unauthenticated users who self-register can remotely execute arbitrary commands within the configured command set.
  • Compromise of the underlying server account used by File Browser, including data theft, tampering, or deletion.
  • Lateral movement within the hosting environment, depending on system configuration and network segmentation.
  • Deployment of malware, cryptominers, or backdoors using the inherited execution capabilities.
  • Integrity loss for files managed by File Browser, including unauthorized modification of hosted content or configuration files.

General mitigation guidance

Effective mitigation focuses on establishing strict least-privilege defaults and clear separation between trusted and self-service user profiles:

  • Design default user templates so they never grant powerful capabilities (like command execution) to accounts created through unauthenticated signup flows.
  • Introduce distinct permission profiles for "self-registered" users versus "admin-created" users, and apply the minimal profile to self-registered accounts.
  • Implement a deny-by-default stance for sensitive operations (execution, shell commands, system-level actions), requiring explicit elevation or administrative approval.
  • Treat server-side execution features as privileged: limit them to tightly controlled roles and disable them on publicly accessible instances whenever possible.
  • Regularly review configuration for features such as signup, execution, and default permissions to ensure they align with security policy and deployment exposure.

These patterns reduce the risk that configuration or workflow changes will unintentionally expose high-privilege functionality to untrusted users.

How teams detect issues like this

Several approaches can help detect this class of privilege misconfiguration:

  • Configuration auditing: Periodically inspect File Browser configuration for:
  • Signup enabled in combination with server-side execution.
  • Default user templates that grant Execute permission and provide command lists.
  • Access control review: During code review, flag patterns where:
  • High-privilege capabilities are tied to generic "defaults" without explicit differentiation between trusted and untrusted creation paths.
  • Only a single flag (e.g., Admin) is stripped for untrusted users while other powerful permissions remain.
  • Logging and monitoring: Enable detailed audit logs for:
  • New user registrations.
  • Invocation of server-side commands, especially from newly created accounts or from IP ranges associated with anonymous users.
  • Automated checks: Use policy-as-code and configuration validation tools to enforce rules like "no execute permissions for self-registered roles" and to alert when signup and execution are enabled simultaneously in internet-exposed deployments.

Sources

SourceLink
github.comgithub.com/filebrowser/filebrowser/releases/tag/v2.62.2
github.comgithub.com/filebrowser/filebrowser/security/advisories/GHSA-x8jc-jvqm-pm3f

Frequently asked

questions

Yes. If the File Browser instance is reachable over the network and exposes the signup endpoint with server-side execution enabled and permissive defaults, a remote attacker can create an account and gain execution capabilities.

No prior credentials are required when signup is enabled. The attacker only needs to self-register to receive an account that, under vulnerable configurations, already includes the Execute permission and associated commands.

Use strict least-privilege defaults for untrusted user creation paths, segregate permission templates for self-registered versus administrator-created accounts, and ensure that high-risk capabilities like command execution are never enabled by default for untrusted users.

During design and implementation, explicitly model trust levels and user creation flows, avoid sharing high-privilege templates across both trusted and untrusted paths, enforce deny-by-default for sensitive operations, and back these rules with configuration validation, code review guidelines, and automated policy checks in CI/CD pipelines.

Find out what's already
exploitable in your codebase.