Ressources · 43

OAuth et OpenID Connect : vérifier une intégration de bout en bout

Distinguer connexion, délégation et droits sur les données, puis tester redirections, jetons, sessions et révocation.

· 10 min

Salle fictive vide de vérification des identités : deux clés de sécurité, carte vierge et dossier bordeaux Illustration éditoriale générée par IA

Ce que ce guide permet

  • Séparer identité et autorisation
  • Éviter une redirection ou un jeton accepté à tort
  • Tester les refus aussi précisément que les succès
  • Vérifier la fin des accès après départ ou incident

Contrôle express

  • Quel fournisseur et quel émetteur sont attendus ?
  • L’URI de retour est-elle enregistrée précisément ?
  • Un ID token est-il utilisé à tort comme access token ?
  • Chaque ressource vérifie-t-elle son propriétaire ?
  • Quels accès restent actifs après révocation ?

Méthode pas à pas

  1. 01

    Dessiner le flux réel

    Identifiez client public ou confidentiel, navigateur, serveur d’autorisation, API et fournisseur OIDC. Notez où les codes et jetons circulent, qui les conserve et quels rôles sont accordés. Un diagramme commercial ne suffit pas à décrire le déploiement réel.

    Livrable : flux, frontières de confiance et propriétaire de chaque composant.

  2. 02

    Contrôler la transaction de connexion

    Utilisez le flux code avec PKCE adapté au client. Vérifiez S256, liaison à la transaction, URI enregistrée et protection contre les requêtes forgées. Testez une URI non prévue, un vérificateur incorrect, un code rejoué et un émetteur inattendu. La RFC 9700 distingue exigences et recommandations selon le type de client.

    Livrable : cas de test et résultats autorisés/refusés.

  3. 03

    Valider le jeton au bon endroit

    L’API vérifie le jeton d’accès selon son format et les règles du fournisseur : signature ou introspection, émetteur, audience, expiration et droits. Le client OIDC valide séparément le jeton d’identité. Une signature valide ne prouve pas qu’un jeton est destiné à cette API.

    Livrable : contrat de validation et tests d’audience et de date.

  4. 04

    Vérifier les droits métier

    Testez un objet d’un autre compte, un rôle inférieur, un champ privé et une action d’administration. La présence d’un scope ou d’une passerelle authentifiée ne remplace pas le contrôle serveur sur la ressource demandée. Utilisez des comptes et données de test autorisés.

    Livrable : matrice rôle, objet, opération et refus attendu.

  5. 05

    Exercer expiration et révocation

    Distinguez session locale, session du fournisseur, access token et refresh token. Testez départ, appareil perdu, changement de rôle, rotation des clés et indisponibilité du fournisseur. Documentez le délai résiduel d’accès au lieu de supposer que déconnexion signifie révocation immédiate.

    Livrable : chronologie de perte d’accès et exceptions.

  6. 06

    Observer sans exposer les secrets

    Journalisez identifiant de transaction, décision de validation, catégorie d’erreur et version de configuration. Excluez codes, jetons et secrets. Préparez diagnostic, arrêt de l’intégration et retour à une configuration validée ; rejouez les tests après changement du fournisseur.

    Livrable : procédure d’exploitation et contrôle de non-régression.

Cas de recette proposés

Scénarios fictifs à adapter dans un environnement autorisé. Ils ne décrivent aucun résultat client ni une certification.

Situation fictiveContrôle proposéPreuve à conserver
Un compte A connecté demande un document réservé au compte B.Vérifier le refus par l’API, même si la connexion et le jeton sont valides pour A. Ne pas assimiler authentification et droit sur l’objet.Version du service, rôles, identifiants fictifs, résultat attendu et réponse observée ; aucun jeton brut.
Un rôle est retiré alors qu’une session et un jeton d’accès existent encore.Observer les accès restants selon le contrat de session et de validation déployé. Documenter le délai et le contrôle effectif, sans promettre une révocation instantanée universelle.Chronologie du retrait, chemins testés, état des sessions et décision corrective.

Exemple d’application

Situation illustrative

Situation illustrative : deux clients utilisent le même fournisseur d’identité. Un jeton valide pour le premier est présenté à l’API du second.

Décision et preuve attendue

