Saltar al contenido principal

Entropía y Aleatoriedad en Criptomonedas: Por Qué Importa

Cada clave privada de criptomonedas, cada frase semilla y cada dirección que usas comienza con un número aleatorio. La seguridad de todo tu portafolio cripto se basa en una suposición: que ese número era realmente impredecible. Si el generador de números aleatorios que produjo tu clave era débil, sesgado o predecible, tus fondos pueden ser robados, no por romper la criptografía, sino adivinando la clave.

Esta guía explica qué significa la entropía en un contexto criptográfico, cómo funcionan los generadores de números aleatorios, qué ha salido mal históricamente cuando falló la aleatoriedad y cómo asegurarte de que tu generación de claves sea sólida.

¿Qué Es la Entropía?​

En teoría de la información, la entropía mide la cantidad de incertidumbre o imprevisibilidad en un dato. En criptografía, la entropía cuantifica cuántos bits de aleatoriedad genuina contiene un valor.

Una clave privada de 256 bits debería tener 256 bits de entropía, lo que significa que un atacante debe intentar, en promedio, 2^255 intentos para encontrarla (la mitad del espacio de búsqueda, en promedio). Si la clave se generó con solo 32 bits de entropía real (porque el RNG estaba defectuoso), el atacante necesita solo alrededor de 2^31 intentos, aproximadamente 2 mil millones, que una computadora moderna puede agotar en minutos.

Medición de la Entropía​

La entropía se mide en bits. La entropía de una variable aleatoria X es:

H(X) = -sum(p(x) * log2(p(x))) for all possible values x

Para un número aleatorio uniforme de 256 bits:

  • Cada bit tiene probabilidad 0.5 de ser 0 o 1.
  • Entropía = 256 bits (máxima para este tamaño).

Para un generador sesgado donde cada bit tiene probabilidad 0.7 de ser 1:

  • Entropía por bit = -(0.7 * log2(0.7) + 0.3 * log2(0.3)) = 0.881 bits.
  • Entropía total para 256 bits = 225.5 bits (11.9% menos que lo ideal).

Incluso sesgos pequeños se acumulan en muchos bits y pueden reducir significativamente el nivel de seguridad efectivo.

Entropía en el Contexto de BIP-39​

Longitud MnemónicaEntropíaNivel de SeguridadFuerza Bruta a 10^12/seg
12 palabras128 bits128-bit~10^19 años
15 palabras160 bits160-bit~10^28 años
18 palabras192 bits192-bit~10^38 años
24 palabras256 bits256-bit~10^57 años

Estos números asumen que la entropía es realmente uniforme. Si el RNG está defectuoso, el nivel de seguridad real podría ser drásticamente menor.

Tipos de Generadores de Números Aleatorios​

Generadores Verdaderos de Números Aleatorios (TRNG)​

Los TRNG muestrean fenómenos físicos que son inherentemente impredecibles a nivel cuántico:

  • Ruido térmico — Fluctuaciones aleatorias de voltaje en resistencias causadas por la agitación térmica de electrones.
  • Ruido de disparo — Fluctuaciones aleatorias de corriente debido a la naturaleza discreta del flujo de electrones.
  • Decaimiento radiactivo — El momento de eventos individuales de decaimiento es fundamentalmente impredecible.
  • Ruido atmosférico — Ruido de radiofrecuencia de rayos y otros procesos atmosféricos.

Las hardware wallets como Ledger y Trezor usan TRNG integrados en chip. Estos muestrean fuentes de ruido físico y acondicionan la salida mediante whitening y pruebas de salud.

Ventajas: Aleatoriedad verdadera desde la física; sin estado determinista que predecir.
Desventajas: Dependiente del hardware; puede fallar silenciosamente si la fuente de ruido se degrada; el rendimiento puede ser limitado.

Generadores Pseudoaleatorios Criptográficamente Seguros (CSPRNG)​

Un CSPRNG es un algoritmo determinista que produce una salida indistinguible de la aleatoriedad real, dada una semilla suficientemente aleatoria:

  • Linux: /dev/urandom (usa ChaCha20 o un cifrado similar, sembrado desde entropía de hardware).
  • macOS: /dev/urandom (arc4random, sembrado desde entropía de hardware).
  • Windows: BCryptGenRandom (proveedor CNG).
  • Navegadores web: crypto.getRandomValues() (delegado al CSPRNG del SO).
  • Python: os.urandom() o módulo secrets.
  • Node.js: crypto.randomBytes().

Ventajas: Rápido; algoritmos bien estudiados; disponible en todas las plataformas.
Desventajas: Tan fuerte como la entropía inicial de la semilla; determinista: si se conoce el estado interno, toda la salida futura es predecible.

