Déclencheurs Lambda création d'une stimulation d'authentification personnalisée - Amazon Cognito
Authentification SRP

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/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

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

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

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

Pour plus d'informations sur la mise en œuvre de l'authentification personnalisée, voir Flux d'authentification personnalisé et stimulations

Authentification entre les opérations d'API InitiateAuthou AdminInitiateAuth, et RespondToAuthChallengeou AdminRespondToAuthChallenge. 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 revientIssueTokens.

Rubriques

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 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.

  2. 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.

  3. Après réception de ces entrées, votre fonction Lambda répond avec challengeName: PASSWORD_VERIFIER, issueTokens: false, failAuthentication: false.

  4. 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.

  5. 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.

  6. 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 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 à un NEW_PASSWORD_REQUIRED défi avec unNEW_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, voirExemple de définition de la stimulation d'authentification.

É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 inclureCHALLENGE_NAME: SRP_A, et les valeurs pour SRP_A etUSERNAME.

  2. 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.

  3. Après réception de ces entrées, votre fonction Lambda répond avec challengeName: PASSWORD_VERIFIER, issueTokens: false, failAuthentication: false.

  4. 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.

  5. 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

  2. session[1]- PASSWORD_VERIFIER résultat

  3. session[2]- NEW_PASSWORD_REQUIRED résultat

  4. É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]"
    }
}

  2. InitiateAuth réponse

    {
    "ChallengeName": "PASSWORD_VERIFIER",
    "ChallengeParameters": {
        "USER_ID_FOR_SRP": "testuser"
    },
    "Session": "[session_id_1]"
}

  3. 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]"
}

  4. RespondToAuthChallenge réponse avec NEW_PASSWORD_REQUIRED défi

    {
    "ChallengeName": "NEW_PASSWORD_REQUIRED",
    "ChallengeParameters": {},
    "Session": "[session_id_2]"
}

  5. RespondToAuthChallenge demande auprès de NEW_PASSWORD_REQUIRED

    {
    "ChallengeName": "NEW_PASSWORD_REQUIRED",
    "ClientId": "1example23456789",
    "ChallengeResponses": {
        "NEW_PASSWORD": "[password]",
        "USERNAME": "testuser"
    },
    "Session": "[session_id_2]"
}

  6. RespondToAuthChallenge réponse avec un défi personnalisé CAPTCHA

    {
    "ChallengeName": "CUSTOM_CHALLENGE",
    "ChallengeParameters": {
        "captchaUrl": "url/123.jpg"
    },
    "Session": "[session_id_3]"
}

  7. 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": {}
}