Summary
Voyager 1.3.0 contains a directory traversal flaw in the /admin/voyager-assets endpoint, where the asset path parameter can be manipulated to escape the intended directory.
An attacker who can send crafted requests to this endpoint may read arbitrary files on the server, including sensitive system files and application configuration files, leading to information disclosure and potential further compromise.
Affected context
The vulnerability occurs in Voyager 1.3.0 installations that expose the /admin/voyager-assets route and use a path parameter to locate and serve asset files from the server's filesystem.
It is present when user-controlled path fragments are concatenated with filesystem paths without adequate normalization or restriction to a specific base directory.
In such setups, crafted path sequences (such as directory traversal patterns) can break out of the allowed asset directory and reach other files the application process can read.
Exploit preconditions
- Attack surface: HTTP(S) interface, specifically the
/admin/voyager-assetsendpoint. - Required access: Ability to send requests to the Voyager application; depending on how the route is protected, this may be unauthenticated or limited to authenticated users.
- Trigger point: Supplying a malicious
path(or similarly named) parameter containing traversal sequences that the server uses to build a filesystem path. - Why exploitation is possible: The application trusts the asset path parameter, directly incorporating it into filesystem operations without robust canonicalization, normalization, or enforcement of a fixed root directory, enabling traversal outside the intended asset directory.
Why this happens
This issue stems from insecure handling of filesystem paths derived from user input, mapped to CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal').
The implementation likely concatenates a user-supplied path segment with a base assets directory and then reads from disk without strict checks that the resulting path remains within the intended directory.
Without canonicalization and enforcement of a safe root, sequences like ../ or equivalent constructs allow the resultant path to reference arbitrary readable files on the system.
Potential impact
- An attacker may read sensitive system files (for example,
/etc/passwd) that can be used for reconnaissance or subsequent attacks. - An attacker may access application secrets stored in configuration files (for example,
.envfiles containing database credentials, API keys, or encryption keys). - An attacker may gather detailed information about the server environment, file layout, and configuration, assisting in privilege escalation or lateral movement.
- An attacker could potentially leak source code or logs, exposing business logic or additional vulnerabilities.
General mitigation guidance
Mitigation typically focuses on constraining filesystem access and distrusting user-supplied paths:
- Enforce strict resolution of requested paths against a fixed, known-safe base directory, rejecting requests that resolve outside it.
- Normalize and canonicalize paths before use, and explicitly block sequences or patterns that enable directory traversal.
- Use high-level file serving mechanisms or framework helpers that implement safe path handling instead of manually concatenating paths.
- Store secrets (such as configuration and credentials) outside web-accessible directories and apply least-privilege filesystem permissions so the application process only has access to what it truly needs.
- Apply defense in depth through environment hardening (e.g., restricting read access to particularly sensitive files where feasible).
How teams detect issues like this
Detection approaches can include:
- Static analysis rules that flag direct concatenation of user input into filesystem paths or file access APIs without validation.
- Code review checklists that require verification of path canonicalization and root directory enforcement for any file-serving endpoints.
- Runtime monitoring or web application firewalls configured to detect and alert on common traversal patterns (for example, repetitive
../sequences) in request parameters. - Security testing, including automated scanners and manual penetration tests, that probe file-serving endpoints for traversal behavior and unauthorized file read capabilities.

