OpenID Connect sur Auth0 : ID Token, UserInfo et discovery endpoint expliqués

OIDC est la couche identité par-dessus OAuth2. Découvrez comment Auth0 implémente l'ID Token, le UserInfo endpoint et le discovery document pour une authentification moderne.

Par Auth0.Expert · 2025-01-15 · 12 min de lecture

OIDC JWT Architecture

OpenID Connect sur Auth0 : guide complet

TL;DR

OAuth 2.0 = autorisation. OIDC = authentification. L'ID Token est un JWT signé qui prouve qui est l'utilisateur. Ce guide explique comment Auth0 implémente OIDC et comment valider correctement un ID Token.

---

La confusion OAuth2 vs OIDC

Point de douleur #1 : les développeurs utilisent l'access_token pour récupérer l'identité de l'utilisateur. C'est une erreur — l'access_token est pour les APIs, l'ID token est pour l'authentification.

Point de douleur #2 : ne pas valider la signature de l'ID Token → n'importe qui peut falsifier l'identité.

Point de douleur #3 : utiliser nonce sans le vérifier → vulnérable au replay attack.

---

Anatomie d'un ID Token Auth0

Voici un exemple d'ID Token Auth0, représenté sous forme de JSON, pour illustrer les claims transmis. Le token permet aux applications de vérifier l'identité de l’utilisateur et certaines informations clés.

// Header
{
  "alg": "RS256",
  "typ": "JWT",
  "kid": "abc123"
}

// Payload
{
  "iss": "https://YOUR_DOMAIN.auth0.com/",
  "sub": "auth0|507f1f77bcf86cd799439011",
  "aud": "YOUR_CLIENT_ID",
  "exp": 1735689600,
  "iat": 1735686000,
  "nonce": "n-0S6_WzA2Mj",
  "email": "[email protected]",
  "email_verified": true,
  "name": "Jean Dupont",
  "picture": "https://s.gravatar.com/avatar/..."
}

Claims obligatoires OIDC

Ce tableau récapitule les claims standards OIDC présents dans l’ID Token, leur rôle, et comment les valider côté client pour sécuriser vos intégrations.

| Claim | Description | Validation | |-------|-------------|------------| | iss | Émetteur | Doit correspondre à votre domaine Auth0 | | sub | Subject (ID utilisateur) | Stable et unique | | aud | Audience | Doit être votre client_id | | exp | Expiration (Unix timestamp) | Doit être dans le futur | | iat | Issued At | Pour détecter les tokens trop anciens |

---

Discovery Document

Avant d’implémenter OpenID Connect, il est essentiel de savoir où sont exposés les endpoints et propriétés supportées. Auth0 fournit ce document au format standard OIDC.

curl https://YOUR_DOMAIN.auth0.com/.well-known/openid-configuration

Cette commande permet de récupérer dynamiquement la configuration de l’IdP Auth0 pour automatiser la découverte de vos applications.

{
  "issuer": "https://YOUR_DOMAIN.auth0.com/",
  "authorization_endpoint": "https://YOUR_DOMAIN.auth0.com/authorize",
  "token_endpoint": "https://YOUR_DOMAIN.auth0.com/oauth/token",
  "userinfo_endpoint": "https://YOUR_DOMAIN.auth0.com/userinfo",
  "jwks_uri": "https://YOUR_DOMAIN.auth0.com/.well-known/jwks.json",
  "scopes_supported": ["openid", "profile", "email", "address", "phone", "offline_access"],
  "response_types_supported": ["code", "token", "id_token"],
  "id_token_signing_alg_values_supported": ["HS256", "RS256"]
}

---

Valider un ID Token correctement

Voici un exemple de fonction Python qui permet de valider un ID Token Auth0 de bout en bout : récupération des clés, vérification de la signature, matching du client, et validité des propriétés OIDC. La validation côté backend est essentielle pour la sécurité des applications.

# Python avec python-jose
from jose import jwt, JWTError
import httpx

async def verify_id_token(token: str, client_id: str, domain: str) -> dict:
    # 1. Récupérer les clés publiques
    jwks_uri = f"https://{domain}/.well-known/jwks.json"
    async with httpx.AsyncClient() as client:
        resp = await client.get(jwks_uri)
    jwks = resp.json()

    # 2. Décoder le header pour trouver le kid
    unverified_header = jwt.get_unverified_header(token)

    # 3. Trouver la clé correspondante
    rsa_key = {}
    for key in jwks["keys"]:
        if key["kid"] == unverified_header["kid"]:
            rsa_key = {
                "kty": key["kty"],
                "kid": key["kid"],
                "n": key["n"],
                "e": key["e"],
            }

    # 4. Valider et décoder
    payload = jwt.decode(
        token,
        rsa_key,
        algorithms=["RS256"],
        audience=client_id,
        issuer=f"https://{domain}/",
    )
    return payload

Ce code vérifie intégralement la signature, l’audience et l’émetteur, garantissant que l’ID Token provient bien de votre tenant Auth0 et qu’il est valide pour votre application.

---

UserInfo Endpoint

Lorsqu’il n’est pas possible d’ajouter tous les claims dans un JWT (pour des raisons de taille ou de sécurité), récupérez les données utilisateur à la demande via l’endpoint UserInfo.

const userInfo = await fetch('https://YOUR_DOMAIN.auth0.com/userinfo', {
  headers: { Authorization: `Bearer ${accessToken}` }
}).then(r => r.json());
// { sub, name, email, email_verified, picture, ... }

Auth0 specific : activez les scopes profile, email, address, phone dans votre application pour enrichir les claims retournés.

---

Fonctionnalités Auth0 natives OIDC

Pour étendre le comportement par défaut, Auth0 propose plusieurs fonctionnalités avancées OIDC, telles que la gestion de la session, la personnalisation des claims, et le support des logouts conformes OIDC.

// Action Auth0 : ajouter des claims custom
exports.onExecutePostLogin = async (event, api) => {
  const namespace = 'https://auth0.expert/';
  api.idToken.setCustomClaim(`${namespace}role`, event.user.app_metadata.role);
  api.idToken.setCustomClaim(`${namespace}tenant_id`, event.user.app_metadata.tenant_id);
};

Cette Action Auth0 ajoute dynamiquement des claims personnalisés dans l’ID Token, selon les données utilisateur de votre application.

---

Outils open source OIDC

Voici quelques outils open source populaires pour la gestion des protocoles OIDC, côté fournisseur d’identité comme côté client, pour couvrir différents frameworks et langages.

| Outil | Langage | Stars | Usage | |-------|---------|-------|-------| | keycloak | Java | 22k | Alternative IdP open source | | oidc-provider | Node.js | 3.4k | Implémenter votre propre OP | | nextauth.js | TypeScript | 24k | OIDC client pour Next.js | | dex | Go | 9k | IdP fédéré open source | | python-jose | Python | 1.4k | Validation JWT/OIDC |

---

> 💡 Conseil expert : utilisez toujours RS256 (asymétrique) plutôt que HS256 (symétrique) pour vos ID Tokens en production. Avec RS256, seul Auth0 peut signer — avec HS256, votre secret doit être partagé avec vos APIs.

📧 [email protected]