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-71313

CVE-2026-71313: Local Directory Traversal in rclone via Unsafe Encoding Configurations

Amit Schendel
Amit Schendel
Senior Security Researcher

Aug 6, 2026·7 min read·36 visits

Executive Summary (TL;DR)

In rclone versions v1.51.0 to v1.74.x, configured local target encodings that omit dot-protection allow malicious remote filenames to escape the designated sync root and manipulate arbitrary host files.

A local encoding path traversal vulnerability exists in rclone versions from v1.51.0 up to v1.75.0. When non-default local encoding parameters (such as Slash, None, or Raw) are specified, rclone's standard decoder maps safely encoded fullwidth dot-dot characters back into native directory traversal components. Since the local backend historically lacked a post-resolution path containment check, these relative segments resolved outside the designated synchronization root, allowing arbitrary file creation and modification on the host system.

Vulnerability Overview

The affected component is rclone's local backend implementation. Rclone is a widely used command-line utility designed to synchronize files and directories between local storage and various cloud storage providers. The local backend manages direct file and directory read/write operations when syncing files onto the host operating system. This component exposes a critical attack surface whenever rclone operates on untrusted remote repositories.

The vulnerability is classified under CWE-22 (Improper Limitation of a Pathname to a Restricted Directory / 'Path Traversal'). When certain non-default local destination encoding configurations are enabled, rclone maps standard-encoded fullwidth dot sequences into directory traversal path components. The local directory boundary constraint is not validated during this decoding process, which allows remote storage sources to write to arbitrary paths.

The vulnerability has an impact on file integrity and availability. An attacker who controls a synchronized remote repository can construct specific filenames that escape the intended local destination directory when downloaded by a vulnerable client configuration. This enables unauthorized write operations to administrative or critical system paths on the target machine.

Root Cause Analysis

To safely process object names across disparate file storage platforms, rclone uses a standardized transformation architecture. Many cloud storage providers allow characters that are restricted on local host filesystems, such as backslashes, colons, or relative directory markers. Rclone translates these dangerous remote characters into safe Unicode equivalent representations during standard operation to prevent directory traversal and file corruption during synchronization.

Specifically, a double-dot relative reference (..) is translated into fullwidth double dots (..) during transmission. Under default configurations, when the local backend writes these files to the local disk, the standard encoder (defined by encoder.OS) maintains safety by preserving the fullwidth characters or applying safe transformations. This translation logic is handled by the FromStandardPath function, which maps normalized paths back to native representations.

However, if the local backend's encoding is manually configured to exclude the Dot flag, such as with --local-encoding Slash, None, or Raw, FromStandardPath translates the safe fullwidth dot sequence (..) back into native literal dots (..). This output is then passed to Go's filepath.Join function alongside the target root path of the synchronization directory.

Go's filepath.Join automatically cleans the combined string to evaluate relative path segments. While filepath.Join removes redundant path separators and simplifies relative steps, it does not restrict the resolved path from climbing past the parent boundaries of the root folder. If the relative input contains sufficient parent directory sequences, the final clean path is resolved entirely outside of the intended target directory.

Code Analysis

Prior to version v1.75.0, the path resolution in rclone's local backend relied entirely on the encoding subsystem to prevent traversal. The following snippet illustrates the vulnerable path calculation logic within backend/local/local.go:

// Vulnerable path calculation in local.go
func (f *Fs) localPath(name string) string {
	// f.opt.Enc.FromStandardPath decodes fullwidth characters based on configuration
	// filepath.FromSlash converts forward slashes to native OS separators
	// filepath.Join resolves the combined path but lacks boundary validation
	return filepath.Join(f.root, filepath.FromSlash(f.opt.Enc.FromStandardPath(name)))
}

If the configuration excludes the Dot flag, the returned path escapes the designated root without raising an error. The patch in version v1.75.0 addresses this by introducing a post-resolution verification check. This check computes the relationship between the final path and the intended destination root using the standard library's filepath.Rel function:

// Patched path calculation in local.go
func (f *Fs) localPath(name string) (string, error) {
	native := filepath.FromSlash(f.opt.Enc.FromStandardPath(name))
	localPath := filepath.Join(f.root, native)
	
	// Calculate the relative path from the root to the target path
	rel, err := filepath.Rel(f.root, localPath)
	
	// If the calculation fails, or if the relative path resolves to parent directories,
	// return an explicit path escape error
	if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) {
		return "", fserrors.NoRetryError(fmt.Errorf("%q: %w", name, errPathEscapes))
	}
	return localPath, nil
}

