Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
ReconAuthenticate to RustFS with low-privileged credentials
-
DeliveryIdentify target objects in restricted source bucket
-
ExploitInitiate multipart upload to attacker-controlled destination bucket
-
InstallIssue UploadPartCopy referencing restricted source
-
C2Bypass destination copy-source policy via independent ACL checks
-
ExecuteComplete multipart upload to assemble copied objects
-
ImpactExfiltrate replicated data from attacker bucket
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V8 - Authorization Authorization logic validation
MITRE ATT&CK
1 technique across 1 tactic: Privilege Escalation The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Attacker must (1) hold valid RustFS credentials with s3:GetObject permission on at least one source object and s3:PutObject permission on a destination bucket - consistent with PR:L in the CVSS vector - and (2) issue the S3 UploadPartCopy multipart operation specifying an x-amz-copy-source that the destination bucket's policy was meant to disallow; no user interaction, no special platform, and no non-default configuration is required, and the RustFS instance must be running any version prior to 1.0.0-beta.2. Exploitation is limited by the requirement for pre-existing authenticated access and is only security-relevant in deployments that rely on per-bucket copy-source policy constraints (typical of multi-tenant or policy-segmented object stores); single-tenant deployments where one principal already has cross-bucket access derive no additional capability from the bug. |
| Impact | The CVSS 4.0 vector AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:N/VA:N (base 7.1) indicates a network-reachable, low-complexity attack requiring low privileges, no user interaction, with high confidentiality impact but no integrity or availability impact - consistent with a data-exfiltration / unauthorized-copy primitive rather than RCE or destruction. The PR:L requirement is significant: the attacker must already hold valid credentials with GetObject on some source and PutObject on some destination, so this is a privilege-escalation / lateral-movement issue inside a multi-tenant or policy-segmented deployment rather than an unauthenticated internet-facing flaw. EPSS, KEV status, SSVC decision values, and POC availability were not provided in the input; no public exploit was identified at time of analysis and the CVE is not present in CISA KEV. Real-world priority is moderate-to-high for operators running RustFS as a shared/multi-tenant object store where bucket-level policy isolation is part of the security model, and lower for single-tenant deployments where any authenticated principal would already have broad object access. |
| Exploit ScenarioDerived | An authenticated tenant in a shared RustFS deployment initiates a multipart upload to a destination bucket they control, then issues UploadPartCopy requests referencing objects in a second bucket whose policy was intended to forbid being used as a copy source to that destination; RustFS approves each request because GetObject and PutObject are evaluated independently, and the attacker assembles a complete copy of the restricted objects inside their own bucket. No public proof-of-concept was identified at time of analysis, but the attack is straightforward to script against any S3 SDK given valid credentials. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – May 28, 2026
Improper authorization in RustFS prior to 1.0.0-beta.2 allows authenticated users to perform unauthorized cross-bucket object copies via the S3-compatible UploadPartCopy operation, bypassing destination-bucket policy constraints on permitted copy sources. The Rust-based distributed object storage system validates GetObject on the source and PutObject on the destination independently but never checks whether the destination bucket actually permits the specified source, enabling lateral data movement between buckets. No public exploit identified at time of analysis and the issue is not listed in CISA KEV.
RemediationAI
Upgrade to the vendor-released patched version RustFS 1.0.0-beta.2 or later, which corrects the UploadPartCopy authorization logic per the project advisory at https://github.com/rustfs/rustfs/security/advisories/GHSA-wfxj-ph3v-7mjf. If immediate upgrade is not possible, compensating controls include denying the s3:PutObject action when the request includes an x-amz-copy-source header via a gateway/reverse-proxy rule (which blocks all server-side copies and breaks legitimate multipart-copy workflows), tightening IAM so that no principal simultaneously holds GetObject on cross-tenant source buckets and PutObject on policy-restricted destinations, and auditing existing buckets for objects that may already have been copied in via UploadPartCopy. Each workaround sacrifices native S3 copy functionality, so apply only until the upgrade is rolled out.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
RustFS is a distributed, S3-compatible object storage system implemented in Rust and identified by CPE cpe:2.3:a:rustfs:rustfs. The flaw is a CWE-863 (Incorrect Authorization) defect in the multipart-upload UploadPartCopy handler, which is the S3 API used to copy byte ranges from an existing object into a part of an in-progress multipart upload. In a correct S3 implementation, bucket policies on the destination can constrain the allowed x-amz-copy-source values (for example, restricting copies to objects from a specific source bucket or prefix). RustFS instead evaluates only two independent ACL checks - GetObject on the caller's source reference and PutObject on the destination - and never reconciles the destination bucket's source-copy policy, collapsing what should be a joint authorization decision into two disjoint ones.
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:L/UI:N/VC:H/VI:N/VA:N/SC:N/SI:N/SA:N
Primary rating from GitHub Advisory · only source for this CVE.
CVSS VectorGitHub Advisory
Lifecycle Timeline
2DescriptionGitHub Advisory
RustFS is a distributed object storage system built in Rust. Prior to 1.0.0-beta.2, improper authorization in the UploadPartCopy operation allows copying objects across buckets without enforcing destination bucket restrictions on allowed copy sources. The implementation validates GetObject permission on the source bucket and PutObject on the destination bucket independently, but does not enforce any policy constraints on whether the destination bucket permits the specified copy source. This enables unauthorized cross-bucket data movement. This vulnerability is fixed in 1.0.0-beta.2.
Executive ViewAI
RustFS versions prior to 1.0.0-beta.2 contain an authorization bypass in the UploadPartCopy operation that allows authenticated users to circumvent bucket policies and perform unauthorized cross-bucket data copies, creating lateral data movement risk for organizations relying on bucket isolation as a security boundary. Multi-tenant deployments and environments with sensitive data segregation face elevated risk of unauthorized data access between isolated buckets. Immediate assessment and interim controls are required to prevent lateral movement within RustFS object storage infrastructure.
Disable or restrict UploadPartCopy at API gateway or application middleware layer; enforce supplementary destination-bucket authorization checks in application code; implement real-time monitoring and alerting for cross-bucket copy operations; apply network-level isolation for sensitive buckets pending patch availability.
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
Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.
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
Path traversal in the RustFS /rustfs/rpc/read_file_stream endpoint allows an attacker to read arbitrary files from the h
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
EUVD-2026-32995
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB