Lambda-Auslöser für benutzerdefinierte Authentifizierungsaufforderungen - Amazon Cognito
SRP-Authentifizierung

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Lambda-Auslöser für benutzerdefinierte Authentifizierungsaufforderungen

Beim Aufbau Ihrer Authentifizierungsabläufe für Ihren Amazon Cognito Cognito-Benutzerpool stellen Sie möglicherweise fest, dass Sie Ihr Authentifizierungsmodell über die integrierten Abläufe hinaus erweitern möchten. Ein häufiger Anwendungsfall für die benutzerdefinierten Challenge-Trigger ist die Implementierung zusätzlicher Sicherheitsüberprüfungen, die über Benutzername, Passwort und Multi-Faktor-Authentifizierung (MFA) hinausgehen. Eine benutzerdefinierte Herausforderung ist jede Frage und Antwort, die Sie in einer von Lambda unterstützten Programmiersprache generieren können. Möglicherweise möchten Sie von Benutzern verlangen, dass sie ein CAPTCHA lösen oder eine Sicherheitsfrage beantworten, bevor sie sich authentifizieren dürfen. Ein weiterer potenzieller Bedarf besteht in der Integration mit speziellen Authentifizierungsfaktoren oder -geräten. Oder Sie haben möglicherweise bereits Software entwickelt, die Benutzer mit einem Hardware-Sicherheitsschlüssel oder einem biometrischen Gerät authentifiziert. Die Definition des Authentifizierungserfolgs für eine benutzerdefinierte Abfrage ist die Antwort, die Ihre Lambda-Funktion als richtig akzeptiert: zum Beispiel eine feste Zeichenfolge oder eine zufriedenstellende Antwort von einer externen API.

Sie können die Authentifizierung mit Ihrer benutzerdefinierten Abfrage beginnen und den Authentifizierungsprozess vollständig kontrollieren, oder Sie können eine Benutzername-Passwort-Authentifizierung durchführen, bevor Ihre Anwendung Ihre benutzerdefinierte Abfrage erhält.

Der Lambda-Trigger für benutzerdefinierte Authentifizierungsherausforderungen:

Definiert

Initiiert eine Challenge-Sequenz. Legt fest, ob Sie eine neue Herausforderung initiieren, die Authentifizierung als abgeschlossen markieren oder den Authentifizierungsversuch beenden möchten.

Erzeugt

Stellt die Frage an Ihre Anwendung, die der Benutzer beantworten muss. Diese Funktion kann eine Sicherheitsfrage oder einen Link zu einem CAPTCHA enthalten, das Ihre Anwendung Ihrem Benutzer anzeigen soll.

Überprüft

Kennt die erwartete Antwort und vergleicht sie mit der Antwort, die Ihre Anwendung in der Challenge-Antwort liefert. Die Funktion ruft möglicherweise die API Ihres CAPTCHA-Dienstes auf, um die erwarteten Ergebnisse des Lösungsversuchs Ihres Benutzers abzurufen.

Diese drei Lambda-Funktionen sind miteinander verknüpft, um einen Authentifizierungsmechanismus zu bieten, den Sie vollständig kontrollieren können und den Sie selbst entworfen haben. Da für die benutzerdefinierte Authentifizierung Anwendungslogik in Ihrem Client und in den Lambda-Funktionen erforderlich ist, können Sie die benutzerdefinierte Authentifizierung nicht innerhalb der verwalteten Anmeldung verarbeiten. Dieses Authentifizierungssystem erfordert zusätzlichen Entwickleraufwand. Ihre Anwendung muss den Authentifizierungsablauf mit der Benutzerpools-API durchführen und die daraus resultierende Herausforderung mit einer maßgeschneiderten Anmeldeschnittstelle bewältigen, die die Frage in den Mittelpunkt der benutzerdefinierten Authentifizierungsherausforderung stellt.

Lambda-Auslöser für Aufforderungen

Weitere Informationen zur Implementierung der benutzerdefinierten Authentifizierung finden Sie unter Benutzerdefinierter Authentifizierungsablauf und Aufforderungen

Authentifizierung zwischen den API-Vorgängen InitiateAuthoder AdminInitiateAuth, und RespondToAuthChallengeoder AdminRespondToAuthChallenge. In diesem Ablauf führt ein Benutzer die Authentifizierung durch Beantwortung aufeinanderfolgender Aufforderungen durch, bis die Authentifizierung entweder fehlschlägt oder Token für den Benutzer ausgestellt werden. Eine Antwort auf eine Herausforderung könnte eine neue Herausforderung sein. In diesem Fall reagiert Ihre Anwendung so oft wie nötig auf neue Herausforderungen. Eine erfolgreiche Authentifizierung erfolgt, wenn die Funktion Define Auth Challenge die bisherigen Ergebnisse analysiert, feststellt, dass alle Challenges beantwortet wurden, und ein Ergebnis zurückgibtIssueTokens.

Themen

SRP-Authentifizierung in benutzerdefinierten Challenge-Flows

