RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien

Le problème concret : RFC 9700 face à OAuth 2.0

La difficulté réelle apparaît lorsque le comportement nominal rencontre les droits, les erreurs et la production.

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c11 part de OAuth 2.0 et traite PKCE comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à redirect URI de produire un résultat observable avant que open redirector puisse déclencher l’effet attendu autour de RFC 9700. Ce niveau de détail rend « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien » révisable : chaque affirmation opérationnelle renvoie à PKCE, à une condition concrète et à une preuve plutôt qu’à une formule générale. La décision finale reste bornée par redirect URI et RFC 9700 : ce qui n’est pas démontré par le scénario rfc9700-oauth-modernisation-c11 est présenté comme limite ou hypothèse, jamais comme fait acquis. Cette séquence répond au besoin suivant : Auditer redirect URIs, PKCE, open redirectors et pratiques historiques avant de durcir un client OAuth existant. Elle transforme OAuth 2.0 en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver.

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c12 part de PKCE et traite redirect URI comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à open redirector de produire un résultat observable avant que RFC 9700 puisse déclencher l’effet attendu autour de OAuth 2.0. Pour tester redirect URI, la fixture rfc9700-oauth-modernisation-c12 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à open redirector. L’exploitation surveille alors la transition entre open redirector et RFC 9700, tandis que la sécurité vérifie que OAuth 2.0 ne reçoit ni autorité implicite ni donnée excédentaire. Si la vérification de RFC 9700 échoue, le rollback restaure la configuration liée à OAuth 2.0, rejoue rfc9700-oauth-modernisation-c12 et compare le nouvel état au témoin produit par PKCE.

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c13 part de redirect URI et traite open redirector comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à RFC 9700 de produire un résultat observable avant que OAuth 2.0 puisse déclencher l’effet attendu autour de PKCE. Ce niveau de détail rend « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien » révisable : chaque affirmation opérationnelle renvoie à open redirector, à une condition concrète et à une preuve plutôt qu’à une formule générale. La décision finale reste bornée par RFC 9700 et PKCE : ce qui n’est pas démontré par le scénario rfc9700-oauth-modernisation-c13 est présenté comme limite ou hypothèse, jamais comme fait acquis. Cette séquence répond au besoin suivant : Auditer redirect URIs, PKCE, open redirectors et pratiques historiques avant de durcir un client OAuth existant. Elle transforme redirect URI en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver.

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c14 part de open redirector et traite RFC 9700 comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à OAuth 2.0 de produire un résultat observable avant que PKCE puisse déclencher l’effet attendu autour de redirect URI. Pour tester RFC 9700, la fixture rfc9700-oauth-modernisation-c14 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à OAuth 2.0. L’exploitation surveille alors la transition entre OAuth 2.0 et PKCE, tandis que la sécurité vérifie que redirect URI ne reçoit ni autorité implicite ni donnée excédentaire. Si la vérification de PKCE échoue, le rollback restaure la configuration liée à redirect URI, rejoue rfc9700-oauth-modernisation-c14 et compare le nouvel état au témoin produit par open redirector.

Frontières de confiance autour de PKCE