L’API refuse l’audience incorrecte, conserve une trace sans jeton et ne renvoie aucune donnée. Ce refus devient un test de régression.

Distinguer les mécanismes

MécanismeUtilitéPoint de vigilance
OAuth 2.0Déléguer l’accès à une ressourceContrôle serveur des droits sur l’objet
OpenID ConnectÉtablir l’identité avec un ID token validéValidation de l’émetteur, audience et transaction
Session applicativeMaintenir la connexion à l’applicationExpiration, invalidation et protection de la session

Indicateurs de pilotage

IndicateurCe qu’il mesurePremière action
Refus correctsCas interdits effectivement bloquésCorriger chaque acceptation inattendue
Délai de révocationTemps jusqu’à disparition des accès concernésVérifier sessions et jetons séparément
Erreurs de validationRejets par cause et versionDistinguer attaque et mauvaise configuration

Erreurs fréquentes

  • Confondre authentification et autorisation
  • Accepter toute audience après vérification de signature
  • Enregistrer une URI de retour trop large
  • Journaliser les jetons pour faciliter le débogage

Questions fréquentes

PKCE remplace-t-il tous les contrôles ?

Non. Il protège l’échange du code dans le flux prévu ; validation des jetons, redirections, autorisation métier et sessions restent à vérifier.

Un JWT est-il une permission ?

JWT est un format. Les revendications ne deviennent utilisables qu’après validation et application des règles de votre API.

Faut-il développer soi-même la validation ?

Préférez une bibliothèque maintenue et la documentation du fournisseur, puis testez votre configuration. Une bibliothèque correcte peut être mal paramétrée.

Quelle preuve conserver pour une vérification utile ?

Conservez le contexte du compte, les rôles attendus, l’objet demandé et les réponses de l’API. Un test de connexion réussi ne prouve pas que les droits sur chaque ressource sont corrects ; les journaux de recette ne doivent contenir aucun secret de session.

OAuth/OIDC : audience et droits

Quel jeton pour quel destinataire ? Un contrat de validation vérifiable

Une intégration OAuth/OIDC sûre relie chaque jeton à son usage, à son émetteur et au composant qui doit le recevoir. Un ID token renseigne le client OIDC sur une authentification ; un access token est présenté à une ressource protégée. La réussite de la connexion ne suffit pas à autoriser une lecture, une modification ou un appel d’outil par un agent IA.

Ce complément décrit un profil précis : l’API consomme un JWT access token conforme à RFC 9068. OAuth 2.0 n’impose pas le format JWT à tous les jetons d’accès. Les clients doivent traiter leurs access tokens comme opaques ; le contrat de validation appartient au serveur de ressources. Les exemples ci-dessous sont fictifs, sans secret ni signature utilisable.

Destinations des codes et jetons
Destinations des codes et jetons Quatre lignes indépendantes montrent les destinataires : code vers token endpoint, ID token vers client OIDC, access token vers API, refresh token vers token endpoint. Ce schéma ne représente pas l’ordre complet des échanges. Code → Token endpoint Échange lié à la transaction ID token → Client OIDC Identité et audience client_id Access token → API / ressource Audience et droits à vérifier Refresh token → Token endpoint Renouvellement, pas appel API Destinations distinctes · schéma conceptuel, hors séquence réseau

Quatre objets, quatre usages à séparer

Quatre objets, quatre usages à séparer
ObjetDestinataire et usageFrontière à conserver
Code d’autorisationPoint de terminaison token du serveur d’autorisation : échange du code dans la transaction prévue.Ce code ne constitue pas un droit d’accès à une API ; liaison au client, à la redirection et à PKCE à vérifier.
ID tokenClient OIDC : validation de l’identité et de la transaction ; aud contient son client_id.Ne pas le recycler comme justificatif d’accès à l’API ; appliquer les règles OIDC propres au flux.
Access tokenServeur de ressources : accès dans le périmètre accordé ; l’audience identifie la ressource destinataire.Valider le jeton puis les droits de l’opération et de l’objet. Le client ne dépend pas de son contenu interne.
Refresh tokenPoint de terminaison token du serveur d’autorisation : obtention de nouveaux access tokens.Ne pas l’envoyer au serveur de ressources ; son cycle de vie ne se confond pas avec la session locale.

