CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-88014

CVE-2026-88014: Path Traversal (Zip Slip) and Directory Boundary Bypass in rclone ZIP Backend

Alon Barad
Alon Barad
Software Engineer

Sep 11, 2026·5 min read·29 visits

Executive Summary (TL;DR)

Unsanitized ZIP entry names allow directory traversal (Zip Slip) and sibling folder data exposure in rclone's ZIP backend.

A critical path traversal vulnerability (commonly known as 'Zip Slip') exists in rclone's ZIP archive backend implementation (backend/archive/zip/zip.go) between versions 1.72.0 and 1.75.1. The flaw allows an attacker to write arbitrary files outside the designated extraction directory by supplying a maliciously crafted ZIP archive. Additionally, the backend's directory boundary verification routine failed to enforce strict path limits, causing sibling folders sharing a name prefix to match incorrectly and leading to unauthorized data exposure. This issue has been fully resolved in version 1.75.1.

Vulnerability Overview

The open-source command-line utility rclone allows users to manage and synchronize files across local and cloud storage backends. Within versions 1.72.0 up to (but excluding) 1.75.1, the archive ZIP backend implementation contains a path traversal vulnerability. When mounting, reading, copying, or syncing from an archive using this backend, rclone fails to ensure that the parsed file paths remain within the destination namespace.\n\nThis lack of strict namespace boundary verification enables directory traversal sequences, such as relative dot-dot (..), to bypass safety checks. The issue primarily affects the readZip function in backend/archive/zip/zip.go. An attacker who can influence the ZIP archive supplied to rclone can execute arbitrary file write operations on the destination filesystem.\n\nIn addition to path traversal, a secondary logic flaw exists within the subdirectory containment mechanism. If a subdirectory root is specified to limit operations, rclone uses prefix matching without a trailing slash delimiter. This allows directories sharing a prefix (e.g., 'foobar' and 'foo') to overlap, resulting in unauthorized folder inclusion and exposure.\n\nmermaid\ngraph LR\n A["ZIP Entry: ../../file"] --> B["path.Clean()"]\n B --> C["Result: ../../file"]\n C --> D["Target System Root Escape"]\n

Root Cause Analysis

The core vulnerability lies in how rclone processes metadata returned by the Go standard library's archive/zip package. The standard library provides the file.Name field exactly as it appears in the ZIP file central directory header, without performing any validation or filtering on relative path components.\n\nIn the vulnerable implementation, the readZip method processes each entry using Go's lexical path utility: path.Clean(file.Name). While path.Clean collapses intermediate directory levels and removes duplicate separators, it does not neutralize leading relative path segments if there are no preceding directories to offset them. For example, path.Clean('../../etc/cron.d/evil') resolves exactly to ../../etc/cron.d/evil.\n\nBecause the empty root configuration is the default mode when extracting a ZIP file, these unneutralized parent directory markers flow directly into rclone's synchronization and copy engines. If the destination storage backend lacks independent confinement, the file paths resolve relative to the system root, permitting arbitrary file creation or overwrite.\n\nFurthermore, the subdirectory isolation checks used a simple strings.HasPrefix(remote, f.root) call. Without verifying that the match is followed by a path separator, a configured root of foo matches any sibling beginning with those three letters, such as foobar/data.txt.

Code Analysis

Below is the relevant segment of the vulnerable code in backend/archive/zip/zip.go before the patches were applied:\n\ngo\n// Vulnerable implementation\nfor _, file := range zr.File {\n\tremote := strings.Trim(path.Clean(file.Name), "/")\n\tif remote == "." {\n\t\tremote = ""\n\t}\n\tremote = path.Join(f.prefix, remote)\n\tif f.root != "" {\n\t\t// Ignore all files outside the root\n\t\tif !strings.HasPrefix(remote, f.root) {\n\t\t\tcontinue\n\t\t}\n\t}\n}\n\n\nIn the patched code, the utility sanitize.Path is introduced. This function identifies and blocks absolute paths and directory traversal structures, such as those targeting parent namespaces via .. delimiters:\n\ngo\n// Patched implementation\nfor _, file := range zr.File {\n\t// Skip entries whose name escapes the archive's own namespace\n\tremote, err := sanitize.Path(file.Name)\n\tif err != nil {\n\t\tskipped++\n\t\tcontinue\n\t}\n\tremote = path.Join(f.prefix, remote)\n\tif f.root != "" {\n\t\t// Ignore all files outside the root, requiring a path\n\t\t// boundary so that root "foo" does not also match a\n\t\t// sibling entry such as "foobar"\n\t\tif remote != f.root && !strings.HasPrefix(remote, f.root+"/") {\n\t\t\tcontinue\n\t\t}\n\t}\n}\n\n\nThe revised logic ensures that all relative trajectories are safely trapped, and that subdirectory isolation is guaranteed by appending the / path delimiter during the prefix comparison step.

