Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
ReconIdentify internet- or intranet-reachable RustFS without CORS config
-
DeliveryConfirm victim has browser-cached credentials for target origin
-
ExploitDeliver phishing lure to victim
-
InstallVictim browser loads attacker page, issues credentialed cross-origin fetch
-
C2Unpatched RustFS reflects Origin with Allow-Credentials: true
-
ExecuteBrowser forwards ambient credentials, exposes response to attacker JS
-
ImpactExfiltrate S3 object data to attacker-controlled endpoint
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A07:2025 - Authentication Failures
ASVS 5.0
V6 - Authentication Authentication required for critical functions
MITRE ATT&CK
1 technique across 1 tactic: Initial Access The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Three concurrent conditions must hold. First, RUSTFS_CORS_ALLOWED_ORIGINS must be unset on the target deployment (default state per the vendor description) - deployments with this variable explicitly configured are not vulnerable regardless of the value. Second, the victim's browser must hold ambient credentials for the RustFS origin in one of the three specific forms described by the vendor: saved HTTP Basic Auth credentials stored by the browser for that host, a reverse-proxy SSO or session cookie scoped to the RustFS origin, or a TLS client certificate that the browser will automatically present to that origin. Victims who have never authenticated to the target RustFS instance via a browser cannot be exploited. Third, the victim must be induced to load a page under attacker control while those credentials are active (UI:P per CVSS 4.0). CVSS PR:N confirms the attacker requires no prior account or privileges on the RustFS server itself. Exploitation is bounded by the AT:P condition: environments where RustFS is accessed only by programmatic S3 clients (SDKs, CLI tools, server-side code) with no browser-mediated authentication flow are not exploitable through this vector, as no ambient browser credentials will exist. |
| Impact | The CVSS 4.0 score of 6.0 accurately reflects a moderate but conditionally high-impact vulnerability. The vector AV:N/AC:L/AT:P/PR:N/UI:P/VC:H/VI:L/VA:N describes a network-reachable, low-complexity attack that nevertheless carries two significant mitigating prerequisites: AT:P (the victim must have active ambient credentials for the RustFS origin in their browser) and UI:P (the victim must visit an attacker-controlled page). The high confidentiality impact (VC:H) is well-founded - successful exploitation yields full read access to cross-origin S3 object responses. No EPSS score was provided in the input data, precluding quantitative exploitation-probability assessment. The vulnerability is not listed in CISA KEV and no public POC exploit code has been identified, indicating this is not a mass-exploitation scenario at present. Real-world risk is highest for organizations that expose RustFS to internal or semi-trusted networks where users authenticate via browser-cached HTTP Basic Auth or SSO cookies, and where social-engineering lures are plausible (e.g., phishing emails to employees). The tag 'Authentication Bypass' is partially misleading: this is not a bypass of RustFS's own authentication mechanism but rather a bypass of the browser's same-origin policy, which serves as an implicit cross-origin access control boundary. The CVSS integrity impact of VI:L is plausible if the attacker can issue state-changing S3 API calls (e.g., DELETE or PUT) cross-origin, though the primary demonstrated risk is confidentiality. |
| Exploit ScenarioDerived | An attacker registers a convincing domain and hosts a page containing a few lines of JavaScript that call fetch('https://storage.target.internal/sensitive-bucket/confidential.pdf', {credentials: 'include'}) and POST the response body to an attacker-controlled collection endpoint. The attacker sends a phishing link to an employee who previously authenticated to the internal RustFS instance via a reverse proxy SSO portal, leaving a session cookie scoped to the RustFS origin in their browser. When the employee visits the malicious page, the browser - observing the reflected Origin and Access-Control-Allow-Credentials: true headers from the unpatched RustFS server - forwards the SSO cookie and exposes the response to the attacker's JavaScript, completing silent exfiltration. No public POC code has been identified; however, the attack requires only standard Fetch API calls available in any modern browser. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – May 28, 2026
CORS origin reflection in RustFS's S3 listener exposes stored object data to cross-origin theft via browser-credentialed requests against all versions prior to 1.0.0-beta.2. When the RUSTFS_CORS_ALLOWED_ORIGINS environment variable is unset - the default state - the ConditionalCorsLayer middleware reflects any incoming Origin header verbatim as Access-Control-Allow-Origin while simultaneously asserting Access-Control-Allow-Credentials: true and Access-Control-Allow-Headers: *, including on preflight and error responses, nullifying the browser's same-origin policy protections. An unauthenticated attacker (PR:N) who lures a victim with ambient RustFS credentials to a malicious web page can exfiltrate object storage contents; no confirmed active exploitation (CISA KEV) and no public exploit identified at time of analysis. The fix is vendor-released in 1.0.0-beta.2.
RemediationAI
Upgrade to RustFS 1.0.0-beta.2 - the vendor-released patch confirmed by GitHub Security Advisory GHSA-x5xv-223c-8vm7 at https://github.com/rustfs/rustfs/security/advisories/GHSA-x5xv-223c-8vm7. This is the definitive fix and should be prioritized on any deployment reachable from browsers or reverse proxies carrying user credentials. As an immediate compensating control prior to patching, explicitly set the RUSTFS_CORS_ALLOWED_ORIGINS environment variable to a restrictive, allowlisted set of trusted origins (e.g., RUSTFS_CORS_ALLOWED_ORIGINS=https://trusted-dashboard.example.com); this disables the reflection behavior by giving the ConditionalCorsLayer an explicit list to match against. Trade-off: this requires knowing all legitimate cross-origin consumers in advance and will break any unlisted origins. If cross-origin browser access to RustFS is not required at all, configure a reverse proxy (nginx, Caddy, HAProxy) to strip or override CORS response headers before they reach clients, or add a WAF rule to block OPTIONS preflight requests from untrusted origins. Additionally, audit browser credential exposure: revoke or rotate HTTP Basic Auth credentials and SSO session cookies scoped to the RustFS origin, as these are the specific credential classes exploitable in this attack. TLS client certificate bindings to the RustFS origin should also be reviewed if applicable.
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 written in Rust. The vulnerable component is the ConditionalCorsLayer middleware within the S3 listener - a Tower-based HTTP middleware layer responsible for injecting CORS response headers. When RUSTFS_CORS_ALLOWED_ORIGINS is unset, the layer enters a fully permissive mode: it echoes the request's Origin header back as Access-Control-Allow-Origin (origin reflection), pairs this with Access-Control-Allow-Credentials: true, and wildcards Access-Control-Allow-Headers. Per the CORS specification, browsers permit cross-origin JavaScript to read responses only when the server reflects the exact request origin alongside the credentials flag - precisely the condition this misconfiguration creates. CWE-306 (Missing Authentication for Critical Function) applies in the sense that the CORS gate - which functions as an access-control boundary for browser-originated cross-domain requests - is entirely absent when the environment variable is not configured, effectively treating all origins as trusted. The CPE cpe:2.3:a:rustfs:rustfs:*:*:*:*:*:*:*:* with no version floor indicates every released version before 1.0.0-beta.2 carries this behavior.
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:P/PR:N/UI:P/VC:H/VI:L/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, when RUSTFS_CORS_ALLOWED_ORIGINS is unset, the RustFS S3 listener's ConditionalCorsLayer reflects any request Origin value back as Access-Control-Allow-Origin and also sets Access-Control-Allow-Credentials: true and Access-Control-Allow-Headers: * on responses, including preflight responses and error responses. This creates a permissive cross-domain policy with untrusted origins. A browser visiting an attacker-controlled page can issue credentialed cross-origin requests to a reachable RustFS deployment and read the response when the victim browser has ambient credentials for the RustFS origin, such as saved HTTP Basic Auth credentials, reverse-proxy SSO cookies, or TLS client certificates. This vulnerability is fixed in 1.0.0-beta.2.
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-32999
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB