/

CVE-2026-73286

Severity:

HIGH RISK

(8.1)

Authorization Bypass (CWE-863) in RustFS Request Headers

CVE-2026-73286

Deferred

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-863

Impact:

Unauthorized Access

Severity:

HIGH RISK

(8.1)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

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.

Sources

SourceLink
github.comgithub.com/rustfs/rustfs/blob/380ed40b471887014fe21d069b61df9eacca074b/.agents/skills/security-advisory-lessons/references/advisory-patterns.md?plain=1#L45
github.comgithub.com/rustfs/rustfs/commit/92f83bfe155d8a3b9cdd903086e5b28d52339efb
github.comgithub.com/rustfs/rustfs/releases/tag/1.0.0-beta.12
github.comgithub.com/rustfs/rustfs/security/advisories/GHSA-6r96-hmgc-726c

Frequently asked

questions

Yes, it may be exploitable through authenticated object-storage requests when

attacker-controlled headers can influence identity-based policy evaluation.

The attacker generally needs valid authentication or another ability to submit

requests that reach RustFS authorization logic. Anonymous exploitation is not

implied by the vulnerability description.

Keep client-controlled headers separate from trusted authorization context and

derive identity and group attributes from validated server-side sources only.

Apply strict schemas, provenance checks, and fail-closed authorization behavior.

Use allowlisted policy inputs, test conflicting and attacker-controlled header

values, enforce least privilege, and include authorization data-flow reviews in

development and deployment processes.

Find out what's already
exploitable in your codebase.