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.

