/

CVE-2026-50567

Severity:

HIGH RISK

(7.7)

Path Traversal (CWE-22) in Fission Fetcher Zip Handling

CVE-2026-50567

Deferred

Vulnerability type

Category:

Path Traversal

CWE:

CWE-22

Impact:

Arbitrary File Write on Server

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

A path traversal vulnerability in Fission's fetcher component allows crafted ZIP archives to write files outside the intended destination directory.

If an attacker can control a Package.Spec.Source.URL or Deployment.URL, they can cause arbitrary file writes within the fetcher sidecar's reachable filesystem, potentially impacting other tenants or sensitive volumes.

Affected context

This issue affects Fission deployments that:

  • Use the Fission fetcher sidecar to download and unpack function packages or deployment archives.
  • Accept archive URLs via Package.Spec.Source.URL or Deployment.URL that may be influenced by users or less-trusted components.
  • Rely on ZIP extraction to a per-environment directory without enforcing that extracted paths remain under the target directory.

The vulnerability primarily manifests when the fetcher processes untrusted or semi-trusted ZIP archives and writes them to shared or sensitive locations such as tenant package directories or mounted secret/config volumes.

Exploit preconditions

  • Attack surface: The ZIP unpacking logic in the fission-fetcher sidecar within per-environment pods.
  • Required access: Ability to supply or influence the URL of a ZIP archive via Package.Spec.Source.URL or Deployment.URL (for example, through a deployment pipeline, configuration, or multi-tenant API).
  • Trigger point: Invocation of the Unarchive function in pkg/utils/zip.go, when the fetcher downloads and unzips the attacker-controlled archive.
  • Why exploitation is possible: The code joined each archive entry name with the destination directory using filepath.Join but did not verify that the resulting path remained within the intended destination. ZIP entries containing sequences like ../../ could therefore escape the target directory and overwrite arbitrary files reachable by the fetcher process.

Why this happens

The vulnerability stems from insufficient validation of file paths when extracting ZIP archives.

While filepath.Join normalizes paths, it does not prevent directory traversal if the input contains .. components. The Unarchive function trusted archive entry names and wrote files to the joined path without checking that it still resided under the designated extraction root.

This aligns with CWE-22: Improper Limitation of a Pathname to a Restricted Directory, where user-influenced paths are not constrained to an expected base directory, enabling attackers to escape the intended filesystem boundary.

Potential impact

  • Overwriting existing files under /tmp or other writable paths reachable by the fetcher process.
  • Writing into other tenants' /packages/<ns>/ directories, enabling code tampering or function hijacking.
  • Modifying mounted secret or configuration volumes, leading to credential theft, configuration subversion, or denial of service.
  • Overwriting the fetcher's own binary or supporting files, potentially enabling persistent compromise within the pod's context.
  • Indirect privilege escalation if overwritten files are executed or consumed by more privileged components.

General mitigation guidance

Effective mitigation focuses on enforcing strict path confinement during archive extraction and reducing trust in archive sources.

Common defensive patterns include:

  • Validating each archive entry by resolving it against the extraction root and rejecting entries whose normalized path does not remain under that root.
  • Explicitly disallowing absolute paths and .. path segments in archive entry names.
  • Extracting to isolated, per-request directories with minimal privileges, and avoiding writing into shared or sensitive mount points where possible.
  • Running the fetcher sidecar with the least privileges necessary, restricting filesystem permissions and limiting access to secrets and critical configuration paths.
  • Treating externally supplied package or deployment URLs as untrusted inputs, enforcing allowlists or repository-based sourcing rather than arbitrary URLs.

How teams detect issues like this

Organizations can identify and monitor for this class of issue using:

  • Static analysis rules or linters that flag archive extraction routines lacking checks to enforce that target paths remain within a configured base directory.
  • Code review checklists emphasizing safe handling of paths derived from archives, user input, or network sources, including specific verification of ZIP/TAR extraction helpers.
  • Policy-based controls in CI/CD pipelines that prevent introduction of new archive extraction utilities without path traversal protections.
  • Runtime monitoring for unusual write patterns by fetcher pods, such as writes to unexpected directories or to mounted secret/config volumes, using Kubernetes audit logs or filesystem activity monitoring tools.

Sources

SourceLink
github.comgithub.com/fission/fission/pull/3444
github.comgithub.com/fission/fission/releases/tag/v1.25.0
github.comgithub.com/fission/fission/security/advisories/GHSA-q6vm-xqc9-v3ff

Frequently asked

questions

It can be, if an attacker can remotely influence the Package.Spec.Source.URL or Deployment.URL to point to a malicious ZIP archive. In multi-tenant or self-service environments, this often translates to practical remote exploitability through standard APIs.

The attacker needs the ability to control or manipulate the archive URL consumed by the fetcher. They do not necessarily need shell access to the pod, but they must be able to trigger the fetcher to download and extract a crafted ZIP.

The safest pattern is to enforce strict path validation for each archive entry: normalize the combined path, verify that it remains within the intended extraction directory, and reject any entry that attempts to escape it. Additionally, disallow absolute paths and .. segments in archive contents.

Use well-reviewed archive extraction helpers that implement path traversal protections by default, treat all externally sourced archives as untrusted, and apply least-privilege principles to components that write to the filesystem. Incorporating security-focused code review and automated checks for path-based vulnerabilities into the development lifecycle further reduces the chance of recurrence.

Find out what's already
exploitable in your codebase.