PRNG No Criptográficos (NUNCA Usar para Claves)​

Las funciones aleatorias de librería estándar en la mayoría de los lenguajes de programación están diseñadas para simulación estadística, no para criptografía:

  • Python: random.random() (Mersenne Twister — determinista, estado recuperable desde 624 salidas).
  • JavaScript: Math.random() (xorshift128+ en V8 — predecible).
  • C: rand() (generador congruencial lineal — trivialmente predecible).
  • Java: java.util.Random (congruencial lineal — predecible).

Estos generadores tienen baja entropía, periodos cortos y estado predecible. Usarlos para generar claves equivale a no usar aleatoriedad en absoluto. Nunca generes claves privadas o frases semilla con estas funciones.

Fallos Históricos de la Aleatoriedad​

El Bug de Android SecureRandom (2013)​

En agosto de 2013, se descubrió una falla crítica en la implementación de SecureRandom de Android. El PRNG de Java no estaba correctamente inicializado en ciertos dispositivos Android, lo que provocó que múltiples apps de wallet de Bitcoin generaran claves privadas desde un estado predecible. Un atacante explotó esto para robar aproximadamente 55 BTC. El bug afectaba la generación del nonce de firmas ECDSA: usar el mismo nonce dos veces permite calcular la clave privada a partir de dos firmas.

El "Blockchain Bandit" (2019)​

El investigador de seguridad Adrian Bednarek descubrió que se habían generado wallets con claves privadas trivialmente débiles: claves como 1, 2, 3 o palabras simples de diccionario hasheadas una vez. Un atacante estuvo vaciando sistemáticamente fondos de estas direcciones durante años, acumulando más de 45,000 ETH. El bandido simplemente enumeraba claves de baja entropía y verificaba si tenían fondos.

Ejemplos de claves que fueron drenadas:

  • Clave privada 0x0000000000000000000000000000000000000000000000000000000000000001 (el número 1)
  • Claves privadas derivadas de contraseñas y frases comunes

La Vulnerabilidad Milk Sad (2023)​

El comando seed de la herramienta libbitcoin-explorer (bx) usaba Mersenne Twister sembrado con solo 32 bits de tiempo del sistema. Esto significaba que todas las claves generadas con esta herramienta tenían como máximo 32 bits de entropía: aproximadamente 4.3 mil millones de posibilidades. Los atacantes hicieron fuerza bruta sobre estas claves y robaron fondos.

El Bug de Claves Débiles de Debian OpenSSL (2008)​

Un mantenedor de Debian eliminó accidentalmente una línea de código que proporcionaba entropía al generador de números aleatorios de OpenSSL. Durante dos años (2006-2008), cada clave criptográfica generada en sistemas Debian y Ubuntu tenía solo 15 bits de entropía provenientes del ID de proceso, produciendo como máximo 32,767 claves únicas. Todas las claves SSH, certificados SSL y cualquier clave de criptomonedas generada durante ese período en sistemas afectados quedaron comprometidas.

Lecciones Aprendidas​

  1. Nunca confíes en una sola fuente de entropía sin verificación.
  2. Errores pequeños de implementación pueden reducir catastróficamente la entropía.
  3. Los atacantes explotan activamente la aleatoriedad débil: no es teórico.
  4. El código abierto y auditado es esencial para operaciones críticas de entropía.

Fuentes de Entropía en Detalle​

Pool de Entropía del Sistema Operativo​

Los sistemas operativos modernos mantienen un pool de entropía alimentado por múltiples fuentes:

  • Temporización de interrupciones — La temporización de interrupciones de hardware (teclado, ratón, disco, red) aporta entradas impredecibles.
  • Temporización de E/S de disco — La temporización precisa de operaciones de lectura/escritura de disco varía por factores mecánicos y electrónicos.
  • RNG de hardware — Las CPU modernas (Intel RDRAND, AMD) incluyen generadores aleatorios integrados en chip.
  • Entropía al arranque — Algunos sistemas guardan entropía entre reinicios (/var/lib/systemd/random-seed en Linux).

El SO mezcla estas fuentes en un pool de entropía usando primitivas criptográficas, y luego usa el pool para sembrar su CSPRNG. En kernels Linux modernos (5.18+), /dev/urandom se bloqueará hasta que se haya recolectado suficiente entropía durante el arranque, y después no volverá a bloquearse.

Entropía en el Navegador (crypto.getRandomValues)​

