Summary
RustFS before 1.0.0-beta.12 improperly incorporates attacker-controlled request headers into server-derived identity and authorization condition values. An authenticated caller may use this behavior to satisfy identity- based policy conditions and access resources beyond the intended authorization scope.
Affected context
The issue occurs in RustFS distributed object storage deployments where authenticated requests are evaluated against identity-based policies and request headers are processed alongside server-derived condition values. Deployments are at greater risk when callers can supply headers that influence authorization decisions without sufficient separation between trusted identity attributes and client-controlled input.
Exploit preconditions
- Attack surface: Authenticated object-storage request and policy evaluation
interfaces
- Required access: A valid account or other access sufficient to submit
authenticated requests
- Trigger point: Authorization processing involving identity-related
condition keys
- Why exploitation is possible: Attacker-controlled header values are
folded into values that policy evaluation treats as server-derived identity
attributes
Why this happens
The underlying bug is an authorization data-integrity failure. RustFS combines client-controlled request headers with trusted identity and policy context, allowing untrusted values to influence conditions intended to represent server-established attributes such as user identity, groups, signatures, or directory-provider context. This maps to CWE-863, Incorrect Authorization, because policy decisions may grant access without reliably enforcing the intended identity and privilege boundaries.
Potential impact
- An authenticated user may access objects or operations outside the intended policy scope
- Authorization conditions may be satisfied with attacker-controlled identity-related values
- Sensitive object data could be disclosed or modified
- Tenant, user, or administrative boundaries could be weakened
- Attackers could use unauthorized permissions for follow-on activity
General mitigation guidance
Mitigation generally focuses on preserving a strict trust boundary between request inputs and authorization context. Authorization logic should derive identity, group, signature, and directory attributes only from trusted, validated server-side sources, while treating request headers as untrusted unless they are independently authenticated and integrity-protected. Policy evaluation should use typed, allowlisted condition inputs with explicit precedence rules, and deployments should apply least privilege, tenant isolation, and narrowly scoped credentials. Secure-by-default behavior should deny access when identity attributes are missing, ambiguous, or inconsistent.
How teams detect issues like this
Detection can include static analysis and code review for authorization decisions that merge request headers with principal, user, group, signature, or directory-derived values. Reviewers can search for untrusted header data flowing into policy condition maps, missing provenance checks, implicit key precedence, and authorization tests that omit conflicting or duplicate identity inputs. Dynamic testing can compare authorization outcomes across controlled header variations, while policy enforcement can require explicit provenance and schema validation for every condition attribute. Automated security review tools may help identify these data-flow patterns.

