Usando autenticação de dois fatores em automações codificadas

Implemente a geração de código de autenticação de dois fatores em automações codificadas do Studio usando código C# de amostra ou um arquivo NUPKG.

Esse tutorial mostra como incluir código de exemplo que gera códigos de autenticação de dois fatores para suas automações. Aqui estão as maneiras de implementar o código de autenticação de dois fatores:

• Copie e cole o código em um arquivo .cs de seu projeto de destino.
• Use um arquivo NUPKG de amostra em seu projeto. Ao optar por usar o arquivo NUPKG de amostra, você tem a capacidade de adicionar a autenticação de dois fatores como uma atividade dentro de seus arquivos XAML.
  Dica:

  Independentemente de você optar por integrar o gerador de código de autenticação de dois fatores de amostra em seus arquivos CS (para automações codificadas) ou arquivos XAML (para automações de pouco código), lembre-se de que você pode invocar uma automação codificada em uma de pouco código e vice-versa. Para obter mais informações sobre automações híbridas, acesse Criação de automações híbridas – Combinando fluxos de trabalho codificados e de baixo código.

Copie e cole o código em arquivos .cs

Para usar a amostra de autenticação de dois fatores em sua automação codificada, você pode copiar e colar o seguinte código de amostra em um arquivo .cs de seu projeto de destino.

Observação:

O código de amostra gera um novo código de autenticação a cada 30 segundos. Por exemplo, se um código de autenticação for gerado em 3 horas, 45 minutos e 27 segundos, esse código está disponível por três segundos. Um novo código é gerado na marca de 30 segundos.

using System;
using System.Collections.Generic;
using UiPath.CodedWorkflows;
using System.Security.Cryptography;

namespace GenerateTwoFactorAuthenticationCode
{
    public class Workflow : CodedWorkflow
    {
        [Workflow]
        public string Execute(string secretKey)
        {
            return AuthenticationCode(secretKey);
        }

        private string AuthenticationCode(string secret)
        {
            // Step 1: Decode the base32 secret key
            byte[] key = Base32Decode(secret);

            // Step 2: Calculate the time step (current time divided by 30 seconds)
            long unixTime = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
            long timeStep = unixTime / 30;

            // Step 3: Convert time step to byte array (8 bytes, big-endian)
            byte[] timeBytes = BitConverter.GetBytes(timeStep);
            if (BitConverter.IsLittleEndian)
                Array.Reverse(timeBytes);

            // Step 4: Generate HMAC-SHA1 hash using the time step as message and secret key
            using (HMACSHA1 hmac = new HMACSHA1(key))
            {
                byte[] hash = hmac.ComputeHash(timeBytes);

                // Step 5: Extract dynamic binary code (4 bytes) from the hash
                int offset = hash[hash.Length - 1] & 0x0F;
                int binaryCode = (hash[offset] & 0x7F) << 24
                               | (hash[offset + 1] & 0xFF) << 16
                               | (hash[offset + 2] & 0xFF) << 8
                               | (hash[offset + 3] & 0xFF);

                // Step 6: Modulo to get a 6-digit code
                int otp = binaryCode % 1_000_000;

                // Return the OTP as a zero-padded 6-digit string
                return otp.ToString("D6");
            }
        }

        // Base32 decoding function to get the byte array from the base32-encoded key
        private static byte[] Base32Decode(string base32)
        {
            // Decode Base32-encoded string to byte array
            const string base32Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
            int bitBuffer = 0;
            int bitBufferLen = 0;
            var result = new List<byte>();

            foreach (char c in base32.ToUpper())
            {
                if (c == '=') break;

                int index = base32Chars.IndexOf(c);
                if (index < 0) throw new ArgumentException("Invalid Base32 character");

                bitBuffer = (bitBuffer << 5) | index;
                bitBufferLen += 5;

                if (bitBufferLen >= 8)
                {
                    result.Add((byte)(bitBuffer >> (bitBufferLen - 8)));
                    bitBufferLen -= 8;
                }
            }

            return result.ToArray();
        }
    }
}

Usar um arquivo NUPKG de amostra

Se você quiser usar um arquivo NUPKG de amostra para incluir o código de dois fatores em suas automações, siga estas etapas:

1. Baixe o seguinte arquivo NUPKG: GenerateTwoFactorAuthenticationCode.nupkg.
2. Carregue o arquivo NUPKG baixado para seu feed do Orchestrator Host ou Tenant, que são acessíveis por meio de sua instância do Studio. Para obter mais informações sobre o carregamento do arquivo NUPKG como uma biblioteca personalizada no Orchestrator, acesse Carregamento manual de uma biblioteca no Orchestrator.
3. Abra seu projeto do Studio e acesse o menu Gerenciar Pacotes.
4. Pesquise o arquivo NUPKG GenerateTwoFactorAuthenticationCode que você salvou anteriormente em seu feed do Orchestrator Host ou Orchestrator Tenant e instale-o.

Figura 1. A biblioteca personalizada no menu Gerenciar Pacotes

Resultado

Depois de instalar o arquivo, navegue até o painel Atividades e localize GenerateTwoFactorAuthenticationCode. Arraste e solte a atividade Get 2FA token em seus arquivos XAML para gerar um código de autenticação para suas automações.

Figura 2. A amostra de código GenerateTwoFactorAuthentication no painel de atividades