/

CVE-2026-34783

Severity:

HIGH RISK

(8.1)

Path Traversal in Ferret Web Data Engine

CVE-2026-34783

Analyzed

Vulnerability type

Category:

Path Traversal / Directory Traversal

CWE:

CWE-22, CWE-73

Impact:

Arbitrary File Write leading to Remote Code Execution

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

A path traversal flaw in Ferret's IO::FS::WRITE standard library function allows untrusted web data to influence filesystem write locations on the host running Ferret.

When scraping sites that embed ../ sequences in returned filenames and using those values to build output paths, an attacker may control both the file path and its contents, potentially leading to remote code execution.

Affected context

This vulnerability affects workflows where Ferret is used to scrape untrusted or semi-trusted websites and then write scraped content to disk using IO::FS::WRITE.

It becomes relevant when operators derive output file paths directly or indirectly from data returned by target sites (for example, using scraped filenames or URLs to construct directory and file names) without normalizing or constraining those paths.

The issue is most impactful on systems where Ferret runs with permissions that allow writing to sensitive directories such as user home paths, cron directories, SSH configuration locations, or web server document roots.

Exploit preconditions

  • Attack surface: The Ferret scraping logic that processes responses from external websites and invokes IO::FS::WRITE.
  • Required access: Ability to control content served by a website that is being scraped by Ferret (e.g., running the target site, injecting content into it, or influencing response data).
  • Trigger point: The scraping script uses attacker-controlled filename or path components (containing ../) to construct arguments passed to IO::FS::WRITE.
  • Why exploitation is possible: IO::FS::WRITE accepts paths without enforcing directory boundaries, canonicalization, or allowlists. As a result, directory traversal sequences in attacker-supplied data can escape the intended output directory and target arbitrary filesystem locations writable by the Ferret process.

Why this happens

The core issue aligns with CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal') and is closely related to CWE-73: External Control of File Name or Path.

IO::FS::WRITE trusts the file path it receives and does not constrain it to an expected root directory, nor does it sanitize or normalize traversal patterns such as ../.

At an abstract level, the bug class is "unvalidated external path usage": application logic constructs file paths using data obtained from an untrusted source (the scraped website) and passes them directly to a filesystem write API, allowing the caller to escape the intended storage directory.

Because the same untrusted source also supplies file contents, the pattern becomes an arbitrary file write primitive wherever the Ferret process has write permissions.

Potential impact

  • Arbitrary file creation and overwriting in directories writable by the Ferret process.
  • Remote code execution by dropping executable scripts or binaries in locations that are later invoked by scheduled tasks (e.g., cron jobs).
  • Insertion of malicious SSH keys into authorized_keys, enabling unauthorized remote access under the Ferret user's account.
  • Modification of shell startup files (e.g., .bashrc, .profile) to execute attacker-controlled commands on interactive login or shell startup.
  • Deployment of web shells or modified assets into web server document roots, enabling command execution via HTTP requests.
  • Tampering with application configuration files, logs, or data stores, potentially leading to data corruption or privilege escalation in adjacent services.

General mitigation guidance

Effective mitigation centers on constraining filesystem access and breaking the trust link between external data and file paths:

  • Restrict IO::FS::WRITE to operate only within a designated base directory, rejecting or rewriting any path that does not resolve under this root after canonicalization.
  • Normalize and validate all file paths before writing, explicitly stripping or denying directory traversal components (../, absolute paths, drive prefixes, and symlink escapes where possible).
  • Derive output filenames from trusted, controlled templates (e.g., generated IDs, hashes, or whitelisted patterns) instead of directly reusing filenames or path segments from scraped data.
  • Apply the principle of least privilege to the Ferret runtime environment: run it under an account with minimal filesystem permissions and no write access to sensitive system locations.
  • Separate concerns by using distinct, non-sensitive directories for scraped data storage, avoiding home directories, configuration paths, and execution directories.
  • Consider additional hardening such as filesystem sandboxing, containers, or chroot-like mechanisms to ensure that even if a path traversal occurs, it cannot reach critical parts of the host filesystem.

How teams detect issues like this

Detection efforts can focus on both code and runtime behaviors:

  • Static analysis and code review:
  • Flag any use of IO::FS::WRITE (or similar filesystem APIs) where path parameters are derived from HTTP responses, HTML attributes, or other untrusted web data.
  • Look for patterns that concatenate or interpolate unvalidated user-controlled strings into file paths, especially those lacking normalization or checks for ../, absolute paths, or disallowed prefixes.
  • Enforce coding standards that require path canonicalization and base-directory enforcement for all file operations.
  • Configuration and policy checks:
  • Audit Ferret scripts and workflows for assumptions about "safe" target sites; treat all scraped sources as untrusted.
  • Implement policy in CI/CD pipelines to prevent merging scripts that write to sensitive directories or rely on raw filenames from external sources.
  • Runtime monitoring and logging:
  • Log filesystem writes with full resolved paths and correlate them with scraping activity; alert on writes outside of expected data directories.
  • Use host-based intrusion detection or EDR solutions to detect unusual file creation in cron directories, SSH configuration paths, or web roots by the Ferret process.
  • Automated security scanning tools or SAST platforms can be configured to recognize these patterns and integrate checks into development workflows.

Sources

SourceLink
github.comgithub.com/MontFerret/ferret/commit/160ebad6bd50f153453e120f6d909f5b83322917
github.comgithub.com/MontFerret/ferret/security/advisories/GHSA-j6v5-g24h-vg4j

Frequently asked

questions

Yes. If an attacker can control or influence the content served by a website that a Ferret operator scrapes, they can remotely influence the file paths and contents written by IO::FS::WRITE, potentially achieving code execution on the system running Ferret.

The attacker does not need direct access to the victim machine. They need the ability to control the responses of a site that the Ferret script processes—such as being the site owner, compromising the site, or injecting data into its output—so that they can embed malicious filenames and payloads into the scraped data.

The most robust fix is to ensure IO::FS::WRITE and related functionality only operate within a strictly defined directory, after canonicalizing paths and rejecting any that escape this boundary. Additionally, avoid using untrusted data as file paths; instead, generate or map to controlled filenames and enforce strict validation rules.

Treat all data from scraped websites as untrusted, especially when it influences filesystem operations. Establish a standard pattern where file paths are derived from trusted templates, normalized, and validated against allowlists; run scraping tools under restricted accounts; and integrate security checks (static analysis, code review guidelines, and runtime monitoring) that specifically look for unvalidated external control of file paths.

Find out what's already
exploitable in your codebase.