As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Acionadores do Lambda de desafio personalizado de autenticação
Ao criar seus fluxos de autenticação para seu grupo de usuários do Amazon Cognito, você pode querer estender seu modelo de autenticação além dos fluxos integrados. Um caso de uso comum dos acionadores de desafio personalizados é implementar verificações de segurança adicionais além do nome de usuário, senha e autenticação multifator (MFA). Desafio personalizado é qualquer pergunta e resposta que você possa gerar em uma linguagem de programação compatível com Lambda. Por exemplo, você pode exigir que os usuários resolvam um CAPTCHA ou respondam a uma pergunta de segurança antes de poderem se autenticar. Outra necessidade potencial é a integração com fatores ou dispositivos de autenticação especializados. Ou talvez você já tenha desenvolvido um software que autentica usuários com uma chave de segurança de hardware ou um dispositivo biométrico. A definição de sucesso na autenticação para um desafio personalizado é qualquer resposta que sua função do Lambda aceite como correta: uma string fixa, por exemplo, ou uma resposta satisfatória de uma API externa.
Você pode iniciar a autenticação com seu desafio personalizado e controlar totalmente o processo de autenticação, ou pode realizar a autenticação por nome de usuário e senha antes que sua aplicação receba seu desafio personalizado.
O acionador do Lambda do desafio de autenticação personalizada:
**[Define](user-pool-lambda-define-auth-challenge.md)**
Inicia uma sequência de desafios. Determina se você deseja iniciar um novo desafio, marcar a autenticação como concluída ou interromper a tentativa de autenticação.
**[Cria](user-pool-lambda-create-auth-challenge.md)**
Emite a pergunta para a aplicação para o usuário responder. Essa função pode apresentar uma pergunta de segurança ou um link para um CAPTCHA que sua aplicação deve exibir para o usuário.
**[Verifica](user-pool-lambda-verify-auth-challenge-response.md)**
Conhece a resposta esperada e a compara com a resposta que sua aplicação fornece na resposta ao desafio. A função pode chamar a API do seu serviço CAPTCHA para recuperar os resultados esperados da tentativa de solução do usuário.
Essas três funções do Lambda se agrupam para apresentar um mecanismo de autenticação que está completamente sob seu controle e sob seu próprio padrão. Como a autenticação personalizada requer lógica de aplicação no seu cliente e nas funções do Lambda, você não pode processar a autenticação personalizada no login gerenciado. Esse sistema de autenticação exige um esforço adicional do desenvolvedor. Sua aplicação deve realizar o fluxo de autenticação com a API de grupos de usuários e lidar com o desafio resultante com uma interface de login personalizada que coloque a pergunta no centro do desafio de autenticação personalizada.
![\[Acionadores do Lambda de desafio\]](http://docs.aws.amazon.com/pt_br/cognito/latest/developerguide/images/lambda-challenges.png)
Para mais informações sobre como implementar uma autenticação personalizada, consulte [Fluxo de autenticação personalizado e desafios](amazon-cognito-user-pools-authentication-flow-methods.md#Custom-authentication-flow-and-challenges).
Autenticação entre as operações da API [InitiateAuth](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_InitiateAuth.html)ou [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)ou [AdminRespondToAuthChallenge](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminRespondToAuthChallenge.html). Nesse fluxo, um usuário faz a autenticação respondendo desafios sucessivos até que ela falhe ou ele receba os tokens. Uma resposta ao desafio pode ser um novo desafio. Nesse caso, sua aplicação responde quantas vezes forem necessárias aos novos desafios. A autenticação bem-sucedida acontece quando a função define auth analisa os resultados até o momento, determina que todos os desafios foram respondidos e retorna `IssueTokens`.
**Topics**
+ [Autenticação SRP em fluxos de desafio personalizados](#user-pool-lambda-challenge-srp-authentication)
+ [Acionador do Lambda para definir desafio de autenticação](user-pool-lambda-define-auth-challenge.md)
+ [Acionador do Lambda de criar desafio de autenticação](user-pool-lambda-create-auth-challenge.md)
+ [Acionador do Lambda de verificar resposta do desafio de autenticação](user-pool-lambda-verify-auth-challenge-response.md)
## Autenticação SRP em fluxos de desafio personalizados
Você pode fazer com que o Amazon Cognito verifique senhas de usuário antes que ele emita seus desafios personalizados. Todos os gatilhos do Lambda associados à categoria Autenticação das [cotas de taxa de solicitação](quotas.md#category_operations.title) serão executados quando você realizar a autenticação SRP em um fluxo de desafio personalizado. Veja uma visão geral do processo:
1. Sua aplicação inicia o login chamando `InitiateAuth` ou `AdminInitiateAuth` com o mapa `AuthParameters`. Os parâmetros devem incluir `CHALLENGE_NAME: SRP_A,` e os valores de `SRP_A` e `USERNAME`.
1. O Amazon Cognito invoca o acionador do Lambda de desafio de autenticação com uma sessão inicial que contém `challengeName: SRP_A` e `challengeResult: true`.
1. Depois de receber essas entradas, a função do Lambda responde com `challengeName: PASSWORD_VERIFIER`, `issueTokens: false`, `failAuthentication: false`.
1. Se a verificação de senha for bem-sucedida, o Amazon Cognito invocará sua função do Lambda novamente com uma nova sessão contendo `challengeName: PASSWORD_VERIFIER` e `challengeResult: true`.
1. Para iniciar seus desafios personalizados, sua função do Lambda responde com `challengeName: CUSTOM_CHALLENGE`, `issueTokens: false` e `failAuthentication: false`. Se você não quiser iniciar seu fluxo de autenticação personalizado com a verificação de senha, poderá iniciar o login com o mapa `AuthParameters` incluindo `CHALLENGE_NAME: CUSTOM_CHALLENGE`.
1. O loop de desafios se repetirá até que todos os desafios sejam respondidos.
O exemplo a seguir mostra uma solicitação `InitiateAuth` inicial que precede a autenticação personalizada com um fluxo SRP.
```
{
"AuthFlow": "CUSTOM_AUTH",
"ClientId": "1example23456789",
"AuthParameters": {
"CHALLENGE_NAME": "SRP_A",
"USERNAME": "testuser",
"SRP_A": "[SRP_A]",
"SECRET_HASH": "[secret hash]"
}
}
```
### Redefinição de senha no fluxo SRP de autenticação personalizada
Quando os usuários têm status `FORCE_CHANGE_PASSWORD`, seu fluxo de autenticação personalizado deve integrar a etapa de alteração de senha e, ao mesmo tempo, manter a integridade de seus desafios de autenticação. O Amazon Cognito invoca seu acionador do Lambda [desafio de definição de autenticação](user-pool-lambda-define-auth-challenge.md) durante o desafio `NEW_PASSWORD_REQUIRED`. Nesse cenário, um usuário que faz login com um fluxo de desafio personalizado e autenticação SRP pode definir uma nova senha se estiver em um estado de redefinição de senha.
Quando os usuários têm o status `FORCE_CHANGE_PASSWORD` ou `RESET_REQUIRED`, eles devem [responder](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_RespondToAuthChallenge.html#API_RespondToAuthChallenge_RequestParameters) a um desafio `NEW_PASSWORD_REQUIRED` com um `NEW_PASSWORD`. Na autenticação personalizada com SRP, o Amazon Cognito retorna um desafio `NEW_PASSWORD_REQUIRED` depois que os usuários concluem o desafio `PASSWORD_VERIFIER` SRP. Seu acionador de desafio de definição de autenticação recebe os dois resultados do desafio na matriz `session` e pode continuar com desafios personalizados adicionais depois que o usuário alterar a senha com sucesso.
Seu acionador do Lambda do desafio de autenticação definido deve gerenciar a sequência de desafios pela autenticação SRP, redefinição de senha e desafios personalizados subsequentes. O acionador recebe uma matriz de desafios concluídos no parâmetro `session`, incluindo os resultados `PASSWORD_VERIFIER` e `NEW_PASSWORD_REQUIRED`. Para obter um exemplo de implementação, consulte [Exemplo de definição do desafio de autenticação](user-pool-lambda-define-auth-challenge.md#aws-lambda-triggers-define-auth-challenge-example).
#### Etapas do fluxo de autenticação
Para usuários que precisam verificar a senha antes de desafios personalizados, o processo segue estas etapas:
1. Sua aplicação inicia o login chamando `InitiateAuth` ou `AdminInitiateAuth` com o mapa `AuthParameters`. Os parâmetros devem incluir `CHALLENGE_NAME: SRP_A` e os valores de `SRP_A` e `USERNAME`.
1. O Amazon Cognito invoca o acionador do Lambda de desafio de autenticação com uma sessão inicial que contém `challengeName: SRP_A` e `challengeResult: true`.
1. Depois de receber essas entradas, a função do Lambda responde com `challengeName: PASSWORD_VERIFIER`, `issueTokens: false`, `failAuthentication: false`.
1. Se a verificação da senha for bem-sucedida, uma das duas coisas acontecerá:
**Para usuários com status normal:**
O Amazon Cognito invoca sua função do Lambda novamente com uma nova sessão contendo `challengeName: PASSWORD_VERIFIER` e `challengeResult: true`.
Para iniciar seus desafios personalizados, sua função do Lambda responde com `challengeName: CUSTOM_CHALLENGE`, `issueTokens: false` e `failAuthentication: false`.
**Para usuários com status `RESET_REQUIRED` ou `FORCE_CHANGE_PASSWORD`:**
O Amazon Cognito invoca sua função do Lambda com uma sessão contendo `challengeName: PASSWORD_VERIFIER` e `challengeResult: true`.
Sua função do Lambda deve responder com `challengeName: NEW_PASSWORD_REQUIRED`, `issueTokens: false` e `failAuthentication: false`.
Após a alteração bem-sucedida da senha, o Amazon Cognito invoca sua função do Lambda com uma sessão contendo os resultados `PASSWORD_VERIFIER` e `NEW_PASSWORD_REQUIRED`.
Para iniciar seus desafios personalizados, sua função do Lambda responde com `challengeName: CUSTOM_CHALLENGE`, `issueTokens: false` e `failAuthentication: false`.
1. O loop de desafios se repetirá até que todos os desafios sejam respondidos.
Se você não quiser iniciar seu fluxo de autenticação personalizado com a verificação de senha, poderá iniciar o login com o mapa `AuthParameters` incluindo `CHALLENGE_NAME: CUSTOM_CHALLENGE`.
#### Gerenciamento de sessões
O fluxo de autenticação mantém a continuidade da sessão por meio de uma série de resultados de sessões IDs e desafios. Cada resposta ao desafio gera um novo ID de sessão para evitar erros de reutilização da sessão, o que é importante principalmente para fluxos de autenticação multifator.
Os resultados do desafio são armazenados cronologicamente na matriz de sessões que seus acionadores do Lambda recebem. Para usuários com status `FORCE_CHANGE_PASSWORD`, a matriz da sessão contém:
1. `session[0]` – Desafio `SRP_A` inicial
1. `session[1]` – Resultado `PASSWORD_VERIFIER`
1. `session[2]` – Resultado `NEW_PASSWORD_REQUIRED`
1. Elementos subsequentes – Resultados de desafios personalizados adicionais
#### Exemplo de fluxo de autorização
O exemplo a seguir demonstra um fluxo completo de autenticação personalizada para um usuário com status `FORCE_CHANGE_PASSWORD` que precisa concluir a alteração da senha e um desafio CAPTCHA personalizado.
1. **InitiateAuth request**
```
{
"AuthFlow": "CUSTOM_AUTH",
"ClientId": "1example23456789",
"AuthParameters": {
"CHALLENGE_NAME": "SRP_A",
"USERNAME": "testuser",
"SRP_A": "[SRP_A]"
}
}
```
1. **InitiateAuth resposta**
```
{
"ChallengeName": "PASSWORD_VERIFIER",
"ChallengeParameters": {
"USER_ID_FOR_SRP": "testuser"
},
"Session": "[session_id_1]"
}
```
1. **RespondToAuthChallenge solicitação com `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 resposta com `NEW_PASSWORD_REQUIRED` desafio**
```
{
"ChallengeName": "NEW_PASSWORD_REQUIRED",
"ChallengeParameters": {},
"Session": "[session_id_2]"
}
```
1. **RespondToAuthChallenge solicitação com `NEW_PASSWORD_REQUIRED`**
```
{
"ChallengeName": "NEW_PASSWORD_REQUIRED",
"ClientId": "1example23456789",
"ChallengeResponses": {
"NEW_PASSWORD": "[password]",
"USERNAME": "testuser"
},
"Session": "[session_id_2]"
}
```
1. **RespondToAuthChallenge resposta com desafio personalizado de CAPTCHA**
```
{
"ChallengeName": "CUSTOM_CHALLENGE",
"ChallengeParameters": {
"captchaUrl": "url/123.jpg"
},
"Session": "[session_id_3]"
}
```
1. **RespondToAuthChallenge solicitação com resposta ao desafio personalizado CAPTCHA**
```
{
"ChallengeName": "CUSTOM_CHALLENGE",
"ClientId": "1example23456789",
"ChallengeResponses": {
"ANSWER": "123",
"USERNAME": "testuser"
},
"Session": "[session_id_3]"
}
```
**6. Resposta final de sucesso**
```
{
"AuthenticationResult": {
"AccessToken": "eyJra456defEXAMPLE",
"ExpiresIn": 3600,
"IdToken": "eyJra789ghiEXAMPLE",
"RefreshToken": "eyJjd123abcEXAMPLE",
"TokenType": "Bearer"
},
"ChallengeParameters": {}
}
```
# Acionador do Lambda para definir desafio de autenticação
O gatilho de desafio define auth é uma função do Lambda que mantém a sequência de desafios em um fluxo de autenticação personalizado. Ele declara o sucesso ou o fracasso da sequência de desafios e define o próximo desafio se a sequência ainda não estiver completa.
![\[Acionadores do Lambda de desafio\]](http://docs.aws.amazon.com/pt_br/cognito/latest/developerguide/images/lambda-challenges1.png)
**Definir o desafio de autenticação**
O Amazon Cognito invoca esse acionador para iniciar o [fluxo de autenticação personalizado](https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-authentication-flow.html#amazon-cognito-user-pools-custom-authentication-flow).
A solicitação desse acionador do Lambda contém `session`. O parâmetro `session` é uma matriz que contém todos os desafios apresentados ao usuário no processo de autenticação atual. A solicitação também inclui o resultado correspondente. A matriz `session` armazena detalhes do desafio (`ChallengeResult`) em ordem cronológica. O desafio `session[0]` representa o primeiro que o usuário recebe.
**Topics**
+ [Parâmetros do acionador do Lambda para definir o desafio de autenticação](#cognito-user-pools-lambda-trigger-syntax-define-auth-challenge)
+ [Exemplo de definição do desafio de autenticação](#aws-lambda-triggers-define-auth-challenge-example)
## Parâmetros do acionador do Lambda para definir o desafio de autenticação
A solicitação que o Amazon Cognito transmite para essa função do Lambda é uma combinação dos parâmetros abaixo e dos [parâmetros comuns](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-working-with-lambda-triggers.html#cognito-user-pools-lambda-trigger-syntax-shared) que o Amazon Cognito adiciona a todas as solicitações.
------
#### [ JSON ]
```
{
"request": {
"userAttributes": {
"string": "string",
. . .
},
"session": [
ChallengeResult,
. . .
],
"clientMetadata": {
"string": "string",
. . .
},
"userNotFound": boolean
},
"response": {
"challengeName": "string",
"issueTokens": boolean,
"failAuthentication": boolean
}
}
```
------
### Parâmetros de solicitação para definir o desafio de autenticação
Quando o Amazon Cognito invoca sua função do Lambda, ele fornece os seguintes parâmetros:
**userAttributes**
Um ou mais pares de nome-valor que representam atributos de usuário.
**userNotFound**
Um booleano que é preenchido pelo Amazon Cognito quando `PreventUserExistenceErrors` é definido como `ENABLED` para o cliente de grupo de usuários. Um valor de `true` significa que o ID do usuário (nome de usuário, endereço de e-mail e outros detalhes) não correspondeu a nenhum usuário existente. Quando `PreventUserExistenceErrors` é definido como `ENABLED`, o serviço não informa a aplicação dos usuários inexistentes. Recomendamos que suas funções do Lambda mantenham a mesma experiência do usuário e contabilizem a latência. Dessa forma, o autor da chamada não consegue detectar comportamentos diferentes quando o usuário existe ou não existe.
**sessão**
Uma matriz de elementos `ChallengeResult`. Cada regra contém os seguintes elementos:
**challengeName**
Um dos seguintes tipos de desafio: `CUSTOM_CHALLENGE`, `SRP_A`, `PASSWORD_VERIFIER`, `SMS_MFA`, `EMAIL_OTP`, `SOFTWARE_TOKEN_MFA`, `DEVICE_SRP_AUTH`, `DEVICE_PASSWORD_VERIFIER` ou `ADMIN_NO_SRP_AUTH`.
Quando sua função define auth challenge emite um desafio `PASSWORD_VERIFIER` para um usuário que configurou a autenticação multifator, o Amazon Cognito prossegue com um desafio `SMS_MFA`, `EMAIL_OTP` ou `SOFTWARE_TOKEN_MFA`. Essas são as instruções para um código de autenticação multifator. Em sua função, inclua o tratamento de eventos de entrada de desafios `SMS_MFA`, `EMAIL_OTP` e `SOFTWARE_TOKEN_MFA`. Você não precisa invocar os desafios de MFA usando sua função de desafio define auth.
Quando sua função estiver determinando se um usuário fez a autenticação com êxito e você precisar emitir tokens para ele, sempre confira `challengeName` em sua função “define auth challenge” e garantir que corresponda ao valor esperado.
**challengeResult**
Defina como `true` se o usuário tiver concluído o desafio com êxito; do contrário, defina-o como `false`.
**challengeMetadata**
Seu nome para o desafio personalizado. Usado somente se `challengeName` for `CUSTOM_CHALLENGE`.
**clientMetadata**
Um ou mais pares de chave/valor que você pode fornecer como entrada personalizada para a função do Lambda especificada para o acionador definir desafio de autenticação. Para passar esses dados para sua função Lambda, você pode usar o `ClientMetadata` parâmetro nas operações [AdminRespondToAuthChallenge](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminRespondToAuthChallenge.html)e da [RespondToAuthChallenge](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_RespondToAuthChallenge.html)API. A solicitação que invoca a função define auth challenge não inclui dados transmitidos no ClientMetadata parâmetro [AdminInitiateAuth](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminInitiateAuth.html)e [InitiateAuth](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_InitiateAuth.html)operações de API.
### Parâmetros de resposta para definir o desafio de autenticação
Na resposta, você pode retornar o próximo estágio do processo de autenticação.
**challengeName**
Uma string que contém o nome do próximo desafio. Se você deseja apresentar um novo desafio ao seu usuário, especifique o nome do desafio aqui.
**issueTokens**
Se você determinar que o usuário concluiu os desafios de autenticação de forma adequada; defina-o como `true`. Se o usuário não cumprir os desafios devidamente, defina como `false`.
**failAuthentication**
Se quiser encerrar o processo de autenticação atual, defina-o como `true`. Para continuar o processo de autenticação atual, defina-o como `false`.
## Exemplo de definição do desafio de autenticação
Este exemplo definirá uma série de desafios de autenticação e emitirá tokens somente se o usuário concluir todos os desafios com êxito. Quando os usuários concluem a autenticação SRP com os desafios `SRP_A` e `PASSWORD_VERIFIER`, essa função transmite a eles um `CUSTOM_CHALLENGE` que invoca o acionador do desafio de criação de autorização. Em combinação com nosso [exemplo de desafio de criação de autenticação](user-pool-lambda-create-auth-challenge.md#aws-lambda-triggers-create-auth-challenge-example), essa sequência oferece um desafio CAPTCHA para o desafio três e uma pergunta de segurança para o desafio quatro.
Depois que o usuário resolve o CAPTCHA e responde à pergunta de segurança, essa função confirma que seu grupo de usuários pode emitir tokens. A autenticação SRP não é necessária; você também pode definir o CAPTCHA e a pergunta de segurança como desafios um e dois. Caso sua função de definição de desafio de autenticação não declare desafios de SRP, o sucesso de seus usuários será determinado inteiramente pelas respostas deles aos seus prompts personalizados.
------
#### [ 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 };
```
------
# Acionador do Lambda de criar desafio de autenticação
O acionador de desafio create auth é uma função do Lambda que tem os detalhes de cada desafio declarado pelo acionador de desafio define auth. Ele processa o nome do desafio declarado pelo acionador de desafio define auth e retorna um `publicChallengeParameters` que sua aplicação deve apresentar ao usuário. Essa função então fornece ao seu grupo de usuários a resposta para o desafio `privateChallengeParameters`, que seu grupo de usuários passa para o acionador do desafio verify auth. Onde seu acionador de desafio define auth gerencia a sequência de desafios, seu acionador de desafio create auth gerencia o conteúdo do desafio.
![\[Acionadores do Lambda de desafio\]](http://docs.aws.amazon.com/pt_br/cognito/latest/developerguide/images/lambda-challenges2.png)
**Criar desafio de autenticação**
O Amazon Cognito invocará esse acionador depois de **Definir desafio de autenticação** se um desafio personalizado tiver sido especificado como parte do acionador **Definir desafio de autenticação**. Ele cria um [fluxo de autenticação personalizado](https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-authentication-flow.html#amazon-cognito-user-pools-custom-authentication-flow).
Esse acionador do Lambda é invocado para criar um desafio a ser apresentado ao usuário. A solicitação deste acionador do Lambda inclui `challengeName` e `session`. O `challengeName` é uma string que representa o nome do próximo desafio a ser apresentado ao usuário. O valor desse atributo é definido no acionador do Lambda Definir desafio de autenticação.
O loop de desafio será repetido até todos os desafios serem respondidos.
**Topics**
+ [Parâmetros do acionador do Lambda de criar desafio de autenticação](#cognito-user-pools-lambda-trigger-syntax-create-auth-challenge)
+ [Exemplo de criar desafio de autenticação](#aws-lambda-triggers-create-auth-challenge-example)
## Parâmetros do acionador do Lambda de criar desafio de autenticação
A solicitação que o Amazon Cognito transmite para essa função do Lambda é uma combinação dos parâmetros abaixo e dos [parâmetros comuns](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-working-with-lambda-triggers.html#cognito-user-pools-lambda-trigger-syntax-shared) que o Amazon Cognito adiciona a todas as solicitações.
------
#### [ JSON ]
```
{
"request": {
"userAttributes": {
"string": "string",
. . .
},
"challengeName": "string",
"session": [
ChallengeResult,
. . .
],
"clientMetadata": {
"string": "string",
. . .
},
"userNotFound": boolean
},
"response": {
"publicChallengeParameters": {
"string": "string",
. . .
},
"privateChallengeParameters": {
"string": "string",
. . .
},
"challengeMetadata": "string"
}
}
```
------
### Parâmetros de solicitação de criar desafio de autenticação
**userAttributes**
Um ou mais pares de nome-valor que representam atributos de usuário.
**userNotFound**
Este booleano é preenchido quando `PreventUserExistenceErrors` é configurado como `ENABLED` para o cliente de grupo de usuários.
**challengeName**
O nome do novo desafio.
**sessão**
O elemento session é uma matriz de elementos `ChallengeResult`, cada um deles contendo os seguintes elementos:
**challengeName**
O tipo de desafio. Um destes: `"CUSTOM_CHALLENGE"`, `"PASSWORD_VERIFIER"`, `"SMS_MFA"`, `"DEVICE_SRP_AUTH"`, `"DEVICE_PASSWORD_VERIFIER"`, `"NEW_PASSWORD_REQUIRED"` ou `"ADMIN_NO_SRP_AUTH"`.
**challengeResult**
Defina como `true` se o usuário tiver concluído o desafio com êxito; do contrário, defina-o como `false`.
**challengeMetadata**
Seu nome para o desafio personalizado. Usado somente se `challengeName` for `"CUSTOM_CHALLENGE"`.
**clientMetadata**
Um ou mais pares de chave-valor que você pode fornecer como entrada personalizada para a função Lambda especificada para o acionador de criação do desafio de autenticação. Você pode usar o ClientMetadata parâmetro nas ações [AdminRespondToAuthChallenge](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminRespondToAuthChallenge.html)e da [RespondToAuthChallenge](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_RespondToAuthChallenge.html)API para passar esses dados para sua função Lambda. A solicitação que invoca a função create auth challenge não inclui dados transmitidos no ClientMetadata parâmetro [AdminInitiateAuth](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminInitiateAuth.html)e [InitiateAuth](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_InitiateAuth.html)nas operações da API.
### Parâmetros de resposta de criar desafio de autenticação
**publicChallengeParameters**
Um ou mais pares de chave-valor do aplicativo cliente que serão usados no desafio a ser apresentado ao usuário. Este parâmetro deve conter todas as informações necessárias para apresentar com precisão o desafio ao usuário.
**privateChallengeParameters**
Esse parâmetro é usado somente pelo acionador do Lambda Verificar resposta do desafio de autenticação. Este parâmetro deve conter todas as informações necessárias para validar a resposta do usuário para o desafio. Em outras palavras, o parâmetro `publicChallengeParameters` contém a pergunta apresentada ao usuário, enquanto `privateChallengeParameters` contém as respostas válidas da pergunta.
**challengeMetadata**
Seu nome para o desafio personalizado, caso esse seja um desafio personalizado.
## Exemplo de criar desafio de autenticação
Essa função tem dois desafios personalizados que correspondem à sequência de desafios em nosso [exemplo de definição de desafio de autenticação](user-pool-lambda-define-auth-challenge.md#aws-lambda-triggers-define-auth-challenge-example). Os dois primeiros desafios são a autenticação SRP. Para o terceiro desafio, essa função retorna um URL CAPTCHA para sua aplicação na resposta do desafio. Sua aplicação renderiza o CAPTCHA no URL fornecido e retorna a entrada do usuário. O URL da imagem CAPTCHA é adicionado aos parâmetros de desafio público como "`captchaUrl`", e a resposta esperado é adicionada aos parâmetros de desafio privado.
Para o quarto desafio, essa função retorna uma pergunta de segurança. Sua aplicação renderiza a pergunta e solicita que o usuário responda. Depois que os usuários resolverem os dois desafios personalizados, o acionador do de definição de desafio autenticação confirma que seu grupo de usuários pode emitir tokens.
------
#### [ 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 };
```
------
# Acionador do Lambda de verificar resposta do desafio de autenticação
O acionador do desafio verify auth é uma função do Lambda que compara a resposta fornecida pelo usuário com uma resposta conhecida. Essa função informa ao seu grupo de usuários se o usuário respondeu ao desafio corretamente. Quando o gatilho do desafio verify auth responde com um `answerCorrect` of`true`, a sequência de autenticação pode continuar.
![\[Acionadores do Lambda de desafio\]](http://docs.aws.amazon.com/pt_br/cognito/latest/developerguide/images/lambda-challenges3.png)
**Verificar a resposta do desafio de autenticação**
O Amazon Cognito invoca esse acionador para verificar se a resposta do usuário a um desafio de autenticação personalizado é válida ou não. Ele faz parte de um [fluxo de autenticação personalizado](https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-authentication-flow.html#amazon-cognito-user-pools-custom-authentication-flow) do grupo de usuários.
A solicitação deste trigger contém os parâmetros `privateChallengeParameters` e `challengeAnswer`. O acionador do Lambda de criação de desafio de autenticação retorna valores `privateChallengeParameters` e contém a resposta esperada do usuário. O parâmetro `challengeAnswer` contém a resposta do usuário para o desafio.
A resposta contém o atributo `answerCorrect`. Se o usuário concluir o desafio com êxito, o Amazon Cognito definirá o valor do atributo como `true`. Se o usuário não concluir o desafio com êxito, o Amazon Cognito definirá o valor como `false`.
O loop de desafios se repetirá até que o usuário responda a todos os desafios.
**Topics**
+ [Parâmetros do acionador do Lambda de verificar desafio de autenticação](#cognito-user-pools-lambda-trigger-syntax-verify-auth-challenge)
+ [Exemplo de resposta de verificar desafio de autenticação](#aws-lambda-triggers-verify-auth-challenge-response-example)
## Parâmetros do acionador do Lambda de verificar desafio de autenticação
A solicitação que o Amazon Cognito transmite para essa função do Lambda é uma combinação dos parâmetros abaixo e dos [parâmetros comuns](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-working-with-lambda-triggers.html#cognito-user-pools-lambda-trigger-syntax-shared) que o Amazon Cognito adiciona a todas as solicitações.
------
#### [ JSON ]
```
{
"request": {
"userAttributes": {
"string": "string",
. . .
},
"privateChallengeParameters": {
"string": "string",
. . .
},
"challengeAnswer": "string",
"clientMetadata": {
"string": "string",
. . .
},
"userNotFound": boolean
},
"response": {
"answerCorrect": boolean
}
}
```
------
### Parâmetros de solicitação de verificar desafio de autenticação
**userAttributes**
Esse parâmetro contém um ou mais pares de nome-valor que representam atributos de usuário.
**userNotFound**
Quando o Amazon Cognito define `PreventUserExistenceErrors` como `ENABLED` para o cliente de grupo de usuários, ele preenche esse booleano.
**privateChallengeParameters**
Esse parâmetro vem do acionador de criação de desafio de autenticação. Para determinar se o usuário passou em um desafio, o Amazon Cognito compara os parâmetros com **challengeAnswer** do usuário.
Esse parâmetro contém todas as informações necessárias para validar a resposta do usuário para o desafio. Essas informações incluem a pergunta que o Amazon Cognito apresenta ao usuário (`publicChallengeParameters`) e as respostas válidas para a pergunta (`privateChallengeParameters`). Somente o acionador do Lambda de verificação da resposta do desafio de autenticação usa esse parâmetro.
**challengeAnswer**
Esse valor de parâmetro é a resposta do usuário para o desafio.
**clientMetadata**
Esse parâmetro contém um ou mais pares de chave-valor que você pode fornecer como entrada personalizada à função do Lambda para o acionador de verificação do desafio de autenticação. Para passar esses dados para sua função Lambda, use o ClientMetadata parâmetro nas operações [AdminRespondToAuthChallenge](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminRespondToAuthChallenge.html)e da [RespondToAuthChallenge](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_RespondToAuthChallenge.html)API. O Amazon Cognito não inclui dados do ClientMetadata parâmetro [AdminInitiateAuth](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminInitiateAuth.html)e operações de [InitiateAuth](https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_InitiateAuth.html)API na solicitação que ele passa para a função de desafio de verificação de autenticação.
### Parâmetros de resposta de verificar desafio de autenticação
**answerCorrect**
Se o usuário concluir o desafio com êxito, o Amazon Cognito definirá esse parâmetro como `true`. Se o usuário não concluir o desafio com êxito, o Amazon Cognito definirá o parâmetro como `false`.
## Exemplo de resposta de verificar desafio de autenticação
A função de verificação do desafio de autorização confere se a resposta do usuário a um desafio corresponde à resposta esperada. A resposta do usuário é definida pela entrada da sua aplicação, e a resposta preferencial é definida por `privateChallengeParameters.answer` na resposta da [resposta do acionador criar desafio de autenticação](user-pool-lambda-create-auth-challenge.md#aws-lambda-triggers-create-auth-challenge-example). Tanto a resposta correta quanto a resposta dada fazem parte do evento de entrada para essa função.
Neste exemplo, se a resposta do usuário corresponder à resposta esperada, o Amazon Cognito definirá o parâmetro `answerCorrect` como `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 };
```
------