/

CVE-2026-33645

Severity:

HIGH RISK

(7.1)

Path Traversal File Write in Fireshare Chunked Upload

CVE-2026-33645

Analyzed

Vulnerability type

Category:

Path Traversal / Arbitrary File Write

CWE:

CWE-22, CWE-73

Impact:

Authenticated Arbitrary File Write

Severity:

HIGH RISK

(7.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

An authenticated path traversal vulnerability in Fireshare's chunked upload endpoint allows attacker-controlled file paths to be constructed from the checkSum multipart field without proper validation.

Under affected configurations, an authenticated user can write arbitrary files outside the intended upload directory to any path writable by the Fireshare process, potentially enabling further compromise depending on the surrounding deployment.

Affected context

This vulnerability occurs in Fireshare deployments that expose the chunked upload endpoint and accept user uploads from authenticated clients.

The issue is triggered when the server uses the checkSum multipart field directly in filesystem path construction, without normalizing or constraining it to a dedicated upload directory.

Any environment where the Fireshare process has write access to sensitive or executable directories (for example, shared /tmp directories in containers or host-mounted paths) is at elevated risk.

Exploit preconditions

  • Attack surface: HTTP(S) chunked upload endpoint exposed by Fireshare
  • Required access: Valid authenticated user account with permission to perform uploads
  • Trigger point: Submission of a crafted multipart/form-data request where the checkSum field contains traversal sequences or targeted paths
  • Why exploitation is possible: The server-side upload logic incorporates the checkSum value into filesystem paths without sanitization, normalization, or directory containment checks, allowing traversal outside the intended upload directory

Why this happens

The core issue is the direct use of user-supplied data in filesystem path construction.

The checkSum multipart field is treated as a trusted component of the destination path, and the application does not enforce that the resolved path remains within a designated uploads directory.

This maps to CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal') and is related to CWE-73: External Control of File Name or Path, where external input controls file locations, enabling writes to unintended files or directories.

Potential impact

  • Attackers could write arbitrary files to locations writable by the Fireshare process.
  • Attackers may place or overwrite temporary files in shared directories (e.g., /tmp in a container) that could influence other services or processes.
  • Attackers could tamper with application or configuration files if those paths are writable, potentially impacting service behavior or availability.
  • Attackers might set up conditions for follow-on attacks such as privilege escalation, local code execution, or data exfiltration depending on the broader system and deployment configuration.

General mitigation guidance

Effective mitigation focuses on constraining file system writes and removing direct trust in user-supplied paths.

Useful defensive patterns include:

  • Strictly resolving and normalizing paths, then enforcing that all upload destinations remain under a single, dedicated upload root directory (e.g., using canonical path checks).
  • Ignoring user-supplied path fragments for server-side storage and instead deriving filenames from server-generated identifiers, internal mapping tables, or opaque tokens.
  • Applying allowlists for valid filename patterns and rejecting any input containing path separators or traversal sequences.
  • Running the Fireshare service under a dedicated OS account with minimal filesystem privileges and restricting writable directories to non-sensitive locations.
  • Separating executable code, configuration, logs, and uploads into distinct directories with tightly scoped permissions so that uploaded content cannot influence execution paths.

How teams detect issues like this

Detection typically involves a combination of code-centric and operational approaches:

  • Static analysis: Configure rules to flag string concatenation or interpolation that combines user-controlled input (such as multipart fields) with filesystem operations (open, write, rename, move) without normalization or containment checks.
  • Code review: During manual review, look for upload handlers and file operations that use request parameters directly in path construction, and verify that canonical-path checks and directory allowlists are applied.
  • Logging and monitoring: Enable detailed logging of upload destinations and consider anomaly detection for file writes occurring outside known upload directories.
  • Security testing: Incorporate test cases that attempt directory traversal in upload-related fields into automated security tests or DAST tooling to catch regressions early.

Sources

SourceLink
github.comgithub.com/ShaneIsrael/fireshare/releases/tag/v1.5.2
github.comgithub.com/ShaneIsrael/fireshare/security/advisories/GHSA-7q8r-vpq3-89m7

Frequently asked

questions

Yes. Any remote client that can authenticate and access the chunked upload endpoint can attempt to exploit the vulnerability over the network, provided they can send crafted multipart/form-data requests.

The issue as described requires an authenticated user with upload capability. Whether this is a low-privilege or more restricted role depends on the Fireshare deployment and how accounts are managed.

The safest pattern is to avoid using user-supplied data directly in filesystem paths. Instead, store uploads in a fixed directory using server-generated identifiers, enforce canonical path checks to keep all file operations within that directory, and reject any input that introduces path separators or traversal sequences.

Adopt a standard file-handling abstraction that centralizes path normalization and containment checks, enforce secure coding guidelines around file operations, and include automated tests and static analysis rules that flag direct use of request parameters in path construction.

Find out what's already
exploitable in your codebase.