import base64
import hashlib
import hmac
import struct
import time
def generar_totp(secreto_base32: str, marca_tiempo: int = None, paso: int = 30, digitos: int = 6) -> str:
"""
Genera un token TOTP conforme al estándar RFC 6238.
:param secreto_base32: Clave secreta compartida en formato Base32 (ej. ‘JBSWY3DPEHPK3PXP’)
:param marca_tiempo: Marca de tiempo Unix en segundos. Por defecto toma time.time()
:param paso: Ventana de tiempo en segundos (por defecto: 30)
:param digitos: Número de dígitos del código generado (por defecto: 6)
:return: Código OTP formateado con ceros a la izquierda (ej. ‘045812’)
"""
if marca_tiempo is None:
marca_tiempo = int(time.time())
1. Normalizar la cadena Base32 y agregar el relleno ’=’ necesario
secreto_normalizado = secreto_base32.replace(” ”, "").upper()
relleno_necesario = (8 - len(secreto_normalizado) % 8) % 8
secreto_normalizado += ”=” * relleno_necesario
bytes_clave = base64.b32decode(secreto_normalizado)
2. Calcular el contador de tiempo T como entero de 64 bits en formato big-endian
contador_tiempo = marca_tiempo // paso
bytes_tiempo = struct.pack(“>Q”, contador_tiempo)  # 8 bytes big-endian sin signo
3. Calcular el resumen HMAC-SHA1 (20 bytes)
resumen_hmac = hmac.new(bytes_clave, bytes_tiempo, hashlib.sha1).digest()
4. Aplicar el Truncamiento Dinámico (Dynamic Truncation)
desplazamiento = resumen_hmac[-1] & 0x0F  # 4 bits inferiores del byte 20
Desempaquetar 4 bytes en el desplazamiento y enmascarar el bit de signo MSB
codigo_binario = struct.unpack(“>I”, resumen_hmac[desplazamiento : desplazamiento + 4])[0] & 0x7FFFFFFF
5. Operación de módulo y formateo con ceros a la izquierda
codigo_otp = codigo_binario % (10 ** digitos)
return str(codigo_otp).zfill(digitos)
if name == “main”:
clave_prueba = “JBSWY3DPEHPK3PXP”
print(f”Código TOTP Generado: {generar_totp(clave_prueba)}”)

const crypto = require('crypto');
// Decodificador Base32 RFC 4648 en JavaScript Puro
function decodificarBase32(strBase32) {
const alfabeto = ‘ABCDEFGHIJKLMNOPQRSTUVWXYZ234567’;
const limpio = strBase32.replace(/=+$/, ”).toUpperCase().replace(/\s+/g, ”);
let bits = 0, valor = 0, indice = 0;
const salida = new Uint8Array(Math.floor((limpio.length * 5) / 8));
for (let i = 0; i < limpio.length; i++) {
const val = alfabeto.indexOf(limpio[i]);
if (val === -1) continue;
valor = (valor << 5) | val;
bits += 5;
if (bits >= 8) {
salida[indice++] = (valor >>> (bits - 8)) & 255;
bits -= 8;
}
}
return Buffer.from(salida.buffer, 0, indice);
}
function generarTOTP(secretoBase32, marcaTiempo = Math.floor(Date.now() / 1000), paso = 30, digitos = 6) {
const clave = decodificarBase32(secretoBase32);
const contador = Math.floor(marcaTiempo / paso);
// Asignar búfer de 8 bytes en formato Big-Endian
const buffer = Buffer.alloc(8);
buffer.writeBigUInt64BE(BigInt(contador), 0);
// Calcular HMAC-SHA1
const hmac = crypto.createHmac(‘sha1’, clave).update(buffer).digest();
// Truncamiento Dinámico (Dynamic Truncation)
const desplazamiento = hmac[hmac.length - 1] & 0x0f;
const binario = ((hmac[desplazamiento] & 0x7f) << 24) |
((hmac[desplazamiento + 1] & 0xff) << 16) |
((hmac[desplazamiento + 2] & 0xff) << 8) |
(hmac[desplazamiento + 3] & 0xff);
const otp = binario % (10 ** digitos);
return otp.toString().padStart(digitos, ‘0’);
}
console.log(“TOTP Calculado:”, generarTOTP(“JBSWY3DPEHPK3PXP”));

async function generarTOTPEnNavegador(secretoBase32, marcaTiempo = Math.floor(Date.now() / 1000)) {
const bytesClave = decodificarBase32(secretoBase32);
const contador = Math.floor(marcaTiempo / 30);
// 1. Importar la clave secreta binaria en SubtleCrypto
const claveCripto = await window.crypto.subtle.importKey(
“raw”,
bytesClave,
{ name: “HMAC”, hash: { name: “SHA-1” } },
false,
[“sign”]
);
// 2. Codificar búfer contador de 8 bytes en formato Big-Endian
const buffer = new ArrayBuffer(8);
const vista = new DataView(buffer);
vista.setBigUint64(0, BigInt(contador), false); // false = Big-Endian
// 3. Ejecutar la firma criptográfica HMAC
const firma = await window.crypto.subtle.sign(“HMAC”, claveCripto, buffer);
const resultadoHmac = new Uint8Array(firma);
// 4. Truncamiento Dinámico
const desplazamiento = resultadoHmac[resultadoHmac.length - 1] & 0x0f;
const binario = ((resultadoHmac[desplazamiento] & 0x7f) << 24) |
((resultadoHmac[desplazamiento + 1] & 0xff) << 16) |
((resultadoHmac[desplazamiento + 2] & 0xff) << 8) |
(resultadoHmac[desplazamiento + 3] & 0xff);
const otp = binario % 1000000;
return otp.toString().padStart(6, ‘0’);
}

package main
import (
“crypto/hmac”
“crypto/sha1”
“encoding/base32”
“encoding/binary”
“fmt”
“math”
“strings”
“time”
)
// GenerarTOTP calcula tokens temporales conformes al estándar RFC 6238
func GenerarTOTP(secretoBase32 string, marcaTiempo int64, paso int64, digitos int) (string, error) {
// 1. Sanear la clave Base32 y decodificar
limpio := strings.ToUpper(strings.ReplaceAll(secretoBase32, ” ”, ""))
clave, err := base32.StdEncoding.WithPadding(base32.NoPadding).DecodeString(limpio)
if err != nil {
clave, err = base32.StdEncoding.DecodeString(limpio)
if err != nil {
return "", err
}
}
// 2. Codificar el contador de tiempo de 64 bits en formato Big-Endian
contador := uint64(marcaTiempo / paso)
buf := make([]byte, 8)
binary.BigEndian.PutUint64(buf, contador)
// 3. Calcular HMAC-SHA1
mac := hmac.New(sha1.New, clave)
mac.Write(buf)
hash := mac.Sum(nil)
// 4. Truncamiento Dinámico
desplazamiento := hash[len(hash)-1] & 0x0f
codigoBinario := binary.BigEndian.Uint32(hash[desplazamiento:desplazamiento+4]) & 0x7fffffff
// 5. Aritmética modular
mod := uint32(math.Pow10(digitos))
otp := codigoBinario % mod
formato := fmt.Sprintf(“%%0%dd”, digitos)
return fmt.Sprintf(formato, otp), nil
}
func main() {
codigo, err := GenerarTOTP(“JBSWY3DPEHPK3PXP”, time.Now().Unix(), 30, 6)
if err != nil {
panic(err)
}
fmt.Printf(“TOTP Calculado en Go: %s\n”, codigo)
}