/

CVE-2026-75842

Severity:

HIGH RISK

(7.7)

Path Traversal (CWE-22) in ArcadeDB OpenCypher Query

CVE-2026-75842

Deferred

Vulnerability type

Category:

Path Traversal

CWE:

CWE-22

Impact:

Arbitrary File Read and Sensitive Information Disclosure

Severity:

HIGH RISK

(7.7)

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

ArcadeDB contains an arbitrary file read vulnerability in the OpenCypher

LOAD CSV FROM clause. An authenticated user with read query privileges may

use a local file source to retrieve files accessible to the server process,

exposing sensitive information through query responses.

Affected context

The vulnerability occurs in ArcadeDB deployments where authenticated users

can submit OpenCypher queries containing the LOAD CSV FROM clause. Risk is

present when local file sources are accepted and the database server process

can access sensitive paths. The exposed data depends on filesystem

permissions and the privileges assigned to the server account.

Exploit preconditions

  • Attack surface: OpenCypher query execution and the LOAD CSV FROM clause
  • Required access: An authenticated account with read query privileges
  • Trigger point: Processing a LOAD CSV request that references a local file source
  • Why exploitation is possible: The query engine may resolve attacker-controlled

file paths without sufficiently restricting access to the server filesystem

Why this happens

The underlying bug is insufficient restriction of filesystem paths accepted by

a data-loading query feature. When user-controlled input can select local

files without strong path validation, canonicalization, and access policy

enforcement, the application may read data outside its intended working

directory. This behavior maps to CWE-22, Improper Limitation of a Pathname to

a Restricted Directory, commonly known as path traversal.

Potential impact

  • Attackers may read sensitive local files
  • Database credentials, configuration values, or application secrets could be disclosed
  • Query responses may expose operating-system or deployment metadata
  • The server process's filesystem permissions could determine the scope of data exposure
  • Exfiltrated information could support further compromise

General mitigation guidance

Mitigation generally focuses on reducing trust in query-supplied file locations

and isolating database processes from sensitive filesystem data.

Common defensive patterns include:

  • Restricting CSV loading to approved, non-local sources or controlled directories
  • Applying canonical path validation and an explicit allowlist before file access
  • Disabling local-file loading where it is not required
  • Running the database under a dedicated, least-privileged operating-system account
  • Limiting filesystem permissions, container mounts, and access to host paths
  • Avoiding exposure of raw file contents in query responses unless necessary
  • Separating data-import identities and policies from ordinary read-query privileges

How teams detect issues like this

Detection approaches may include:

  • Static analysis for file APIs that combine user-controlled query values with filesystem paths
  • Code review of LOAD CSV handling, URI scheme validation, and path canonicalization
  • Tests that verify local-file sources and traversal attempts are rejected
  • Query auditing for LOAD CSV usage, local file schemes, unusual path patterns, and

unexpected response sizes

  • Policy enforcement that blocks local filesystem access from database query interfaces
  • Automated security review tools that identify insufficient path restrictions

Sources

SourceLink
github.comgithub.com/ArcadeData/arcadedb/security/advisories/GHSA-hfp5-6gcp-8c75
vulncheck.comvulncheck.com/advisories/arcadedb-before-arbitrary-file-read-via-load-csv

Frequently asked

questions

It may be exploitable through the database query interface when that interface

is network-accessible and the attacker has valid credentials with the required

read query privileges.

Exploitation requires authentication and permission to submit queries that reach

the affected OpenCypher LOAD CSV functionality. The resulting access is also

constrained by the database server process's filesystem permissions.

The safest pattern is to prevent query users from selecting arbitrary local

paths, allow only explicitly approved data sources, and disable local-file

loading when it is unnecessary.

Enforce strict URI and path policies, use canonicalization with allowlists,

apply least-privilege filesystem permissions, and monitor database queries for

unexpected local-file access.

Find out what's already
exploitable in your codebase.