Severity:

CRITICAL RISK

(9.8)

Path Traversal in FalkorDB Browser File Upload API

CVE-2026-6057

Deferred

Vulnerability type

Category:

Path Traversal / Directory Traversal

CWE:

CWE-22

Impact:

Remote Code Execution via Arbitrary File Write

Severity:

CRITICAL RISK

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

FalkorDB Browser 1.9.3 exposes an unauthenticated path traversal issue in its file upload API, enabling attackers to write files outside the intended upload directory.

By abusing crafted file paths, a remote attacker can plant arbitrary files in sensitive locations and potentially achieve remote code execution on the server.

Affected context

The vulnerability appears in FalkorDB Browser deployments that expose the file upload API over a network interface without strong authentication or strict path validation.

It is most relevant when:

  • The server runs with permissions that allow writing into executable or configuration directories
  • Uploaded files can be interpreted as code (e.g., scripts, templates, or plugins)
  • User-supplied paths are used to determine where files are stored on disk

Exploit preconditions

  • Attack surface: Public or internal HTTP(S) endpoint providing the FalkorDB Browser file upload API.
  • Required access: None; the vulnerability is described as unauthenticated, so any network user who can reach the API can attempt exploitation.
  • Trigger point: Sending a crafted upload request with a manipulated filename or path (e.g., sequences that navigate out of the intended directory) so that the server writes the file to an attacker-chosen location.
  • Why exploitation is possible: The upload handler insufficiently normalizes and validates user-controlled path elements before constructing filesystem paths, allowing directory traversal and arbitrary file placement.

Why this happens

This issue stems from improper restriction of pathnames in file operations, matching CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal').

The file upload logic likely concatenates user-supplied filenames or path segments with a server-side base directory without robust canonicalization, whitelisting, or enforcement of a fixed storage root.

As a result, special path components (such as directory traversal sequences or absolute paths) are honored by the filesystem, letting an attacker escape the intended directory and target arbitrary writable locations, which can lead to remote code execution when written files are executed or interpreted by other components.

Potential impact

  • Creation or overwriting of files in directories outside the intended upload location
  • Placement of web-executable or script files that can be invoked to execute arbitrary code
  • Modification of application or system configuration files that may be reloaded and executed
  • Escalation from simple file write to full remote code execution under the service account
  • Facilitation of further compromise, persistence mechanisms, or lateral movement within the environment

General mitigation guidance

Effective mitigation focuses on constraining file system access and hardening the upload pipeline:

  • Enforce strict, server-side control of upload destinations: never accept directory paths or traversal sequences from clients; map uploads to server-generated filenames in a fixed directory.
  • Normalize and canonicalize paths and then verify that the resolved path remains within a designated, non-executable upload root before performing any file operation.
  • Use allowlists for acceptable filename patterns and block any path separators or traversal tokens in user-supplied values.
  • Store uploads in directories that are not executable and not used for code, templates, or dynamic configurations.
  • Run the FalkorDB Browser service under a dedicated account with minimal filesystem permissions, especially excluding sensitive system and application directories from write access.

How teams detect issues like this

Detection can combine code-centric and operational approaches:

  • Static analysis: Search for filesystem writes that use user-derived filename or path parameters without canonicalization and bounds checking; flag concatenations like base_dir + user_input in upload handlers.
  • Code review: Examine file upload controllers or middleware for:
  • Direct use of request parameters in path construction
  • Missing checks that the final path is within an approved directory
  • Upload directories that overlap with executable or configuration paths
  • Runtime monitoring: Enable logging of upload requests and resulting filesystem operations; alert on paths containing traversal patterns or unexpected destination directories.
  • Policy enforcement: Incorporate secure file handling policies into CI/CD and use security scanning tools that can highlight path traversal patterns in web APIs.

Sources

SourceLink
github.comgithub.com/FalkorDB/falkordb-browser
github.comgithub.com/FalkorDB/falkordb-browser/pull/1611

Frequently asked

questions

Yes. Because the file upload API is unauthenticated, any remote user who can reach the FalkorDB Browser endpoint can attempt to exploit the path traversal to write arbitrary files, which may lead to remote code execution.

The attacker only needs network access to the vulnerable file upload API. No prior authentication or local system access is required, although the eventual impact is limited by the permissions of the FalkorDB Browser service account and filesystem configuration.

The safest pattern is to completely decouple user input from filesystem paths: generate server-side filenames, store all uploads in a single non-executable directory, and enforce strict canonicalization plus directory containment checks before writing any file.

Adopt a secure file handling standard that forbids user-controlled paths, mandates path canonicalization and directory whitelisting, enforces least-privilege filesystem permissions, and integrates static analysis or code review checks specifically targeting path traversal and arbitrary file upload patterns.

Find out what's already
exploitable in your codebase.