This refactoring changes the function signature to return both the path string and an error. When the path resolution escapes the directory boundary, the function returns a non-retryable error (errPathEscapes). Every caller within local.go that accesses the filesystem was updated to handle this error and abort the write transaction immediately.

Exploitation Mechanics

Exploitation of this vulnerability requires a set of specific execution criteria. First, an attacker must control or gain write access to a remote repository that is synchronized by a target user. The attacker populates this remote source with objects containing encoded traversal patterns. For instance, the attacker creates an object named ../../etc/cron.d/malicious_cron within the remote cloud bucket.

Second, the victim must run rclone with a command-line configuration that overrides the default safe encoding of the local destination. The command must specify an encoding that omits the standard Dot translation, as shown in the following example execution:

rclone sync remote:source /var/tmp/sync_destination --local-encoding Slash

During synchronization, rclone fetches the object list and decodes the standard fullwidth dot sequence into native directory traversal characters (..). Because the destination path is resolved purely via filepath.Join without containment checks, the local backend writes the attacker-supplied file content to the host directory, bypasses the /var/tmp/sync_destination boundary, and deposits the payload directly in /etc/cron.d/.

Impact Assessment

The security consequences of a successful path traversal exploit are significant and depend on the execution privileges of the rclone process. If the command runs with administrative or root permissions, the attacker can overwrite sensitive system files or inject executable scripts into system-wide directories such as /etc/cron.d or /etc/profile.d. This results in arbitrary code execution with the permissions of the host operating system.

In environments where rclone runs as an unprivileged user, the exploit remains highly impactful. The attacker can modify or overwrite user configuration files like ~/.bashrc, ~/.ssh/authorized_keys, or local application files. These modifications allow for local privilege escalation, persistent access, or lateral movement within the network.

The CVSS v3.1 base score of 6.9 is characterized by a network attack vector and high integrity impact, but requires high attack complexity because the vulnerability depends on specific user configuration choices. The scope of the attack is changed because the security controls separating the synchronized directory from the surrounding operating system filesystem are bypassed entirely.

Mitigation and Remediation

The most effective remediation is to upgrade rclone to version v1.75.0 or later. In these updated versions, the local backend natively implements the filepath.Rel validation step, terminating the sync operation and throwing a path escape error before executing any local file creation or modification commands.

If immediate system upgrades are not feasible, administrators must audit all automated scripts, cron tasks, and user configuration files to ensure that custom local encoding options are disabled. In particular, configurations must not define --local-encoding or the equivalent configuration keys with parameters such as Slash, None, or Raw. The default encoder settings must be restored to guarantee standard safety protections.

As a defense-in-depth practice, rclone processes should be executed under restricted user profiles or containerized sandboxes. Restricting the file system access of the process using mechanisms like AppArmor, SELinux, or lightweight containers limits the impact of potential directory traversals by ensuring the process cannot write to critical administrative system directories even if a path escape occurs.

Fix Analysis (1)

Technical Appendix

CVSS Score
6.9/ 10

Affected Systems

rclone command-line utility (v1.51.0 through v1.74.x)

Affected Versions Detail

Product
Affected Versions
Fixed Version
rclone
rclone
>= 1.51.0, < 1.75.0v1.75.0
AttributeDetail
CWE IDCWE-22 (Improper Limitation of a Pathname to a Restricted Directory)
Attack VectorNetwork (AV:N)
CVSS v3.1 Score6.9 (Medium)
Exploit StatusPoC-level
CISA KEV StatusNo

MITRE ATT&CK Mapping

T1083File and Directory Discovery
Discovery
T1005Data from Local System
Collection
CWE-22
Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal')

References & Sources

  • [1]https://github.com/rclone/rclone/security/advisories/GHSA-7p4m-qxvv-g567
  • [2]https://github.com/rclone/rclone/commit/6a69713864b1d8f6edbc03d8af735f9624576d6e
  • [3]https://github.com/rclone/rclone/releases/tag/v1.75.0

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

•about 1 hour ago•CVE-2026-109481
7.5

CVE-2026-109481: Cross-Site Request Forgery Leading to Elevation of Privilege in ASP.NET Core