Cuando usas una herramienta web como el generador de SafeSeed, se utiliza la API crypto.getRandomValues() del navegador. Esta delega al CSPRNG del sistema operativo:

  • Chrome: delega al CSPRNG del SO (BoringSSL).
  • Firefox: delega al CSPRNG del SO (NSS).
  • Safari: delega al CSPRNG del SO (CommonCrypto).

Esto se considera seguro para generación de claves, siempre que el SO subyacente sea seguro. La principal preocupación es ejecutarlo en un entorno donde el CSPRNG del SO pueda estar comprometido (por ejemplo, una máquina virtual con fuentes de entropía insuficientes o un sistema operativo comprometido).

Entropía en Hardware Wallets​

Las hardware wallets usan generadores verdaderos de números aleatorios integrados en chip:

  • Ledger (Secure Element ST33): Usa el TRNG del chip ST33, que muestrea ruido analógico. La salida pasa pruebas de salud NIST SP 800-90B antes de usarse.
  • Trezor: Usa el RNG de hardware del chip STM32. Trezor también soporta mezclar entropía aportada por el usuario mediante tiradas de dado.
  • Coldcard: Usa el TRNG del secure element ATECC608A más el RNG de hardware del MCU, mezclando ambas fuentes.

Entropía con Tiradas de Dado​

Lanzar dados manualmente es el método más transparente para generar entropía:

  • Un dado justo de seis caras produce log2(6) = 2.585 bits de entropía por tirada.
  • 100 tiradas producen aproximadamente 258.5 bits de entropía, suficiente para una frase semilla de 24 palabras.
  • El usuario puede verificar físicamente la aleatoriedad (dados justos, lanzamientos justos, sin manipulación).

Verificar la equidad de los dados:

  • Usa dados de precisión grado casino (bordes afilados, no redondeados).
  • Lanza sobre una superficie dura y plana con tope.
  • No "coloques" los dados: deja que rueden libremente.
  • Registra cada resultado de inmediato y en secuencia.
Herramienta SafeSeed

El Generador de Frase Semilla de SafeSeed te permite ingresar tu propia entropía (como resultados de tiradas de dado) para generar una frase semilla BIP-39. Esto te permite verificar la fuente de aleatoriedad mientras sigues beneficiándote de la implementación correcta de BIP-39 de la herramienta. Usa la herramienta sin conexión para máxima seguridad; consulta nuestra guía de Generación de Claves Offline.

Pruebas y Verificación de Aleatoriedad​

Suite de Pruebas Estadísticas NIST​

NIST SP 800-22 define una batería de pruebas estadísticas para evaluar generadores de números aleatorios:

  • Prueba de frecuencia — ¿Hay cantidades aproximadamente iguales de 0 y 1?
  • Prueba de frecuencia por bloques — ¿Los subbloques de bits están distribuidos de forma aproximadamente uniforme?
  • Prueba de rachas — ¿Las secuencias de bits idénticos consecutivos (rachas) tienen la longitud esperada?
  • Prueba de racha más larga — ¿La racha más larga está dentro de los límites esperados?
  • Prueba de rango de matrices — ¿Los rangos de matrices binarias siguen distribuciones esperadas?
  • Prueba espectral — ¿La DFT de la secuencia de bits muestra propiedades esperadas?

Estas pruebas pueden detectar sesgos y patrones, pero no pueden demostrar que un generador sea seguro. Solo pueden detectar fallas.

Suite de Pruebas Dieharder​

Una batería de pruebas estadísticas más completa que incluye las pruebas Diehard originales más pruebas adicionales. Disponible como software de código abierto en Linux.

Verificación Práctica para Usuarios​

La mayoría de los usuarios no pueden ejecutar suites de pruebas NIST. Pasos de verificación práctica:

  1. Verificación de fuente — ¿La herramienta usa crypto.getRandomValues(), os.urandom() o un RNG de hardware? Revisa el código fuente.
  2. Prueba de generación cruzada — Genera múltiples frases semilla y verifica que sean diferentes cada vez.
  3. Visualización de entropía — Algunas herramientas muestran la entropía bruta; verifica que parezca aleatoria (sin patrones obvios).
  4. Auditoría de código abierto — ¿La herramienta es de código abierto y ha sido auditada?

Mezcla de Fuentes de Entropía​

La mejor práctica para generación de claves de alta seguridad es mezclar múltiples fuentes de entropía:

Final Entropy = Hash(Hardware RNG output || OS CSPRNG output || User dice rolls || Timing data)

Mezclar fuentes asegura que, incluso si una fuente está comprometida o sesgada, la salida final siga siendo segura siempre que al menos una fuente proporcione entropía suficiente. Este es el enfoque usado por hardware wallets y herramientas de generación de claves bien diseñadas.

