Adicione a autenticação de dois fatores (2FA) a um bot da Microsoft com a Verify API da Nexmo

A autenticação de dois fatores (2FA) é cada vez mais utilizada para aumentar a segurança em applications. À medida que os bots se tornam cada vez mais populares, os desenvolvedores precisarão considerar como integrar a 2FA aos seus bots. Nesta demonstração, veremos como usar a Verify API com o Microsoft Bot Framework.

Pré-requisitos

Nesta postagem, não vamos entrar em detalhes sobre a criação de um bot. Partimos do princípio de que você sabe como configurar o Visual Studio para criar projetos de bot. Se você não estiver familiarizado com o Microsoft Bot Framework, pode acessar a página de documentação aqui.

O Bot Builder SDK para .NET é compatível, atualmente, com C#. O Visual Studio para Mac não é compatível. Você precisará de um computador com Windows para poder executar esta demonstração.

Para configurar a autenticação de duas etapas (2FA), estamos usando Verify API do Nexmo Verify e a Biblioteca de Cliente Nexmo para C#

Como isso funciona?

No nosso cenário, vamos adicionar a autenticação de dois fatores a um bot no momento do cadastro. Como usuário novo, você precisará fornecer algumas informações para preencher seu perfil, como seu nome e número de telefone.

Em seguida, o bot tentará verificar esse número de telefone enviando um PIN por meio da Verify API. O próximo passo é coletar o PIN e verificá-lo.

Configurando o projeto do bot

A primeira coisa a fazer para configurar a autenticação de dois fatores (2FA) com um bot é criar um bot. Faz sentido, não é mesmo? No Visual Studio, crie um novo projeto do tipo “Bot Application”: Arquivo --> Novo --> Projeto --> Aplicativo de bot

Creating and Saving new project

Como usar o Nexmo com o bot

Usar as APIs da Nexmo com um aplicativo de bot não é diferente de usá-las com qualquer outro projeto .NET. Instale a biblioteca cliente da Nexmo para C# por meio do Console do Gerenciador de Pacotes do NuGet.

Install-Package Nexmo.Csharp.Client -Version 3.0.1’

Criação do formulário de perfil

Para verificar o número de telefone do usuário no momento do cadastro, vamos coletar algumas informações para criar o perfil do usuário.

Com o Microsoft Bot Framework, existem algumas maneiras de gerenciar o fluxo da conversa e criar diálogos. Neste caso, vamos usar o FormFlow , pois ele simplifica o processo de gerenciamento de uma conversa guiada como a nossa.

2fa Typing message

Adicione uma classe 'UserProfile' ao projeto; essa classe define o formulário. A classe inclui algumas propriedades para nos ajudar a criar o perfil e um método 'BuildForm()' que utiliza o 'FormBuilder' para criar o formulário e definir uma mensagem simples de boas-vindas.

Certifique-se de importar o namespace FormFlow para poder usar o FormFlow.

Microsoft.Bot.Builder.FormFlow

using Microsoft.Bot.Builder.Dialogs;
using Microsoft.Bot.Builder.FormFlow;
using System;

namespace _2FABotDemo
{
    [Serializable]
    public class UserProfile
    {
        [Prompt("What's your first name?")]
        public string FirstName;
        [Prompt("How about your last name?")]
        public string LastName;
        [Prompt("I now need your phone number in its international format but without '+' or '00'. I will send you a verification code shortly.")]
        public string PhoneNumber;
        public static IForm<UserProfile> BuildForm()
        {
            return new FormBuilder<UserProfile>().Message("Welcome! Before I'm of any use to you, I will need to verify your identity. Please answer the following questions.")
                .OnCompletion(async (context, UserProfile) => {
                    context.PrivateConversationData.SetValue<bool>("ProfileComplete", true);
                    await context.PostAsync("Your profile is complete.");
                })
                .Build();
        }
    }
}

Como usar o formulário

Agora que temos um formulário de perfil, precisamos conectá-lo à estrutura para podermos realmente usá-lo. Isso é feito adicionando-o ao controlador 'MessagesController.cs' por meio do método 'MakeRootDialog()'.

O método 'MakeRootDialog()' chama, por sua vez, o método 'FormDialog.FromForm' para criar o formulário de perfil do usuário. Assim que o perfil do usuário estiver preenchido, o bot enviará um código de verificação para o número de telefone fornecido pelo usuário.

Para maior clareza, estamos agrupando os métodos relacionados à verificação (ou seja, para envio e verificação) em uma classe auxiliar chamada 'VerifyHelper.cs'.

public  string RequestId { get; set; }
public Client Client { get; set; }

