/

CVE-2026-25059

Severity:

HIGH RISK

(8.8)

Path Traversal in OpenList Frontend File Operation Handlers

CVE-2026-25059

Analyzed

Vulnerability type

Category:

Path Traversal

CWE:

CWE-22

Impact:

Unauthorized File Access and Modification

Severity:

HIGH RISK

(8.8)

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

A path traversal flaw in OpenList Frontend's file management handlers allows filename components from user requests to be concatenated with validated directories without proper normalization or rejection of traversal sequences.

When an authenticated user injects .. segments into filenames, they may escape their authorized directory and access or manipulate other users' files within the same storage mount.

Affected context

The vulnerability occurs in OpenList Frontend deployments that use the built-in file management functionality in server/handles/fsmanage.go.

The issue surfaces when:

  • User-supplied filename components from req.Names are accepted as part of file paths
  • Paths are constructed using stdpath.Join with a previously validated base directory
  • No additional checks ensure that the final, joined path remains within the authorized directory tree

In such setups, traversal sequences in filenames can cause operations to affect files outside the intended user directory but still within the same storage mount.

Exploit preconditions

  • Attack surface: HTTP file management endpoints exposed by OpenList Frontend (e.g., file delete, rename, copy handlers).
  • Required access: Valid authenticated user with permission to perform file operations within their own area.
  • Trigger point: Submission of file operation requests containing filename components in req.Names that include .. or equivalent traversal patterns.
  • Why exploitation is possible: The application validates only the base directory, then directly joins it with untrusted filename components using stdpath.Join, without verifying that the resulting normalized path still resides within the authorized directory. This allows crafted paths to break out of the user's directory and reach other users' files on the same mount.

Why this happens

This issue stems from improper restriction of file path construction when using user-supplied input.

Instead of treating filename components as untrusted and enforcing strict validation or whitelisting, the code concatenates them with a trusted base directory via stdpath.Join.

While Join normalizes paths, it does not enforce directory boundaries; .. segments can move the resulting path above the intended root.

This aligns with CWE-22: Improper Limitation of a Pathname to a Restricted Directory, where insufficient post-join checks allow callers to escape the intended directory scope and operate on arbitrary files within the underlying filesystem scope.

Potential impact

  • Authenticated users could read metadata or contents of files belonging to other users on the same storage mount (if read operations are available).
  • Users can delete files owned by other users, causing data loss or service disruption.
  • Users can rename or move other users' files, leading to confusion, misrouting of data, or integrity issues.
  • Users can copy sensitive files from other users' directories into locations they control, facilitating data exfiltration.
  • File-level isolation between users within a shared storage mount can be effectively bypassed.

General mitigation guidance

Effective mitigation focuses on strict path containment and defensive handling of user-supplied path components:

  • Treat every path element from client input as untrusted; normalize and validate the final resolved path after joining it with the base directory.
  • Enforce a canonicalization step (e.g., Clean or equivalent) followed by a check that the resolved path still has the intended base directory as its prefix and does not traverse above it.
  • Reject any request where computed paths contain .., absolute paths, or symbolic-link-driven escapes from the authorized root.
  • Separate per-user storage roots and ensure file operations are always scoped to the authenticated user's root directory, not a shared top-level directory.
  • Apply least-privilege principles at the filesystem layer where possible (e.g., per-user directories with distinct OS-level permissions) so that even logic errors do not automatically grant cross-user access.
  • Centralize path normalization and authorization logic in a single utility used by all file-related handlers to avoid inconsistent checks.

How teams detect issues like this

Organizations can identify and monitor this class of vulnerability using:

  • Static analysis: Rules that flag calls constructing filesystem paths from user-controlled input (e.g., combining request parameters with directory paths) without a subsequent containment check or canonicalization.
  • Code review patterns: Look for handlers that:
  • Accept filenames or relative paths from HTTP parameters or JSON bodies
  • Use path.Join, filepath.Join, or similar functions with these values
  • Do not verify that the resulting path is still under an expected root or rely only on initial directory validation.
  • Security testing and fuzzing: Automated tests that inject .., nested traversal sequences (like a/../../b), URL-encoded variants, or trailing slashes in file operation APIs to see whether they can access or modify files outside the intended directory.
  • Runtime monitoring: Logging full resolved paths and user identifiers for file operations, then analyzing logs for unexpected cross-user access patterns or traversal-like paths, with alerts for anomalies.
  • Automated code scanning tools and CI checks can be configured to flag any new code that builds file paths from request data without passing through a vetted path-sanitization helper.

Sources

SourceLink
github.comgithub.com/OpenListTeam/OpenList/commit/7b78fed106382430c69ef351d43f5d09928fff14
github.comgithub.com/OpenListTeam/OpenList/releases/tag/v4.1.10
github.comgithub.com/OpenListTeam/OpenList/security/advisories/GHSA-qmj2-8r24-xxcq

Frequently asked

questions

It is remotely exploitable through the application's HTTP interface, provided the attacker can authenticate and access the file management functions. No local shell access to the server is required.

The attacker must be an authenticated user with normal permissions to perform file operations in their own area. From that baseline, they can craft traversal sequences to target files belonging to other users within the same storage mount.

The most robust fix is to ensure that all file paths derived from user input are resolved against a known base directory, normalized, and then checked so that the resulting canonical path remains within that base. Any path that escapes the base directory, is absolute, or contains traversal markers should be rejected before filesystem operations occur.

Establish a standard, reusable path-handling utility that:

  • Receives a base directory and user-supplied components
  • Performs canonicalization
  • Enforces directory containment checks

Require all file-related handlers to use this utility, complement it with static analysis rules to catch direct, ad hoc path joins, and document secure path handling patterns as part of your engineering guidelines.

Find out what's already
exploitable in your codebase.