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