Exploitation Method

An attacker must craft a ZIP archive where the central directory header contains one or more file names embedded with path traversal components. Since standard compression tools often automatically strip relative paths, the malicious archive must be generated programmatically or modified using hex-editing techniques.\n\nFor example, an entry named ../../../../etc/cron.d/malicious_job is packaged inside payload.zip. The target user must then execute an rclone operation against the archive, using either the copy, sync, or mount functions. An example command sequence is shown below:\n\nbash\nrclone copy :zip:payload.zip /home/user/target_directory\n\n\nUpon execution, rclone reads the metadata, resolves the target destination relative to the output root, and processes the relative markers. This shifts the target file write outside of /home/user/target_directory and directs it straight to /etc/cron.d/malicious_job. If the rclone command is executed with sufficient host permissions, the file is successfully created, potentially leading to privilege escalation or arbitrary command execution via cron.

Impact Assessment

The impact of CVE-2026-88014 is primarily classified as an Integrity compromise, rated with a CVSS v3.1 base score of 6.3. The attack complexity is low, but exploitation is contingent on user interaction, as a victim must run rclone on a crafted zip file.\n\nThe potential consequences are dictated by the permissions of the user running the rclone process. If executed within an automated backup pipeline or system task running as the root user, an attacker can modify sensitive files such as shell profiles, cron directories, systemd service units, or authorization keys.\n\nThe secondary path matching issue compromises Confidentiality and Integrity by allowing a user restricted to folder foo to read and write files within folder foobar. This exposes shared multi-tenant environments to cross-directory access and unexpected data manipulation.

Mitigation & Remediation

The primary remediation strategy is upgrading all rclone clients and installations to version 1.75.1 or later. The patch completely sanitizes relative path sequences in ZIP entry extraction and implements strict path-delimiter checking on subdirectory matching.\n\nIf immediate software upgrade is not possible, the following defensive configurations should be established:\n\n* Restrict user access to the ZIP backend implementation by filtering or blocking the :zip: remote scheme in untrusted environments.\n* Execute rclone operations inside sandboxed environments or under low-privileged accounts using system controls like AppArmor, SELinux, or Docker boundaries.\n* Implement strict write restrictions on the directory target, ensuring the execution process cannot write outside of its specified home directory or workspace.

Technical Appendix

CVSS Score
6.3/ 10
CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:C/C:N/I:H/A:N

Affected Systems

rclone installations utilizing the ZIP backend between versions 1.72.0 and 1.75.0
AttributeDetail
CWE IDCWE-22
Attack VectorLocal (AV:L)
CVSS Score6.3
EPSS ScoreNot Populated
Exploit StatusPoC (unit tests available)
KEV StatusNo
ImpactArbitrary File Write / Path Traversal
CWE-22
Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal')

Vulnerability Timeline

Patched subdirectory root matching sibling directory exposure (Commit 5dae3adbf571a6cd9ba501eb47397a7e871e1ae0)
2026-08-20
Patched primary Zip Slip traversal vulnerability using sanitize.Path (Commit 6507e13d5a83789f500af96d7188c302c9d74d98)
2026-08-25
Official security advisory published via GitHub Advisory Database and rclone v1.75.1 released
2026-09-10

References & Sources

  • [1]Official GitHub Advisory
  • [2]Primary Path Traversal Fix Commit
  • [3]Subdirectory Boundary Fix Commit
  • [4]Rclone Release Tag (v1.75.1)
  • [5]Official CVE.org Record
  • [6]NVD Entry

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•2 days ago•CVE-2026-115895
8.8

CVE-2026-115895: Code Injection via Unsanitized Import Alias in Happy DOM ECMAScript Module Compiler

CVE-2026-115895 is a high-severity code injection vulnerability (CWE-94) in the happy-dom npm package prior to version 21.0.4. The vulnerability exists within the ECMAScriptModuleCompiler component, which transforms ECMAScript module syntax into executable Node.js functions when JavaScript evaluation is enabled. Due to an incomplete fix for CVE-2026-33943, the compiler failed to validate local named import aliases against legal JavaScript identifier rules. Attackers supplying crafted module imports—specifically utilizing destructuring default initializers alongside JSON module attributes—can inject arbitrary JavaScript expressions directly into the host Node.js runtime context.

