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.
# Déclencheurs Lambda création d'une stimulation d'authentification personnalisée
Au fur et à mesure que vous développez vos flux d'authentification pour votre groupe d'utilisateurs Amazon Cognito, vous souhaiterez peut-être étendre votre modèle d'authentification au-delà des flux intégrés. L'un des cas d'utilisation courants des déclencheurs de défi personnalisés consiste à mettre en œuvre des contrôles de sécurité supplémentaires au-delà du nom d'utilisateur, du mot de passe et de l'authentification multifactorielle (MFA). Un défi personnalisé est une question et une réponse que vous pouvez générer dans un langage de programmation compatible avec Lambda. Par exemple, vous pouvez demander aux utilisateurs de résoudre un CAPTCHA ou de répondre à une question de sécurité avant d'être autorisés à s'authentifier. Un autre besoin potentiel est l'intégration de facteurs ou de dispositifs d'authentification spécialisés. Vous avez peut-être déjà développé un logiciel qui authentifie les utilisateurs à l'aide d'une clé de sécurité matérielle ou d'un dispositif biométrique. La réussite de l'authentification pour un défi personnalisé se définit par la réponse que votre fonction Lambda considère comme correcte : une chaîne fixe, par exemple, ou une réponse satisfaisante d'une API externe.
Vous pouvez démarrer l'authentification avec votre défi personnalisé et contrôler entièrement le processus d'authentification, ou vous pouvez effectuer une authentification par nom d'utilisateur et mot de passe avant que votre application ne reçoive votre défi personnalisé.
Le déclencheur Lambda du défi d'authentification personnalisé :
**[Définit](user-pool-lambda-define-auth-challenge.md)**
Lance une séquence de défis. Détermine si vous souhaitez lancer un nouveau défi, marquer l'authentification comme terminée ou arrêter la tentative d'authentification.
**[Crée](user-pool-lambda-create-auth-challenge.md)**
Envoie la question à votre application à laquelle l'utilisateur doit répondre. Cette fonction peut présenter une question de sécurité ou un lien vers un CAPTCHA que votre application doit afficher à l'utilisateur.
**[Vérifie](user-pool-lambda-verify-auth-challenge-response.md)**
Connaît la réponse attendue et la compare à la réponse fournie par votre application dans la réponse au défi. La fonction peut appeler l'API de votre service CAPTCHA pour récupérer les résultats attendus de la tentative de solution de votre utilisateur.
Ces trois fonctions Lambda s'enchaînent pour présenter un mécanisme d'authentification entièrement sous votre contrôle et conçu par vous-même. Comme l'authentification personnalisée nécessite une logique d'application dans votre client et dans les fonctions Lambda, vous ne pouvez pas traiter l'authentification personnalisée dans le cadre d'une connexion gérée. Ce système d'authentification nécessite des efforts supplémentaires de la part des développeurs. Votre application doit exécuter le flux d'authentification avec l'API des groupes d'utilisateurs et gérer le défi qui en résulte à l'aide d'une interface de connexion personnalisée qui place la question au centre du défi d'authentification personnalisé.
![\[Déclencheurs Lambda de stimulation\]](http://docs.aws.amazon.com/fr_fr/cognito/latest/developerguide/images/lambda-challenges.png)
Pour plus d'informations sur la mise en œuvre de l'authentification personnalisée, voir [Flux d'authentification personnalisé et stimulations](amazon-cognito-user-pools-authentication-flow-methods.md#Custom-authentication-flow-and-challenges)
Authentification entre les opérations d'API [InitiateAuth](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_InitiateAuth.html)ou [AdminInitiateAuth](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminInitiateAuth.html), et [RespondToAuthChallenge](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_RespondToAuthChallenge.html)ou [AdminRespondToAuthChallenge](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminRespondToAuthChallenge.html). Dans ce flux, un utilisateur s'authentifie en répondant à des défis successifs jusqu'à ce que l'authentification échoue ou que l'utilisateur reçoive les jetons. Une réponse à un défi peut être un nouveau défi. Dans ce cas, votre candidature répond autant de fois que nécessaire aux nouveaux défis. Une authentification réussie se produit lorsque la fonction de défi define auth analyse les résultats obtenus jusqu'à présent, détermine que tous les défis ont été résolus et revient`IssueTokens`.
**Topics**
+ [Authentification SRP dans les flux de défis personnalisés](#user-pool-lambda-challenge-srp-authentication)
+ [Déclencheur Lambda Définition d'une stimulation d'authentification](user-pool-lambda-define-auth-challenge.md)
+ [Déclencheur Lambda création d'une stimulation d'authentification](user-pool-lambda-create-auth-challenge.md)
+ [Déclencheur Lambda Vérification de la réponse à la stimulation d'authentification](user-pool-lambda-verify-auth-challenge-response.md)
## Authentification SRP dans les flux de défis personnalisés
Vous pouvez demander à Amazon Cognito de vérifier les mots de passe utilisateur avant d'émettre vos stimulations personnalisées. Tous les déclencheurs Lambda associés à la catégorie Authentification des [quotas de taux de demande](quotas.md#category_operations.title) s'exécutent lorsque vous effectuez une authentification SRP dans un flux de stimulation personnalisé. Voici un aperçu du processus :
1. Votre application initie la connexion en appelant `InitiateAuth` ou `AdminInitiateAuth` avec le mappage `AuthParameters`. Les paramètres doivent inclure `CHALLENGE_NAME: SRP_A,` et les valeurs pour `SRP_A` et `USERNAME`.
1. Amazon Cognito appelle votre déclencheur Lambda Définition de la question de sécurité d'authentification avec une session initiale qui contient `challengeName: SRP_A` et `challengeResult: true`.
1. Après réception de ces entrées, votre fonction Lambda répond avec `challengeName: PASSWORD_VERIFIER`, `issueTokens: false`, `failAuthentication: false`.
1. Si la vérification du mot de passe réussit, Amazon Cognito appelle votre fonction Lambda à nouveau avec une nouvelle session contenant `challengeName: PASSWORD_VERIFIER` et `challengeResult: true`.
1. Pour initier vos demandes de vérification personnalisées, votre fonction Lambda répond avec `challengeName: CUSTOM_CHALLENGE`, `issueTokens: false` et `failAuthentication: false`. Si vous ne souhaitez pas démarrer votre flux d'authentification personnalisé avec la vérification du mot de passe, vous pouvez initier une connexion avec le mappage `AuthParameters` en incluant `CHALLENGE_NAME: CUSTOM_CHALLENGE`.
1. La boucle de stimulation se répète jusqu'à ce que toutes les réponses soient apportées à la stimulation.
Voici un exemple de `InitiateAuth` demande de démarrage qui précède l'authentification personnalisée par un flux SRP.
```
{
"AuthFlow": "CUSTOM_AUTH",
"ClientId": "1example23456789",
"AuthParameters": {
"CHALLENGE_NAME": "SRP_A",
"USERNAME": "testuser",
"SRP_A": "[SRP_A]",
"SECRET_HASH": "[secret hash]"
}
}
```
### Réinitialisation du mot de passe dans le flux SRP d'authentification personnalisé
Lorsque les utilisateurs ont un `FORCE_CHANGE_PASSWORD` statut, votre flux d'authentification personnalisé doit intégrer l'étape de changement de mot de passe tout en préservant l'intégrité de vos défis d'authentification. Amazon Cognito invoque le déclencheur Lambda de votre [défi de définition](user-pool-lambda-define-auth-challenge.md) d'authentification pendant le défi. `NEW_PASSWORD_REQUIRED` Dans ce scénario, un utilisateur qui se connecte à l'aide d'un flux de défi personnalisé et d'une authentification SRP peut définir un nouveau mot de passe s'il est en état de réinitialisation du mot de passe.
Lorsque les utilisateurs ont le `FORCE_CHANGE_PASSWORD` statut `RESET_REQUIRED` ou, ils doivent [répondre](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_RespondToAuthChallenge.html#API_RespondToAuthChallenge_RequestParameters) à un `NEW_PASSWORD_REQUIRED` défi avec un`NEW_PASSWORD`. Dans le cadre de l'authentification personnalisée avec SRP, Amazon Cognito renvoie `NEW_PASSWORD_REQUIRED` un défi une fois que les utilisateurs ont terminé le `PASSWORD_VERIFIER` défi SRP. Votre déclencheur de défi d'authentification reçoit les deux résultats du défi dans le `session` tableau et peut procéder à des défis personnalisés supplémentaires une fois que l'utilisateur a correctement modifié son mot de passe.
Votre déclencheur Lambda de définition du défi d'authentification doit gérer la séquence de défis par le biais de l'authentification SRP, de la réinitialisation du mot de passe et des défis personnalisés ultérieurs. Le déclencheur reçoit un ensemble de défis terminés dans le `session` paramètre, y compris les deux `PASSWORD_VERIFIER` et les `NEW_PASSWORD_REQUIRED` résultats. Pour un exemple de mise en œuvre, voir[Exemple de définition de la stimulation d'authentification](user-pool-lambda-define-auth-challenge.md#aws-lambda-triggers-define-auth-challenge-example).
#### Étapes du flux d'authentification
Pour les utilisateurs qui doivent vérifier leur mot de passe avant de procéder à des contestations personnalisées, le processus suit les étapes suivantes :
1. Votre application initie la connexion en appelant `InitiateAuth` ou `AdminInitiateAuth` avec le mappage `AuthParameters`. Les paramètres doivent inclure`CHALLENGE_NAME: SRP_A`, et les valeurs pour `SRP_A` et`USERNAME`.
1. Amazon Cognito appelle votre déclencheur Lambda Définition de la question de sécurité d'authentification avec une session initiale qui contient `challengeName: SRP_A` et `challengeResult: true`.
1. Après réception de ces entrées, votre fonction Lambda répond avec `challengeName: PASSWORD_VERIFIER`, `issueTokens: false`, `failAuthentication: false`.
1. Si la vérification du mot de passe réussit, l'une des deux choses suivantes se produit :
**Pour les utilisateurs en état normal :**
Amazon Cognito invoque à nouveau votre fonction Lambda avec une nouvelle session contenant et. `challengeName: PASSWORD_VERIFIER` `challengeResult: true`
Pour initier vos demandes de vérification personnalisées, votre fonction Lambda répond avec `challengeName: CUSTOM_CHALLENGE`, `issueTokens: false` et `failAuthentication: false`.
**Pour les utilisateurs ayant un `FORCE_CHANGE_PASSWORD` statut `RESET_REQUIRED` ou un statut :**
Amazon Cognito invoque votre fonction Lambda avec une session contenant et. `challengeName: PASSWORD_VERIFIER` `challengeResult: true`
Votre fonction Lambda doit répondre avec `challengeName: NEW_PASSWORD_REQUIRED`, `issueTokens: false` et `failAuthentication: false`.
Une fois le changement de mot de passe réussi, Amazon Cognito appelle votre fonction Lambda avec une session contenant à la fois les résultats et. `PASSWORD_VERIFIER` `NEW_PASSWORD_REQUIRED`
Pour initier vos demandes de vérification personnalisées, votre fonction Lambda répond avec `challengeName: CUSTOM_CHALLENGE`, `issueTokens: false` et `failAuthentication: false`.
1. La boucle de stimulation se répète jusqu'à ce que toutes les réponses soient apportées à la stimulation.
Si vous ne souhaitez pas démarrer votre flux d'authentification personnalisé avec la vérification du mot de passe, vous pouvez initier une connexion avec le mappage `AuthParameters` en incluant `CHALLENGE_NAME: CUSTOM_CHALLENGE`.
#### Gestion de session
Le flux d'authentification assure la continuité des sessions grâce à une série de résultats de sessions IDs et de défis. Chaque réponse au défi génère un nouvel identifiant de session pour éviter les erreurs de réutilisation de session, ce qui est particulièrement important pour les flux d'authentification multifactoriels.
Les résultats du défi sont stockés chronologiquement dans le tableau de sessions que reçoivent vos déclencheurs Lambda. Pour les utilisateurs en `FORCE_CHANGE_PASSWORD` statut, le tableau de sessions contient :
1. `session[0]`- `SRP_A` Défi initial
1. `session[1]`- `PASSWORD_VERIFIER` résultat
1. `session[2]`- `NEW_PASSWORD_REQUIRED` résultat
1. Éléments suivants - Résultats des défis personnalisés supplémentaires
#### Exemple de flux d'authentification
L'exemple suivant illustre un flux d'authentification personnalisé complet pour un utilisateur en `FORCE_CHANGE_PASSWORD` statut qui doit effectuer à la fois le changement de mot de passe et un défi CAPTCHA personnalisé.
1. **InitiateAuth demande**
```
{
"AuthFlow": "CUSTOM_AUTH",
"ClientId": "1example23456789",
"AuthParameters": {
"CHALLENGE_NAME": "SRP_A",
"USERNAME": "testuser",
"SRP_A": "[SRP_A]"
}
}
```
1. **InitiateAuth réponse**
```
{
"ChallengeName": "PASSWORD_VERIFIER",
"ChallengeParameters": {
"USER_ID_FOR_SRP": "testuser"
},
"Session": "[session_id_1]"
}
```
1. **RespondToAuthChallenge demande auprès de `PASSWORD_VERIFIER`**
```
{
"ChallengeName": "PASSWORD_VERIFIER",
"ClientId": "1example23456789",
"ChallengeResponses": {
"PASSWORD_CLAIM_SIGNATURE": "[claim_signature]",
"PASSWORD_CLAIM_SECRET_BLOCK": "[secret_block]",
"TIMESTAMP": "[timestamp]",
"USERNAME": "testuser"
},
"Session": "[session_id_1]"
}
```
1. **RespondToAuthChallenge réponse avec `NEW_PASSWORD_REQUIRED` défi**
```
{
"ChallengeName": "NEW_PASSWORD_REQUIRED",
"ChallengeParameters": {},
"Session": "[session_id_2]"
}
```
1. **RespondToAuthChallenge demande auprès de `NEW_PASSWORD_REQUIRED`**
```
{
"ChallengeName": "NEW_PASSWORD_REQUIRED",
"ClientId": "1example23456789",
"ChallengeResponses": {
"NEW_PASSWORD": "[password]",
"USERNAME": "testuser"
},
"Session": "[session_id_2]"
}
```
1. **RespondToAuthChallenge réponse avec un défi personnalisé CAPTCHA**
```
{
"ChallengeName": "CUSTOM_CHALLENGE",
"ChallengeParameters": {
"captchaUrl": "url/123.jpg"
},
"Session": "[session_id_3]"
}
```
1. **RespondToAuthChallenge demande avec réponse au défi personnalisé CAPTCHA**
```
{
"ChallengeName": "CUSTOM_CHALLENGE",
"ClientId": "1example23456789",
"ChallengeResponses": {
"ANSWER": "123",
"USERNAME": "testuser"
},
"Session": "[session_id_3]"
}
```
**6. Réponse finale concernant le succès**
```
{
"AuthenticationResult": {
"AccessToken": "eyJra456defEXAMPLE",
"ExpiresIn": 3600,
"IdToken": "eyJra789ghiEXAMPLE",
"RefreshToken": "eyJjd123abcEXAMPLE",
"TokenType": "Bearer"
},
"ChallengeParameters": {}
}
```
# Déclencheur Lambda Définition d'une stimulation d'authentification
Le déclencheur de défi define auth est une fonction Lambda qui gère la séquence de défi dans un flux d'authentification personnalisé. Il déclare le succès ou l'échec de la séquence de défis et définit le défi suivant si la séquence n'est pas encore terminée.
![\[Déclencheurs Lambda de stimulation\]](http://docs.aws.amazon.com/fr_fr/cognito/latest/developerguide/images/lambda-challenges1.png)
**Définir le défi d'authentification**
Amazon Cognito appelle ce déclencheur pour initier le [flux d'authentification personnalisé](https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-authentication-flow.html#amazon-cognito-user-pools-custom-authentication-flow).
La demande de ce déclencheur Lambda contient `session`. Le paramètre `session` est un tableau contenant toutes les demandes de vérification présentées à l'utilisateur dans le processus d'authentification en cours. La demande inclut également le résultat correspondant. Le tableau `session` stocke les détails des demandes de vérification (`ChallengeResult`) dans l'ordre chronologique. La demande de vérification `session[0]` représente la première demande de vérification que l'utilisateur reçoit.
**Topics**
+ [Paramètres du déclencheur Lambda Définition d'une stimulation d'authentification](#cognito-user-pools-lambda-trigger-syntax-define-auth-challenge)
+ [Exemple de définition de la stimulation d'authentification](#aws-lambda-triggers-define-auth-challenge-example)
## Paramètres du déclencheur Lambda Définition d'une stimulation d'authentification
La demande qu’Amazon Cognito transmet à cette fonction Lambda est une combinaison des paramètres ci-dessous et des [paramètres courants](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-working-with-lambda-triggers.html#cognito-user-pools-lambda-trigger-syntax-shared) qu’Amazon Cognito ajoute à toutes les demandes.
------
#### [ JSON ]
```
{
"request": {
"userAttributes": {
"string": "string",
. . .
},
"session": [
ChallengeResult,
. . .
],
"clientMetadata": {
"string": "string",
. . .
},
"userNotFound": boolean
},
"response": {
"challengeName": "string",
"issueTokens": boolean,
"failAuthentication": boolean
}
}
```
------
### Paramètres de demande de définition de la stimulation d'authentification
Quand Amazon Cognito appelle votre fonction Lambda, Amazon Cognito fournit les paramètres suivants :
**userAttributes**
Une ou plusieurs paires nom-valeur représentant les attributs utilisateur.
**userNotFound**
Booléen renseigné par Amazon Cognito quand `PreventUserExistenceErrors` est défini sur `ENABLED` pour votre client de groupe d'utilisateurs. Une valeur `true` signifie que l'ID utilisateur (nom d'utilisateur, adresse e-mail, etc.) ne correspond à aucun utilisateur existant. Quand `PreventUserExistenceErrors` a pour valeur `ENABLED`, le service n'informe pas l'application des utilisateurs inexistants. Nous vous recommandons de faire en sorte que vos fonctions Lambda conservent la même expérience utilisateur et tiennent compte de la latence. De cette façon, l'appelant ne peut pas détecter un comportement différent quand l'utilisateur existe ou n'existe pas.
**séance**
Tableau d'éléments `ChallengeResult`. Chacun contient les éléments suivants :
**challengeName**
L'un des types de défis suivants : `CUSTOM_CHALLENGE``SRP_A`,`PASSWORD_VERIFIER`,`SMS_MFA`,`EMAIL_OTP`,`SOFTWARE_TOKEN_MFA`,`DEVICE_SRP_AUTH`,`DEVICE_PASSWORD_VERIFIER`, ou`ADMIN_NO_SRP_AUTH`.
Lorsque votre fonction de définition du défi d'authentification lance un `PASSWORD_VERIFIER` défi à un utilisateur qui a configuré l'authentification multifactorielle, Amazon Cognito lance ensuite `SMS_MFA` un défi`EMAIL_OTP`, ou. `SOFTWARE_TOKEN_MFA` Voici les instructions pour saisir un code d'authentification multifactoriel. Dans votre fonction, incluez la gestion des événements d'entrée provenant de `SMS_MFA``EMAIL_OTP`, et des `SOFTWARE_TOKEN_MFA` défis. Vous n'avez pas besoin d'invoquer de défis MFA dans votre fonction de définition du défi d'authentification.
Quand votre fonction détermine si un utilisateur s'est authentifié correctement et doit recevoir des jetons, vérifiez toujours `challengeName` dans votre fonction de définition de la stimulation d'authentification et s'il correspond à la valeur attendue.
**challengeResult**
Défini sur `true` si l'utilisateur a répondu à la demande de vérification avec succès, ou sur `false` dans le cas contraire.
**challengeMetadata**
Votre nom pour la demande de vérification personnalisée. Utilisé uniquement si `challengeName` est `CUSTOM_CHALLENGE`.
**clientMetadata**
Une ou plusieurs paires clé-valeur que vous pouvez fournir en tant qu'entrée personnalisée à la fonction Lambda que vous spécifiez pour le déclencheur Définition d'une stimulation d'authentification. Pour transmettre ces données à votre fonction Lambda, vous pouvez utiliser le `ClientMetadata` paramètre dans les opérations [AdminRespondToAuthChallenge](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminRespondToAuthChallenge.html)et [RespondToAuthChallenge](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_RespondToAuthChallenge.html)API. La demande qui invoque la fonction de défi define auth n'inclut pas les données transmises dans le ClientMetadata paramètre ni dans les opérations [AdminInitiateAuth](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminInitiateAuth.html)d'[InitiateAuth](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_InitiateAuth.html)API.
### Paramètres de réponse de définition de la stimulation d'authentification
Dans la réponse, vous pouvez renvoyer l'étape suivante du processus d'authentification.
**challengeName**
Chaîne contenant le nom de la prochaine demande de vérification. Si vous souhaitez présenter une nouvelle demande de vérification pour votre utilisateur, spécifiez ici son nom.
**issueTokens**
Si vous déterminez que l'utilisateur a suffisamment répondu aux demandes de vérification d'authentification, définissez la valeur `true`. Si l'utilisateur n'a pas suffisamment répondu aux demandes de vérification, définissez la valeur `false`.
**failAuthentication**
Si vous souhaitez mettre fin au processus d'authentification actuel, définissez la valeur `true`. Pour poursuivre le processus d'authentification actuel, définissez la valeur `false`.
## Exemple de définition de la stimulation d'authentification
Cet exemple définit une série de demandes de vérification d'authentification et émet des jetons seulement si l'utilisateur répond avec succès à toutes les demandes de vérification. Lorsque les utilisateurs terminent l'authentification SRP avec les `PASSWORD_VERIFIER` défis `SRP_A` and, cette fonction leur transmet un `CUSTOM_CHALLENGE` qui invoque le déclencheur du défi create auth. En combinaison avec notre [exemple de défi de création d'authentification](user-pool-lambda-create-auth-challenge.md#aws-lambda-triggers-create-auth-challenge-example), cette séquence fournit un défi CAPTCHA pour le défi 3 et une question de sécurité pour le défi 4.
Une fois que l'utilisateur a résolu le CAPTCHA et répondu à la question de sécurité, cette fonction confirme que votre groupe d'utilisateurs peut émettre des jetons. L'authentification SRP n'est pas requise ; vous pouvez également définir le CAPTCHA et la question de sécurité comme défis 1 et 2. Dans le cas où votre fonction de définition du défi d'authentification ne déclare pas les défis SRP, le succès de vos utilisateurs est entièrement déterminé par leurs réponses à vos demandes personnalisées.
------
#### [ Node.js ]
```
const handler = async (event) => {
if (
event.request.session.length === 1 &&
event.request.session[0].challengeName === "SRP_A"
) {
event.response.issueTokens = false;
event.response.failAuthentication = false;
event.response.challengeName = "PASSWORD_VERIFIER";
} else if (
event.request.session.length === 2 &&
event.request.session[1].challengeName === "PASSWORD_VERIFIER" &&
event.request.session[1].challengeResult === true
) {
event.response.issueTokens = false;
event.response.failAuthentication = false;
event.response.challengeName = "CUSTOM_CHALLENGE";
} else if (
event.request.session.length === 3 &&
event.request.session[2].challengeName === "CUSTOM_CHALLENGE" &&
event.request.session[2].challengeResult === true
) {
event.response.issueTokens = false;
event.response.failAuthentication = false;
event.response.challengeName = "CUSTOM_CHALLENGE";
} else if (
event.request.session.length === 4 &&
event.request.session[3].challengeName === "CUSTOM_CHALLENGE" &&
event.request.session[3].challengeResult === true
) {
event.response.issueTokens = true;
event.response.failAuthentication = false;
} else {
event.response.issueTokens = false;
event.response.failAuthentication = true;
}
return event;
};
export { handler };
```
------
# Déclencheur Lambda création d'une stimulation d'authentification
Le déclencheur de défi create auth est une fonction Lambda qui contient les détails de chaque défi déclaré par le déclencheur de défi define auth. Il traite le nom du défi déclaré par le déclencheur du défi define auth et renvoie un `publicChallengeParameters` que votre application doit présenter à l'utilisateur. Cette fonction fournit ensuite à votre groupe d'utilisateurs la réponse au défi`privateChallengeParameters`, que votre groupe d'utilisateurs transmet au déclencheur du défi de vérification de l'authentification. Là où votre déclencheur de défi d'authentification gère la séquence de défis, votre déclencheur de défi de création d'authentification gère le contenu du défi.
![\[Déclencheurs Lambda de stimulation\]](http://docs.aws.amazon.com/fr_fr/cognito/latest/developerguide/images/lambda-challenges2.png)
**Créer un défi d'authentification**
Amazon Cognito appelle ce déclencheur après la **Définition d'une stimulation d'authentification** si une stimulation personnalisée a été spécifiée dans le déclencheur **Définition d'une stimulation d'authentification**. Il crée un [flux d'authentification personnalisé](https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-authentication-flow.html#amazon-cognito-user-pools-custom-authentication-flow).
Ce déclencheur Lambda est appelé pour créer une stimulation à présenter à l'utilisateur. La demande de ce déclencheur Lambda inclut les paramètres `challengeName` et `session`. `challengeName` est une chaîne et constitue le nom de la prochaine demande de vérification pour l'utilisateur. La valeur de cet attribut est définie dans le déclencheur Lambda Définition d'une stimulation d'authentification.
La boucle de stimulation se répète jusqu'à ce que toutes les réponses soient apportées à la stimulation.
**Topics**
+ [Paramètres du déclencheur Lambda création d'une stimulation d'authentification](#cognito-user-pools-lambda-trigger-syntax-create-auth-challenge)
+ [Exemple de création d'une stimulation d'authentification](#aws-lambda-triggers-create-auth-challenge-example)
## Paramètres du déclencheur Lambda création d'une stimulation d'authentification
La demande qu'Amazon Cognito transmet à cette fonction Lambda est une combinaison des paramètres ci-dessous et des [paramètres courants](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-working-with-lambda-triggers.html#cognito-user-pools-lambda-trigger-syntax-shared) qu'Amazon Cognito ajoute à toutes les demandes.
------
#### [ JSON ]
```
{
"request": {
"userAttributes": {
"string": "string",
. . .
},
"challengeName": "string",
"session": [
ChallengeResult,
. . .
],
"clientMetadata": {
"string": "string",
. . .
},
"userNotFound": boolean
},
"response": {
"publicChallengeParameters": {
"string": "string",
. . .
},
"privateChallengeParameters": {
"string": "string",
. . .
},
"challengeMetadata": "string"
}
}
```
------
### Paramètres de demande de création d'une stimulation d'authentification
**userAttributes**
Une ou plusieurs paires nom-valeur représentant des attributs utilisateur.
**userNotFound**
Cette valeur booléenne est utilisée lorsque `PreventUserExistenceErrors` est défini sur `ENABLED` pour votre client de groupe d'utilisateurs.
**challengeName**
Nom de la nouvelle demande de vérification.
**séance**
L'élément session est un tableau d'éléments `ChallengeResult`, chacun d'entre eux contenant les éléments suivants :
**challengeName**
Type de demande de vérification. L'un des suivants : `"CUSTOM_CHALLENGE"``"PASSWORD_VERIFIER"`,`"SMS_MFA"`,`"DEVICE_SRP_AUTH"`,`"DEVICE_PASSWORD_VERIFIER"`,`"NEW_PASSWORD_REQUIRED"`, ou`"ADMIN_NO_SRP_AUTH"`.
**challengeResult**
Défini sur `true` si l'utilisateur a répondu à la demande de vérification avec succès, ou sur `false` dans le cas contraire.
**challengeMetadata**
Votre nom pour la demande de vérification personnalisée. Utilisé uniquement si `challengeName` est `"CUSTOM_CHALLENGE"`.
**clientMetadata**
Une ou plusieurs paires clé-valeur que vous pouvez fournir en tant qu'entrée personnalisée à la fonction Lambda que vous spécifiez pour le déclencheur Création d'une stimulation d'authentification. Vous pouvez utiliser le ClientMetadata paramètre dans les actions [AdminRespondToAuthChallenge](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminRespondToAuthChallenge.html)et [RespondToAuthChallenge](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_RespondToAuthChallenge.html)API pour transmettre ces données à votre fonction Lambda. La demande qui invoque la fonction de défi create auth n'inclut pas les données transmises dans le ClientMetadata paramètre ni dans les opérations [AdminInitiateAuth](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminInitiateAuth.html)d'[InitiateAuth](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_InitiateAuth.html)API.
### Paramètres de réponse de création d'une stimulation d'authentification
**publicChallengeParameters**
Une ou plusieurs paires clé-valeur que l'application client doit utiliser dans la demande de vérification à présenter à l'utilisateur. Ce paramètre doit contenir toutes les informations nécessaires pour présenter avec précision la demande de vérification à l'utilisateur.
**privateChallengeParameters**
Ce paramètre est utilisé uniquement par le déclencheur Lambda Vérification de la réponse à la stimulation d'authentification. Ce paramètre doit contenir toutes les informations qui sont nécessaire pour valider la réponse de l'utilisateur à la demande de vérification. En d'autres termes, le paramètre `publicChallengeParameters` contient la question qui est posée à l'utilisateur et `privateChallengeParameters` contient les réponses valides pour la question.
**challengeMetadata**
Votre nom pour la demande de vérification personnalisée, s'il s'agit d'une demande de vérification personnalisée.
## Exemple de création d'une stimulation d'authentification
Cette fonction comporte deux défis personnalisés qui correspondent à la séquence de défis décrite dans notre [exemple de défi de définition de l'authentification](user-pool-lambda-define-auth-challenge.md#aws-lambda-triggers-define-auth-challenge-example). Les deux premiers défis sont l'authentification SRP. Pour le troisième défi, cette fonction renvoie une URL CAPTCHA à votre application dans la réponse au défi. Votre application affiche le CAPTCHA à l'URL donnée et renvoie les données saisies par l'utilisateur. L'URL de l'image CAPTCHA est ajoutée aux paramètres de demande de vérification publics sous la forme « `captchaUrl` », et la réponse attendue est ajoutée aux paramètres de demande de vérification privés.
Pour le quatrième défi, cette fonction renvoie une question de sécurité. Votre application affiche la question et invite l'utilisateur à y répondre. Une fois que les utilisateurs ont résolu les deux défis personnalisés, le déclencheur du défi de définition de l'authentification confirme que votre groupe d'utilisateurs peut émettre des jetons.
------
#### [ Node.js ]
```
const handler = async (event) => {
if (event.request.challengeName !== "CUSTOM_CHALLENGE") {
return event;
}
if (event.request.session.length === 2) {
event.response.publicChallengeParameters = {};
event.response.privateChallengeParameters = {};
event.response.publicChallengeParameters.captchaUrl = "url/123.jpg";
event.response.privateChallengeParameters.answer = "5";
}
if (event.request.session.length === 3) {
event.response.publicChallengeParameters = {};
event.response.privateChallengeParameters = {};
event.response.publicChallengeParameters.securityQuestion =
"Who is your favorite team mascot?";
event.response.privateChallengeParameters.answer = "Peccy";
}
return event;
};
export { handler };
```
------
# Déclencheur Lambda Vérification de la réponse à la stimulation d'authentification
Le déclencheur du défi Verify Auth est une fonction Lambda qui compare la réponse fournie par un utilisateur à une réponse connue. Cette fonction indique à votre groupe d'utilisateurs si l'utilisateur a répondu correctement au défi. Lorsque le déclencheur du défi de vérification de l'authentification répond par un « `answerCorrect` of »`true`, la séquence d'authentification peut se poursuivre.
![\[Déclencheurs Lambda de stimulation\]](http://docs.aws.amazon.com/fr_fr/cognito/latest/developerguide/images/lambda-challenges3.png)
**Vérifier la réponse au défi d'authentification**
Amazon Cognito appelle ce déclencheur pour vérifier si la réponse de l'utilisateur à une demande de vérification d'authentification personnalisée est valide ou non. Il fait partie du [flux d'authentification personnalisé](https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-authentication-flow.html#amazon-cognito-user-pools-custom-authentication-flow) d'un groupe d'utilisateurs.
La demande pour ce déclencheur contient les paramètres `privateChallengeParameters` et `challengeAnswer`. Le déclencheur Lambda Création d'une demande de vérification d'authentification renvoie les valeurs de `privateChallengeParameters` et contient la réponse attendue de l'utilisateur. Le paramètre `challengeAnswer` contient la réponse de l'utilisateur pour la demande de vérification.
La réponse contient l'attribut `answerCorrect`. Si l'utilisateur répond à la demande de vérification, Amazon Cognito définit la valeur de l'attribut sur `true`. Si l'utilisateur ne répond pas correctement à la demande de vérification, Amazon Cognito définit la valeur sur `false`.
La boucle de demande de vérification se répète jusqu'à ce que les utilisateurs aient répondu à toutes les demandes de vérification.
**Topics**
+ [Paramètres du déclencheur Lambda Vérification de la réponse à la stimulation d'authentification](#cognito-user-pools-lambda-trigger-syntax-verify-auth-challenge)
+ [Exemple de vérification de la réponse à la stimulation d'authentification](#aws-lambda-triggers-verify-auth-challenge-response-example)
## Paramètres du déclencheur Lambda Vérification de la réponse à la stimulation d'authentification
La demande qu'Amazon Cognito transmet à cette fonction Lambda est une combinaison des paramètres ci-dessous et des [paramètres courants](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-working-with-lambda-triggers.html#cognito-user-pools-lambda-trigger-syntax-shared) qu'Amazon Cognito ajoute à toutes les demandes.
------
#### [ JSON ]
```
{
"request": {
"userAttributes": {
"string": "string",
. . .
},
"privateChallengeParameters": {
"string": "string",
. . .
},
"challengeAnswer": "string",
"clientMetadata": {
"string": "string",
. . .
},
"userNotFound": boolean
},
"response": {
"answerCorrect": boolean
}
}
```
------
### Paramètres de demande de vérification de la réponse à la stimulation d'authentification
**userAttributes**
Ce paramètre contient une ou plusieurs paires nom-valeur représentant les attributs utilisateur.
**userNotFound**
Quand Amazon Cognito définit `PreventUserExistenceErrors` sur `ENABLED` pour votre client de groupe d'utilisateurs, Amazon Cognito renseigne ce booléen.
**privateChallengeParameters**
Ce paramètre provient du déclencheur Création d'une demande de vérification d'authentification. Pour déterminer si l'utilisateur a réussi un défi, Amazon Cognito compare ces paramètres au paramètre **challengeAnswer** d'un utilisateur.
Ce paramètre contient toutes les informations qui sont nécessaires pour valider la réponse de l'utilisateur à la demande de vérification. Ces informations incluent la question posée par Amazon Cognito à l'utilisateur (`publicChallengeParameters`), et les réponses valides à la question (`privateChallengeParameters`). Seul le déclencheur Lambda Vérification de la réponse à la demande de vérification d'authentification utilise ce paramètre.
**challengeAnswer**
La valeur de ce paramètre est la réponse de l'utilisateur à la demande de vérification.
**clientMetadata**
Ce paramètre contient une ou plusieurs paires clé-valeur que vous pouvez fournir en tant qu'entrée personnalisée à la fonction Lambda pour le déclencheur Vérification de la réponse à la demande de vérification d'authentification. Pour transmettre ces données à votre fonction Lambda, utilisez le ClientMetadata paramètre dans les opérations [AdminRespondToAuthChallenge](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminRespondToAuthChallenge.html)et [RespondToAuthChallenge](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_RespondToAuthChallenge.html)API. Amazon Cognito n'inclut pas les données issues du ClientMetadata paramètre [AdminInitiateAuth](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminInitiateAuth.html)et des opérations d'[InitiateAuth](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_InitiateAuth.html)API dans la demande transmise à la fonction de vérification de l'authentification.
### Paramètres de réponse de vérification de la réponse à la stimulation d'authentification
**answerCorrect**
Si l'utilisateur répond à la demande de vérification, Amazon Cognito définit ce paramètre sur `true`. Si l'utilisateur ne répond pas correctement à la demande de vérification, Amazon Cognito définit le paramètre sur `false`.
## Exemple de vérification de la réponse à la stimulation d'authentification
Cette fonction de vérification de l'authentification vérifie si la réponse de l'utilisateur à un défi correspond à la réponse attendue. La réponse de l'utilisateur est définie par les entrées de votre application et la réponse préférée est définie `privateChallengeParameters.answer` dans la réponse du [déclencheur du défi Create Auth](user-pool-lambda-create-auth-challenge.md#aws-lambda-triggers-create-auth-challenge-example). La bonne réponse et la réponse donnée font partie de l'événement d'entrée de cette fonction.
Dans cet exemple, si la réponse de l'utilisateur correspond à la réponse attendue, Amazon Cognito définit le `answerCorrect` paramètre sur. `true`
------
#### [ Node.js ]
```
const handler = async (event) => {
if (
event.request.privateChallengeParameters.answer ===
event.request.challengeAnswer
) {
event.response.answerCorrect = true;
} else {
event.response.answerCorrect = false;
}
return event;
};
export { handler };
```
------