Huit contrôles à inscrire dans le contrat

Huit contrôles à inscrire dans le contrat
ContrôleRègle et périmètreTrace attendue, sans jeton
Profil et typPour RFC 9068, contrôler typ = at+jwt ou application/at+jwt. D’autres profils nécessitent leurs propres règles ; « tout JWT signé » est un contrat trop large.Profil configuré et cas de confusion ID token/access token refusé.
Algorithme et clésVérifier la signature avec les clés de l’émetteur attendu et les algorithmes autorisés par la configuration. RFC 9068 exclut alg = none ; une valeur reçue ne fixe pas seule la politique.Version de la politique cryptographique et résultat, sans matériel secret.
Émetteur issComparer exactement la valeur à l’émetteur attendu. Un autre hôte, chemin ou suffixe n’est pas rendu fiable par sa ressemblance.Identifiant de configuration et motif issuer_mismatch.
Audience audLe destinataire attendu doit figurer dans aud. Une liste d’audiences reste possible ; la présence du bon destinataire ne dispense pas des autres contrôles.Ressource attendue et scénario de jeton destiné à une autre API.
Expiration expL’instant courant doit précéder exp ; la faible tolérance d’horloge éventuelle est une politique explicite. Le jeu pédagogique utilise zéro seconde de tolérance.Horloge de test, tolérance configurée et frontière d’expiration testée.
Scopes et objetRelier chaque scope à la ressource et à l’opération. Contrôler ensuite propriétaire, locataire et règles métier côté serveur. RFC 9068 ne définit pas toute cette autorisation.Action, objet de test, règle appliquée et refus inter-locataires.
Transaction OIDC et PKCESi nonce a été envoyé, vérifier sa présence et son égalité dans l’ID token. RFC 9700 impose PKCE aux clients publics et le recommande aux clients confidentiels ; challenge lié à la transaction, S256 recommandé.Tests de nonce incorrect, code rejoué et mauvais code_verifier dans le flux autorisé.
Durée et fin des accèsDistinguer expiration des access tokens, renouvellement et session applicative. RFC 9700 demande une liaison au client émetteur (sender-constrained) ou une rotation pour détecter le rejeu des refresh tokens des clients publics.Chronologie d’accès résiduel, départ utilisateur et procédure de révocation testée.
Lire un jeu de revendications fictif, sans le prendre pour une preuve

Horloge pédagogique : 2026-10-22 à 10:00:00 UTC. Le JSON montre uniquement un en-tête et des revendications lisibles ; aucune sérialisation JWT signée n’est fournie. exp correspond à 10:05:00 UTC et iat à 09:59:00 UTC. Les domaines .example et les identifiants sont réservés à ce scénario.

{
    "header": {
        "typ": "at+jwt",
        "alg": "RS256",
        "kid": "training-key-01"
    },
    "claims": {
        "iss": "https://identity.example/",
        "sub": "training-subject-17",
        "aud": "https://api.example/evidence",
        "exp": 1792663500,
        "iat": 1792663140,
        "jti": "training-event-001",
        "client_id": "training-console",
        "scope": "evidence:read"
    }
}

Décoder du JSON ne valide ni une signature ni la confiance dans les clés. Dans les cas indiqués, la cryptographie est une hypothèse d’exercice, jamais un contrôle réellement exécuté par cette page. Le profil comporte aussi des revendications obligatoires, dont sub, client_id, iat et jti : le tableau des huit contrôles n’est pas un validateur complet. Le sujet ne désigne pas nécessairement une personne ; un jti ne crée pas à lui seul un mécanisme anti-rejeu.

Dix scénarios de revue : décision, limite et preuve attendue

01 · Jeton destiné à l’API : poursuivre les contrôles métier

Situation : iss, aud, typ et exp correspondent au contrat fictif ; evidence:read est présent. La signature est supposée vérifiée uniquement pour l’exercice.

Décision : poursuivre vers le contrôle de l’opération et de l’objet, sans conclure automatiquement « accès autorisé ». Preuve attendue : règle métier et objet de test examinés séparément.

02 · Signature supposée correcte, mauvaise audience

Variation : aud vise https://api.example/billing au lieu de la ressource evidence. Les autres hypothèses restent identiques.