Amit Schendel
Amit Schendel
8 views•10 min read
•2 days ago•CVE-2026-115883
6.0

CVE-2026-115883: Cross-Namespace Access via Dot-Delimited Labels in LangGraph Postgres and SQLite Stores

An improper input validation and authorization bypass vulnerability exists in the LangGraph storage layer affecting langgraph, langgraph-checkpoint-postgres, and langgraph-checkpoint-sqlite. Because relational store implementations serialize namespace tuples into dot-delimited strings without validating labels on read, search, delete, and batch operations, an attacker who controls a namespace label can inject periods (.) to traverse namespace boundaries and access, modify, or delete data belonging to other namespaces.

Amit Schendel
Amit Schendel
8 views•9 min read
•2 days ago•CVE-2026-115886
6.5

CVE-2026-115886: Unauthenticated Server-Side Request Forgery and Unsafe Reflection in MLflow Scorer Evaluation Endpoints

CVE-2026-115886 (GHSA-2wqp-q3c6-ccj5) is a Server-Side Request Forgery (SSRF) and Unsafe Reflection vulnerability in MLflow versions 3.12.0rc0 prior to 3.17.0. Unauthenticated REST API endpoints accept serialized third-party scorer JSON payloads that are dynamically deserialized and reflectively instantiated without sanitizing constructor keyword arguments. When optional dependencies such as trulens and trulens-providers-litellm are installed, attackers can inject egress-steering arguments into the scorer payload, forcing the MLflow server to dispatch outbound HTTP requests to arbitrary internal destinations or cloud metadata services.

Alon Barad
Alon Barad
12 views•10 min read
•2 days ago•CVE-2026-113872
7.5

CVE-2026-113872: Unauthenticated Process Crash in Express Multer via Late Busboy Stream Resumption

CVE-2026-113872 (GHSA-q7qp-rjg7-q26m) is a high-severity denial-of-service vulnerability affecting the multer multipart/form-data upload middleware for Node.js and Express in versions 2.0.0 through 2.4.0. When an endpoint is configured to accept multiple files using an asynchronous fileFilter callback, a crafted, truncated multipart HTTP request can trigger an unhandled error event on the underlying busboy stream parser after request teardown has already completed. Because all error listeners are stripped during teardown, Node.js treats the resulting error event as an uncaught exception and immediately terminates the server process.

Amit Schendel
Amit Schendel
9 views•12 min read
•2 days ago•CVE-2026-115897
2.1

CVE-2026-115897: Cross-Site Scripting via Function Body Boundary Bypass in serialize-javascript

CVE-2026-115897 (also tracked as GHSA-m5mm-p8h7-m29v and aliased as CVE-2026-115754) is a Cross-Site Scripting (XSS) vulnerability in the Yahoo serialize-javascript npm package prior to version 7.1.3. The flaw exists in the regular expression used by escapeFunctionBody() to neutralize HTML script closing tags within serialized JavaScript functions. Because function bodies are sanitized in isolation before structural formatting is applied, a function whose string representation terminates directly with the sequence '</script' bypasses the positive lookahead check. When combined with serialization formatting options that introduce whitespace delimiters and a subsequent property that supplies a closing bracket, an attacker can prematurely terminate an enclosing HTML <script> block and inject arbitrary HTML or JavaScript into the rendered document.

Amit Schendel
Amit Schendel
7 views•13 min read
•2 days ago•CVE-2026-109841
5.9

CVE-2026-109841: Subresource Integrity Verification Bypass in Node.js Undici

CVE-2026-109841 is a Subresource Integrity (SRI) verification bypass vulnerability in undici, the official HTTP/1.1 and HTTP/2 client library for Node.js that powers the global fetch() implementation. The flaw stems from improper handling of case sensitivity (CWE-178) when validating cryptographic hash algorithm tokens within SRI metadata. Because undici compared incoming algorithm identifiers against a strictly lowercase set without prior ASCII-lowercase normalization, valid uppercase or mixed-case tokens such as SHA256- or Sha384- were treated as unrecognized algorithms and discarded. Under SRI forward-compatibility rules, discarding all provided tokens results in an empty integrity list, causing undici to fail open and accept tampered HTTP response bodies without cryptographic verification.

Alon Barad
Alon Barad
15 views•9 min read