Le bon design sépare ce que le modèle propose de ce que l’application autorise et vérifie.

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c21 part de PKCE et traite redirect URI comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à open redirector de produire un résultat observable avant que RFC 9700 puisse déclencher l’effet attendu autour de OAuth 2.0. Si la vérification de RFC 9700 échoue, le rollback restaure la configuration liée à OAuth 2.0, rejoue rfc9700-oauth-modernisation-c21 et compare le nouvel état au témoin produit par PKCE. Ce niveau de détail rend « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien » révisable : chaque affirmation opérationnelle renvoie à redirect URI, à une condition concrète et à une preuve plutôt qu’à une formule générale. La décision finale reste bornée par open redirector et OAuth 2.0 : ce qui n’est pas démontré par le scénario rfc9700-oauth-modernisation-c21 est présenté comme limite ou hypothèse, jamais comme fait acquis.

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c22 part de redirect URI et traite open redirector comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à RFC 9700 de produire un résultat observable avant que OAuth 2.0 puisse déclencher l’effet attendu autour de PKCE. Cette séquence répond au besoin suivant : Auditer redirect URIs, PKCE, open redirectors et pratiques historiques avant de durcir un client OAuth existant. Elle transforme redirect URI en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver. Pour tester open redirector, la fixture rfc9700-oauth-modernisation-c22 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à RFC 9700. L’exploitation surveille alors la transition entre RFC 9700 et OAuth 2.0, tandis que la sécurité vérifie que PKCE ne reçoit ni autorité implicite ni donnée excédentaire.

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c23 part de open redirector et traite RFC 9700 comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à OAuth 2.0 de produire un résultat observable avant que PKCE puisse déclencher l’effet attendu autour de redirect URI. Si la vérification de PKCE échoue, le rollback restaure la configuration liée à redirect URI, rejoue rfc9700-oauth-modernisation-c23 et compare le nouvel état au témoin produit par open redirector. Ce niveau de détail rend « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien » révisable : chaque affirmation opérationnelle renvoie à RFC 9700, à une condition concrète et à une preuve plutôt qu’à une formule générale. La décision finale reste bornée par OAuth 2.0 et redirect URI : ce qui n’est pas démontré par le scénario rfc9700-oauth-modernisation-c23 est présenté comme limite ou hypothèse, jamais comme fait acquis.

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c24 part de RFC 9700 et traite OAuth 2.0 comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à PKCE de produire un résultat observable avant que redirect URI puisse déclencher l’effet attendu autour de open redirector. Cette séquence répond au besoin suivant : Auditer redirect URIs, PKCE, open redirectors et pratiques historiques avant de durcir un client OAuth existant. Elle transforme RFC 9700 en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver. Pour tester OAuth 2.0, la fixture rfc9700-oauth-modernisation-c24 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à PKCE. L’exploitation surveille alors la transition entre PKCE et redirect URI, tandis que la sécurité vérifie que open redirector ne reçoit ni autorité implicite ni donnée excédentaire.

Construire le chemin de décision avec redirect URI

Le point de départ n’est pas une fonctionnalité, mais une frontière de décision observable.

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c31 part de redirect URI et traite open redirector comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à RFC 9700 de produire un résultat observable avant que OAuth 2.0 puisse déclencher l’effet attendu autour de PKCE. L’exploitation surveille alors la transition entre RFC 9700 et OAuth 2.0, tandis que la sécurité vérifie que PKCE ne reçoit ni autorité implicite ni donnée excédentaire. Si la vérification de OAuth 2.0 échoue, le rollback restaure la configuration liée à PKCE, rejoue rfc9700-oauth-modernisation-c31 et compare le nouvel état au témoin produit par redirect URI. Ce niveau de détail rend « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien » révisable : chaque affirmation opérationnelle renvoie à open redirector, à une condition concrète et à une preuve plutôt qu’à une formule générale.

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c32 part de open redirector et traite RFC 9700 comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à OAuth 2.0 de produire un résultat observable avant que PKCE puisse déclencher l’effet attendu autour de redirect URI. La décision finale reste bornée par OAuth 2.0 et redirect URI : ce qui n’est pas démontré par le scénario rfc9700-oauth-modernisation-c32 est présenté comme limite ou hypothèse, jamais comme fait acquis. Cette séquence répond au besoin suivant : Auditer redirect URIs, PKCE, open redirectors et pratiques historiques avant de durcir un client OAuth existant. Elle transforme open redirector en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver. Pour tester RFC 9700, la fixture rfc9700-oauth-modernisation-c32 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à OAuth 2.0.

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c33 part de RFC 9700 et traite OAuth 2.0 comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à PKCE de produire un résultat observable avant que redirect URI puisse déclencher l’effet attendu autour de open redirector. L’exploitation surveille alors la transition entre PKCE et redirect URI, tandis que la sécurité vérifie que open redirector ne reçoit ni autorité implicite ni donnée excédentaire. Si la vérification de redirect URI échoue, le rollback restaure la configuration liée à open redirector, rejoue rfc9700-oauth-modernisation-c33 et compare le nouvel état au témoin produit par RFC 9700. Ce niveau de détail rend « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien » révisable : chaque affirmation opérationnelle renvoie à OAuth 2.0, à une condition concrète et à une preuve plutôt qu’à une formule générale.

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c34 part de OAuth 2.0 et traite PKCE comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à redirect URI de produire un résultat observable avant que open redirector puisse déclencher l’effet attendu autour de RFC 9700. La décision finale reste bornée par redirect URI et RFC 9700 : ce qui n’est pas démontré par le scénario rfc9700-oauth-modernisation-c34 est présenté comme limite ou hypothèse, jamais comme fait acquis. Cette séquence répond au besoin suivant : Auditer redirect URIs, PKCE, open redirectors et pratiques historiques avant de durcir un client OAuth existant. Elle transforme OAuth 2.0 en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver. Pour tester PKCE, la fixture rfc9700-oauth-modernisation-c34 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à redirect URI.

