Qu'est-ce que PKCE protège réellement?
J'essaie de comprendre comment PKCE fonctionne dans une application mobile et il y a quelque chose que je ne comprends pas très bien.
Donc, à partir de ce que je peux rassembler, l'application cliente crée une chaîne aléatoire cryptographiquement sécurisée connue sous le nom de vérificateur de code. Celui-ci est ensuite stocké. À partir de cela, l'application génère ensuite un défi de code. Le défi de code est ensuite envoyé dans une demande d'API à un serveur avec la façon dont le défi a été généré, par exemple S256 ou plain. Le serveur stocke ce défi avec un code d'autorisation approprié pour la demande en question.
Lorsque le client essaie ensuite d'échanger le code contre un jeton d'accès, il envoie également le vérificateur de code d'origine dans la demande. Le serveur récupère ensuite le défi stocké et la méthode utilisée à l'origine pour le générer pour ce code particulier et génère le hachage s256/plain équivalent et les compare. S'ils correspondent, il renvoie un jeton d'accès.
Ce que je ne comprends pas, c'est comment cela est censé remplacer un secret dans une application cliente? Certes, si vous vouliez usurper cela, vous prendriez simplement le client_id comme normal et généreriez votre propre vérificateur de code et défi et vous êtes dans la même position que si PKCE n'était pas requis en premier lieu. Qu'est-ce que PKCE essaie réellement de résoudre ici si l'idée originale était qu'il s'agit essentiellement d'un "secret dynamique"? Je suppose que ce n'est là que si quelqu'un "écoute" quand le auth_code est renvoyé, mais si vous utilisez à nouveau SSL, est-ce nécessaire? Il est censé remplacer le fait que vous ne devriez pas stocker un secret dans une application publique, mais le fait que le client soit responsable de la génération plutôt que d'un serveur donne l'impression que cela n'aide pas vraiment.
Cette écriture Okta a à ce sujet explique cela assez bien à mon humble avis.
Je pense que c'est parce que PKCE est destiné aux applications natives (par exemple Android, iOS, UWP, Electron, etc.) où vous quittez le contexte de sécurité de votre application et accédez au navigateur pour vous authentifier, et comptez sur le retour sécurisé de votre application depuis le navigateur. Vous n'avez pas nécessairement TLS sur la redirection vers votre application (dans le cas de schémas personnalisés, vous comptez sur le système d'exploitation pour ramener la réponse à votre application) donc dans le cas où votre code d'autorisation irait dans un endroit malveillant, la réception L'application ne pourrait pas obtenir de jeton d'accès sans le secret dynamique.
Les mérites d'un secret dynamique sur un client public sont évidents ici - et l'hypothèse pour PKCE est qu'il n'est pas difficile d'intercepter la réponse du navigateur à votre application.
La raison pour laquelle PKCE est important est que sur le système d'exploitation mobile, le système d'exploitation permet aux applications de s'enregistrer pour gérer les URI de redirection afin qu'une application malveillante puisse s'inscrire et recevoir des redirections avec le code d'autorisation pour les applications légitimes. Ceci est connu comme une attaque d'interception de code d'autorisation.
Attaque d'interception de code d'autorisation
Ceci est décrit par WSO2 ici:
Étant donné que plusieurs applications peuvent être enregistrées en tant que gestionnaire pour l'URI de redirection spécifique, la vulnérabilité de ce flux est qu'un client malveillant pourrait également s'enregistrer en tant que gestionnaire pour le même schéma d'URI qu'une application légitime gère. Si cela se produit, il est possible que le système d'exploitation analyse l'URI du client malveillant. Le déroulement de cette attaque est illustré dans le diagramme suivant.
Dans certains systèmes d'exploitation tels qu'Android, à l'étape 5 du flux, l'utilisateur est invité à sélectionner l'application pour gérer l'URI de redirection avant qu'il ne soit analysé à l'aide d'une activité "Action complète utilisant". Cela peut éviter qu'une application malveillante ne la gère, car l'utilisateur peut identifier et sélectionner l'application légitime. Cependant, certains systèmes d'exploitation (tels que iOS) ne disposent pas d'un tel schéma.
Pour mieux comprendre cela, voici un diagramme et une discussion d'OpenID. Vous pouvez voir que le navigateur du système mobile a la responsabilité de recevoir l'URI de redirection et de le router vers l'application appropriée.
Cependant, étant donné que les systèmes d'exploitation mobiles peuvent permettre à de nombreuses applications de s'enregistrer pour le même URI de redirection, une application malveillante peut s'enregistrer et recevoir un code d'autorisation légitime comme indiqué dans ce diagramme, également par WSO2:
Atténuation des attaques par PKCE
PKCE atténue cela en exigeant un partage des connaissances entre l'application qui lance la demande OAuth 2.0 (demande de code d'authentification) et celle qui échange le code d'authentification contre un jeton. Dans le cas d'une attaque d'interception de code d'authentification, le L'application malveillante n'a pas le vérificateur pour terminer l'échange de jetons.