Décision : refuser le jeton pour cette API. Une signature correcte ne change pas son destinataire. Preuve attendue : aucun contenu de la ressource retourné et motif d’audience enregistré sans jeton.

03 · Émetteur différent malgré des revendications plausibles

Variation : iss vaut https://other-identity.example/. Sa forme HTTPS ne le rend pas équivalent à l’émetteur configuré.

Décision : refuser la correspondance d’émetteur. Preuve attendue : comparaison exacte avec https://identity.example/ et test de non-régression.

04 · Expiration atteinte à la seconde exacte

Variation : exp est égal à l’horloge de test, 10:00:00 UTC, avec zéro seconde de tolérance dans ce scénario.

Décision : refuser pour expiration. « Maintenant est avant exp » est faux à égalité ; ne pas transformer cet exemple en tolérance universelle pour tous les systèmes. Preuve attendue : tests avant, à et après la frontière avec la politique réelle.

05 · ID token présenté comme jeton d’accès

Variation : un ID token fictif porte typ = JWT et aud = training-console. Il vise le client OIDC.

Décision : le refuser comme JWT access token du profil RFC 9068. Valider ce jeton côté client OIDC ne lui donne pas le rôle d’un jeton d’accès. Preuve attendue : règles de validation distinctes par type de jeton.

06 · Scope d’écriture présenté pour une lecture

Variation : scope vaut evidence:write alors que l’appel exige evidence:read.

Décision : refuser cette lecture selon la politique de l’exercice, qui ne prévoit aucune implication write → read. Les noms et relations de scopes sont propres au contrat. Preuve attendue : matrice explicite opération/scope, sans déduction à partir du nom.

07 · JSON lisible, cryptographie non vérifiée

Situation : le JSON est lisible et ses valeurs semblent correspondre, mais la validation cryptographique et la confiance dans les clés ne sont pas établies.

Décision : arrêter l’acceptation ; l’état est non vérifié. Preuve attendue : résultat de la bibliothèque configurée et du contrat de confiance. Aucune donnée protégée ne doit être libérée sur la seule lecture des revendications.

08 · Bon jeton, objet d’un autre locataire

Situation : les vérifications du jeton de test sont supposées réussies. L’objet demandé appartient à un autre locataire et la politique métier interdit cette lecture.

Décision : refuser l’objet. evidence:read ne donne pas accès à toutes les preuves de tous les comptes. Preuve attendue : test serveur inter-locataires et absence de fuite dans le contenu ou les champs retournés.

09 · Liste d’audiences contenant la ressource attendue

Variation : aud contient https://api.example/evidence et https://api.example/archive. La ressource attendue figure bien dans la liste.

Décision : ce contrôle d’audience peut être satisfait ; poursuivre tous les autres contrôles. Une liste n’est pas un joker. Preuve attendue : chaque scope reste interprétable pour la ressource, sans permission ambiguë.

10 · ID token avec nonce différent de la transaction

Transaction OIDC distincte des cas API : nonce envoyé = training-transaction-A ; nonce reçu = training-transaction-B.

Décision : refuser l’ID token pour cette transaction selon OIDC Core §3.1.3.7. Ce contrôle ne remplace ni PKCE ni les règles de l’API. Preuve attendue : comparaison avec la transaction d’origine et test d’absence de nonce lorsqu’il a été envoyé.

Six éléments utiles dans un dossier de recette

  • Carte des clients, émetteurs, API et audiences attendues, avec un responsable par frontière.
  • Contrat de validation versionné : format, bibliothèques, clés de confiance, algorithmes et tolérance d’horloge.
  • Matrice action, scope, locataire et objet ; préciser les refus et les implications de droits effectivement prévues.
  • Jeux de test synthétiques, horloge fixe, variantes négatives et résultats observés dans l’environnement autorisé.
  • Chronologie séparée des sessions, access tokens et refresh tokens lors de départ, révocation et panne fournisseur.
  • Journal expurgé : référence de transaction interne, version de politique, motif de décision et date ; exclure jetons, codes et secrets.

Sources primaires et périmètre de lecture

Sources vérifiées le

Références officielles

Date de consultation des références : . La méthode et la fiche de travail proposent des contrôles à adapter à votre contexte ; elles ne constituent pas une certification.