Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Trigger Lambda di richieste di autenticazione personalizzate
Man mano che crei i flussi di autenticazione per il tuo pool di utenti Amazon Cognito, potresti scoprire di voler estendere il tuo modello di autenticazione oltre i flussi integrati. Un caso d'uso comune per i trigger di sfida personalizzati consiste nell'implementare controlli di sicurezza aggiuntivi oltre a nome utente, password e autenticazione a più fattori (MFA). Una sfida personalizzata è qualsiasi domanda e risposta che puoi generare in un linguaggio di programmazione supportato da Lambda. Ad esempio, potresti voler richiedere agli utenti di risolvere un CAPTCHA o rispondere a una domanda di sicurezza prima di poter effettuare l'autenticazione. Un'altra potenziale esigenza è l'integrazione con fattori o dispositivi di autenticazione specializzati. Oppure potresti aver già sviluppato un software che autentica gli utenti con una chiave di sicurezza hardware o un dispositivo biometrico. La definizione di successo dell'autenticazione per una sfida personalizzata è la risposta che la funzione Lambda accetta come corretta: una stringa fissa, ad esempio, o una risposta soddisfacente da un'API esterna.
Puoi avviare l'autenticazione con la tua sfida personalizzata e controllare completamente il processo di autenticazione, oppure puoi eseguire l'autenticazione nome utente e password prima che l'applicazione riceva la sfida personalizzata.
Il trigger Lambda della sfida di autenticazione personalizzata:
**[Definisce](user-pool-lambda-define-auth-challenge.md)**
Avvia una sequenza di sfida. Determina se si desidera avviare una nuova sfida, contrassegnare l'autenticazione come completata o interrompere il tentativo di autenticazione.
**[Crea](user-pool-lambda-create-auth-challenge.md)**
Invia all'applicazione la domanda a cui l'utente deve rispondere. Questa funzione potrebbe presentare una domanda di sicurezza o un collegamento a un CAPTCHA che l'applicazione dovrebbe mostrare all'utente.
**[Verifica](user-pool-lambda-verify-auth-challenge-response.md)**
Conosce la risposta prevista e la confronta con la risposta fornita dall'applicazione nella risposta alla sfida. La funzione potrebbe richiamare l'API del servizio CAPTCHA per recuperare i risultati attesi del tentativo di soluzione dell'utente.
Queste tre funzioni Lambda si concatenano per presentare un meccanismo di autenticazione completamente sotto il tuo controllo e progettato da te. Poiché l'autenticazione personalizzata richiede la logica dell'applicazione nel client e nelle funzioni Lambda, non è possibile elaborare l'autenticazione personalizzata all'interno dell'accesso gestito. Questo sistema di autenticazione richiede un impegno aggiuntivo da parte degli sviluppatori. L'applicazione deve eseguire il flusso di autenticazione con l'API dei pool di utenti e gestire la sfida risultante con un'interfaccia di accesso personalizzata che ponga la domanda al centro della sfida di autenticazione personalizzata.
![\[Trigger Lambda di richieste\]](http://docs.aws.amazon.com/it_it/cognito/latest/developerguide/images/lambda-challenges.png)
Per ulteriori informazioni sull'implementazione dell'autenticazione personalizzata, consulta [Flusso di autenticazione personalizzato e sfide](amazon-cognito-user-pools-authentication-flow-methods.md#Custom-authentication-flow-and-challenges)
Autenticazione tra le operazioni API [InitiateAuth](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_InitiateAuth.html)o [AdminInitiateAuth](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminInitiateAuth.html), e [RespondToAuthChallenge](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_RespondToAuthChallenge.html)o [AdminRespondToAuthChallenge](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminRespondToAuthChallenge.html). In questo flusso, l'autenticazione di un utente viene effettuata rispondendo a richieste successive di autenticazione finché l'utente non viene bloccato in caso di esito negativo oppure riceve i relativi token. Una risposta alla sfida potrebbe essere una nuova sfida. In questo caso, l'applicazione risponde tutte le volte necessarie alle nuove sfide. L'autenticazione ha successo quando la funzione define auth challenge analizza i risultati finora ottenuti, determina che tutte le sfide hanno avuto risposta e restituisce i risultati. `IssueTokens`
**Topics**
+ [Autenticazione SRP nei flussi di verifica personalizzati](#user-pool-lambda-challenge-srp-authentication)
+ [Definizione del trigger Lambda di una richiesta di autenticazione](user-pool-lambda-define-auth-challenge.md)
+ [Creazione del trigger Lambda di una richiesta di autenticazione](user-pool-lambda-create-auth-challenge.md)
+ [Trigger Lambda di una verifica di risposta di una richiesta di autenticazione](user-pool-lambda-verify-auth-challenge-response.md)
## Autenticazione SRP nei flussi di verifica personalizzati
Puoi fare in modo che Amazon Cognito verifichi le password degli utenti prima di emettere le tue richieste personalizzate. Tutti i trigger Lambda associati alla categoria Autenticazione delle [quote del tasso di richiesta](quotas.md#category_operations.title) verranno eseguiti quando si esegue l'autenticazione SRP in un flusso di richiesta personalizzato. Ecco una panoramica del processo:
1. La tua app avvia la procedura di accesso chiamando `InitiateAuth` o `AdminInitiateAuth` con la mappatura `AuthParameters`. I parametri devono includere `CHALLENGE_NAME: SRP_A,` e i valori per `SRP_A` e `USERNAME`.
1. Amazon Cognito invoca il tuo trigger Lambda define auth challenge con una sessione iniziale contenente `challengeName: SRP_A` e `challengeResult: true`.
1. Dopo aver ricevuto questi input, la funzione Lambda risponde con `challengeName: PASSWORD_VERIFIER`, `issueTokens: false`, `failAuthentication: false`.
1. Se la verifica della password ha esito positivo, Amazon Cognito richiama nuovamente la funzione Lambda con una nuova sessione contenente `challengeName: PASSWORD_VERIFIER` e `challengeResult: true`.
1. La funzione Lambda avvia le tue sifde personalizzate rispondendo con `challengeName: CUSTOM_CHALLENGE`, `issueTokens: false` e `failAuthentication: false`. Se non desideri avviare il flusso di autenticazione personalizzato con la verifica della password, è possibile avviare l'accesso con la mappa `AuthParameters` che include `CHALLENGE_NAME: CUSTOM_CHALLENGE`.
1. Il loop di sfide si ripete finché non viene data risposta a tutte le sfide.
Di seguito è riportato un esempio di `InitiateAuth` richiesta di avvio che precede l'autenticazione personalizzata con un flusso SRP.
```
{
"AuthFlow": "CUSTOM_AUTH",
"ClientId": "1example23456789",
"AuthParameters": {
"CHALLENGE_NAME": "SRP_A",
"USERNAME": "testuser",
"SRP_A": "[SRP_A]",
"SECRET_HASH": "[secret hash]"
}
}
```
### Reimpostazione della password nel flusso SRP di autenticazione personalizzato
Quando `FORCE_CHANGE_PASSWORD` lo status degli utenti è impostato, il flusso di autenticazione personalizzato deve integrare la fase di modifica della password, mantenendo al contempo l'integrità dei problemi di autenticazione. Amazon Cognito richiama il trigger [Lambda della tua sfida di autenticazione definita durante la sfida](user-pool-lambda-define-auth-challenge.md). `NEW_PASSWORD_REQUIRED` In questo scenario, un utente che accede con un flusso di verifica personalizzato e l'autenticazione SRP può impostare una nuova password se si trova in uno stato di reimpostazione della password.
Quando gli utenti sono nello `FORCE_CHANGE_PASSWORD` stato `RESET_REQUIRED` o, devono [rispondere a una sfida](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_RespondToAuthChallenge.html#API_RespondToAuthChallenge_RequestParameters) con un`NEW_PASSWORD_REQUIRED`. `NEW_PASSWORD` Nell'autenticazione personalizzata con SRP, Amazon Cognito restituisce `NEW_PASSWORD_REQUIRED` una sfida dopo che gli utenti hanno completato la `PASSWORD_VERIFIER` sfida SRP. Il trigger define auth challenge riceve entrambi i risultati della sfida nell'`session`array e può procedere con ulteriori sfide personalizzate dopo che l'utente ha modificato con successo la propria password.
Il trigger Lambda define auth challenge deve gestire la sequenza di sfida tramite l'autenticazione SRP, la reimpostazione della password e le successive sfide personalizzate. Il trigger riceve una serie di sfide completate nel `session` parametro, incluse entrambe `PASSWORD_VERIFIER` e i risultati. `NEW_PASSWORD_REQUIRED` Per un esempio di implementazione, vedere[Definizione di un esempio di una richiesta di autenticazione](user-pool-lambda-define-auth-challenge.md#aws-lambda-triggers-define-auth-challenge-example).
#### Fasi del flusso di autenticazione
Per gli utenti che devono verificare la propria password prima delle sfide personalizzate, la procedura segue questi passaggi:
1. La tua app avvia la procedura di accesso chiamando `InitiateAuth` o `AdminInitiateAuth` con la mappatura `AuthParameters`. I parametri devono includere `CHALLENGE_NAME: SRP_A` e i valori per `SRP_A` e`USERNAME`.
1. Amazon Cognito invoca il tuo trigger Lambda define auth challenge con una sessione iniziale contenente `challengeName: SRP_A` e `challengeResult: true`.
1. Dopo aver ricevuto questi input, la funzione Lambda risponde con `challengeName: PASSWORD_VERIFIER`, `issueTokens: false`, `failAuthentication: false`.
1. Se la verifica della password ha esito positivo, si verifica una delle due seguenti situazioni:
**Per gli utenti in stato normale:**
Amazon Cognito richiama nuovamente la funzione Lambda con una nuova sessione contenente and. `challengeName: PASSWORD_VERIFIER` `challengeResult: true`
La funzione Lambda avvia le tue sifde personalizzate rispondendo con `challengeName: CUSTOM_CHALLENGE`, `issueTokens: false` e `failAuthentication: false`.
**Per gli utenti che rientrano nel nostro status: `RESET_REQUIRED` `FORCE_CHANGE_PASSWORD`**
Amazon Cognito richiama la funzione Lambda con una sessione contenente e. `challengeName: PASSWORD_VERIFIER` `challengeResult: true`
La tua funzione Lambda dovrebbe rispondere con `challengeName: NEW_PASSWORD_REQUIRED`, `issueTokens: false` e `failAuthentication: false`.
Dopo aver modificato con successo la password, Amazon Cognito richiama la funzione Lambda con una sessione contenente sia i risultati che. `PASSWORD_VERIFIER` `NEW_PASSWORD_REQUIRED`
La funzione Lambda avvia le tue sifde personalizzate rispondendo con `challengeName: CUSTOM_CHALLENGE`, `issueTokens: false` e `failAuthentication: false`.
1. Il loop di sfide si ripete finché non viene data risposta a tutte le sfide.
Se non desideri avviare il flusso di autenticazione personalizzato con la verifica della password, è possibile avviare l'accesso con la mappa `AuthParameters` che include `CHALLENGE_NAME: CUSTOM_CHALLENGE`.
#### Gestione della sessione
Il flusso di autenticazione mantiene la continuità della sessione attraverso una serie di risultati di sessioni IDs e sfide. Ogni risposta alla sfida genera un nuovo ID di sessione per prevenire errori di riutilizzo della sessione, il che è particolarmente importante per i flussi di autenticazione a più fattori.
I risultati della sfida vengono archiviati in ordine cronologico nell'array di sessioni ricevuto dai trigger Lambda. Per gli utenti con `FORCE_CHANGE_PASSWORD` status, l'array di sessione contiene:
1. `session[0]`- `SRP_A` Sfida iniziale
1. `session[1]`- `PASSWORD_VERIFIER` risultato
1. `session[2]`- `NEW_PASSWORD_REQUIRED` risultato
1. Elementi successivi: risultati di ulteriori sfide personalizzate
#### Esempio di flusso di autenticazione
L'esempio seguente mostra un flusso di autenticazione personalizzato completo per un utente con `FORCE_CHANGE_PASSWORD` status che deve completare sia la modifica della password che una sfida CAPTCHA personalizzata.
1. **InitiateAuth richiesta**
```
{
"AuthFlow": "CUSTOM_AUTH",
"ClientId": "1example23456789",
"AuthParameters": {
"CHALLENGE_NAME": "SRP_A",
"USERNAME": "testuser",
"SRP_A": "[SRP_A]"
}
}
```
1. **InitiateAuth risposta**
```
{
"ChallengeName": "PASSWORD_VERIFIER",
"ChallengeParameters": {
"USER_ID_FOR_SRP": "testuser"
},
"Session": "[session_id_1]"
}
```
1. **RespondToAuthChallenge richiesta con `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 risposta con `NEW_PASSWORD_REQUIRED` sfida**
```
{
"ChallengeName": "NEW_PASSWORD_REQUIRED",
"ChallengeParameters": {},
"Session": "[session_id_2]"
}
```
1. **RespondToAuthChallenge richiesta con `NEW_PASSWORD_REQUIRED`**
```
{
"ChallengeName": "NEW_PASSWORD_REQUIRED",
"ClientId": "1example23456789",
"ChallengeResponses": {
"NEW_PASSWORD": "[password]",
"USERNAME": "testuser"
},
"Session": "[session_id_2]"
}
```
1. **RespondToAuthChallenge risposta con sfida personalizzata CAPTCHA**
```
{
"ChallengeName": "CUSTOM_CHALLENGE",
"ChallengeParameters": {
"captchaUrl": "url/123.jpg"
},
"Session": "[session_id_3]"
}
```
1. **RespondToAuthChallenge richiesta con risposta alla sfida personalizzata CAPTCHA**
```
{
"ChallengeName": "CUSTOM_CHALLENGE",
"ClientId": "1example23456789",
"ChallengeResponses": {
"ANSWER": "123",
"USERNAME": "testuser"
},
"Session": "[session_id_3]"
}
```
**6. Risposta finale di successo**
```
{
"AuthenticationResult": {
"AccessToken": "eyJra456defEXAMPLE",
"ExpiresIn": 3600,
"IdToken": "eyJra789ghiEXAMPLE",
"RefreshToken": "eyJjd123abcEXAMPLE",
"TokenType": "Bearer"
},
"ChallengeParameters": {}
}
```
# Definizione del trigger Lambda di una richiesta di autenticazione
Il trigger define auth challenge è una funzione Lambda che mantiene la sequenza di sfida in un flusso di autenticazione personalizzato. Dichiara il successo o il fallimento della sequenza di sfida e imposta la sfida successiva se la sequenza non è ancora completa.
![\[Trigger Lambda di richieste\]](http://docs.aws.amazon.com/it_it/cognito/latest/developerguide/images/lambda-challenges1.png)
**Definisci la sfida di autenticazione**
Amazon Cognito richiama questo trigger per avviare il [flusso di autenticazione personalizzato](https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-authentication-flow.html#amazon-cognito-user-pools-custom-authentication-flow).
La richiesta per questo trigger Lambda include `session`. Il parametro `session` è una matrice contenente tutte le sfide a cui l'utente viene sottoposto nel processo di autenticazione in corso. La richiesta include anche il risultato corrispondente. La matrice `session` archivia i dettagli della sfida (`ChallengeResult`) in ordine cronologico. La richiesta `session[0]` rappresenta la prima sfida che l'utente riceve.
**Topics**
+ [Parametri del trigger Lambda di definizione delle richieste di autenticazione](#cognito-user-pools-lambda-trigger-syntax-define-auth-challenge)
+ [Definizione di un esempio di una richiesta di autenticazione](#aws-lambda-triggers-define-auth-challenge-example)
## Parametri del trigger Lambda di definizione delle richieste di autenticazione
La richiesta passata da Amazon Cognito a questa funzione Lambda è una combinazione dei parametri seguenti e dei [parametri comuni](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-working-with-lambda-triggers.html#cognito-user-pools-lambda-trigger-syntax-shared) aggiunti da Amazon Cognito a tutte le richieste.
------
#### [ JSON ]
```
{
"request": {
"userAttributes": {
"string": "string",
. . .
},
"session": [
ChallengeResult,
. . .
],
"clientMetadata": {
"string": "string",
. . .
},
"userNotFound": boolean
},
"response": {
"challengeName": "string",
"issueTokens": boolean,
"failAuthentication": boolean
}
}
```
------
### Parametri di richiesta di definizione sfida di autenticazione
Quando Amazon Cognito richiama la tua funzione Lambda, fornisce i seguenti parametri:
**userAttributes**
Una o più coppie nome-valore che rappresentano gli attributi utente.
**userNotFound**
Valore booleano che viene popolato da Amazon Cognito quando `PreventUserExistenceErrors` è impostato su `ENABLED` per il client del bacino d'utenza. Un valore `true` indica che l'ID utente (nome utente, indirizzo e-mail e altri dettagli) non corrisponde ad alcun utente esistente. Quando `PreventUserExistenceErrors` è impostato su `ENABLED`, il servizio non informa l'app riguardo a utenti inesistenti. Raccomandiamo che le tue funzioni Lambda mantengano la stessa esperienza utente e tengano conto della latenza. In questo modo, l'intermediario non può rilevare comportamenti diversi quando l'utente esiste o non esiste.
**sessione**
Una matrice di elementi `ChallengeResult`. Ognuna contiene i seguenti elementi:
**challengeName**
Uno dei seguenti tipi di sfida:`CUSTOM_CHALLENGE`,`SRP_A`,`PASSWORD_VERIFIER`,`SMS_MFA`,`EMAIL_OTP`,`SOFTWARE_TOKEN_MFA`, `DEVICE_SRP_AUTH``DEVICE_PASSWORD_VERIFIER`, o`ADMIN_NO_SRP_AUTH`.
Quando la funzione define auth challenge genera una `PASSWORD_VERIFIER` sfida per un utente che ha configurato l'autenticazione a più fattori, Amazon Cognito la segue con `SMS_MFA` una sfida`EMAIL_OTP`, o. `SOFTWARE_TOKEN_MFA` Queste sono le istruzioni per un codice di autenticazione a più fattori. Nella tua funzione, includi la gestione degli eventi di input e delle `SMS_MFA` sfide`EMAIL_OTP`. `SOFTWARE_TOKEN_MFA` Non è necessario richiamare alcuna sfida MFA nella funzione define auth challenge.
Quando la funzione determina se un utente ha completato l'autenticazione ed è necessario emettere token, controlla sempre `challengeName` nella funzione Definisci la sfida di autenticazione e verifica che corrisponda al valore previsto.
**challengeResult**
Imposta su `true` se l'utente ha completato con successo la sfida o altrimenti su `false`.
**challengeMetaData**
Il tuo nome per la sfida personalizzata. Usato solo se `challengeName` è `CUSTOM_CHALLENGE`.
**clientMetadata**
Una o più coppie chiave-valore che è possibile fornire come input personalizzato alla funzione Lambda specificata per il trigger di definizione di una richiesta di autenticazione. Per passare questi dati alla funzione Lambda, puoi utilizzare il `ClientMetadata` parametro nelle operazioni [AdminRespondToAuthChallenge](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminRespondToAuthChallenge.html)e [RespondToAuthChallenge](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_RespondToAuthChallenge.html)API. La richiesta che richiama la funzione define auth challenge non include i dati passati nel ClientMetadata parametro e nelle operazioni API. [AdminInitiateAuth[InitiateAuth](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_InitiateAuth.html)](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminInitiateAuth.html)
### Parametri di risposta di definizione sfida di autenticazione
Nella risposta, puoi restituire la prossima fase del processo di autenticazione.
**challengeName**
Una stringa che include il nome della sfida successiva. Se desideri presentare una nuova sfida al tuo utente, specifica qui il nome della sfida.
**issueTokens**
Se stabilisci che l'utente abbia completato abbastanza sfide per essere autenticato, imposta su `true`. Se l'utente non ha soddisfatto i criteri delle sfide, imposta su `false`.
**failAuthentication**
Se desideri terminare l'attuale processo di autenticazione, imposta su `true`. Per continuare il processo di autenticazione corrente, imposta su `false`.
## Definizione di un esempio di una richiesta di autenticazione
Questo esempio definisce una serie di sfide per l'autenticazione e rilascia token solo se l'utente completa correttamente tutte le sfide. Quando gli utenti completano l'autenticazione SRP con le `PASSWORD_VERIFIER` sfide `SRP_A` e, questa funzione passa loro una risposta `CUSTOM_CHALLENGE` che richiama il trigger create auth challenge. In combinazione con il nostro [esempio di sfida di creazione di autenticazione, questa sequenza fornisce una sfida](user-pool-lambda-create-auth-challenge.md#aws-lambda-triggers-create-auth-challenge-example) CAPTCHA per la sfida tre e una domanda di sicurezza per la sfida quattro.
Dopo che l'utente ha risolto il CAPTCHA e risposto alla domanda di sicurezza, questa funzione conferma che il pool di utenti può emettere token. L'autenticazione SRP non è richiesta; puoi anche impostare il CAPTCHA e la domanda di sicurezza come sfide uno e due. Nel caso in cui la funzione define auth challenge non dichiari le sfide SRP, il successo degli utenti è determinato interamente dalle loro risposte ai prompt personalizzati.
------
#### [ 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 };
```
------
# Creazione del trigger Lambda di una richiesta di autenticazione
Il trigger create auth challenge è una funzione Lambda che contiene i dettagli di ogni sfida dichiarata dal trigger define auth challenge. Elabora il nome della sfida dichiarato dal trigger define auth challenge e restituisce un messaggio `publicChallengeParameters` che l'applicazione deve presentare all'utente. Questa funzione fornisce quindi al pool di utenti la risposta alla sfida`privateChallengeParameters`, che il pool di utenti passa al trigger verify auth challenge. Laddove il trigger define auth challenge gestisce la sequenza della sfida, il trigger create auth challenge gestisce il contenuto della sfida.
![\[Trigger Lambda di richieste\]](http://docs.aws.amazon.com/it_it/cognito/latest/developerguide/images/lambda-challenges2.png)
**Crea una sfida di autenticazione**
Amazon Cognito richiama questo trigger dopo la **definizione di una richiesta di autenticazione** nel caso in cui una richiesta personalizzata sia stata specificata come parte del trigger di **definizione di una richiesta di autenticazione**. Crea un [flusso di autenticazione personalizzato](https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-authentication-flow.html#amazon-cognito-user-pools-custom-authentication-flow).
Questo trigger Lambda viene richiamato per creare una richiesta da presentare all'utente. La richiesta per questo trigger Lambda include `challengeName` e `session`. Il `challengeName` è una stringa, nonché il nome della prossima sfida per l'utente. Il valore di questo attributo è impostato nel trigger Lambda di definizione di una richiesta di autenticazione.
Il loop di sfide si ripeterà finché non viene data risposta a tutte le sfide.
**Topics**
+ [Parametri del trigger Lambda di creazione di una richiesta di autenticazione](#cognito-user-pools-lambda-trigger-syntax-create-auth-challenge)
+ [Creazione di un esempio di una richiesta di autenticazione](#aws-lambda-triggers-create-auth-challenge-example)
## Parametri del trigger Lambda di creazione di una richiesta di autenticazione
La richiesta passata da Amazon Cognito a questa funzione Lambda è una combinazione dei parametri seguenti e dei [parametri comuni](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-working-with-lambda-triggers.html#cognito-user-pools-lambda-trigger-syntax-shared) aggiunti da Amazon Cognito a tutte le richieste.
------
#### [ JSON ]
```
{
"request": {
"userAttributes": {
"string": "string",
. . .
},
"challengeName": "string",
"session": [
ChallengeResult,
. . .
],
"clientMetadata": {
"string": "string",
. . .
},
"userNotFound": boolean
},
"response": {
"publicChallengeParameters": {
"string": "string",
. . .
},
"privateChallengeParameters": {
"string": "string",
. . .
},
"challengeMetadata": "string"
}
}
```
------
### Parametri di richiesta di creazione sfida di autenticazione
**userAttributes**
Una o più coppie nome-valore che rappresentano gli attributi utente.
**userNotFound**
Questo valore booleano viene popolato quando `PreventUserExistenceErrors` è impostato su `ENABLED` per il client del bacino d'utenza.
**challengeName**
Il nome della nuova sfida.
**sessione**
L'elemento della sessione è una matrice di elementi `ChallengeResult`, ognuno dei quali contiene i seguenti elementi:
**challengeName**
Il tipo di sfida. Uno dei seguenti:`"CUSTOM_CHALLENGE"`,`"PASSWORD_VERIFIER"`,`"SMS_MFA"`,`"DEVICE_SRP_AUTH"`, `"DEVICE_PASSWORD_VERIFIER"``"NEW_PASSWORD_REQUIRED"`, o`"ADMIN_NO_SRP_AUTH"`.
**challengeResult**
Imposta su `true` se l'utente ha completato con successo la sfida o altrimenti su `false`.
**challengeMetaData**
Il tuo nome per la sfida personalizzata. Usato solo se `challengeName` è `"CUSTOM_CHALLENGE"`.
**clientMetadata**
Una o più coppie chiave-valore che è possibile fornire come input personalizzato alla funzione Lambda specificata per il trigger di creazione di una richiesta di autenticazione. Puoi utilizzare il ClientMetadata parametro nelle azioni [AdminRespondToAuthChallenge](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminRespondToAuthChallenge.html)e [RespondToAuthChallenge](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_RespondToAuthChallenge.html)API per passare questi dati alla tua funzione Lambda. La richiesta che richiama la funzione create auth challenge non include i dati passati nel ClientMetadata [AdminInitiateAuth](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminInitiateAuth.html)parametro e le operazioni API. [InitiateAuth](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_InitiateAuth.html)
### Parametri di risposta di creazione sfida di autenticazione
**publicChallengeParameters**
Una o più coppie chiave-valore per l'app del client da usare nella sfida che deve essere presentata all'utente. Questo parametro deve contenere tutte le informazioni necessarie per presentare, in maniera accurata, la sfida all'utente.
**privateChallengeParameters**
Questo parametro viene utilizzato solo dal trigger Lambda di una verifica di risposta di una richiesta di autenticazione. Questo parametro dovrebbe contenere tutte le informazioni necessarie per convalidare la risposta dell'utente alla sfida. In altre parole, il parametro `publicChallengeParameters` contiene la domanda che viene presentata all'utente e `privateChallengeParameters` contiene le risposte valide per la domanda.
**challengeMetaData**
Il tuo nome per la sfida personalizzata, se questa è una sfida personalizzata.
## Creazione di un esempio di una richiesta di autenticazione
Questa funzione ha due sfide personalizzate che corrispondono alla sequenza di sfida nel nostro esempio di challenge [define auth.](user-pool-lambda-define-auth-challenge.md#aws-lambda-triggers-define-auth-challenge-example) Le prime due sfide sono l'autenticazione SRP. Per la terza sfida, questa funzione restituisce un URL CAPTCHA all'applicazione nella risposta alla sfida. L'applicazione esegue il rendering del CAPTCHA all'URL specificato e restituisce l'input dell'utente. L'URL per l'immagine CAPTCHA viene aggiunto ai parametri di sfida pubblica come "`captchaUrl`", e la risposta prevista viene aggiunta ai parametri di sfida privata.
Per la quarta sfida, questa funzione restituisce una domanda di sicurezza. L'applicazione esegue il rendering della domanda e richiede all'utente la risposta. Dopo che gli utenti hanno risolto entrambe le sfide personalizzate, il trigger define auth challenge conferma che il pool di utenti può emettere token.
------
#### [ 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 };
```
------
# Trigger Lambda di una verifica di risposta di una richiesta di autenticazione
Il trigger verify auth challenge è una funzione Lambda che confronta la risposta fornita dall'utente con una risposta nota. Questa funzione indica al gruppo di utenti se l'utente ha risposto correttamente alla sfida. Quando il trigger di verifica dell'autenticazione risponde con un `answerCorrect` of`true`, la sequenza di autenticazione può continuare.
![\[Trigger Lambda di richieste\]](http://docs.aws.amazon.com/it_it/cognito/latest/developerguide/images/lambda-challenges3.png)
**Verifica la risposta alla sfida di autenticazione**
Amazon Cognito richiama questo trigger per verificare se la risposta dell'utente finale per una richiesta di autenticazione personalizzata è valida o meno. Fa parte di un [flusso di autenticazione personalizzato](https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-authentication-flow.html#amazon-cognito-user-pools-custom-authentication-flow) di un bacino d'utenza.
La richiesta per questo trigger include il `privateChallengeParameters` e la `challengeAnswer`. II trigger Lambda di creazione di una richiesta di autenticazione restituisce valori `privateChallengeParameters` e include la risposta prevista fornita dall'utente. Il parametro `challengeAnswer` contiene la risposta dell'utente per la sfida.
La risposta contiene l'attributo `answerCorrect`. Se l'utente completa correttamente la sfida, Amazon Cognito imposta il valore dell'attributo su `true`. Se l'utente non completa correttamente la sfida, Amazon Cognito imposta il valore su `false`.
Il loop di sfide si ripete finché gli utenti non rispondono a tutte le sfide.
**Topics**
+ [Parametri del trigger Lambda della verifica di una richiesta di autenticazione](#cognito-user-pools-lambda-trigger-syntax-verify-auth-challenge)
+ [Verifica di un esempio di risposta di una richiesta di autenticazione](#aws-lambda-triggers-verify-auth-challenge-response-example)
## Parametri del trigger Lambda della verifica di una richiesta di autenticazione
La richiesta passata da Amazon Cognito a questa funzione Lambda è una combinazione dei parametri seguenti e dei [parametri comuni](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-working-with-lambda-triggers.html#cognito-user-pools-lambda-trigger-syntax-shared) aggiunti da Amazon Cognito a tutte le richieste.
------
#### [ JSON ]
```
{
"request": {
"userAttributes": {
"string": "string",
. . .
},
"privateChallengeParameters": {
"string": "string",
. . .
},
"challengeAnswer": "string",
"clientMetadata": {
"string": "string",
. . .
},
"userNotFound": boolean
},
"response": {
"answerCorrect": boolean
}
}
```
------
### Parametri di richiesta di verifica sfida di autenticazione
**userAttributes**
Questo parametro contiene una o più coppie nome-valore che rappresentano gli attributi dell'utente.
**userNotFound**
Quando Amazon Cognito imposta `PreventUserExistenceErrors` su `ENABLED` per il tuo client del bacino d'utenza, Amazon Cognito popola questo valore booleano.
**privateChallengeParameters**
Questo parametro proviene dal trigger Creazione di una richiesta di autenticazione. Per determinare se l'utente ha superato una sfida, Amazon Cognito confronta i parametri con quelli della **challengeAnswer** di un utente.
Questo parametro contiene tutte le informazioni necessarie per convalidare la risposta dell'utente alla sfida. Tali informazioni includono la domanda che Amazon Cognito pone all'utente (`publicChallengeParameters`) e le risposte valide per la domanda (`privateChallengeParameters`). Questo parametro viene utilizzato solo dal trigger Lambda di verifica della risposta di una richiesta di autenticazione.
**challengeAnswer**
Il valore di questo parametro è la risposta dell'utente alla sfida.
**clientMetadata**
Una o più coppie chiave-valore che è possibile fornire come input personalizzato alla funzione Lambda specificata per il trigger di verifica di una richiesta di autenticazione. Per passare questi dati alla funzione Lambda, usa il ClientMetadata parametro nelle operazioni [AdminRespondToAuthChallenge](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminRespondToAuthChallenge.html)e [RespondToAuthChallenge](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_RespondToAuthChallenge.html)API. Amazon Cognito non include i dati del ClientMetadata parametro [AdminInitiateAuth](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminInitiateAuth.html)e le operazioni [InitiateAuth](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_InitiateAuth.html)API nella richiesta che passa alla funzione verify auth challenge.
### Parametri di risposta di verifica sfida di autenticazione
**answerCorrect**
Se l'utente completa correttamente la sfida, Amazon Cognito imposta questo parametro su `true`. Se l'utente non completa correttamente la sfida, Amazon Cognito imposta il parametro su `false`.
## Verifica di un esempio di risposta di una richiesta di autenticazione
Questa funzione di verifica dell'autenticazione verifica se la risposta dell'utente a una sfida corrisponde alla risposta prevista. La risposta dell'utente è definita in base all'input dell'applicazione e la risposta preferita è definita `privateChallengeParameters.answer` nella risposta della risposta del [trigger di creazione dell'autenticazione](user-pool-lambda-create-auth-challenge.md#aws-lambda-triggers-create-auth-challenge-example). Sia la risposta corretta che la risposta data fanno parte dell'evento di input di questa funzione.
In questo esempio, se la risposta dell'utente corrisponde alla risposta prevista, Amazon Cognito imposta il `answerCorrect` parametro su. `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 };
```
------