Mezcla con XOR​

Un método simple de mezcla es XOR: si tienes 256 bits de la fuente A y 256 bits de la fuente B:

Mixed = A XOR B

Si A o B es verdaderamente aleatoria, el resultado es verdaderamente aleatorio. Si ambas están sesgadas pero son independientes, el resultado es menos sesgado que cualquiera de las dos.

Mezcla con Hash​

Para mezclar fuentes de distintas longitudes o calidades, hashea todo junto:

Mixed = SHA-256(Source_A || Source_B || Source_C)

La función hash actúa como extractor de entropía, produciendo una salida uniforme independientemente del formato de entrada.

Entropía en Configuraciones Multi-Firma​

Las wallets multifirma proporcionan una forma de redundancia de entropía: incluso si una clave se generó con entropía débil, el atacante también debe comprometer las otras claves. Una multifirma 2-de-3 donde cada clave se genera de forma independiente ofrece seguridad equivalente a la clave más fuerte, no a la más débil.

Este es un argumento poderoso a favor de configuraciones multifirma para almacenamiento de alto valor.

Preguntas Frecuentes​

¿Qué es la entropía en criptomonedas?​

La entropía es la medida de aleatoriedad o imprevisibilidad en los datos usados para generar claves criptográficas. En criptomonedas, la seguridad de tus claves privadas y frases semilla depende por completo de tener entropía suficiente. Una clave de 256 bits debería contener 256 bits de aleatoriedad real; si la entropía es menor, la clave se vuelve adivinable.

¿Cuánta entropía necesito para una wallet segura?​

Una frase semilla BIP-39 de 12 palabras proporciona 128 bits de entropía y una de 24 palabras proporciona 256 bits. Ambas se consideran seguras contra ataques de fuerza bruta con la tecnología actual. Para almacenamiento a largo plazo de alto valor, se recomiendan 256 bits (24 palabras) para ofrecer el máximo margen de seguridad.

¿Es seguro Math.random() para generar claves cripto?​

Absolutamente no. Math.random() y PRNG no criptográficos similares (random de Python, rand() de C) son deterministas, predecibles y de baja entropía. Nunca deben usarse para generación de claves criptográficas. Usa siempre crypto.getRandomValues() en navegadores, os.urandom() en Python o un generador aleatorio de hardware.

¿Puedo generar mi propia entropía pensando en números aleatorios?​

No. Los humanos son notoriamente malos para generar números aleatorios. Los estudios muestran de forma consistente que las secuencias "aleatorias" elegidas por humanos tienen mucha menos entropía de la que parecen tener. Usa en su lugar un proceso físico (dados, RNG de hardware) o un RNG de software criptográficamente seguro.

¿Cómo verifico que el generador de números aleatorios de mi wallet sea seguro?​

Revisa el código fuente de la wallet (si es de código abierto) para verificar que use un CSPRNG o un TRNG de hardware. Busca llamadas a crypto.getRandomValues(), os.urandom() o APIs de RNG de hardware. Para hardware wallets, revisa la documentación de seguridad del fabricante y los reportes de auditoría de terceros.

¿Qué es el "blockchain bandit" y qué enseña sobre la entropía?​

El "blockchain bandit" es un atacante que robó sistemáticamente criptomonedas de wallets generadas con claves privadas débiles (como el número 1, 2, 3, o claves derivadas de contraseñas simples). Esto demostró que los atacantes enumeran activamente claves de baja entropía y vacían cualquier fondo que encuentran. Subraya la importancia crítica de usar generación de números aleatorios de alta entropía.

¿Son confiables los generadores aleatorios de hardware wallets?​

Los TRNG de hardware wallets suelen ser confiables, pero representan un único punto de confianza. Para máxima seguridad, puedes mezclar la salida del RNG de hardware con entropía aportada por el usuario (tiradas de dado). Algunas hardware wallets (como Trezor y Coldcard) soportan esta mezcla de forma nativa. Esto asegura que incluso si el RNG de hardware está comprometido, la clave resultante siga siendo segura.

¿El sistema operativo (Linux, macOS, Windows) afecta la seguridad de las claves?​

Sí. La calidad y la implementación del CSPRNG del SO afectan la seguridad de las claves. Las versiones modernas de Linux, macOS y Windows ofrecen generadores de números aleatorios criptográficamente seguros (/dev/urandom, arc4random, BCryptGenRandom). Sin embargo, el bug de Debian OpenSSL de 2006-2008 mostró que vulnerabilidades a nivel de SO pueden reducir catastróficamente la entropía. Mantén tu SO actualizado y usa software bien auditado.

Guías Relacionadas​