Vérifier le comportement de open redirector

Un système exploitable commence par une question simple : qui décide, sur quelles preuves, et que peut-on annuler ?

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c41 part de open redirector et traite RFC 9700 comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à OAuth 2.0 de produire un résultat observable avant que PKCE puisse déclencher l’effet attendu autour de redirect URI. Pour tester RFC 9700, la fixture rfc9700-oauth-modernisation-c41 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à OAuth 2.0. L’exploitation surveille alors la transition entre OAuth 2.0 et PKCE, tandis que la sécurité vérifie que redirect URI ne reçoit ni autorité implicite ni donnée excédentaire. Si la vérification de PKCE échoue, le rollback restaure la configuration liée à redirect URI, rejoue rfc9700-oauth-modernisation-c41 et compare le nouvel état au témoin produit par open redirector.

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c42 part de RFC 9700 et traite OAuth 2.0 comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à PKCE de produire un résultat observable avant que redirect URI puisse déclencher l’effet attendu autour de open redirector. Ce niveau de détail rend « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien » révisable : chaque affirmation opérationnelle renvoie à OAuth 2.0, à une condition concrète et à une preuve plutôt qu’à une formule générale. La décision finale reste bornée par PKCE et open redirector : ce qui n’est pas démontré par le scénario rfc9700-oauth-modernisation-c42 est présenté comme limite ou hypothèse, jamais comme fait acquis. Cette séquence répond au besoin suivant : Auditer redirect URIs, PKCE, open redirectors et pratiques historiques avant de durcir un client OAuth existant. Elle transforme RFC 9700 en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver.

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c43 part de OAuth 2.0 et traite PKCE comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à redirect URI de produire un résultat observable avant que open redirector puisse déclencher l’effet attendu autour de RFC 9700. Pour tester PKCE, la fixture rfc9700-oauth-modernisation-c43 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à redirect URI. L’exploitation surveille alors la transition entre redirect URI et open redirector, tandis que la sécurité vérifie que RFC 9700 ne reçoit ni autorité implicite ni donnée excédentaire. Si la vérification de open redirector échoue, le rollback restaure la configuration liée à RFC 9700, rejoue rfc9700-oauth-modernisation-c43 et compare le nouvel état au témoin produit par OAuth 2.0.

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c44 part de PKCE et traite redirect URI comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à open redirector de produire un résultat observable avant que RFC 9700 puisse déclencher l’effet attendu autour de OAuth 2.0. Ce niveau de détail rend « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien » révisable : chaque affirmation opérationnelle renvoie à redirect URI, à une condition concrète et à une preuve plutôt qu’à une formule générale. La décision finale reste bornée par open redirector et OAuth 2.0 : ce qui n’est pas démontré par le scénario rfc9700-oauth-modernisation-c44 est présenté comme limite ou hypothèse, jamais comme fait acquis. Cette séquence répond au besoin suivant : Auditer redirect URIs, PKCE, open redirectors et pratiques historiques avant de durcir un client OAuth existant. Elle transforme PKCE en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver.

Échecs plausibles, signaux et diagnostic

