CVE-2026-88016: 
Rclone Analyse et atténuation des vulnérabilités

CVE-2026-88016 is a symlink-following vulnerability in rclone's local backend that allows an attacker controlling source contents to apply arbitrary ownership, permissions, and timestamps to files or directories outside the intended backup destination. When rclone is run with -l/--links, a malicious source can plant a .rclonelink object that creates a real symlink at the destination; subsequent directory metadata operations (chmod, chown, chtimes, birth-time writes) follow that symlink out of the destination tree without proper sandboxing. All rclone versions up to and including 1.75.0 are affected; the issue is fixed in version 1.75.1. It carries a CVSS v3.1 base score of 7.1 (High) (GitHub Advisory, Feedly).

The root cause is classified as CWE-59 (Improper Link Resolution Before File Access / Link Following) and CWE-281 (Improper Preservation of Permissions). In backend/local/local.go, MkdirMetadata calls os.Lstat on the destination path; if a symlink already exists there, os.Lstat succeeds and the errors.Is(err, os.ErrNotExist) guard is not triggered, so the os.Root-sandboxed f.Mkdir path is bypassed and a Directory object is built directly on the symlink path. Because a Directory always has translatedLink=false, the CVE-2024-52522 NOFOLLOW branch (which gates on if o.translatedLink) is never taken, causing writeMetadataToFile to call raw os.Chown/os.Chmod (metadata.go:131/158) and setTimes to call raw os.Chtimes (local.go:1318) — all of which follow the planted symlink to a target outside the destination. Modification-time escape requires only --links; chmod/chown escape additionally requires --metadata. A proof-of-concept demonstrating the two-run backup attack model is included in the security advisory (GitHub Advisory, Fix Commit).

A successful attack allows an attacker who controls the rclone source (e.g., a malicious or compromised remote, shared bucket) to apply attacker-chosen file permissions (chmod), ownership (chown), modification times (chtimes), and birth times to arbitrary files or directories outside the backup destination. The integrity impact is high — an attacker can, for example, set permissions to 0777 on sensitive directories outside the destination tree. When rclone runs as root with --metadata and the source specifies uid=0, the chown primitive can be used to take ownership of out-of-tree paths, reaching the privilege-escalation ceiling previously identified in CVE-2024-52522. Confidentiality impact is limited (low), and availability impact is low, but the scope is changed since resources outside the vulnerable component can be affected (GitHub Advisory).

A proof-of-concept is included in the official security advisory and has been verified end-to-end against the real fs/sync.Sync engine on rclone HEAD, demonstrating both the two-run backup model and a single-run variant for certain remote backends. Exploitation requires low privileges (attacker must control source contents), user interaction (a victim must run rclone with --links), and high attack complexity (requires a two-step or coordinated source manipulation). No in-the-wild exploitation has been reported, and the EPSS score is 0.0 at time of publication. The vulnerability is not listed in the CISA KEV catalog (GitHub Advisory, Feedly).

1. Control the source: The attacker gains control over the rclone source — a malicious remote, compromised shared bucket, or local directory that the victim syncs from with --links.
2. Plant the symlink: Place a .rclonelink file (e.g., pwn.rclonelink) in the source whose content is the absolute path of the target outside the destination (e.g., /home/victim/secret.d). When the victim runs rclone sync --links /src /dest, rclone faithfully recreates this as a real symlink dest/pwn -> /home/victim/secret.d.
3. Swap source object to a directory: Remove pwn.rclonelink from the source and replace it with a real directory pwn/ containing at least one file, setting the directory's mode and mtime to attacker-chosen values (e.g., chmod 777 /src/pwn).
4. Trigger metadata application: The victim runs rclone sync --links [--metadata] /src /dest again. MkdirMetadata calls os.Lstat on dest/pwn, which succeeds (the symlink exists), bypassing the os.Root-guarded f.Mkdir path.
5. Metadata escapes the destination: writeMetadataToFile calls raw os.Chmod/os.Chown and setTimes calls raw os.Chtimes on dest/pwn, which POSIX resolves through the symlink to /home/victim/secret.d, applying the attacker's chosen mode, ownership, and timestamps to the out-of-tree target.
6. Verify impact: The outside directory now has attacker-controlled permissions (e.g., drwxrwxrwx) and mtime, while os.Root correctly blocked any content writes (GitHub Advisory).

• File System: Presence of unexpected .rclonelink files in the rclone source directory or remote, particularly those whose content is an absolute path pointing outside the intended destination tree; unexpected permission or timestamp changes on directories outside the rclone destination after a sync operation.
• Logs: rclone sync logs showing MkdirMetadata or DirSetModTime operations on paths that correspond to symlinks in the destination; audit logs (auditd on Linux) recording chmod, chown, or utimes syscalls on paths outside the destination directory originating from the rclone process.
• Process: rclone process performing os.Chmod, os.Chown, or os.Chtimes on paths outside the configured destination root, observable via strace -e trace=chmod,chown,utimes -p <rclone_pid>.
• Network: Unexpected or modified objects (.rclonelink files with suspicious absolute-path content) appearing in monitored cloud storage buckets or remotes (GitHub Advisory).

Upgrade rclone to version 1.75.1, which routes directory metadata (chmod/chown/chtimes) through the os.Root sandbox when TranslateSymlinks is set, and extends the NOFOLLOW birth-time write to all --links operations (rclone v1.75.1 Release, Fix Commit). As a short-term workaround for users who cannot upgrade immediately, avoid using --links (-l) when syncing from untrusted or shared sources; additionally, omitting --metadata prevents the chmod/chown escape (though chtimes escape still applies with --links alone). Users running rclone as root with --metadata from untrusted sources are at highest risk and should prioritize upgrading (GitHub Advisory).

The vulnerability was reported by security researcher Jace (@manus-use on GitHub) and remediated by rclone maintainer Nick Craig-Wood (ncw). The advisory notes this is part of a series of related symlink-escape issues in rclone's local backend, following CVE-2024-52522 and CVE-2026-54572, indicating ongoing scrutiny of rclone's sandbox confinement for symlink handling (GitHub Advisory). No broader media coverage or significant social media discussion has been identified at this time.