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

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 autenticação de dois fatores de amostra em seus arquivos .cs (para automações codificadas) ou arquivos XAML (para automações de baixo código), lembre-se de que você pode invocar uma automação codificada em uma automação de baixo 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();
        }
    }
}

Use um arquivo NUPGK 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
   

   

   
   

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. O exemplo de código GenerateTwoFactorAuthentication no painel Atividades