/

CVE-2026-42075

Severity:

HIGH RISK

(8.1)

Path Traversal in Evolver Skill Download Command

CVE-2026-42075

Deferred

Vulnerability type

Category:

Path Traversal / Directory Traversal

CWE:

CWE-22

Impact:

Arbitrary File Write on Filesystem

Severity:

HIGH RISK

(8.1)

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

Evolver's skill download (fetch) command accepts user-controlled output paths via the --out= flag without proper validation, enabling path traversal on the underlying filesystem.

An attacker who can invoke this command can write files to arbitrary locations, potentially overwriting sensitive system files or planting malicious content in trusted directories.

Affected context

This vulnerability arises in environments where Evolver is installed and the skill download (fetch) command is available for use, including automated pipelines, shared development machines, or multi-tenant agent infrastructures.

The risk becomes significant when:

  • The --out= flag is exposed to untrusted input (e.g., user-supplied parameters, web/API wrappers, or agent plugins).
  • Evolver is executed with elevated privileges or in contexts with broad filesystem access.
  • The host filesystem contains sensitive or critical files that can be overwritten or created in deterministically guessed paths.

In such setups, even indirect control of the --out= parameter can enable writing content to security-critical locations.

Exploit preconditions

  • Attack surface: The Evolver CLI or any service wrapper (e.g., web endpoints, RPC services, orchestration scripts) that allows invoking the skill download (fetch) command.
  • Required access: Ability to execute the Evolver fetch operation or influence its --out= argument (direct CLI access, CI job parameters, or indirectly through an exposed API).
  • Trigger point: Supplying a crafted path, including directory traversal sequences (e.g., sequences that navigate up the directory tree), as the value of the --out= flag when initiating a skill download.
  • Why exploitation is possible: The --out= path is accepted without normalization or restriction to a safe base directory; user-controlled paths are joined or used directly, allowing the process to write downloaded skill files to arbitrary filesystem locations accessible under the process's permissions.

Why this happens

The core issue is a lack of path validation and confinement when handling user-supplied filesystem paths in the Evolver fetch command.

Instead of normalizing and validating the output path against an allowed base directory or using a controlled storage root, the implementation trusts the raw --out= parameter.

This aligns with CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal'), where untrusted input is used to construct filesystem paths without:

  • Stripping or rejecting traversal sequences, and
  • Enforcing that the resolved path remains under a designated, safe directory.

As a result, the application unintentionally provides a primitive for arbitrary file writes wherever the running process has write permission.

Potential impact

  • Overwriting configuration files used by Evolver or other applications, potentially altering behavior or disabling security controls.
  • Creating or modifying executable scripts, binaries, or libraries in locations that may later be executed by the system or other users.
  • Dropping malicious files into directories that are implicitly trusted (e.g., plugin directories, startup folders, load paths).
  • Tampering with logs or data files, leading to data corruption, integrity loss, or misleading audit trails.
  • Escalating privileges in chained attacks when combined with misconfigurations (e.g., writable paths in privileged service contexts).

General mitigation guidance

Mitigation generally focuses on constraining how user-supplied paths are interpreted and where files can be written:

  • Constrain output to a safe root: Resolve the requested --out= path, normalize it, and ensure it remains within a dedicated, application-controlled base directory (e.g., an Evolver-managed skills folder).
  • Reject traversal patterns: Treat path segments that attempt to traverse upward or reference special device paths as invalid; fail fast with clear error messaging.
  • Apply allowlists: Limit output locations to known, preconfigured directories or patterns rather than arbitrary paths from users.
  • Run with least privilege: Execute Evolver with minimal filesystem rights so that even if a path traversal occurs, it cannot affect sensitive system locations.
  • Isolate storage: Use containerization or chroot-like mechanisms to restrict Evolver's visible filesystem to non-critical paths.

These patterns reduce the risk that user-controlled paths can escape intended directories or affect critical files.

How teams detect issues like this

Effective detection combines code-level analysis with runtime and configuration review:

  • Static analysis: Search for code paths where user input is passed directly to filesystem APIs (e.g., open, write, create) as path arguments, especially around the --out= handling logic.
  • Path normalization checks: During code review, verify that any output path derived from external input is normalized and checked against a canonical base directory.
  • Policy enforcement: Adopt internal guidelines or linting rules that disallow unvalidated paths in CLI options and require path-constraint utilities for any file-writing functionality.
  • Runtime monitoring: Enable logging for file write operations in Evolver, and review for unusual destinations (e.g., writes outside expected skill directories).
  • Automated security testing: Use DAST or fuzzing frameworks to supply traversal-like values to CLI wrappers or APIs that control Evolver, observing for file creation outside permitted directories.

Sources

SourceLink
github.comgithub.com/EvoMap/evolver/releases/tag/v1.69.3
github.comgithub.com/EvoMap/evolver/security/advisories/GHSA-r466-rxw4-3j9j

Frequently asked

questions

It can be, depending on how Evolver is exposed. If the fetch command or its --out= parameter is reachable through remote interfaces (such as web APIs, orchestration services, or agents that accept remote instructions), an attacker may exploit it over the network. In purely local, single-user deployments, exploitability is generally limited to local users.

The attacker needs to execute Evolver's skill download (fetch) operation or control the value of its --out= flag. This can range from direct shell access to more indirect control, such as manipulating parameters passed by a web UI, CI/CD job, or automation that wraps Evolver.

The most robust fix is to strictly confine all skill downloads to an application-controlled directory tree, using path normalization and an explicit check that the final resolved path remains within a trusted base directory. Any path failing this check should be rejected, and direct writes to arbitrary user-specified filesystem locations should be avoided.

Adopt a defensive design approach for file I/O: never trust raw user-supplied paths, centralize path handling in utility functions that enforce base-directory confinement, and include path traversal checks in code review and static analysis rules. Combining these practices with least-privilege execution and filesystem isolation significantly reduces the risk of path traversal and arbitrary file write issues.

Find out what's already
exploitable in your codebase.