public VerifyHelper()
{
    Client = new Client(creds: new Nexmo.Api.Request.Credentials
    {
         ApiKey = "NEXMO_API_KEY",
         ApiSecret = "NEXMO_API_SECRET"
    });
}

public  void SendVerificationCode(string phoneNumber)
{
     var result = Client.NumberVerify.Verify(new NumberVerify.VerifyRequest
     {
          number = phoneNumber,
          brand = "NexmoQS"
     });

     RequestId = result.request_id;
}

internal static IDialog<UserProfile> MakeRootDialog() => Chain.From(() => FormDialog.FromForm(UserProfile.BuildForm))
                .Do(async (context, userprofile) =>
                {
                    SetVerify(new VerifyHelper());
                    try
                    {
                        var completed = await userprofile;
                        GetVerify().SendVerificationCode(completed.PhoneNumber);
                        await context.PostAsync("All Done! I sent a verification code to the phone number you provided. Could you please tell me the code once you receive it?");
                    }
                    catch (FormCanceledException<UserProfile> e)
                    {
                        string reply;
                        if (e.InnerException == null)
                        {
                            reply = $"You quit on {e.Last} -- maybe you can finish next time!";
                        }
                        else
                        {
                            reply = "Sorry, I've had a short circuit. Please try again.";
                        }
                        await context.PostAsync(reply);
                    }
                });

A função 'MakeRootDialog()' é chamada pelo método 'Conversation.SendAsync()'.

await Conversation.SendAsync(activity, () => MakeRootDialog());

Agora que o código foi enviado, o próximo passo é Verify-lo assim que o usuário o fornecer ao bot.

Verify Code

Isso é feito por meio do método 'CheckVerificationCode' no arquivo 'VerifyHelper.cs'.

public  string CheckVerificationCode(string code)
{
     var result = Client.NumberVerify.Check(new NumberVerify.CheckRequest
     {
          request_id = RequestId,
          code = code
     });

     if (result.status == "0")
     {
         return "Verification Sucessful";
     }
     else
     {
          return result.error_text;
     }
}

Como você pode ver, esse método retorna uma string porque queremos usar essa string para nos comunicarmos com o usuário por meio do bot. Outro ponto a ser observado aqui é o ‘RequestId’. Esse é o identificador da solicitação de verificação a ser verificada. Quando enviamos o código de verificação, simplesmente armazenamos esse identificador.

Agora, voltemos ao bot. Mencionamos que estamos criando o formulário no arquivo 'MessageController.cs'. Isso porque o método 'Post' dentro do 'MessageController.cs' é responsável por receber qualquer mensagem do usuário e abrir a caixa de diálogo principal.

Portanto, quando o usuário digitar o código de verificação, o bot ainda interceptará essa mensagem no método POST, da mesma forma que faz com as informações do perfil do usuário. Por isso, precisamos de uma maneira de indicar ao bot qual ação correta deve ser realizada em seguida. Se você observar atentamente o método `BuildForm` no arquivo `UserProfile.cs`, perceberá que estamos definindo a variável booleana `ProfileComplete` como `true` ao concluir o processo.

.OnCompletion(async (context, UserProfile) => {
                    context.PrivateConversationData.SetValue<bool>("ProfileComplete", true);

Então, o que acontece é que, sempre que o usuário digitar algo, verificaremos se a variável `ProfileComplete` está definida como `true` ou não. Se o perfil estiver completo, presume-se que o usuário tenha inserido o código de verificação e passamos a verificar se esse código é válido; caso contrário, continuamos preenchendo o perfil na caixa de diálogo principal.

StateClient sc = activity.GetStateClient();
                BotData userData = sc.BotState.GetPrivateConversationData(
                    activity.ChannelId, activity.Conversation.Id, activity.From.Id);

var boolProfileComplete = userData.GetProperty<bool>("ProfileComplete");

if (!boolProfileComplete)
{
   await Conversation.SendAsync(activity, () => MakeRootDialog());
}
else
{
   ConnectorClient connector = new ConnectorClient(new Uri(activity.ServiceUrl));
   Activity replyMessage = activity.CreateReply(GetVerify().CheckVerificationCode(activity.Text));
   await connector.Conversations.ReplyToActivityAsync(replyMessage);
}

Em poucas palavras

O objetivo desta demonstração é orientá-lo sobre como adicionar a autenticação de dois fatores (2FA) às suas aplicações de bot da Microsoft usando a API Nexmo Verify no momento do cadastro.

Criamos um formulário de perfil de usuário e, em seguida, enviamos um código de verificação para o número de telefone fornecido pelo usuário. Assim que o usuário inserir o código que lhe foi enviado, faremos a verificação. Fique de olho no nosso blog para ver mais exemplos e cenários sobre como usar as APIs da Nexmo com o Microsoft Bot Framework.