RustFS
CVE-2025-68705
HIGH
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain or guess RPC shared secret
-
DeliveryForge HMAC-SHA256 signed RPC request
-
ExploitCall read_file_stream with ../ traversal path
-
ExecutionBypass missing path validation
-
ImpactRead arbitrary host files (/etc/passwd)
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 | Exploitation requires a request to the /rustfs/rpc/read_file_stream endpoint carrying a valid x-rustfs-signature (HMAC-SHA256 over '{url}|{method}|{timestamp}') and x-rustfs-timestamp, computed with the RPC shared secret from RUSTFS_SECRET_KEY - the POC succeeded using the default secret 'rustfsadmin'. The attacker supplies disk and volume parameters plus a traversal path (e.g. ../../../../etc/passwd) and must know the target file's size for the length parameter. LIMITING FACTORS: the internal RPC endpoint must be network-reachable, and the attacker must know or guess the RPC secret (so changing the default secret and restricting RPC exposure materially reduces risk); affected only on versions 1.0.0-alpha.13 through 1.0.0-alpha.78. |
| Impact | Signals conflict and net out to a lower real-world priority than the 8.8 score suggests. The official CVSS:4.0 vector asserts PR:N (unauthenticated) with VC:H/VI:H, but the GHSA proof-of-concept directly contradicts this: the /rustfs/rpc/read_file_stream endpoint requires a valid HMAC-SHA256 signature computed over the request using the RPC shared secret (RUSTFS_SECRET_KEY), so an attacker must possess or guess that secret before path traversal is reachable - the PR:N metric appears to understate authentication and should be verified with the vendor. Exploitation status is 'publicly available exploit code exists' (POC in the GHSA, with working /etc/passwd read) - this is NOT active exploitation; the CVE is absent from CISA KEV. EPSS is only 0.04% (13th percentile), consistent with a niche, newly-released product and a secret-gated attack surface rather than mass exploitation. The source-code evidence corroborates the root cause (PathBuf::join without canonicalization at local.rs:1791, fixed by has_bad_path_component/is_valid_object_prefix validation in alpha.79). Net: a confirmed, patched, real path-traversal flaw with a working POC, but gated by RPC secret knowledge, low EPSS, no KEV, and a small deployment base - moderate priority, patch on normal cadence unless the RPC secret is default ('rustfsadmin' per POC) or exposed. |
| Exploit ScenarioDerived | An attacker who knows or guesses the RustFS RPC secret (the POC used the default 'rustfsadmin') crafts a signed GET request to /rustfs/rpc/read_file_stream with path=../../../../etc/passwd, bypassing the missing path sanitization and reading arbitrary host files such as /etc/passwd, /etc/hosts, and /etc/hostname. A public proof-of-concept demonstrating this read exists in the GitHub Security Advisory. Because the vector is network-based with low complexity, exploitation is trivial once the shared RPC secret is obtained. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv2 – Oct 15, 2026
Path traversal in the RustFS /rustfs/rpc/read_file_stream endpoint allows an attacker to read arbitrary files from the host filesystem in versions 1.0.0-alpha.13 through 1.0.0-alpha.78, exposing sensitive data such as /etc/passwd, /etc/hosts, and container metadata. Exploitation requires a request carrying a valid HMAC-SHA256 x-rustfs-signature and x-rustfs-timestamp computed from the RPC shared secret (RUSTFS_SECRET_KEY); the published proof-of-concept succeeded using the default secret 'rustfsadmin', and the attacker must also supply a length value matching the target file's size. Publicly available exploit code exists and the vendor has released a patch in 1.0.0-alpha.79, but real-world risk is tempered by a low EPSS of 0.04% (13th percentile), no CISA KEV listing, and the requirement that the internal RPC endpoint be network-reachable with a known or guessed secret.
Earlier versions of this analysis (1)
RustFS distributed object storage has path traversal enabling arbitrary file read via the RPC file stream endpoint.
RemediationAI
Upgrade RustFS to 1.0.0-alpha.79 or later, the vendor-confirmed fix release, which incorporates the path-validation routines (has_bad_path_component, is_valid_object_prefix, check_bucket_and_object_names) introduced by commit ab752458ce431c6397175d167beee2ea00507d3e; the full advisory is at https://github.com/rustfs/rustfs/security/advisories/GHSA-pq29-69jg-9mxc. Because exploitation depends on a valid HMAC-SHA256 signature over the RPC request, the single most effective compensating control is to replace the default RUSTFS_SECRET_KEY value 'rustfsadmin' with a high-entropy secret - this immediately invalidates the published proof-of-concept and any signature-based attempts, with the trade-off that all legitimate RPC clients must be reconfigured with the new key and any automation relying on the default will break. Additionally, restrict network exposure of the internal RPC listener (historically bound on port 9000) so that only trusted management hosts or the cluster's private network can reach /rustfs/rpc/read_file_stream; blocking or firewalling this path from untrusted networks removes remote reachability entirely, at the cost of possibly disrupting legitimate administrative tooling. Until patching is complete, deployments should also avoid running the process with privileges broader than necessary and consider read-only or restricted filesystem mounts for the data volumes, which limits what an exploited traversal can reach but does not eliminate the vulnerability. Note that no public exploit development beyond the advisory's own proof-of-concept has been confirmed, and EPSS remains low (0.04%), so prioritized patching plus secret rotation and RPC network restriction is proportionate.
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in cargo
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The issue is a classic CWE-22 path traversal in RustFS, a distributed object storage system written in Rust. In crates/ecstore/src/disk/local.rs (around line 1791), the file path is constructed with PathBuf::join(Path::new(&path)) and only a length check (check_path_length) is applied before opening the file for reading. Because join() does not canonicalize or validate the resulting path, a crafted 'path' parameter containing '../' sequences escapes the intended volume directory and resolves to arbitrary filesystem locations, including absolute paths. The vulnerable endpoint, /rustfs/rpc/read_file_stream, is part of the internal RPC surface and is protected by an HMAC-SHA256 signature scheme over '{url}|{method}|{timestamp}' using a shared secret from RUSTFS_SECRET_KEY; the weak link is that deployments frequently retain the default secret 'rustfsadmin', which the proof-of-concept used to bypass this control. The vendor fix in commit ab752458ce431c6397175d167beee2ea00507d3e adds a battery of validation helpers in crates/ecstore/src/bucket/utils.rs - has_bad_path_component (rejects '.' and '..' segments, leading slashes, and over-length paths), is_valid_object_prefix (rejects '//', null bytes, and invalid UTF-8), is_valid_object_name, and check_bucket_and_object_names - which are applied across copy/get/delete object argument checks. Independently assessed impact is confidentiality-only (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N) via a valid RPC signature, which is more conservative than the vendor advisory's estimated 9.9 and the associated 8.8 score, and unlike the advisory's claim of arbitrary read/write, the assessed impact is file disclosure rather than modification.
Know when Rustfs 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
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:N/SC:N/SI:N/SA:N/E:P
Network RPC endpoint (AV:N/AC:L) gated by a shared HMAC secret per the POC, so PR:L not PR:N; read_file_stream yields arbitrary file read (C:H) with no integrity/availability impact for this endpoint.
Primary rating from Vendor (github).
CVSS VectorVendor: github
Lifecycle Timeline
6DescriptionCVE.org
RustFS is a distributed object storage system built in Rust. In versions 1.0.0-alpha.13 to 1.0.0-alpha.78, RustFS contains a path traversal vulnerability in the /rustfs/rpc/read_file_stream endpoint. This issue has been patched in version 1.0.0-alpha.79.
Executive ViewAI
RustFS versions 1.0.0-alpha.13 through 1.0.0-alpha.78 contain a high-severity path traversal vulnerability that can expose sensitive host files, including credentials and container metadata, to attackers who can reach the internal RPC endpoint and supply a valid HMAC signature. Publicly available exploit code exists, and the published proof-of-concept used the default secret 'rustfsadmin', so organizations running these alpha releases with default credentials or exposed RPC services face a meaningful data-exposure risk. Although there is no CISA KEV listing and a vendor patch is available in 1.0.0-alpha.79, leadership should prioritize remediation because leaked secrets can enable broader environment compromise.
Apply vendor patch.
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.
Affected Products (CPE)CVE.org
RustFS (alpha.13 to alpha.78) has a privilege escalation where restricted service accounts can self-issue unrestricted c
Stored XSS in RustFS distributed object storage system before 1.0.0-alpha.83. Malicious JavaScript persists in stored ob
Incorrect IAM permission validation in RustFS prior to version 1.0.0-alpha.79 permits principals with export-only permis
RustFS versions 1.0.0-alpha.1 through 1.0.0-alpha.79 expose the shared HMAC secret in server logs when processing invali
Authentication bypass in RustFS distributed object storage (versions prior to 1.0.0-beta.2) allows unauthenticated remot
RustFS is a distributed object storage system built in Rust. [CVSS 4.0 MEDIUM]
Privilege escalation in RustFS distributed object storage before 1.0.0-beta.2 lets a low-privileged user holding ImportI
Stored cross-site scripting in RustFS Console (0.1.7 through 0.1.9) lets an attacker upload an HTML payload disguised as
Privilege escalation in RustFS prior to version 1.0.0-beta.11 allows any authenticated user holding CreateServiceAccount
Unauthenticated denial of service and information disclosure in RustFS distributed object storage prior to version 1.0.0
License-enforcement bypass in RustFS distributed object storage (versions prior to 1.0.0-beta.2) stems from a hardcoded
Cross-tenant object injection in RustFS 1.0.0-beta.4 lets a tenant holding only PutObject rights on their own bucket wri
GHSA-pq29-69jg-9mxc
NVD
CVE.org
EPSS
Exploit-DB