/

CVE-2026-33322

Severity:

CRITICAL RISK

(9.8)

Authentication Bypass via JWT Algorithm Confusion

CVE-2026-33322

Analyzed

Vulnerability type

Category:

Authentication Bypass via JWT Algorithm Confusion

CWE:

CWE-287

Impact:

Full Authentication Bypass and Privilege Escalation

Severity:

CRITICAL RISK

(9.8)

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

A JWT algorithm confusion flaw in MinIO's OpenID Connect authentication allows an attacker who knows the OIDC ClientSecret to forge arbitrary identity tokens.

Under these conditions, the attacker can obtain S3 credentials with any policy, including highly privileged roles such as consoleAdmin.

Affected context

This vulnerability affects MinIO deployments configured to use OpenID Connect (OIDC) for authentication within the impacted release range.

The issue occurs in environments where:

  • MinIO relies on JWTs issued by an OIDC provider to authenticate and authorize users.
  • The same shared client secret used for OIDC is known to or obtainable by an attacker.
  • MinIO does not strictly enforce expected JWT signing algorithms and key usage.

In such setups, misinterpretation of token algorithms can cause MinIO to trust tokens that were not legitimately issued by the identity provider.

Exploit preconditions

  • Attack surface: MinIO HTTP(S) API and web console endpoints that rely on OIDC authentication and JWT validation.
  • Required access/knowledge:
  • Knowledge of the OIDC ClientSecret configured for MinIO.
  • Network access to the MinIO instance's authentication endpoints.
  • Trigger point: Submission of a crafted JWT as part of the OIDC authentication flow, leveraging algorithm confusion to bypass normal signature checks.
  • Why exploitation is possible: The JWT validation logic does not strictly bind tokens to a specific signing algorithm and verification method.

This discrepancy allows an attacker with the shared secret to craft tokens that MinIO incorrectly treats as valid OIDC identity tokens for arbitrary users and policies.

Why this happens

The root cause is improper authentication logic around JWT verification, aligning with CWE-287: Improper Authentication.

MinIO's OIDC integration accepts identity tokens without adequately constraining:

  • Which JWT algorithms are permissible, and
  • How signatures should be verified based on those algorithms and keys.

Algorithm confusion occurs when the verifier accepts a token under a different cryptographic scheme than intended (for example, treating a token that should be verified using an asymmetric key as if it were verified with a symmetric secret).

Because the ClientSecret is shared and known to the attacker, they can generate tokens that appear correctly signed under the misapplied algorithm.

This breaks the trust assumption that only the identity provider can issue valid tokens and causes MinIO to authenticate and authorize attackers as any user or role.

Potential impact

  • Attacker can obtain S3 credentials with arbitrary policies, including consoleAdmin-level access.
  • Full compromise of MinIO-managed data, including reading, modifying, and deleting objects.
  • Creation, alteration, or deletion of users, buckets, and access policies.
  • Potential pivot from MinIO into broader infrastructure where MinIO is integrated (e.g., CI/CD pipelines, data processing jobs).
  • Long-lived persistence via creation of backdoor accounts, access keys, or policies.

General mitigation guidance

Effective mitigation focuses on hardening authentication flows and reducing trust in shared secrets:

  • Enforce strict JWT validation rules:
  • Accept only explicitly configured signing algorithms.
  • Bind each algorithm to the appropriate verification method (e.g., asymmetric keys from the OIDC provider for tokens that should be signed with public-key cryptography).
  • Prefer asymmetric signing (e.g., RS256/ES256) for OIDC tokens so that compromise of a client secret does not enable token forging.
  • Treat the OIDC ClientSecret as highly sensitive:
  • Limit who and what has access to it.
  • Rotate it regularly and on any suspicion of exposure.
  • Apply least-privilege access policies:
  • Avoid broad policies like full admin for routine use.
  • Use narrowly scoped roles for automated systems.
  • Segregate administrative access paths from general user access and require stronger controls (MFA, IP restrictions, or separate identity flows) for high-privilege operations.
  • Integrate authentication logic into security reviews and threat modeling, particularly wherever JWTs or federated identity are used.

How teams detect issues like this

To detect and monitor for this class of issue:

  • Code-level/static analysis:
  • Search for JWT validation code that:
  • Accepts multiple algorithms without explicit allowlists.
  • Uses shared secrets for verifying tokens intended to be asymmetrically signed.
  • Look for authentication flows that trust tokens purely based on structure without strong issuer and audience checks.
  • Configuration and policy review:
  • Verify OIDC configuration enforces expected algorithms and issuer/audience constraints.
  • Review who can access the OIDC ClientSecret and related credentials.
  • Runtime monitoring and logging:
  • Enable detailed audit logs of authentication events, including:
  • Token issuer, subject, and requested policies.
  • Source IP and client identifiers.
  • Alert on:
  • Sudden creation or use of high-privilege roles (e.g., consoleAdmin) from unusual clients.
  • Multiple distinct identities authenticating from the same client or network in a short period.
  • Security testing:
  • Incorporate tests for JWT algorithm confusion into regular penetration testing and CI-based security checks.
  • Use automated tools that flag weak or misconfigured JWT verification logic and ambiguous algorithm handling.

Sources

SourceLink
github.comgithub.com/minio/minio/security/advisories/GHSA-5cx5-wh4m-82fh

Frequently asked

questions

Yes, it can be remotely exploitable if an attacker has network access to the MinIO instance and knows the OIDC ClientSecret. With those conditions met, they can submit forged JWTs over standard authentication endpoints.

The attacker must have:

  • Knowledge of the OIDC ClientSecret configured for MinIO, and
  • Network reachability to the MinIO service.

No prior MinIO account or valid token is required once they possess the secret and exploit the algorithm confusion.

The most robust fix pattern is to enforce strict JWT verification:

  • Allow only specific, expected signing algorithms.
  • Use asymmetric keys from the OIDC provider for token verification.
  • Validate issuer, audience, and other claims rigorously.

Additionally, protect and rotate the OIDC ClientSecret, and avoid over-privileged default policies.

When designing authentication integrations:

  • Treat token verification as a security-critical component, not a simple parsing step.
  • Use well-vetted JWT/OIDC libraries with secure defaults and algorithm allowlists.
  • Prefer asymmetric signing for identity tokens and avoid reusing shared secrets across components.
  • Include federated identity flows in threat models and security reviews, and continuously monitor authentication behavior for anomalies.
Find out what's already
exploitable in your codebase.