Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessPlace crafted ZIP with traversal entries on accessible storage
-
DeliveryVictim or pipeline runs rclone with archive backend against malicious ZIP
-
ExploitreadZip() exposes traversal path as Object.Remote() without namespace check
-
Executionrclone writes attacker content to traversed filesystem path
-
ImpactPersistent access or privilege escalation achieved
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V5 - File Handling Path canonicalization, traversal prevention
MITRE ATT&CK
2 techniques across 2 tactics: Discovery, Collection The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | The victim must invoke rclone using the archive ZIP backend against a ZIP file that contains attacker-controlled central directory entries - for example, rclone copy :archive:/path/to/attacker.zip destination/ or via a configured archive remote. The attacker must be able to place or modify the ZIP file that rclone processes; typical paths include shared cloud storage buckets, CI/CD artifact repositories, or user-downloaded archives from untrusted sources. The destination backend must not independently enforce path confinement - standard backends such as the local filesystem, SFTP, and object storage (S3, GCS) do not. Exploitation requires user interaction (UI:R): a human operator or automated job must invoke the rclone operation against the malicious ZIP. The vulnerability does not affect rclone operations that do not use the archive ZIP backend; normal directory-to-directory sync, individual file transfers, and other backend types are unaffected. |
| Impact | The vendor-assigned CVSS 6.3 with AV:L reflects an assessment that the attacker-controlled ZIP must reach the victim's local execution environment, but rclone's core purpose is syncing from remote and cloud storage backends - an attacker with write access to a shared S3 bucket, Google Drive, or similar cloud source can inject a malicious ZIP that a victim or pipeline then processes via the archive backend, which is a realistic network-accessible attack path not well-captured by AV:L. The S:C Scope Changed metric correctly signals that successful exploitation breaks the confinement boundary and enables writes to arbitrary filesystem paths including privilege-escalation targets like cron directories or SSH authorized_keys. The I:H and C:N profile is consistent with an arbitrary write primitive with no direct read leakage. No EPSS score was provided in the available data, so exploitation probability cannot be quantified; the absence of a KEV listing indicates no confirmed active exploitation at time of analysis. The Zip Slip technique is widely understood with abundant generic reference implementations, lowering the effort required to craft a working exploit once a target deployment is identified. Even a mid-sized municipal IT team in olsztyn running automated rclone sync jobs against externally contributed or shared ZIP archives should treat this as a concrete file-write risk rather than a theoretical edge case, particularly in CI/CD pipelines that process artifacts from partially trusted sources. |
| Exploit ScenarioDerived | An attacker with write access to a shared cloud storage bucket (e.g., S3, Google Drive) places a crafted archive.zip whose central directory contains an entry named ../../.ssh/authorized_keys with attacker-controlled content. When a victim or automated pipeline runs rclone copy remote:archive.zip /tmp/dest/ using the rclone archive backend on an affected version, readZip exposes the traversal path as a valid Object.Remote() value and rclone writes the file to the user's SSH authorized_keys, granting the attacker persistent shell access. No public exploit code is known at time of analysis, but Zip Slip exploitation patterns are well-documented in the security community. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 10, 2026
Path traversal (Zip Slip class) in rclone's archive ZIP backend permits arbitrary file writes outside the intended destination directory when processing a malicious ZIP archive. Versions 1.72.0 through 1.75.0 are affected: the readZip function in backend/archive/zip/zip.go trusts central directory filenames from untrusted ZIP sources without confining path.Clean output to the archive namespace, allowing entries like ../../etc/cron.d/evil to propagate as Object.Remote() values and be written by fs/sync and fs/operations to attacker-chosen filesystem locations. A separate bug used strings.HasPrefix without a path separator, causing root 'foo' to incorrectly match sibling entries named 'foobar'. Vendor-released patch is available in version 1.75.1; no public exploit identified at time of analysis.
RemediationAI
Upgrade rclone to version 1.75.1 or later, which applies two targeted commits: 5dae3adbf571a6cd9ba501eb47397a7e871e1ae0 (namespace confinement fix) and 6507e13d5a83789f500af96d7188c302c9d74d98 (root boundary separator fix), as referenced in the GitHub advisory at https://github.com/rclone/rclone/security/advisories/GHSA-66hp-wgxq-6f5q. If an immediate upgrade is not feasible, avoid using rclone's archive ZIP backend (the :archive: pseudo-backend or archive remote type) against any ZIP file sourced from untrusted, externally writable, or shared storage locations. For automated pipelines, enforce that source ZIP files are fetched exclusively from fully access-controlled, write-protected storage buckets before processing. Note that restricting source access does not address the code-level flaw; it only reduces the likelihood of a malicious ZIP reaching the vulnerable code path.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 packages in go, euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
rclone's archive ZIP backend (backend/archive/zip/zip.go) exposes the contents of a ZIP file as a virtual rclone filesystem. The readZip() method iterates archive/zip.File entries and calls path.Clean on their Name fields - values sourced entirely from the ZIP's untrusted central directory. path.Clean resolves dot-segments and produces a canonical path, but it does not prevent traversal sequences that resolve to locations outside the archive root: a name like ../../etc/cron.d/evil survives cleaning and emerges as a relative path that escapes the intended namespace. These escaped paths are then consumed verbatim by fs/sync and fs/operations as destination-relative write targets, and since most rclone backends (local filesystem, S3, SFTP) do not independently sandbox the path, rclone writes to the traversed location. A secondary bug used strings.HasPrefix(remote, f.root) without appending a path separator, allowing root 'foo' to incorrectly claim entries rooted at 'foobar'. CWE-22 (Improper Limitation of a Pathname to a Restricted Directory - Path Traversal) precisely describes both flaws. The fix in commits 5dae3ad and 6507e13 enforces a separator-bounded prefix check and adds a namespace confinement guard. CPE cpe:2.3:a:rclone:rclone:*:*:*:*:*:*:*:* covers all affected releases from 1.72.0 to 1.75.0 inclusive.
Know when Rclone gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:L/AC:L/PR:N/UI:R/S:C/C:N/I:H/A:N
rclone's primary use is syncing from network and cloud storage, making a network-hosted malicious ZIP the realistic attack vector rather than strictly local access.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
1DescriptionCVE.org
rclone is a command-line program to sync files and directories to and from different cloud storage providers. From 1.72.0 until 1.75.1, the archive ZIP backend method (*Fs).readZip in backend/archive/zip/zip.go accepts archive/zip.File.Name values from an untrusted central directory and exposes cleaned entry names without ensuring that they remain inside the archive namespace. Entries such as ../../etc/cron.d/evil can survive path.Clean and become Object.Remote() values that fs/sync and fs/operations use as destination-relative paths, allowing rclone copy or sync to write outside the selected destination on backends that do not independently confine the path. The non-empty root check also used strings.HasPrefix without a path boundary, so root foo could incorrectly include sibling foobar entries. This issue is fixed in version 1.75.1.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Path traversal exploits occur when applications use user-controlled input to construct file system paths without proper validation.
Authentication bypass in rclone's S3 server mode (rclone serve s3) allows any unauthenticated network attacker to impers
PowerShell smart-quote filename injection in rclone's SFTP backend allows an attacker who controls remote filenames to e
An issue was discovered in Rclone before 1.53.3. Rated high severity (CVSS 7.5), this vulnerability is remotely exploita
Cross-session credential isolation failure in rclone's FTP auth-proxy driver (versions 1.64.0-1.75.0) allows an authenti
Symlink escape in rclone's local backend (prior to v1.75.1) allows an attacker who controls sync source contents to appl
FTP CRLF injection in rclone before 1.75.0 allows an attacker who can place crafted filenames in a source namespace to i
Denial of service in rclone prior to 1.75.1 allows unauthenticated remote attackers to crash individual HTTP or WebDAV c
Path traversal in rclone prior to 1.75.1 allows an attacker who can populate a source object store with raw `..` key seg
Cleartext disclosure of AWS STS session tokens affects rclone before 1.74.4 when its S3 backend follows a redirect that
Authentication/authorization bypass in rclone's dynamic serve interface (versions 1.70.0 through 1.75.0) lets remote att
Path traversal in the `rclone serve restic --private-repos` REST server (versions prior to 1.74.4) allows an authenticat
Arbitrary file write via symlink traversal in Rclone prior to 1.74.4 lets an attacker-controlled remote escape the local
Same weakness CWE-22 – Path Traversal
View allSame technique Path Traversal
View allVendor StatusVendor
SUSE
Severity: Moderate| Product | Status |
|---|---|
| SUSE Linux Enterprise Server 16.0 | Affected |
| SUSE Linux Enterprise Server for SAP applications 16.0 | Affected |
EUVD-2026-75574
GHSA-66hp-wgxq-6f5q
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB