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. Sie könnten beispielsweise verlangen, dass Benutzer ein CAPTCHA lösen oder eine Sicherheitsfrage beantworten müssen, bevor sie sich authentifizieren dürfen. Ein weiterer potenzieller Bedarf ist die 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](user-pool-lambda-define-auth-challenge.md)**
Initiiert eine Challenge-Sequenz. Legt fest, ob Sie eine neue Herausforderung initiieren, die Authentifizierung als abgeschlossen markieren oder den Authentifizierungsversuch beenden möchten.
**[Erzeugt](user-pool-lambda-create-auth-challenge.md)**
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](user-pool-lambda-verify-auth-challenge-response.md)**
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\]](http://docs.aws.amazon.com/de_de/cognito/latest/developerguide/images/lambda-challenges.png)
Weitere Informationen zur Implementierung der benutzerdefinierten Authentifizierung finden Sie unter [Benutzerdefinierter Authentifizierungsablauf und Aufforderungen](amazon-cognito-user-pools-authentication-flow-methods.md#Custom-authentication-flow-and-challenges)
Authentifizierung zwischen den API-Vorgängen [InitiateAuth](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_InitiateAuth.html)oder [AdminInitiateAuth](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminInitiateAuth.html), und [RespondToAuthChallenge](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_RespondToAuthChallenge.html)oder [AdminRespondToAuthChallenge](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminRespondToAuthChallenge.html). 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ückgibt`IssueTokens`.
**Topics**
+ [SRP-Authentifizierung in benutzerdefinierten Challenge-Flows](#user-pool-lambda-challenge-srp-authentication)
+ [Lambda-Auslöser für die Definition einer Authentifizierungsaufforderung](user-pool-lambda-define-auth-challenge.md)
+ [Lambda-Auslöser für die Erstellung einer Authentifizierungsaufforderung](user-pool-lambda-create-auth-challenge.md)
+ [Lambda-Auslöser für die Verifizierung der Antwort auf eine Authentifizierungsaufforderung](user-pool-lambda-verify-auth-challenge-response.md)
## 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](quotas.md#category_operations.title) 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.
1. Amazon Cognito ruft Ihren Lambda-Auslöser „Authentifizierungsaufforderung definieren“ mit einer ersten Sitzung auf, die `challengeName: SRP_A` und `challengeResult: true` enthält.
1. Nachdem Sie diese Eingaben empfangen haben, reagiert Ihre Lambda-Funktion mit `challengeName: PASSWORD_VERIFIER`, `issueTokens: false`, `failAuthentication: false`.
1. 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.
1. 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.
1. 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](user-pool-lambda-define-auth-challenge.md) 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_REQUIRED`antworten](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_RespondToAuthChallenge.html#API_RespondToAuthChallenge_RequestParameters). `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 unter[Beispiel für „Authentifizierungsaufforderung definieren“](user-pool-lambda-define-auth-challenge.md#aws-lambda-triggers-define-auth-challenge-example).
#### 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` und`USERNAME`.
1. Amazon Cognito ruft Ihren Lambda-Auslöser „Authentifizierungsaufforderung definieren“ mit einer ersten Sitzung auf, die `challengeName: SRP_A` und `challengeResult: true` enthält.
1. Nachdem Sie diese Eingaben empfangen haben, reagiert Ihre Lambda-Funktion mit `challengeName: PASSWORD_VERIFIER`, `issueTokens: false`, `failAuthentication: false`.
1. 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 oder`RESET_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.
1. 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.
#### Verwaltung von Sitzungen
Durch den Authentifizierungsablauf wird die Sitzungskontinuität durch eine Reihe von Sitzungs IDs - und Challenge-Ergebnissen aufrechterhalten. 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
1. `session[1]`- `PASSWORD_VERIFIER` Ergebnis
1. `session[2]`- `NEW_PASSWORD_REQUIRED` Ergebnis
1. 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]"
}
}
```
1. **InitiateAuth Antwort**
```
{
"ChallengeName": "PASSWORD_VERIFIER",
"ChallengeParameters": {
"USER_ID_FOR_SRP": "testuser"
},
"Session": "[session_id_1]"
}
```
1. **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]"
}
```
1. **RespondToAuthChallenge Antwort mit `NEW_PASSWORD_REQUIRED` Herausforderung**
```
{
"ChallengeName": "NEW_PASSWORD_REQUIRED",
"ChallengeParameters": {},
"Session": "[session_id_2]"
}
```
1. **RespondToAuthChallenge Anfrage mit `NEW_PASSWORD_REQUIRED`**
```
{
"ChallengeName": "NEW_PASSWORD_REQUIRED",
"ClientId": "1example23456789",
"ChallengeResponses": {
"NEW_PASSWORD": "[password]",
"USERNAME": "testuser"
},
"Session": "[session_id_2]"
}
```
1. **RespondToAuthChallenge Antwort mit benutzerdefinierter CAPTCHA-Herausforderung**
```
{
"ChallengeName": "CUSTOM_CHALLENGE",
"ChallengeParameters": {
"captchaUrl": "url/123.jpg"
},
"Session": "[session_id_3]"
}
```
1. **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": {}
}
```
# Lambda-Auslöser für die Definition einer Authentifizierungsaufforderung
Der Define Auth Challenge Trigger ist eine Lambda-Funktion, die die Abfragesequenz in einem benutzerdefinierten Authentifizierungsablauf beibehält. Sie erklärt den Erfolg oder Misserfolg der Challenge-Sequenz und legt die nächste Challenge fest, falls die Sequenz noch nicht abgeschlossen ist.
![\[Lambda-Auslöser für Aufforderungen\]](http://docs.aws.amazon.com/de_de/cognito/latest/developerguide/images/lambda-challenges1.png)
**Authentifizierungsaufforderung definieren**
Amazon Cognito ruft diesen Auslöser auf, um den [benutzerdefinierten Authentifizierungsablauf](https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-authentication-flow.html#amazon-cognito-user-pools-custom-authentication-flow) zu initiieren.
Die Anforderung für diesen Lambda-Auslöser enthält `session`. Der `session`-Parameter ist ein Array, das alle Aufforderungen enthält, die dem Benutzer im aktuellen Authentifizierungsprozess präsentiert werden. Die Anfrage enthält auch das entsprechende Ergebnis. Das `session`-Array speichert Aufforderungsdetails (`ChallengeResult`) in chronologischer Reihenfolge. Die Aufforderung `session[0]` stellt die erste Aufforderung dar, die der Benutzer erhält.
**Topics**
+ [Definition von Lambda-Auslöserparametern für die Authentifizierungsaufforderung](#cognito-user-pools-lambda-trigger-syntax-define-auth-challenge)
+ [Beispiel für „Authentifizierungsaufforderung definieren“](#aws-lambda-triggers-define-auth-challenge-example)
## Definition von Lambda-Auslöserparametern für die Authentifizierungsaufforderung
Die Anforderung, die Amazon Cognito an diese Lambda-Funktion übergibt, ist eine Kombination der folgenden Parameter und der [allgemeinen Parameter](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-working-with-lambda-triggers.html#cognito-user-pools-lambda-trigger-syntax-shared), die Amazon Cognito allen Anfragen hinzufügt.
------
#### [ JSON ]
```
{
"request": {
"userAttributes": {
"string": "string",
. . .
},
"session": [
ChallengeResult,
. . .
],
"clientMetadata": {
"string": "string",
. . .
},
"userNotFound": boolean
},
"response": {
"challengeName": "string",
"issueTokens": boolean,
"failAuthentication": boolean
}
}
```
------
### Anforderungsparameter für die Definition der Authentifizierungsaufforderung
Wenn Amazon Cognito Ihre Lambda-Funktion aufruft, bietet Amazon Cognito die folgenden Parameter:
**userAttributes**
Ein oder mehrere Name-Wert-Paare, die Benutzerattribute darstellen.
**userNotFound**
Ein boolescher Wert, den Amazon Cognito eingibt, wenn `PreventUserExistenceErrors` für Ihren Benutzerpool-Client auf `ENABLED` festgelegt ist. Ein Wert von `true` bedeutet, dass die Benutzer-ID (Benutzername, E-Mail-Adresse usw.) mit keinem vorhandenen Benutzer übereinstimmt. Wenn `PreventUserExistenceErrors` auf `ENABLED` gesetzt ist, informiert der Service die App nicht über nicht existierende Benutzer. Wir empfehlen, dass Ihre Lambda-Funktionen dieselbe Benutzererfahrung beibehalten und die Latenz berücksichtigen. Auf diese Weise kann der Aufrufer abweichendes Verhalten nicht erkennen, wenn der Benutzer vorhanden ist oder nicht vorhanden ist.
**Sitzung**
Ein Array von `ChallengeResult`-Elementen. Jede enthält die folgenden Elemente:
**challengeName**
Einer der folgenden Challenge-Typen:`CUSTOM_CHALLENGE`,`SRP_A`,`PASSWORD_VERIFIER`,`SMS_MFA`,`EMAIL_OTP`,`SOFTWARE_TOKEN_MFA`, `DEVICE_SRP_AUTH``DEVICE_PASSWORD_VERIFIER`, oder`ADMIN_NO_SRP_AUTH`.
Wenn Ihre Define Auth Challenge-Funktion eine `PASSWORD_VERIFIER` Herausforderung für einen Benutzer ausgibt, der die Multifaktor-Authentifizierung eingerichtet hat, folgt Amazon Cognito darauf mit einer `SMS_MFA``EMAIL_OTP`, oder -Aufforderung. `SOFTWARE_TOKEN_MFA` Dies sind die Eingabeaufforderungen zur Eingabe eines Multi-Faktor-Authentifizierungscodes. Schließen Sie in Ihrer Funktion die Behandlung von Eingabeereignissen aus `SMS_MFA``EMAIL_OTP`, und `SOFTWARE_TOKEN_MFA` Herausforderungen ein. Sie müssen in Ihrer Define Auth Challenge-Funktion keine MFA-Challenges aufrufen.
Wenn Ihre Funktion feststellt, ob ein Benutzer sich erfolgreich authentifiziert hat und Sie Token ausgeben müssen, überprüfen Sie immer den `challengeName` in Ihrer Define-Auth-Challenge, um sicherzustellen, dass er mit dem erwarteten Wert übereinstimmt.
**challengeResult**
Setzen Sie diesen Parameter auf `true`, wenn der Benutzer die Aufforderung erfolgreich abgeschlossen hat. Setzen Sie ihn andernfalls auf `false`.
**challengeMetadata**
Ihr Name für die benutzerdefinierte Aufforderung. Nur verwendet, wenn `challengeName` `CUSTOM_CHALLENGE`entspricht.
**clientMetadata**
Ein oder mehrere Schlüssel-Wert-Paare, die Sie als benutzerdefinierte Eingabe für die Lambda-Funktion bereitstellen können, die Sie für den Auslöser für die Authentifizierungsaufforderung definieren. Um diese Daten an Ihre Lambda-Funktion zu übergeben, können Sie den `ClientMetadata` Parameter in den [RespondToAuthChallenge](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_RespondToAuthChallenge.html)API-Operationen [AdminRespondToAuthChallenge](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminRespondToAuthChallenge.html)und verwenden. Die Anfrage, die die Funktion define auth challenge aufruft, enthält keine Daten, die in den ClientMetadata Parameter-In [AdminInitiateAuth](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminInitiateAuth.html)- und [InitiateAuth](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_InitiateAuth.html)API-Vorgängen übergeben wurden.
### Antwortparameter für die Definition der Authentifizierungsaufforderung
In der Antwort können Sie die nächste Phase des Authentifizierungsvorgangs zurückgeben.
**challengeName**
Eine Zeichenfolge, die den Namen der nächsten Aufforderung enthält. Wenn dem Benutzer eine neue Aufforderung angezeigt werden soll, geben Sie den Namen der Aufforderung hier an.
**issueTokens**
Wenn Sie feststellen, dass der Benutzer den Authentifizierungsaufforderungen ausreichend nachgekommen ist, setzen Sie ihn auf `true`. Wenn der Benutzer den Aufforderungen nicht ausreichend nachgekommen ist, setzen Sie ihn auf `false`.
**failAuthentication**
Wenn Sie den aktuellen Authentifizierungsprozess beenden möchten, setzen Sie ihn auf `true`. Um den aktuellen Authentifizierungsprozess fortzusetzen, setzen Sie ihn auf `false`.
## Beispiel für „Authentifizierungsaufforderung definieren“
Mit diesem Beispiel werden eine Reihe von Aufforderungen für die Authentifizierung definiert. Token werden nur dann ausgegeben, wenn der Benutzer alle Aufforderungen erfolgreich abgeschlossen hat. Wenn Benutzer die SRP-Authentifizierung mit den `SRP_A` und `PASSWORD_VERIFIER` Challenges abschließen, übergibt ihnen diese Funktion eine, `CUSTOM_CHALLENGE` die den Create Auth Challenge-Trigger auslöst. In Kombination mit unserem [Beispiel für die Create Auth Challenge](user-pool-lambda-create-auth-challenge.md#aws-lambda-triggers-create-auth-challenge-example) liefert diese Sequenz eine CAPTCHA-Herausforderung für Herausforderung drei und eine Sicherheitsfrage für Herausforderung vier.
Nachdem der Benutzer das CAPTCHA gelöst und die Sicherheitsfrage beantwortet hat, bestätigt diese Funktion, dass Ihr Benutzerpool Token ausstellen kann. Eine SRP-Authentifizierung ist nicht erforderlich. Sie können das CAPTCHA und die Sicherheitsfrage auch als Herausforderung eins und zwei festlegen. Für den Fall, dass Ihre Funktion zum Definieren einer Authentifizierungsabfrage keine SRP-Herausforderungen deklariert, hängt der Erfolg Ihrer Benutzer ausschließlich von ihren Antworten auf Ihre benutzerdefinierten Eingabeaufforderungen ab.
------
#### [ 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 };
```
------
# Lambda-Auslöser für die Erstellung einer Authentifizierungsaufforderung
Der Create Auth Challenge-Trigger ist eine Lambda-Funktion, die die Details jeder Abfrage enthält, die durch den Define Auth Challenge Trigger deklariert wurde. Sie verarbeitet den durch den Define Auth Challenge-Trigger deklarierten Challenge-Namen und gibt einen Wert zurück`publicChallengeParameters`, den Ihre Anwendung dem Benutzer präsentieren muss. Diese Funktion liefert Ihrem Benutzerpool dann die Antwort auf die Herausforderung`privateChallengeParameters`, die Ihr Benutzerpool an den Verify Auth Challenge-Trigger weiterleitet. Während Ihr Define Auth Challenge-Trigger die Challenge-Sequenz verwaltet, verwaltet Ihr Create Auth Challenge-Trigger den Inhalt der Herausforderung.
![\[Lambda-Auslöser für Aufforderungen\]](http://docs.aws.amazon.com/de_de/cognito/latest/developerguide/images/lambda-challenges2.png)
**Authentifizierungsaufforderung erstellen**
Amazon Cognito aktiviert den Auslöser nach **Authentifizierungsaufforderung definieren**, falls eine benutzerdefinierte Anforderung als Teil des Auslösers für **Authentifizierungsaufforderung definieren** festgelegt wurde. Erstellt einen [benutzerdefinierten Authentifizierungsablauf](https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-authentication-flow.html#amazon-cognito-user-pools-custom-authentication-flow).
Dieser Lambda-Auslöser wird aufgerufen, um eine Aufforderung zu erstellen, die dem Benutzer angezeigt wird. Die Anforderung für diesen Lambda-Auslöser umfasst `challengeName` und `session`. `challengeName` ist eine Zeichenfolge und der Name der nächsten Aufforderung für den Benutzer. Der Wert dieses Attributs wird im Lambda-Auslöser „Authentifizierungsaufforderung definieren“ festgelegt.
Die Aufforderungsschleife wird so lange ausgeführt, bis alle Aufforderungen beantwortet werden.
**Topics**
+ [Lambda-Auslöserparameter für die Erstellung einer Authentifizierungsaufforderung](#cognito-user-pools-lambda-trigger-syntax-create-auth-challenge)
+ [Beispiel für „Authentifizierungsaufforderung erstellen“](#aws-lambda-triggers-create-auth-challenge-example)
## Lambda-Auslöserparameter für die Erstellung einer Authentifizierungsaufforderung
Die Anforderung, die Amazon Cognito an diese Lambda-Funktion übergibt, ist eine Kombination der folgenden Parameter und der [allgemeinen Parameter](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-working-with-lambda-triggers.html#cognito-user-pools-lambda-trigger-syntax-shared), die Amazon Cognito allen Anfragen hinzufügt.
------
#### [ JSON ]
```
{
"request": {
"userAttributes": {
"string": "string",
. . .
},
"challengeName": "string",
"session": [
ChallengeResult,
. . .
],
"clientMetadata": {
"string": "string",
. . .
},
"userNotFound": boolean
},
"response": {
"publicChallengeParameters": {
"string": "string",
. . .
},
"privateChallengeParameters": {
"string": "string",
. . .
},
"challengeMetadata": "string"
}
}
```
------
### Anforderungsparameter für die Erstellung einer Authentifizierungsaufforderung
**userAttributes**
Ein oder mehrere Name-Wert-Paare, die Benutzerattribute darstellen.
**userNotFound**
Dieser boolesche Wert wird eingegeben, wenn `PreventUserExistenceErrors` für Ihren Benutzerpool-Client auf `ENABLED` festgelegt ist.
**challengeName**
Der Name der neuen Aufforderung.
**Sitzung**
Das session-Element ist ein Array aus `ChallengeResult`-Elementen, die jeweils die folgenden Elemente enthalten:
**challengeName**
Der Aufforderungstyp: Einer von:`"CUSTOM_CHALLENGE"`,,`"PASSWORD_VERIFIER"`,`"SMS_MFA"`, `"DEVICE_SRP_AUTH"` `"DEVICE_PASSWORD_VERIFIER"``"NEW_PASSWORD_REQUIRED"`, oder. `"ADMIN_NO_SRP_AUTH"`
**challengeResult**
Setzen Sie diesen Parameter auf `true`, wenn der Benutzer die Aufforderung erfolgreich abgeschlossen hat. Setzen Sie ihn andernfalls auf `false`.
**challengeMetadata**
Ihr Name für die benutzerdefinierte Aufforderung. Nur verwendet, wenn `challengeName` `"CUSTOM_CHALLENGE"`entspricht.
**clientMetadata**
Ein oder mehrere Schlüssel-Wert-Paare, die Sie als benutzerdefinierte Eingabe für die Lambda-Funktion bereitstellen können, die Sie für den Auslöser zum Erstellen einer Authentifizierungsaufforderung angeben. Sie können den ClientMetadata Parameter in den [AdminRespondToAuthChallenge](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminRespondToAuthChallenge.html)und [RespondToAuthChallenge](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_RespondToAuthChallenge.html)API-Aktionen verwenden, um diese Daten an Ihre Lambda-Funktion zu übergeben. Die Anfrage, die die Funktion create auth challenge aufruft, enthält keine Daten, die in den ClientMetadata Parameter-In [AdminInitiateAuth](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminInitiateAuth.html)- und [InitiateAuth](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_InitiateAuth.html)API-Vorgängen übergeben wurden.
### Antwortparameter für die Erstellung einer Authentifizierungsaufforderung
**publicChallengeParameters**
Ein oder mehrere Schlüssel-Wert-Paare für die Client-App zur Verwendung in der Aufforderung, die dem Benutzer angezeigt wird. Dieser Parameter sollte alle erforderlichen Informationen enthalten, um dem Benutzer die Aufforderung richtig anzuzeigen.
**privateChallengeParameters**
Dieser Parameter wird nur vom Lambda-Auslöser „Antwort auf Authentifizierungsaufforderung überprüfen“ verwendet. Dieser Parameter sollte enthalten alle Informationen, die erforderlich ist, um sicherzustellen, dass die Benutzer die Antwort auf die Aufforderung. Anders ausgedrückt, der Parameter `publicChallengeParameters` enthält die Frage, die dem Benutzer angezeigt wird, und `privateChallengeParameters` die gültigen Antworten auf die Frage.
**challengeMetadata**
Ihr Name für die benutzerdefinierte Aufforderung, sofern es sich um eine benutzerdefinierte Aufforderung handelt.
## Beispiel für „Authentifizierungsaufforderung erstellen“
Diese Funktion hat zwei benutzerdefinierte Herausforderungen, die der Challenge-Sequenz in unserem Beispiel für eine [Define Auth](user-pool-lambda-define-auth-challenge.md#aws-lambda-triggers-define-auth-challenge-example) Challenge entsprechen. Bei den ersten beiden Herausforderungen handelt es sich um die SRP-Authentifizierung. Bei der dritten Challenge gibt diese Funktion in der Challenge-Antwort eine CAPTCHA-URL an Ihre Anwendung zurück. Ihre Anwendung rendert das CAPTCHA unter der angegebenen URL und gibt die Benutzereingabe zurück. Die URL für das CAPTCHA-Bild wird den Parametern der öffentlichen Aufforderung als "`captchaUrl`" hinzugefügt. Die erwartete Antwort wird den Parametern der privaten Aufforderung hinzugefügt.
Für die vierte Herausforderung gibt diese Funktion eine Sicherheitsfrage zurück. Ihre Anwendung rendert die Frage und fordert den Benutzer zur Eingabe seiner Antwort auf. Nachdem Benutzer beide benutzerdefinierten Herausforderungen gelöst haben, bestätigt der Trigger zur Definition der Authentifizierungsabfrage, dass Ihr Benutzerpool Token ausstellen kann.
------
#### [ 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 };
```
------
# Lambda-Auslöser für die Verifizierung der Antwort auf eine Authentifizierungsaufforderung
Der Verify Auth Challenge-Trigger ist eine Lambda-Funktion, die die von einem Benutzer bereitgestellte Antwort mit einer bekannten Antwort vergleicht. Diese Funktion teilt Ihrem Benutzerpool mit, ob der Benutzer die Anfrage richtig beantwortet hat. Wenn der Challenge-Trigger zur Überprüfung `answerCorrect` der Authentifizierung mit einem Aus antwortet`true`, kann die Authentifizierungssequenz fortgesetzt werden.
![\[Lambda-Auslöser für Aufforderungen\]](http://docs.aws.amazon.com/de_de/cognito/latest/developerguide/images/lambda-challenges3.png)
**Überprüfen Sie die Antwort auf die Authentifizierungsabfrage**
Amazon Cognito ruft diesen Auslöser auf, um zu überprüfen, ob die Antwort des Benutzers auf eine benutzerdefinierte Authentifizierungsaufforderung gültig ist. Es ist Teil eines [benutzerdefinierten Authentifizierungsablaufs](https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-authentication-flow.html#amazon-cognito-user-pools-custom-authentication-flow) für einen Benutzerpool.
Die Anforderung für diesen Auslöser enthält die Parameter `privateChallengeParameters` und `challengeAnswer`. Die `privateChallengeParameters`-Werte werden vom Lambda-Auslöser „Authentifizierungsaufforderung erstellen“ zurückgegeben und enthalten die erwartete Antwort vom Benutzer. Der Parameter `challengeAnswer` enthält die Benutzerantwort auf die Aufforderung.
Die Antwort enthält das `answerCorrect`-Attribut. Wenn der Benutzer die Herausforderung erfolgreich abgeschlossen hat, legt Amazon Cognito den Attributwert auf `true` fest. Wenn der Benutzer die Herausforderung nicht erfolgreich abgeschlossen hat, legt Amazon Cognito den Wert auf `false` fest.
Die Aufforderungsschleife wird so lange ausgeführt, bis die Benutzer alle Aufforderungen beantwortet hat.
**Topics**
+ [Lambda-Auslöserparameter für die Überprüfung einer Authentifizierungsaufforderung](#cognito-user-pools-lambda-trigger-syntax-verify-auth-challenge)
+ [Beispiel für „Antwort auf Authentifizierungsaufforderung überprüfen“](#aws-lambda-triggers-verify-auth-challenge-response-example)
## Lambda-Auslöserparameter für die Überprüfung einer Authentifizierungsaufforderung
Die Anforderung, die Amazon Cognito an diese Lambda-Funktion übergibt, ist eine Kombination der folgenden Parameter und der [allgemeinen Parameter](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-working-with-lambda-triggers.html#cognito-user-pools-lambda-trigger-syntax-shared), die Amazon Cognito allen Anfragen hinzufügt.
------
#### [ JSON ]
```
{
"request": {
"userAttributes": {
"string": "string",
. . .
},
"privateChallengeParameters": {
"string": "string",
. . .
},
"challengeAnswer": "string",
"clientMetadata": {
"string": "string",
. . .
},
"userNotFound": boolean
},
"response": {
"answerCorrect": boolean
}
}
```
------
### Anforderungsparameter für die Verifizierung einer Authentifizierungsaufforderung
**userAttributes**
Dieser Parameter enthält ein oder mehrere Name-Wert-Paare, die Benutzerattribute darstellen.
**userNotFound**
Amazon Cognito gibt diesen booleschen Wert ein, wenn Amazon Cognito `PreventUserExistenceErrors` für Ihren Benutzerpool-Client auf `ENABLED` festgelegt hat.
**privateChallengeParameters**
Dieser Parameter stammt aus dem Trigger „Authentifizierungsaufforderung erstellen“. Um festzustellen, ob der Benutzer eine Aufforderung erfüllt hat, vergleicht Amazon Cognito die Parameter mit der **challengeAnswer** eines Benutzers.
Dieser Parameter sollte alle erforderlichen Informationen enthalten, um die Antwort des Benutzerstauf die Aufforderung zu validieren. Diese Informationen beinhalten die Frage, die Amazon Cognito dem Benutzer stellt (`publicChallengeParameters`), sowie die gültigen Antworten auf die Frage (`privateChallengeParameters`). Dieser Parameter wird nur vom Lambda-Auslöser „Antwort auf Authentifizierungsaufforderung überprüfen“ verwendet.
**challengeAnswer**
Dieser Parameterwert ist die Antwort des Benutzers auf die Aufforderung.
**clientMetadata**
Dieser Parameter enthält ein oder mehrere Schlüssel-Wert-Paare, die Sie als benutzerdefinierte Eingabe für die Lambda-Funktion für den Auslöser zur Überprüfung der Authentifizierungsaufforderung bereitstellen können. Um diese Daten an Ihre Lambda-Funktion zu übergeben, verwenden Sie den ClientMetadata Parameter in den [RespondToAuthChallenge](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_RespondToAuthChallenge.html)API-Operationen [AdminRespondToAuthChallenge](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminRespondToAuthChallenge.html)und. Amazon Cognito bezieht keine Daten aus dem ClientMetadata Parameter in [AdminInitiateAuth](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminInitiateAuth.html)und [InitiateAuth](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_InitiateAuth.html)API-Operationen in die Anfrage ein, die es an die Verify Auth Challenge-Funktion weiterleitet.
### Antwortparameter für die Verifizierung der Authentifizierungsaufforderung
**answerCorrect**
Wenn der Benutzer die Aufforderung erfolgreich abschließt, legt Amazon Cognito diesen Parameter auf `true` fest. Wenn der Benutzer die Aufforderung nicht erfolgreich abschließt, legt Amazon Cognito den Parameter auf `false` fest.
## Beispiel für „Antwort auf Authentifizierungsaufforderung überprüfen“
Diese Funktion zur Überprüfung der Authentifizierung überprüft, ob die Antwort des Benutzers auf eine Abfrage mit der erwarteten Antwort übereinstimmt. Die Antwort des Benutzers wird durch Eingaben aus Ihrer Anwendung definiert, und die bevorzugte Antwort wird durch die Antwort aus der Antwort `privateChallengeParameters.answer` auf den [Trigger „Create Auth Challenge](user-pool-lambda-create-auth-challenge.md#aws-lambda-triggers-create-auth-challenge-example)“ definiert. Sowohl die richtige Antwort als auch die angegebene Antwort sind Teil des Eingabeereignisses für diese Funktion.
Wenn in diesem Beispiel die Antwort des Benutzers mit der erwarteten Antwort übereinstimmt, setzt Amazon Cognito den `answerCorrect` Parameter auf`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 };
```
------