Skip to content
All writing
August 19, 20265 min read

OIDC Misconfigurations That Quietly Break Login — and How to Catch Them First

OIDC is easy to wire up and easy to wire up wrong. Here are the misconfigurations that cause outages and open doors — and why I built a validator to catch them before they ship.

  • OIDC
  • SSO / Identity
  • AppSec
  • Privacy-first

OpenID Connect is the backbone of modern login. It's also deceptively easy to misconfigure — the happy path works, users log in, and the subtle problems stay invisible until a provider rotates a key, an auditor asks a question, or an attacker finds the gap. After building SAMLCheck for SAML, I built an OIDC Discovery Validator for the other half of the enterprise SSO world.

Here's what actually goes wrong, and what the validator checks.

The discovery document is the contract

Every OIDC provider publishes a discovery document at /.well-known/openid-configuration — a JSON file that tells clients where the endpoints are, which flows are supported, and how tokens are signed. If that contract is wrong or weak, everything built on top of it inherits the problem.

The validator takes the discovery JSON (pasted, or fetched from an issuer URL) and checks it against the OpenID Connect spec.

What breaks, and what to check

  • Issuer / HTTPS consistency. The issuer must exactly match where the document is served, over HTTPS. A mismatch here is both an outage waiting to happen and a trust problem — tokens are validated against the issuer, so drift breaks verification.
  • Required endpoints. Authorization, token, JWKS, userinfo — missing or malformed endpoints mean integrations fail in confusing, intermittent ways.
  • PKCE support (S256). Proof Key for Code Exchange is the defense against authorization-code interception. If a provider doesn't advertise S256, public clients are exposed. This is one of the most common gaps.
  • Weak or deprecated signing algorithms. If the provider advertises weak algorithms — or the dreaded none — token integrity is only as strong as the weakest one a client will accept.
  • Scopes and response types. The advertised capabilities should match what you actually intend to use; surprises here cause both bugs and over-permissioning.

Each check rolls up into a PASS / WARN / FAIL verdict with a parsed summary of the provider's capabilities — so you can sanity-check a provider before you wire up the integration, not after it breaks in production.

Why a validator, not a checklist

The OIDC spec is precise but large, and the difference between "required" and "recommended" fields matters. A checklist in your head misses things; a tool that encodes the spec doesn't. I verified it against Google's real discovery document and JWKS so the checks reflect how a major provider actually behaves.

Like my other tools, it runs client-side with a paste-first design — your provider config doesn't get shipped to a backend to be inspected.

The takeaway

OIDC problems are rarely loud. They're a missing S256, an issuer that doesn't quite match, a signing algorithm nobody audited. Catch them at configuration time and they're a five-minute fix; catch them in production and they're an incident.

Try it

The OIDC Discovery Validator is live — paste a discovery doc or point it at an issuer URL and get a verdict in seconds.

Davis Barillas is a forward deployed engineer working across security, identity, and AI. I build small, sharp, privacy-first tools around the problems I run into in the field.