/

CVE-2026-41145

Severity:

HIGH RISK

(8.2)

Authentication Bypass in MinIO PutObject Handlers

CVE-2026-41145

Analyzed

Vulnerability type

Category:

Authentication Bypass

CWE:

CWE-287

Impact:

Unauthorized Object Write / Data Integrity Compromise

Severity:

HIGH RISK

(8.2)

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

An authentication bypass in MinIO's STREAMING-UNSIGNED-PAYLOAD-TRAILER code path allows object uploads to any bucket using only a valid access key, without the corresponding secret key or a valid signature.

By omitting the Authorization header and supplying credentials solely via query parameters, an attacker can bypass signature verification and write arbitrary objects wherever the impersonated access key has WRITE permission.

Affected context

This vulnerability exists in MinIO deployments that:

  • Support S3-compatible streaming uploads using STREAMING-UNSIGNED-PAYLOAD-TRAILER
  • Rely on AWS Signature V4–style authentication for PutObject and multipart upload operations
  • Accept credentials in both the Authorization header and query string (X-Amz-Credential)

It becomes exploitable when WRITE-capable access keys are known or easily guessable (e.g., defaults, shared keys, leaked keys) and unsigned payload trailers are accepted by the server or front-end proxy.

Exploit preconditions

  • Attack surface: Public or internal MinIO S3-compatible endpoints handling PutObject and multipart upload requests.
  • Required access:
  • Knowledge of a valid MinIO access key that has WRITE permission on at least one bucket (including defaults like minioadmin if unchanged).
  • Knowledge of a target bucket name (any bucket where the key has s3:PutObject access).
  • Trigger point:
  • A request using STREAMING-UNSIGNED-PAYLOAD-TRAILER, with credentials supplied exclusively via the query string (e.g., X-Amz-Credential), and no Authorization header.
  • Why exploitation is possible:
  • The streaming reader's signature check is gated only on the presence of the Authorization header.
  • Authorization logic extracts credentials from either headers or query parameters and trusts them as authenticated identity.
  • When the Authorization header is absent, the signature gate is skipped, doesSignatureMatch is never called, yet the operation proceeds with the permissions of the provided access key.

Why this happens

The root cause is a mismatch between authentication enforcement and credential extraction logic in the STREAMING-UNSIGNED-PAYLOAD-TRAILER path.

PutObjectHandler and PutObjectPartHandler invoke newUnsignedV4ChunkedReader with a conditional signature verification that only engages when an Authorization header is present.

However, permission checks in isPutActionAllowed independently accept credentials from either the Authorization header or the X-Amz-Credential query parameter without requiring that those credentials be cryptographically validated.

This design error aligns with CWE-287: Improper Authentication:

  • The system treats possession of an access key identifier in request metadata as sufficient proof of identity.
  • Cryptographic verification (HMAC signature) is bypassed under certain input shapes (query-only credentials), breaking the assumption that authorization decisions are made on authenticated identities.

At a higher level, this is an inconsistent authentication flow where one component assumes another has done verification, leading to a gap attackers can exploit.

Potential impact

  • Unauthorized upload of arbitrary objects to buckets where the known access key has WRITE permission
  • Data integrity compromise through overwriting or poisoning of existing objects
  • Injection of malicious payloads into data lakes, AI/ML training data, or warehouse/table buckets
  • Facilitation of downstream supply-chain attacks via tampered artifacts stored in MinIO
  • Abuse of storage resources for spam, illegal content, or staging data for further attacks

General mitigation guidance

Effective mitigation focuses on restoring consistent, cryptographically sound authentication for all upload paths and hardening write permissions:

  • Ensure that any path accepting S3 streaming uploads enforces signature verification regardless of whether credentials appear in headers or query parameters.
  • Align request parsing, credential extraction, and authentication checks so that authorization never occurs on unauthenticated identities.
  • Prefer signed payload variants (e.g., STREAMING-AWS4-HMAC-SHA256-PAYLOAD-TRAILER) and treat unsigned streaming payloads as untrusted, or disable them where not strictly needed.
  • Restrict WRITE capabilities (s3:PutObject, multipart upload actions) to narrowly scoped, trusted principals rather than broad or shared access keys.
  • Eliminate or rotate well-known default credentials and enforce strong access key lifecycle practices.
  • Apply least-privilege design in bucket policies so that a compromised or misused access key can affect only a minimal set of objects and buckets.

How teams detect issues like this

Detection can combine code-centric and operational approaches:

  • Static analysis and code review:
  • Search for authentication or signature checks that are conditional on specific headers rather than on the presence of credentials in general.
  • Flag flows where credential extraction and permission checks are separated from cryptographic verification logic, especially when query parameters are accepted as credential sources.
  • Review all streaming upload paths (PutObject, multipart) for alternate parsing branches (e.g., "unsigned" modes) that relax or bypass signature checks.
  • Configuration and policy checks:
  • Audit bucket policies and IAM-like configurations for overly broad s3:PutObject grants and shared access keys.
  • Identify deployments that enable unsigned streaming payload options and verify that compensating controls exist.
  • Runtime and log-based detection:
  • Log and monitor requests containing X-Amz-Content-Sha256: STREAMING-UNSIGNED-PAYLOAD-TRAILER, especially those lacking an Authorization header.
  • Alert on unusual upload patterns where many objects are written by keys that rarely perform writes, or where uploads originate from unexpected network locations.
  • Automated tooling:
  • Integrate security scanners or custom CI checks to enforce a policy that all S3-compatible handlers must verify signatures before authorizing actions.

Sources

SourceLink
github.comgithub.com/minio/minio/commit/76913a9fd5c6e5c2dbd4e8c7faf56ed9e9e24091
github.comgithub.com/minio/minio/pull/16484
github.comgithub.com/minio/minio/security/advisories/GHSA-hv4r-mvr4-25vw

Frequently asked

questions

Any reachable MinIO endpoint that supports the vulnerable STREAMING-UNSIGNED-PAYLOAD-TRAILER path is at risk, provided an attacker knows a valid access key ID with WRITE permission and a target bucket name. The attack does not require possession of the secret key or the ability to generate valid signatures.

The attacker needs only a valid access key value (for example, a default or leaked key) that has s3:PutObject or similar WRITE privileges on at least one bucket. Network-level access to the MinIO S3 endpoint is also required, but no valid cryptographic signature or secret key is needed due to the bypass.

The core fix is to ensure that all code paths performing write operations require successful cryptographic authentication before making authorization decisions. Signature verification must be applied uniformly across header-based and query-based credential flows so that no upload path can proceed using unverified identity data.

Design authentication and authorization as a single, consistent pipeline: extract credentials once, verify them cryptographically, and pass only authenticated identities into permission checks. Avoid special-case branches that relax verification (such as "unsigned" streaming modes) without strong compensating controls, and enforce these design rules with code review checklists, automated tests, and static analysis policies.

Find out what's already
exploitable in your codebase.