Autenticação em múltiplos fatores

import crypto from "node:crypto";

const PASSO_S = 30; // cada código vale 30 segundos
const JANELA = 1; // aceita um passo antes e um depois, para relógios fora de hora

export function totp(segredo: Buffer, passo: number, digitos = 6): string {
  const contador = Buffer.alloc(8);
  contador.writeBigUInt64BE(BigInt(passo));
  const mac = crypto.createHmac("sha1", segredo).update(contador).digest();
  const deslocamento = mac[mac.length - 1] & 0x0f;
  const numero = mac.readUInt32BE(deslocamento) & 0x7fffffff;
  return String(numero % 10 ** digitos).padStart(digitos, "0");
}

/** Devolve o passo aceito, ou null. Guarde o passo para recusar o mesmo código de novo. */
export function verificar(segredo: Buffer, codigo: string, ultimoPasso: number,
                          agora = Date.now() / 1000): number | null {
  const atual = Math.floor(agora / PASSO_S);
  for (let passo = atual - JANELA; passo <= atual + JANELA; passo++) {
    const esperado = Buffer.from(totp(segredo, passo));
    const recebido = Buffer.from(codigo);
    if (passo > ultimoPasso && recebido.length === esperado.length
        && crypto.timingSafeEqual(recebido, esperado)) return passo;
  }
  return null;
}

import hashlib
import hmac
import struct
import time

PASSO_S = 30  # cada código vale 30 segundos
JANELA = 1  # aceita um passo antes e um depois, para relógios fora de hora


def totp(segredo: bytes, passo: int, digitos: int = 6) -> str:
    mac = hmac.new(segredo, struct.pack(">Q", passo), hashlib.sha1).digest()
    deslocamento = mac[-1] & 0x0F
    numero = struct.unpack(">I", mac[deslocamento:deslocamento + 4])[0] & 0x7FFFFFFF
    return str(numero % 10**digitos).zfill(digitos)


def verificar(
    segredo: bytes, codigo: str, ultimo_passo: int, agora: float | None = None
) -> int | None:
    """Devolve o passo aceito, ou None. Guarde o passo para recusar o mesmo código de novo."""
    atual = int((time.time() if agora is None else agora) // PASSO_S)
    for passo in range(atual - JANELA, atual + JANELA + 1):
        if passo > ultimo_passo and hmac.compare_digest(totp(segredo, passo), codigo):
            return passo
    return None

package main

import (
	"crypto/hmac"
	"crypto/sha1"
	"crypto/subtle"
	"encoding/binary"
	"fmt"
	"time"
)

const (
	passoS = 30 // cada código vale 30 segundos
	janela = 1  // aceita um passo antes e um depois, para relógios fora de hora
)

func totp(segredo []byte, passo int64, digitos int) string {
	var contador [8]byte
	binary.BigEndian.PutUint64(contador[:], uint64(passo))
	mac := hmac.New(sha1.New, segredo)
	mac.Write(contador[:])
	soma := mac.Sum(nil)
	deslocamento := soma[len(soma)-1] & 0x0f
	numero := binary.BigEndian.Uint32(soma[deslocamento:]) & 0x7fffffff
	modulo := uint32(1)
	for range digitos {
		modulo *= 10
	}
	return fmt.Sprintf("%0*d", digitos, numero%modulo)
}

// verificar devolve o passo aceito e true. Guarde o passo para recusar o mesmo código de novo.
func verificar(segredo []byte, codigo string, ultimoPasso int64, agora time.Time) (int64, bool) {
	atual := agora.Unix() / passoS
	for passo := atual - janela; passo <= atual+janela; passo++ {
		esperado := totp(segredo, passo, 6)
		if passo > ultimoPasso && subtle.ConstantTimeCompare([]byte(esperado), []byte(codigo)) == 1 {
			return passo, true
		}
	}
	return 0, false
}

import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.util.ArrayList;
import java.util.List;
import java.util.OptionalLong;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;

public class Totp {
    static final long PASSO_S = 30; // cada código vale 30 segundos
    static final int JANELA = 1; // aceita um passo antes e um depois, para relógios fora de hora

    static String totp(byte[] segredo, long passo, int digitos) throws Exception {
        var mac = Mac.getInstance("HmacSHA1");
        mac.init(new SecretKeySpec(segredo, "HmacSHA1"));
        byte[] soma = mac.doFinal(ByteBuffer.allocate(8).putLong(passo).array());
        int deslocamento = soma[soma.length - 1] & 0x0f;
        int numero = ByteBuffer.wrap(soma, deslocamento, 4).getInt() & 0x7fffffff;
        return String.format("%0" + digitos + "d", numero % (int) Math.pow(10, digitos));
    }

    /** Devolve o passo aceito. Guarde-o para recusar o mesmo código de novo. */
    static OptionalLong verificar(byte[] segredo, String codigo, long ultimoPasso, long agoraS)
            throws Exception {
        long atual = agoraS / PASSO_S;
        for (long passo = atual - JANELA; passo <= atual + JANELA; passo++) {
            byte[] esperado = totp(segredo, passo, 6).getBytes(StandardCharsets.US_ASCII);
            byte[] recebido = codigo.getBytes(StandardCharsets.US_ASCII);
            if (passo > ultimoPasso && MessageDigest.isEqual(esperado, recebido)) {
                return OptionalLong.of(passo);
            }
        }
        return OptionalLong.empty();
    }
}

using System.Buffers.Binary;
using System.Security.Cryptography;
using System.Text;

static class Totp
{
    const long PassoS = 30; // cada código vale 30 segundos
    const int Janela = 1; // aceita um passo antes e um depois, para relógios fora de hora

    public static string Gerar(byte[] segredo, long passo, int digitos = 6)
    {
        var contador = new byte[8];
        BinaryPrimitives.WriteInt64BigEndian(contador, passo);
        var soma = HMACSHA1.HashData(segredo, contador);
        var deslocamento = soma[^1] & 0x0f;
        var numero = BinaryPrimitives.ReadInt32BigEndian(soma.AsSpan(deslocamento)) & 0x7fffffff;
        return (numero % (int)Math.Pow(10, digitos)).ToString().PadLeft(digitos, '0');
    }

    /// Devolve o passo aceito, ou null. Guarde o passo para recusar o mesmo código de novo.
    public static long? Verificar(byte[] segredo, string codigo, long ultimoPasso, long agoraS)
    {
        var atual = agoraS / PassoS;
        for (var passo = atual - Janela; passo <= atual + Janela; passo++)
        {
            var esperado = Encoding.ASCII.GetBytes(Gerar(segredo, passo));
            var recebido = Encoding.ASCII.GetBytes(codigo);
            if (passo > ultimoPasso && CryptographicOperations.FixedTimeEquals(esperado, recebido))
                return passo;
        }
        return null;
    }
}