CVE-2026-109481 is a high-severity Cross-Site Request Forgery (CSRF) vulnerability in the ASP.NET Core Blazor Server and interactive component architecture. The flaw exists within the internal circuit state synchronization endpoint (`/_blazor/refresh`), which fails to enforce antiforgery token validation or verify cross-origin request headers. By inducing an authenticated victim to issue a cross-site request targeting a pre-allocated circuit identifier, an unauthenticated attacker can bind the victim's security principal to the attacker's active SignalR circuit, resulting in full privilege elevation within the application scope.

Amit Schendel
Amit Schendel
2 views•9 min read
•about 2 hours ago•CVE-2026-126187
9.5

CVE-2026-126187: Unauthenticated Remote Code Execution in React Server Components

A critical deserialization vulnerability exists in React Server Components (RSC) packages (`react-server-dom-webpack`, `react-server-dom-parcel`, and `react-server-dom-turbopack`) across versions 19.0.0 through 19.3.0. The flaw occurs during the processing of React Flight protocol streams when handling multiple typed arrays sharing a backing ArrayBuffer alongside attacker-controlled inputs. By combining byte-stream buffer detachment semantics with unvalidated thenable invocation and exposed internal response states, an unauthenticated attacker can achieve remote code execution on server runtimes supporting React Server Components.

Alon Barad
Alon Barad
12 views•11 min read
•about 3 hours ago•CVE-2026-125123
2.3

CVE-2026-125123: Improper Output Neutralization and CI Workflow Command Injection in compose-lint CLI Parser

An improper output neutralization vulnerability (CWE-117 / CWE-150) exists in compose-lint version 0.31.0. When compose-lint is invoked on untrusted file paths without a preceding '--' option delimiter, Python's standard argparse module rejects malformed or dash-prefixed paths and writes them directly to standard error without passing through the application's output sanitizer. An attacker submitting a pull request containing crafted directory or file names with carriage returns or Unicode whitespace can inject arbitrary CI workflow commands into GitHub Actions or Azure Pipelines job logs.

Alon Barad
Alon Barad
4 views•10 min read
•about 4 hours ago•CVE-2026-125116
4.8

CVE-2026-125116: Type Confusion in Mongoose Discriminator Resolution

CVE-2026-125116 (GHSA-wr5m-5jph-8m96) is a type confusion vulnerability (CWE-843) in Mongoose, the MongoDB object modeling library for Node.js. When resolving discriminator models or schemas via user-supplied discriminator keys (defaulting to `__t`), Mongoose performs direct property indexing on plain JavaScript registry objects without verifying own-property ownership. Supplying inherited `Object.prototype` property names such as `'constructor'` causes Mongoose to resolve built-in functions rather than valid Mongoose constructors, resulting in unhandled runtime exceptions, schema validation bypasses, and persistent collection query denial of service.

Alon Barad
Alon Barad
4 views•11 min read
•about 5 hours ago•CVE-2026-125119
7.5

CVE-2026-125119: Connection-Level Filter Sanitization Bypass in Mongoose ODM

A flaw in Mongoose's query condition casting pipeline causes the `sanitizeFilter` configuration option to be silently ignored when defined at the connection level via `mongoose.connect()` or `mongoose.createConnection()`. Because internal query methods inspect `Connection.options` rather than `Connection.config`, applications relying on connection-scoped filter sanitization remain vulnerable to NoSQL query selector injection (CWE-943), permitting authentication bypass and unauthorized data access across Mongoose versions 6.x through 9.x.

Amit Schendel
Amit Schendel
4 views•9 min read
•about 6 hours ago•CVE-2026-125110
5.3

CVE-2026-125110: Path Canonicalization Mismatch and Security Header Bypass in Rack::Static

CVE-2026-125110 is a path canonicalization mismatch vulnerability in Rack (specifically within the Rack::Static middleware component). When serving static files, Rack normalizes the requested URL path to resolve the physical file on disk, but evaluates configured path-specific header rules against an unnormalized, raw path that has only undergone URL percent-decoding. Unauthenticated remote attackers can exploit this discrepancy by injecting raw or percent-encoded dot-segments into HTTP requests, causing Rack to serve restricted static assets without their intended security headers.

Amit Schendel
Amit Schendel
6 views•10 min read