La difficulté réelle apparaît lorsque le comportement nominal rencontre les droits, les erreurs et la production.

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c51 part de RFC 9700 et traite OAuth 2.0 comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à PKCE de produire un résultat observable avant que redirect URI puisse déclencher l’effet attendu autour de open redirector. Cette séquence répond au besoin suivant : Auditer redirect URIs, PKCE, open redirectors et pratiques historiques avant de durcir un client OAuth existant. Elle transforme RFC 9700 en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver. Pour tester OAuth 2.0, la fixture rfc9700-oauth-modernisation-c51 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à PKCE. L’exploitation surveille alors la transition entre PKCE et redirect URI, tandis que la sécurité vérifie que open redirector ne reçoit ni autorité implicite ni donnée excédentaire.

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c52 part de OAuth 2.0 et traite PKCE comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à redirect URI de produire un résultat observable avant que open redirector puisse déclencher l’effet attendu autour de RFC 9700. Si la vérification de open redirector échoue, le rollback restaure la configuration liée à RFC 9700, rejoue rfc9700-oauth-modernisation-c52 et compare le nouvel état au témoin produit par OAuth 2.0. Ce niveau de détail rend « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien » révisable : chaque affirmation opérationnelle renvoie à PKCE, à une condition concrète et à une preuve plutôt qu’à une formule générale. La décision finale reste bornée par redirect URI et RFC 9700 : ce qui n’est pas démontré par le scénario rfc9700-oauth-modernisation-c52 est présenté comme limite ou hypothèse, jamais comme fait acquis.

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c53 part de PKCE et traite redirect URI comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à open redirector de produire un résultat observable avant que RFC 9700 puisse déclencher l’effet attendu autour de OAuth 2.0. Cette séquence répond au besoin suivant : Auditer redirect URIs, PKCE, open redirectors et pratiques historiques avant de durcir un client OAuth existant. Elle transforme PKCE en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver. Pour tester redirect URI, la fixture rfc9700-oauth-modernisation-c53 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à open redirector. L’exploitation surveille alors la transition entre open redirector et RFC 9700, tandis que la sécurité vérifie que OAuth 2.0 ne reçoit ni autorité implicite ni donnée excédentaire.

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c54 part de redirect URI et traite open redirector comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à RFC 9700 de produire un résultat observable avant que OAuth 2.0 puisse déclencher l’effet attendu autour de PKCE. Si la vérification de OAuth 2.0 échoue, le rollback restaure la configuration liée à PKCE, rejoue rfc9700-oauth-modernisation-c54 et compare le nouvel état au témoin produit par redirect URI. Ce niveau de détail rend « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien » révisable : chaque affirmation opérationnelle renvoie à open redirector, à une condition concrète et à une preuve plutôt qu’à une formule générale. La décision finale reste bornée par RFC 9700 et PKCE : ce qui n’est pas démontré par le scénario rfc9700-oauth-modernisation-c54 est présenté comme limite ou hypothèse, jamais comme fait acquis.

Déploiement progressif et retour arrière

Le bon design sépare ce que le modèle propose de ce que l’application autorise et vérifie.

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c61 part de OAuth 2.0 et traite PKCE comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à redirect URI de produire un résultat observable avant que open redirector puisse déclencher l’effet attendu autour de RFC 9700. La décision finale reste bornée par redirect URI et RFC 9700 : ce qui n’est pas démontré par le scénario rfc9700-oauth-modernisation-c61 est présenté comme limite ou hypothèse, jamais comme fait acquis. Cette séquence répond au besoin suivant : Auditer redirect URIs, PKCE, open redirectors et pratiques historiques avant de durcir un client OAuth existant. Elle transforme OAuth 2.0 en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver. Pour tester PKCE, la fixture rfc9700-oauth-modernisation-c61 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à redirect URI.

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c62 part de PKCE et traite redirect URI comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à open redirector de produire un résultat observable avant que RFC 9700 puisse déclencher l’effet attendu autour de OAuth 2.0. L’exploitation surveille alors la transition entre open redirector et RFC 9700, tandis que la sécurité vérifie que OAuth 2.0 ne reçoit ni autorité implicite ni donnée excédentaire. Si la vérification de RFC 9700 échoue, le rollback restaure la configuration liée à OAuth 2.0, rejoue rfc9700-oauth-modernisation-c62 et compare le nouvel état au témoin produit par PKCE. Ce niveau de détail rend « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien » révisable : chaque affirmation opérationnelle renvoie à redirect URI, à une condition concrète et à une preuve plutôt qu’à une formule générale.

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c63 part de redirect URI et traite open redirector comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à RFC 9700 de produire un résultat observable avant que OAuth 2.0 puisse déclencher l’effet attendu autour de PKCE. La décision finale reste bornée par RFC 9700 et PKCE : ce qui n’est pas démontré par le scénario rfc9700-oauth-modernisation-c63 est présenté comme limite ou hypothèse, jamais comme fait acquis. Cette séquence répond au besoin suivant : Auditer redirect URIs, PKCE, open redirectors et pratiques historiques avant de durcir un client OAuth existant. Elle transforme redirect URI en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver. Pour tester open redirector, la fixture rfc9700-oauth-modernisation-c63 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à RFC 9700.

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c64 part de open redirector et traite RFC 9700 comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à OAuth 2.0 de produire un résultat observable avant que PKCE puisse déclencher l’effet attendu autour de redirect URI. L’exploitation surveille alors la transition entre OAuth 2.0 et PKCE, tandis que la sécurité vérifie que redirect URI ne reçoit ni autorité implicite ni donnée excédentaire. Si la vérification de PKCE échoue, le rollback restaure la configuration liée à redirect URI, rejoue rfc9700-oauth-modernisation-c64 et compare le nouvel état au témoin produit par open redirector. Ce niveau de détail rend « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien » révisable : chaque affirmation opérationnelle renvoie à RFC 9700, à une condition concrète et à une preuve plutôt qu’à une formule générale.