Sie können Amazon-Cognito-Benutzerpasswörter überprüfen lassen, bevor es Ihre benutzerdefinierten Herausforderungen ausgibt. Alle Lambda-Trigger, die in der Authentifizierungskategorie Ressourcen- und Anforderungskontingente zugeordnet sind, werden ausgeführt, wenn Sie eine SRP-Authentifizierung in einem benutzerdefinierten Challenge-Flow durchführen. Es folgt eine Übersicht über den Prozess:

  1. Ihre App initiiert die Anmeldung, indem InitiateAuth oder AdminInitiateAuth mit der AuthParameters-Karte aufgerufen werden. Parameter müssen CHALLENGE_NAME: SRP_A, und Werte für SRP_A und USERNAME umfassen.

  2. Amazon Cognito ruft Ihren Lambda-Auslöser „Authentifizierungsaufforderung definieren“ mit einer ersten Sitzung auf, die challengeName: SRP_A und challengeResult: true enthält.

  3. Nachdem Sie diese Eingaben empfangen haben, reagiert Ihre Lambda-Funktion mit challengeName: PASSWORD_VERIFIER, issueTokens: false, failAuthentication: false.

  4. Wenn die Kennwortverifizierung erfolgreich ist, ruft Amazon Cognito Ihre Lambda-Funktion erneut mit einer neuen Sitzung auf, die challengeName: PASSWORD_VERIFIER und challengeResult: true enthält.

  5. Ihre Lambda-Funktion initiiert Ihre benutzerdefinierten Aufforderungen, indem sie mit challengeName: CUSTOM_CHALLENGE, issueTokens: false und failAuthentication: false antwortet. Wenn Sie Ihren benutzerdefinierten Authentifizierungsablauf nicht mit Passwortüberprüfung starten möchten, können Sie die Anmeldung mit der AuthParameters-Karte einschließlich CHALLENGE_NAME: CUSTOM_CHALLENGE initiieren.

  6. Die Aufforderungsschleife wird so lange ausgeführt, bis alle Aufforderungen beantwortet sind.

Im Folgenden finden Sie ein Beispiel für eine InitiateAuth Startanforderung, die der benutzerdefinierten Authentifizierung mit einem SRP-Flow vorausgeht.

{
    "AuthFlow": "CUSTOM_AUTH",
    "ClientId": "1example23456789",
    "AuthParameters": {
        "CHALLENGE_NAME": "SRP_A",
        "USERNAME": "testuser",
        "SRP_A": "[SRP_A]",
        "SECRET_HASH": "[secret hash]"
    }
}

Das Passwort wurde im SRP-Flow für die benutzerdefinierte Authentifizierung zurückgesetzt

Wenn sich Benutzer im FORCE_CHANGE_PASSWORD Status befinden, muss Ihr benutzerdefinierter Authentifizierungsablauf den Schritt zur Passwortänderung integrieren und gleichzeitig die Integrität Ihrer Authentifizierungsherausforderungen wahren. Amazon Cognito ruft während der Herausforderung Ihren Lambda-Trigger für die Definitionsauthentifizierungsherausforderung auf. NEW_PASSWORD_REQUIRED In diesem Szenario kann ein Benutzer, der sich mit einem benutzerdefinierten Challenge-Flow und SRP-Authentifizierung anmeldet, ein neues Passwort festlegen, wenn er sich in einem Zustand befindet, in dem das Passwort zurückgesetzt wurde.

Wenn sich Benutzer im FORCE_CHANGE_PASSWORD Status RESET_REQUIRED oder befinden, müssen sie auf eine Aufforderung mit einem NEW_PASSWORD_REQUIREDantworten. NEW_PASSWORD Bei der benutzerdefinierten Authentifizierung mit SRP gibt Amazon Cognito eine NEW_PASSWORD_REQUIRED Aufforderung zurück, nachdem Benutzer die PASSWORD_VERIFIER SRP-Abfrage abgeschlossen haben. Ihr Trigger zur Definition einer Authentifizierungsabfrage empfängt beide Challenge-Ergebnisse im session Array und kann mit weiteren benutzerdefinierten Abfragen fortfahren, nachdem der Benutzer sein Passwort erfolgreich geändert hat.

Ihr Lambda-Trigger zur Definierung der Authentifizierungsherausforderung muss die Abfragesequenz durch SRP-Authentifizierung, Kennwortrücksetzung und nachfolgende benutzerdefinierte Abfragen verwalten. Der Trigger empfängt eine Reihe abgeschlossener Herausforderungen im session Parameter, einschließlich sowohl PASSWORD_VERIFIER der Ergebnisse als auch der Ergebnisse. NEW_PASSWORD_REQUIRED Eine Beispielimplementierung finden Sie unterBeispiel für „Authentifizierungsaufforderung definieren“.

Schritte des Authentifizierungsablaufs

