Entropía de Contraseñas: Cómo Medir y Maximizar la Fortaleza de Tus Contraseñas
Probablemente te han dicho que una “contraseña fuerte” necesita letras mayúsculas, números y caracteres especiales. Pero P@$$w0rd! cumple todas esas reglas — y puede descifrarse en menos de un segundo.
La verdadera medida de la fortaleza de una contraseña no son los caracteres que usas. Es la entropía: un concepto de la teoría de la información que cuantifica cuán impredecible es tu contraseña realmente.
En esta guía aprenderás exactamente cómo funciona la entropía de las contraseñas, cómo calcularla y cómo generar contraseñas que sean genuinamente difíciles de descifrar.
¿Qué Es la Entropía de una Contraseña?
La entropía de una contraseña mide cuán impredecible es, expresada en bits. Cada bit adicional de entropía duplica el número de intentos que un atacante necesita para descifrarla por fuerza bruta.
Piénsalo como dados. Un dado de 6 caras tiene unos 2,6 bits de entropía por tirada — solo hay 6 resultados posibles. Un dado de 20 caras tiene unos 4,3 bits — más caras significa más incertidumbre.
Las contraseñas funcionan igual: más caracteres posibles (“dados” más grandes) y más caracteres en la contraseña (más “tiradas”) aumentan la entropía.
Por eso la entropía es una mejor medida que las reglas de complejidad. Una contraseña puede parecer compleja (Tr0ub4dor&3) pero tener poca entropía porque sigue patrones predecibles. Mientras tanto, una frase aparentemente sencilla (caballo correcto batería grapa) puede tener alta entropía porque se extrae de un gran conjunto de posibilidades.
La Fórmula: Cómo Calcular la Entropía de una Contraseña
La fórmula es sencilla:
E = L × log₂(R)
Donde:
- E = entropía en bits
- L = longitud de la contraseña (número de caracteres)
- R = tamaño del conjunto (número de caracteres posibles por posición)
Tamaños de Conjuntos de Caracteres
| Tipo de carácter | Tamaño del conjunto (R) | Bits por carácter |
|---|---|---|
| Solo minúsculas (a-z) | 26 | 4,70 |
| Minúsculas + dígitos | 36 | 5,17 |
| Mayúsculas + minúsculas + dígitos | 62 | 5,95 |
| ASCII imprimible completo | 94 | 6,55 |
| Lista de palabras Diceware | 7.776 | 12,92 por palabra |
Calcúlalo en Código
// Calcular la entropía de una contraseña en JavaScript
const entropy = (length, poolSize) =>
length * Math.log2(poolSize);
entropy(8, 26); // → 37,60 bits (solo minúsculas)
entropy(12, 62); // → 71,45 bits (alfanumérico)
entropy(16, 94); // → 104,87 bits (charset completo)import math
def entropy(length: int, pool_size: int) -> float:
return length * math.log2(pool_size)
entropy(8, 26) # → 37,60 bits
entropy(12, 62) # → 71,45 bits
entropy(16, 94) # → 104,87 bitsImportante: esta fórmula asume que cada carácter se elige de forma uniformemente aleatoria. Si una persona elige la contraseña usando patrones o palabras del diccionario, la entropía real es mucho menor que el máximo teórico.
¿Cuánta Entropía Es Suficiente?
La respuesta depende de lo que estás protegiendo y de la velocidad con la que un atacante puede adivinar.
Las GPU modernas pueden probar más de 10¹² (un billón) de hashes de contraseñas por segundo contra algoritmos rápidos como MD5. Esto es lo que significa en la práctica:
| Entropía (bits) | Fortaleza | Tiempo de descifrado a 10¹² intentos/s | Recomendado para |
|---|---|---|---|
| < 40 | Débil | Menos de 1 segundo | Nunca usar |
| 40–59 | Regular | Segundos a horas | Cuentas desechables |
| 60–79 | Fuerte | Días a siglos | Cuentas regulares |
| 80–99 | Muy fuerte | Milenios o más | Email, banca |
| 100+ | Extremo | Más allá de la muerte térmica del universo | Claves de cifrado, contraseñas maestras |
Una contraseña de 16 caracteres usando el conjunto ASCII imprimible completo te da unos 105 bits de entropía — bien dentro del rango “extremo”. Puedes generar una al instante con nuestro Generador de Contraseñas Aleatorias, que muestra análisis de entropía en tiempo real para cada contraseña.
Qué Dice el NIST (Actualización 2024)
El NIST SP 800-63B, actualizado en 2024, realizó cambios significativos en las directrices de contraseñas:
- Eliminó las reglas de complejidad obligatorias (sin más caracteres especiales forzados)
- Eliminó los cambios de contraseña periódicos obligatorios
- Aumenta el mínimo a 15 caracteres (frente a 8 en versiones anteriores)
- Enfatiza la verificación contra contraseñas filtradas conocidas
- Favorece la longitud y la aleatoriedad sobre la complejidad
Estos cambios reflejan lo que las matemáticas de la entropía siempre han demostrado: la longitud y la aleatoriedad importan más que la variedad de caracteres.
Por Qué la Longitud Supera a la Complejidad
Veamos las matemáticas. Considera dos formas de aumentar la entropía de una contraseña de 12 caracteres:
Opción A — Mantener 12 caracteres, cambiar de alfanumérico (62) a ASCII completo (94):
- 12 × log₂(94) - 12 × log₂(62) = 78,66 - 71,45 = +7,21 bits
Opción B — Mantener alfanumérico (62), añadir un carácter más (12 → 13):
- 13 × log₂(62) - 12 × log₂(62) = 77,40 - 71,45 = +5,95 bits
Añadir un solo carácter te da casi tanta entropía como cambiar a un conjunto de caracteres mucho mayor. Añade dos caracteres y lo habrás superado.
Ahora considera P@$$w0rd! (9 caracteres). Usa el conjunto ASCII completo pero es demasiado corta. Peor aún, sigue el patrón predecible de “leet speak” que los ataques de diccionario ya contemplan, por lo que su entropía efectiva está muy por debajo de los 59 bits teóricos.
La conclusión: para contraseñas verdaderamente aleatorias, añadir longitud es más eficiente que añadir tipos de caracteres. Pero el verdadero enemigo es la predecibilidad, no la cortedad.
Frase de Contraseña vs Contraseña Aleatoria
| Dimensión | Contraseña aleatoria | Frase de contraseña (Diceware) |
|---|---|---|
| Ejemplo | kX#9mP$2vL!nQ7wR | caballo correcto batería grapa |
| Bits por unidad | 6,55 por carácter | 12,92 por palabra |
| Longitud para ~78 bits | 12 caracteres | 6 palabras |
| Memorabilidad | Difícil | Buena |
| Escritura en móvil | Dolorosa | Fácil |
| Mejor para | Entradas del gestor de contraseñas | Contraseñas maestras, logins memorizados |
Cómo Funciona Diceware
Diceware usa una lista de palabras de 7.776 entradas (6⁵ = 7.776). Lanzas cinco dados para seleccionar cada palabra, dando exactamente 12,92 bits de entropía por palabra.
Cuatro palabras dan ~51 bits; seis palabras dan ~77 bits.
¿Cuál Deberías Usar?
- Para contraseñas almacenadas en un gestor: usa contraseñas aleatorias de 16 o más caracteres con conjuntos de caracteres completos. Nunca las escribes manualmente, por lo que la memorabilidad no importa. Nuestro Generador de Contraseñas Aleatorias puede generar hasta 50 en lote.
- Para tu contraseña maestra: usa una frase Diceware de 5-6 palabras. Es suficientemente memorable para escribirla a diario mientras proporciona 64-77 bits de entropía.
- Para claves API y tokens: usa
openssl randocrypto.randomBytes()para máxima entropía sin requisito de memorabilidad humana.
Entropía en la Práctica: Herramientas y Código para Desarrolladores
Aquí están las formas más comunes en que los desarrolladores generan secretos de alta entropía:
Navegador (Web Crypto API)
// Generación de contraseñas con seguridad criptográfica
function generatePassword(length, charset) {
const array = new Uint32Array(length);
crypto.getRandomValues(array);
return Array.from(array, v => charset[v % charset.length]).join('');
}
const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*';
generatePassword(16, chars);
// → 'kX#9mP$2vL!nQ7wR' (aleatorio cada vez)Node.js
const crypto = require('crypto');
const token = crypto.randomBytes(32).toString('base64url');
// → 'Ql2Hj8xK9mNp3rVw5tYz7uBa0cEf4gIk' (43 caracteres, 256 bits)Python
import secrets
token = secrets.token_urlsafe(32) # 256 bits de entropía
password = secrets.token_hex(16) # 128 bits, formato hexadecimalLínea de Comandos
# 192 bits de entropía, codificado en base64
openssl rand -base64 24
# 256 bits, codificado en hexadecimal
openssl rand -hex 32Comparación de Entropía por Método
| Método | Longitud de salida | Entropía (bits) |
|---|---|---|
| UUID v4 | 36 caracteres | 122 |
openssl rand -base64 24 | 32 caracteres | 192 |
| 16 caracteres ASCII completo | 16 caracteres | 105 |
| 6 palabras Diceware | ~30 caracteres | 78 |
| 4 palabras Diceware | ~20 caracteres | 52 |
Nunca uses
Math.random()para nada relacionado con la seguridad. Usa un PRNG no criptográfico — la salida es predecible si un atacante conoce la semilla. Usa siemprecrypto.getRandomValues()en el navegador ocrypto.randomBytes()en Node.js.
Almacenamiento de Contraseñas: Por Qué la Entropía Sola No Es Suficiente
Incluso una contraseña de 128 bits no vale nada si el servidor la almacena como un hash MD5 simple. Cuando una base de datos se filtra, los atacantes pueden probar billones de hashes MD5 por segundo en una sola GPU.
Aquí es donde entran los algoritmos de hashing lento. Hacen que cada intento sea deliberadamente costoso:
| Algoritmo | Velocidad en GPU | Ralentización efectiva |
|---|---|---|
| MD5 | ~10 mil millones/s | Base (no usar) |
| SHA-256 | ~5 mil millones/s | ~2× más lento |
| bcrypt (cost=12) | ~5/s | ~2 mil millones× más lento |
| argon2id | ~2/s | ~5 mil millones× más lento |
El parámetro de coste de bcrypt es especialmente elegante: cada incremento duplica el trabajo requerido. Un factor de coste de 12 significa 2¹² = 4.096 rondas de hashing. Esto añade efectivamente 12 bits de “entropía de almacenamiento” por encima de la entropía propia de la contraseña.
El modelo de doble protección: las contraseñas de alta entropía protegen contra la fuerza bruta offline, mientras que el hashing lento protege contra las filtraciones de bases de datos. Necesitas ambas.
Para más información sobre algoritmos hash, consulta nuestra comparación de MD5 vs SHA-256 y prueba el Generador de Hash MD5 para explorar cómo diferentes algoritmos producen distintas salidas.
Mitos Comunes sobre Contraseñas Desmontados
”Cambia tu contraseña cada 90 días”
Las directrices del NIST de 2024 recomiendan explícitamente no hacer cambios periódicos obligatorios. Las rotaciones frecuentes llevan a los usuarios a elegir contraseñas más débiles y predecibles — añadiendo un número al final, rotando entre un pequeño conjunto. Cambia las contraseñas solo cuando tengas motivos para creer que han sido comprometidas.
”a→@, e→3 la hace más fuerte”
Las sustituciones de leet speak son de los primeros patrones que comprueban los ataques de diccionario. Reemplazar a con @ en contraseña añade prácticamente cero entropía porque los atacantes ya lo esperan.
La verdadera aleatoriedad — no las sustituciones inteligentes — es lo que aumenta la entropía.
”8 caracteres con símbolos es suficiente”
Incluso con el conjunto ASCII completo de 94 caracteres, 8 caracteres solo dan 52 bits de entropía. A 10¹² intentos por segundo, eso se descifra en unos 75 minutos.
Usa un mínimo de 12 caracteres, 16 o más para cuentas importantes.
”Cuanto más compleja parece, más segura es”
La complejidad visual y la entropía son cosas diferentes. Tr0ub4dor&3 parece compleja pero sigue un patrón predecible de palabra-base-más-sustituciones. mfYq8kL2nR parece más sencilla pero tiene mayor entropía porque es verdaderamente aleatoria.
Para más información sobre cómo construir una estrategia de seguridad integral, consulta Seguridad Web Esencial.
Preguntas Frecuentes
¿Cuántos bits de entropía se consideran seguros?
Para la mayoría de las cuentas en línea, 60-80 bits proporcionan una protección fuerte. Para objetivos de alto valor como contraseñas maestras o claves de cifrado, apunta a 100 o más bits. Cada bit adicional duplica el esfuerzo requerido por el atacante.
¿Añadir caracteres especiales siempre aumenta la entropía?
Solo si los caracteres se eligen aleatoriamente del conjunto completo. Las sustituciones predecibles como @ por a o ! al final añaden prácticamente cero entropía porque los atacantes ya tienen en cuenta estos patrones en sus diccionarios.
¿Cuál es la entropía de una frase Diceware de 4 palabras?
Usando la lista Diceware estándar de 7.776 palabras, cada palabra aporta 12,92 bits. Cuatro palabras dan aproximadamente 51,7 bits — adecuado para usos de baja seguridad. Para cuentas importantes, usa 5-6 palabras (64-78 bits).
¿Es seguro Math.random() para generar contraseñas?
No. Math.random() es un generador de números pseudoaleatorios que no es criptográficamente seguro. Usa crypto.getRandomValues() en el navegador o crypto.randomBytes() en Node.js para la generación aleatoria relacionada con la seguridad.
¿Cómo afecta el factor de coste de bcrypt a la seguridad?
Cada incremento del factor de coste de bcrypt duplica el cómputo necesario para hacer hash (y por tanto para descifrar por fuerza bruta) una contraseña. Un coste de 12 significa 2¹² = 4.096 iteraciones, añadiendo efectivamente 12 bits de dificultad por encima de la entropía intrínseca de la contraseña.
¿Qué cambió en las directrices de contraseñas del NIST de 2024?
El NIST SP 800-63B eliminó los requisitos de complejidad obligatorios (caracteres especiales forzados, mayúsculas y minúsculas mixtas) y la rotación periódica de contraseñas. La nueva guía favorece contraseñas más largas (se recomiendan 15 o más caracteres), la verificación contra bases de datos de contraseñas filtradas y permite todos los caracteres imprimibles incluyendo espacios.
Conclusiones Clave
- Entropía = L × log₂(R) — cada bit extra duplica el número de intentos necesarios
- Longitud > complejidad — añadir un carácter es más efectivo que ampliar el conjunto de caracteres
- Usa las APIs de cripto —
crypto.getRandomValues()ocrypto.randomBytes(), nuncaMath.random() - Gestor de contraseñas + generación aleatoria es la mejor práctica para la mayoría de las personas
- El lado del servidor también importa — usa bcrypt o argon2, nunca almacenes contraseñas con MD5
¿Listo para generar una contraseña de alta entropía? Prueba nuestro Generador de Contraseñas Aleatorias — muestra análisis de entropía en tiempo real para cada contraseña que creas.