Critères de décision pour la production

Le point de départ n’est pas une fonctionnalité, mais une frontière de décision observable.

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c71 part de PKCE et traite redirect URI comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à open redirector de produire un résultat observable avant que RFC 9700 puisse déclencher l’effet attendu autour de OAuth 2.0. Ce niveau de détail rend « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien » révisable : chaque affirmation opérationnelle renvoie à redirect URI, à une condition concrète et à une preuve plutôt qu’à une formule générale. La décision finale reste bornée par open redirector et OAuth 2.0 : ce qui n’est pas démontré par le scénario rfc9700-oauth-modernisation-c71 est présenté comme limite ou hypothèse, jamais comme fait acquis. Cette séquence répond au besoin suivant : Auditer redirect URIs, PKCE, open redirectors et pratiques historiques avant de durcir un client OAuth existant. Elle transforme PKCE en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver.

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c72 part de redirect URI et traite open redirector comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à RFC 9700 de produire un résultat observable avant que OAuth 2.0 puisse déclencher l’effet attendu autour de PKCE. Pour tester open redirector, la fixture rfc9700-oauth-modernisation-c72 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à RFC 9700. L’exploitation surveille alors la transition entre RFC 9700 et OAuth 2.0, tandis que la sécurité vérifie que PKCE ne reçoit ni autorité implicite ni donnée excédentaire. Si la vérification de OAuth 2.0 échoue, le rollback restaure la configuration liée à PKCE, rejoue rfc9700-oauth-modernisation-c72 et compare le nouvel état au témoin produit par redirect URI.

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c73 part de open redirector et traite RFC 9700 comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à OAuth 2.0 de produire un résultat observable avant que PKCE puisse déclencher l’effet attendu autour de redirect URI. Ce niveau de détail rend « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien » révisable : chaque affirmation opérationnelle renvoie à RFC 9700, à une condition concrète et à une preuve plutôt qu’à une formule générale. La décision finale reste bornée par OAuth 2.0 et redirect URI : ce qui n’est pas démontré par le scénario rfc9700-oauth-modernisation-c73 est présenté comme limite ou hypothèse, jamais comme fait acquis. Cette séquence répond au besoin suivant : Auditer redirect URIs, PKCE, open redirectors et pratiques historiques avant de durcir un client OAuth existant. Elle transforme open redirector en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver.

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c74 part de RFC 9700 et traite OAuth 2.0 comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à PKCE de produire un résultat observable avant que redirect URI puisse déclencher l’effet attendu autour de open redirector. Pour tester OAuth 2.0, la fixture rfc9700-oauth-modernisation-c74 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à PKCE. L’exploitation surveille alors la transition entre PKCE et redirect URI, tandis que la sécurité vérifie que open redirector ne reçoit ni autorité implicite ni donnée excédentaire. Si la vérification de redirect URI échoue, le rollback restaure la configuration liée à open redirector, rejoue rfc9700-oauth-modernisation-c74 et compare le nouvel état au témoin produit par RFC 9700.

