Description

rclone before 1.75.1 fails to confine names from server and third-party listing responses to the listed directory, allowing path traversal sequences in object names. Attackers can craft special names containing forward slashes and parent directory references to potentially write outside the destination root, though downstream protections in the local backend currently block actual file escape.

Executive Summary

Technical Details

Mitigations

References

Additional Metadata

{
  "score": "3.1",
  "pubDate": "2026-09-19T12:16:42.027Z",
  "pubdate": "2026-09-19T12:16:42.027Z",
  "executiveSummary": "A path traversal vulnerability exists in rclone versions prior to 1.75.1, stemming from insufficient validation of object names returned by server and third-party listing responses.\nThe vulnerability allows an attacker to manipulate object names containing path traversal sequences, such as forward slashes and directory navigation operators (../), to attempt writes outside of the designated destination root directory.\nWhile downstream protections currently implemented in the local backend prevent successful file system escape and unauthorized arbitrary file write, the flaw represents a significant failure in input sanitization.\nThe vulnerability affects rclone in its handling of untrusted remote directory listings. The primary risk implication involves potential exploitation should those downstream protections be bypassed, disabled, or if different storage backends are utilized that lack equivalent security controls.\nAttackers can leverage this vulnerability by compromising a remote server or performing a man-in-the-middle attack to inject malicious object names into the listing response during a synchronization or copy operation.\nExploitation requires the attacker to influence the metadata provided by the remote source, which is then processed by the vulnerable rclone client.",
  "technicalDetails": "The root cause of this vulnerability is improper neutralization of special characters within directory listing responses. When rclone performs operations involving remote sources, it parses object names provided by the server. In affected versions, the application fails to properly confine these object names to the expected destination directory.\nThe attack flow initiates when a user triggers an rclone operation (such as 'sync' or 'copy') against a malicious or compromised remote repository. The malicious server provides a crafted directory listing response containing object names structured with path traversal payloads, such as '..\\/..\\/target_file'.\nDuring the processing phase, the vulnerable component fails to validate or sanitize the path traversal sequences before constructing the local file path. Consequently, the rclone process attempts to resolve the destination path using the malicious input.\nUnder normal circumstances, this would lead to an arbitrary file write outside the designated root directory, potentially overwriting critical system files or application configuration files. However, the current implementation of rclone includes secondary safety checks within the local storage backend. These downstream protections act as a defense-in-depth measure, identifying and blocking attempts to traverse outside the intended directory, thereby neutralizing the immediate threat of arbitrary file overwrite.\nThe vulnerability is restricted to versions prior to 1.75.1. It does not explicitly require local authentication or high privileges to initiate, as the attack is orchestrated through the remote listing response; however, the impact is strictly governed by the local system's permission model and the effectiveness of the existing backend protections. If a user were to employ a custom or third-party backend that lacks these specific path-validation safeguards, the risk of system-wide impact would increase significantly.\nThe payload behavior is characterized by the injection of path navigation sequences into the metadata fields. If the backend protections were successfully bypassed, the post-exploitation impact would include unauthorized file modification, potential arbitrary code execution (if a configuration file or executable is overwritten), and full compromise of the local storage integrity."
}