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