Contrôles à conserver après la mise en service

Un système exploitable commence par une question simple : qui décide, sur quelles preuves, et que peut-on annuler ?

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c81 part de redirect URI et traite open redirector comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à RFC 9700 de produire un résultat observable avant que OAuth 2.0 puisse déclencher l’effet attendu autour de PKCE. Si la vérification de OAuth 2.0 échoue, le rollback restaure la configuration liée à PKCE, rejoue rfc9700-oauth-modernisation-c81 et compare le nouvel état au témoin produit par redirect URI. Ce niveau de détail rend « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien » révisable : chaque affirmation opérationnelle renvoie à open redirector, à une condition concrète et à une preuve plutôt qu’à une formule générale. La décision finale reste bornée par RFC 9700 et PKCE : ce qui n’est pas démontré par le scénario rfc9700-oauth-modernisation-c81 est présenté comme limite ou hypothèse, jamais comme fait acquis.

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c82 part de open redirector et traite RFC 9700 comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à OAuth 2.0 de produire un résultat observable avant que PKCE puisse déclencher l’effet attendu autour de redirect URI. Cette séquence répond au besoin suivant : Auditer redirect URIs, PKCE, open redirectors et pratiques historiques avant de durcir un client OAuth existant. Elle transforme open redirector en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver. Pour tester RFC 9700, la fixture rfc9700-oauth-modernisation-c82 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à OAuth 2.0. L’exploitation surveille alors la transition entre OAuth 2.0 et PKCE, tandis que la sécurité vérifie que redirect URI ne reçoit ni autorité implicite ni donnée excédentaire.

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c83 part de RFC 9700 et traite OAuth 2.0 comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à PKCE de produire un résultat observable avant que redirect URI puisse déclencher l’effet attendu autour de open redirector. Si la vérification de redirect URI échoue, le rollback restaure la configuration liée à open redirector, rejoue rfc9700-oauth-modernisation-c83 et compare le nouvel état au témoin produit par RFC 9700. Ce niveau de détail rend « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien » révisable : chaque affirmation opérationnelle renvoie à OAuth 2.0, à une condition concrète et à une preuve plutôt qu’à une formule générale. La décision finale reste bornée par PKCE et open redirector : ce qui n’est pas démontré par le scénario rfc9700-oauth-modernisation-c83 est présenté comme limite ou hypothèse, jamais comme fait acquis.

Dans « RFC 9700 : mettre à niveau un flux OAuth 2.0 ancien », le scénario rfc9700-oauth-modernisation-c84 part de OAuth 2.0 et traite PKCE comme une frontière explicite plutôt que comme une hypothèse implicite. Le premier contrôle demande à redirect URI de produire un résultat observable avant que open redirector puisse déclencher l’effet attendu autour de RFC 9700. Cette séquence répond au besoin suivant : Auditer redirect URIs, PKCE, open redirectors et pratiques historiques avant de durcir un client OAuth existant. Elle transforme OAuth 2.0 en point de décision vérifiable, avec une entrée nommée et une sortie que l’équipe peut conserver. Pour tester PKCE, la fixture rfc9700-oauth-modernisation-c84 inclut volontairement un état valide et un état refusé ; le refus doit arriver avant toute modification attribuée à redirect URI. L’exploitation surveille alors la transition entre redirect URI et open redirector, tandis que la sécurité vérifie que RFC 9700 ne reçoit ni autorité implicite ni donnée excédentaire.

Checklist opérationnelle

• Le contrôle autour de RFC 9700 a une entrée, une règle, un refus et une preuve.
• Le contrôle autour de OAuth 2.0 a une entrée, une règle, un refus et une preuve.
• Le contrôle autour de PKCE a une entrée, une règle, un refus et une preuve.
• Le contrôle autour de redirect URI a une entrée, une règle, un refus et une preuve.
• Le contrôle autour de open redirector a une entrée, une règle, un refus et une preuve.