Für Benutzer, die ihr Passwort vor benutzerdefinierten Herausforderungen verifizieren müssen, folgt der Prozess diesen Schritten:

  1. Ihre App initiiert die Anmeldung, indem InitiateAuth oder AdminInitiateAuth mit der AuthParameters-Karte aufgerufen werden. Die Parameter müssen Folgendes enthalten: CHALLENGE_NAME: SRP_A und Werte für SRP_A undUSERNAME.

  2. Amazon Cognito ruft Ihren Lambda-Auslöser „Authentifizierungsaufforderung definieren“ mit einer ersten Sitzung auf, die challengeName: SRP_A und challengeResult: true enthält.

  3. Nachdem Sie diese Eingaben empfangen haben, reagiert Ihre Lambda-Funktion mit challengeName: PASSWORD_VERIFIER, issueTokens: false, failAuthentication: false.

  4. Wenn die Passwortverifizierung erfolgreich ist, passiert eines von zwei Dingen:

    Für Benutzer mit normalem Status:

    Amazon Cognito ruft Ihre Lambda-Funktion erneut mit einer neuen Sitzung auf, die und enthält. challengeName: PASSWORD_VERIFIER challengeResult: true

    Ihre Lambda-Funktion initiiert Ihre benutzerdefinierten Aufforderungen, indem sie mit challengeName: CUSTOM_CHALLENGE, issueTokens: false und failAuthentication: false antwortet.

    Für Benutzer im Status oderRESET_REQUIRED: FORCE_CHANGE_PASSWORD

    Amazon Cognito ruft Ihre Lambda-Funktion mit einer Sitzung auf, die und enthält. challengeName: PASSWORD_VERIFIER challengeResult: true

    Ihre Lambda-Funktion sollte mit challengeName: NEW_PASSWORD_REQUIRED, issueTokens: false und failAuthentication: false antworten.

    Nach erfolgreicher Kennwortänderung ruft Amazon Cognito Ihre Lambda-Funktion mit einer Sitzung auf, die sowohl die als auch die PASSWORD_VERIFIER Ergebnisse enthält. NEW_PASSWORD_REQUIRED

    Ihre Lambda-Funktion initiiert Ihre benutzerdefinierten Aufforderungen, indem sie mit challengeName: CUSTOM_CHALLENGE, issueTokens: false und failAuthentication: false antwortet.

  5. Die Aufforderungsschleife wird so lange ausgeführt, bis alle Aufforderungen beantwortet sind.

Wenn Sie Ihren benutzerdefinierten Authentifizierungsablauf nicht mit Passwortüberprüfung starten möchten, können Sie die Anmeldung mit der AuthParameters-Karte einschließlich CHALLENGE_NAME: CUSTOM_CHALLENGE initiieren.

Sitzungsverwaltung

Der Authentifizierungsablauf gewährleistet die Kontinuität der Sitzung während einer Reihe von Sitzungs IDs - und Challenge-Ergebnissen. Jede Challenge-Antwort generiert eine neue Sitzungs-ID, um Fehler bei der Wiederverwendung von Sitzungen zu vermeiden. Dies ist besonders wichtig bei mehrstufigen Authentifizierungsabläufen.

Challenge-Ergebnisse werden chronologisch in dem Session-Array gespeichert, das Ihre Lambda-Trigger empfangen. Für Benutzer mit FORCE_CHANGE_PASSWORD Status enthält das Sitzungs-Array:

  1. session[0]- Erste SRP_A Herausforderung

  2. session[1]- PASSWORD_VERIFIER Ergebnis

  3. session[2]- NEW_PASSWORD_REQUIRED Ergebnis

  4. Nachfolgende Elemente — Ergebnisse zusätzlicher benutzerdefinierter Herausforderungen

Beispiel für einen Authentifizierungsablauf

Das folgende Beispiel zeigt einen vollständigen benutzerdefinierten Authentifizierungsablauf für einen Benutzer mit FORCE_CHANGE_PASSWORD Status, der sowohl eine Passwortänderung als auch eine benutzerdefinierte CAPTCHA-Abfrage durchführen muss.

  1. InitiateAuth Anfrage

    {
    "AuthFlow": "CUSTOM_AUTH",
    "ClientId": "1example23456789",
    "AuthParameters": {
        "CHALLENGE_NAME": "SRP_A",
        "USERNAME": "testuser",
        "SRP_A": "[SRP_A]"
    }
}

  2. InitiateAuth Antwort

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

  3. RespondToAuthChallenge Anfrage mit 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 Antwort mit NEW_PASSWORD_REQUIRED Herausforderung

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

  5. RespondToAuthChallenge Anfrage mit NEW_PASSWORD_REQUIRED

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

  6. RespondToAuthChallenge Antwort mit benutzerdefinierter CAPTCHA-Herausforderung

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

  7. RespondToAuthChallenge Anfrage mit Antwort auf die benutzerdefinierte CAPTCHA-Herausforderung

    {
    "ChallengeName": "CUSTOM_CHALLENGE",
    "ClientId": "1example23456789",
    "ChallengeResponses": {
        "ANSWER": "123",
        "USERNAME": "testuser"
    },
    "Session": "[session_id_3]"
}

6. Endgültige Erfolgsantwort

{
    "AuthenticationResult": {
        "AccessToken": "eyJra456defEXAMPLE",
        "ExpiresIn": 3600,
        "IdToken": "eyJra789ghiEXAMPLE",
        "RefreshToken": "eyJjd123abcEXAMPLE",
        "TokenType": "Bearer"
    },
    "ChallengeParameters": {}
}