DEV Community

Getsafekey
Getsafekey

Posted on Edited on

6 cosas que haces mal con las contraseñas (y que puedes arreglar hoy)

Si escribes código, en algún momento has generado una contraseña, un token o una clave. Y es muy probable que en alguno de estos seis puntos lo hayas hecho mal. No es una bronca: son errores que aparecen en tutoriales, en Stack Overflow y en producción. Los he reunido en seis artículos completos en getsafekey.com, y aquí va el resumen con lo esencial de cada uno.

1. Usar Math.random() para generar secretos

Es la forma más común de hacerlo mal. Math.random() parece aleatorio, pero es un PRNG determinista: su salida depende por completo de un estado interno, y quien conozca ese estado conoce todas las salidas futuras. En V8 usa el algoritmo xorshift128+, con un estado de 128 bits que se puede reconstruir observando suficientes salidas. Hay herramientas públicas que lo hacen.

Si generas tokens de restablecimiento, identificadores de sesión o claves con Math.random(), un atacante no necesita robar tu base de datos: le basta con observar algunas salidas y hacer las cuentas.

La alternativa es crypto.getRandomValues(), que toma sus bytes del generador criptográficamente seguro del sistema operativo. Y ojo: tampoco basta con usarlo de cualquier manera. Hacer byte % n introduce un sesgo de módulo; lo correcto es el muestreo por rechazo, descartando los valores de la cola desigual.

👉 Artículo completo: Por qué nunca debes usar Math.random() en criptografía

2. Creer que una clave con símbolos es más fuerte que una frase

Una clave de diez caracteres con símbolos parece fuerte porque cuesta escribirla. Una frase de cinco palabras parece débil porque se lee con facilidad. La matemática dice lo contrario.

Con el método Diceware, cada palabra aporta log₂(7.776) ≈ 12,9 bits de entropía. Una frase de 5 palabras tiene 64,6 bits; una de 6, 77,5 bits. Y se recuerda mucho mejor que una clave con símbolos, que acaba escrita en un papel o reutilizada en varios servicios.

La única condición: las palabras tienen que elegirse al azar, con dados o con un generador criptográficamente seguro. En cuanto las inventas tú, la entropía se desploma.

👉 Artículo completo: Contraseñas vs frases de paso: el debate matemático

3. Medir la fuerza en caracteres en vez de en bits

La entropía se mide en bits, y cada bit duplica el trabajo del atacante. Una contraseña de 40 bits cae en unos 9 minutos a mil millones de intentos por segundo; una de 80 bits tardaría unos 19 millones de años. La diferencia entre una y otra no es la longitud aparente, es cómo se generó: una contraseña inventada por una persona tiene la entropía de lo que una persona puede imaginar, mucho menos que la de los mismos caracteres generados al azar.

La regla práctica: para una contraseña maestra o algo valioso, apunta a 70-80 bits. Eso son unas 6 palabras Diceware o 12-14 caracteres aleatorios.

👉 Artículo completo: Bits de entropía y fuerza bruta: cuánta protección real tienes

4. Guardar contraseñas con MD5 o SHA-1

La contraseña nunca se guarda en texto claro: se guarda un hash con sal única por usuario. Pero el algoritmo importa tanto como la sal. MD5 y SHA-1 están diseñados para ser rápidos, y con hardware moderno se pueden probar miles de millones de hashes por segundo. La sal impide las tablas precalculadas, pero no frena la fuerza bruta.

La guía de OWASP recomienda Argon2id como primera opción, y acepta bcrypt, scrypt y PBKDF2. Son algoritmos diseñados para ser lentos a propósito: cada intento cuesta tiempo y memoria. Un hash bcrypt de una contraseña de 8 caracteres tardaría unos 6 años en romperse; el mismo hash en MD5, 14 segundos.

Y una señal de alarma que cualquiera puede comprobar: si un servicio te envía tu contraseña por correo cuando la olvidas, es que la guarda en texto claro o con cifrado reversible.

👉 Artículo completo: OWASP: cómo guardar contraseñas (y cómo saber si un servicio lo hace mal)

5. Pensar que un ordenador cuántico lo romperá todo

El algoritmo de Grover reduce a la mitad la seguridad efectiva de las contraseñas: una de 128 bits pasa a tener la de una de 64. Suena alarmante, pero la solución es conocida desde hace años y ya está aplicada: duplicar la longitud. Con 256 bits, la seguridad efectiva sigue siendo de 128 bits, y eso es inalcanzable incluso para un ordenador cuántico. AES-256 ya usa 256 bits.

La amenaza real es el algoritmo de Shor, que rompería RSA y la criptografía de curva elíptica por completo. Por eso el NIST publicó en 2024 los primeros estándares de criptografía post-cuántica: ML-KEM para el intercambio de claves y ML-DSA para las firmas.

👉 Artículo completo: Criptografía post-cuántica: qué le haría Grover a tus contraseñas

6. Exigir símbolos y cambios de contraseña cada 90 días

La norma NIST SP 800-63B cambió las reglas: mínimo de 8 caracteres para el usuario y de 15 para el servicio, sin reglas de composición obligatorias y sin cambio forzado cada 90 días. Las reglas de "una mayúscula, un número y un símbolo" no añaden seguridad real: los usuarios las cumplen de forma predecible y los atacantes lo saben. Y el cambio forzado cada tres meses solo consigue que la gente añada un número al final.

Lo que importa es la longitud y la aleatoriedad. Y lo que sí recomienda el NIST: comprobar que la contraseña elegida no está en una lista de contraseñas comprometidas, y permitir pegar desde el portapapeles para no bloquear los gestores de contraseñas.

👉 Artículo completo: NIST SP 800-63B y la longitud de las contraseñas: qué dice la norma

Para probarlas

Los seis artículos están publicados en getsafekey.com, donde también tienes el generador: crea las contraseñas en tu navegador con crypto.getRandomValues(), sin que nada salga de tu equipo. Y si necesitas datos de prueba que pasen las validaciones, en quickiden.com tienes el generador de identidades sintéticas.

¿Cuál de los seis errores te suena más? Te leo en los comentarios.

Top comments (0)