Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Utilisation du PKCE dans l'octroi de codes d'autorisation
Amazon Cognito prend en charge l'authentification par clé de preuve pour l'échange de code (PKCE) lors de l'octroi de codes d'autorisation. PKCE est une extension de l'octroi de code d'autorisation OAuth 2.0 pour les clients publics. Le PKCE protège contre le rachat de codes d'autorisation interceptés.
## Comment Amazon Cognito utilise PKCE
Pour démarrer l'authentification avec PKCE, votre application doit générer une valeur de chaîne unique. Cette chaîne est le vérificateur de code, une valeur secrète qu'Amazon Cognito utilise pour comparer le client demandant l'autorisation initiale au client échangeant le code d'autorisation contre des jetons.
Votre application doit appliquer un SHA256 hachage à la chaîne du vérificateur de code et encoder le résultat en base64. Passez la chaîne hachée en [Point de terminaison d’autorisation](authorization-endpoint.md) tant que `code_challenge` paramètre dans le corps de la demande. Lorsque votre application échange le code d'autorisation contre des jetons, elle doit inclure la chaîne du vérificateur de code en texte brut en tant que `code_verifier` paramètre dans le corps de la demande au. [Point de terminaison de jeton](token-endpoint.md) Amazon Cognito effectue la même hash-and-encode opération sur le vérificateur de code. Amazon Cognito ne renvoie les jetons d'identification, d'accès et d'actualisation que s'il détermine que le vérificateur de code génère le même défi de code que celui qu'il a reçu dans la demande d'autorisation.
**Pour implémenter le flux d'octroi d'autorisations avec PKCE**
1. Ouvrez la [console Amazon Cognito](https://console.aws.amazon.com/cognito/home). Si vous y êtes invité, entrez vos AWS informations d'identification.
1. Choisissez **Groupes d’utilisateurs**.
1. Choisissez un groupe d’utilisateurs existant dans la liste ou créez-en un. Si vous créez un groupe d'utilisateurs, vous serez invité à configurer un client d'application et à configurer la connexion gérée au cours de l'assistant.
1. Si vous créez un nouveau groupe d'utilisateurs, configurez un client d'application et configurez la connexion gérée lors de la configuration guidée.
1. Si vous configurez un groupe d'utilisateurs existant, ajoutez un [domaine](cognito-user-pools-assign-domain.md) et un [client d'application public](user-pool-settings-client-apps.md), si ce n'est pas déjà fait.
1. Générez une chaîne alphanumérique aléatoire, généralement un identifiant unique universel ([UUID](cognito-terms.md#terms-uuid)), afin de créer un défi de code pour le PKCE. Cette chaîne est la valeur du `code_verifier` paramètre que vous soumettrez dans votre demande au[Point de terminaison de jeton](token-endpoint.md).
1. Hachez la `code_verifier` chaîne avec l' SHA256 algorithme. Codez le résultat de l'opération de hachage en base64. Cette chaîne est la valeur du `code_challenge` paramètre que vous soumettrez dans votre demande au[Point de terminaison d’autorisation](authorization-endpoint.md).
L'Pythonexemple suivant génère un `code_verifier` et calcule le `code_challenge` :
```
#!/usr/bin/env python3
import secrets
from base64 import urlsafe_b64encode
from hashlib import sha256
from string import ascii_letters
from string import digits
# use the secrets module for cryptographically strong random values
alphabet = ascii_letters + digits
code_verifier = ''.join(secrets.choice(alphabet) for _ in range(128))
code_verifier_hash = sha256(code_verifier.encode()).digest()
code_challenge = urlsafe_b64encode(code_verifier_hash).decode().rstrip('=')
print(f"code challenge: {code_challenge}")
print(f"code verifier: {code_verifier}")
```
Voici un exemple de sortie du Python script :
```
code challenge: Eh0mg-OZv7BAyo-tdv_vYamx1boOYDulDklyXoMDtLg
code verifier: 9D-aW_iygXrgQcWJd0y0tNVMPSXSChIc2xceDhvYVdGLCBk-JWFTmBNjvKSdOrjTTYazOFbUmrFERrjWx6oKtK2b6z_x4_gHBDlr4K1mRFGyE8yA-05-_v7Dxf3EIYJH
```
1. Ouvrez une session de connexion gérée complète avec une demande d'octroi de code d'autorisation auprès de PKCE. Voici un exemple d'URL :
```
https://mydomain.auth.us-east-1.amazoncognito.com/oauth2/authorize?response_type=code&client_id=1example23456789&redirect_uri=https://www.example.com&code_challenge=Eh0mg-OZv7BAyo-tdv_vYamx1boOYDulDklyXoMDtLg&code_challenge_method=S256
```
1. Collectez l'autorisation `code` et échangez-la contre des jetons avec le point de terminaison du jeton. Voici un exemple de demande :
```
POST /oauth2/token HTTP/1.1
Host: mydomain.auth.us-east-1.amazoncognito.com
Content-Type: application/x-www-form-urlencoded
Content-Length: 296
redirect_uri=https%3A%2F%2Fwww.example.com&
client_id=1example23456789&
code=7378f445-c87f-400c-855e-0297d072ff03&
grant_type=authorization_code&
code_verifier=9D-aW_iygXrgQcWJd0y0tNVMPSXSChIc2xceDhvYVdGLCBk-JWFTmBNjvKSdOrjTTYazOFbUmrFERrjWx6oKtK2b6z_x4_gHBDlr4K1mRFGyE8yA-05-_v7Dxf3EIYJH
```
1. Passez en revue la réponse. Il contiendra des jetons d'identification, d'accès et d'actualisation. Pour plus d'informations sur l'utilisation des jetons du pool d'utilisateurs Amazon Cognito, consultez. [Comprendre les jetons Web JSON du pool d'utilisateurs (JWTs)](amazon-cognito-user-pools-using-tokens-with-identity-providers.md)