Seguridad de contraseñas: qué hace que una contraseña sea fuerte de verdad

Los sitios de los bancos siguen obligándote a demostrar que tu contraseña tiene una mayúscula, un número y un símbolo — y luego rechazan las cadenas largas tipo frase de contraseña que de verdad te protegerían. La investigación dice lo contrario de eso que asumen esas reglas. La fortaleza no es una lista de requisitos sobre tipos de carácter; es un número: cuántos intentos tiene que hacer un atacante hasta dar con tu contraseña. Ese número, medido en bits, es lo único que importa. El resto — el signo de exclamación añadido, la letra capitalizada — es, en su mayor parte, teatro.

Entropía: el número detrás de cada contraseña

Toda contraseña que puedas crear bajo tus reglas exactas se puede escribir como una lista. El tamaño de esa lista es tu espacio de búsqueda. Si la contraseña se eligió de forma uniforme dentro de la lista, un atacante que va probando una por una necesita, en promedio, la mitad. El tamaño de ese espacio, expresado como potencia de dos, es la entropía de la contraseña: cuánta incertidumbre tiene que resolver el atacante.

La matemática es simple multiplicación. Con un alfabeto de 26 letras minúsculas, una contraseña de 8 caracteres da 26^8 = 2,1 × 10^11 posibilidades: unos 38 bits. Añade mayúsculas, dígitos y símbolos — un conjunto imprimible completo de 95 caracteres — y los mismos 8 caracteres dan 95^8 = 6,6 × 10^15 posibilidades, unos 52,5 bits. Cada carácter extra multiplica la lista por el tamaño de tu alfabeto.

De aquí salen dos consecuencias. La longitud se acumula: cada carácter añadido suma log2(alfabeto) bits. Y cuanto menor es el alfabeto, menos rinde cada carácter: pasar de 26 a 95 caracteres te da unos 1,9 bits por carácter, mientras que añadir un solo carácter más da 4,7 a 6,6 bits. Ese desequilibrio es todo el argumento a favor de las contraseñas largas.

// Upper bound for a password a real random generator produced.
// Real human choices score lower — patterns occupy a smaller space.
function bits(length, charsetSize) {
  return length * Math.log2(charsetSize);
}
console.log(bits(8, 26));   // ≈ 37.6 → ~2.1 × 10^11 possible
console.log(bits(8, 95));   // ≈ 52.5 → ~6.6 × 10^15 possible
console.log(bits(12, 95));  // ≈ 78.8
console.log(bits(16, 95));  // ≈ 105.1

La fórmula asume aleatoriedad genuina, y esa asunción carga con todo el peso. En elecciones reales es un límite superior, porque los humanos no somos uniformes: Sunshine1 tiene ocho caracteres, pero está a años luz de los 6,6 × 10^15. El espacio de búsqueda real del atacante es el espacio de los patrones comunes, y ese espacio es miles de veces más pequeño.

Por qué las reglas clásicas debilitan las contraseñas

La famosa lista — mínimo 8 caracteres, una mayúscula, un número, un símbolo — se diseñó décadas antes de que las tarjetas gráficas convirtieran el descifrado en un pasatiempo. Falla por partida doble: empuja a la gente hacia plantillas predecibles y castiga lo único que de verdad ayuda: la longitud.

Dile a alguien que necesita una mayúscula, un dígito y un símbolo, y con probabilidad abrumadora tomará una palabra normal y le aplicará los mismos tres gestos: primera letra en mayúscula, un dígito al final, un símbolo pegado. El resultado es Password1! o su equivalente local. Toda la clase sigue una sola plantilla, así que el atacante no tiene que recorrer el espacio de 95 caracteres; recorre el espacio de las plantillas, que es mucho más pequeño. El famoso ejemplo de xkcd, Tr0ub4dor&3, ronda los 28 bits precisamente por esto.

La rotación forzosa lo empeora. Cuando la política exige una contraseña nueva cada 90 días, la gente muta la anterior: Password1! se vuelve Password2!, luego Password3!. Si la antigua se filtra, la siguiente es trivialmente predecible. La guía actual — NIST SP 800‑63B — descarta la caducidad forzada y la ficción de la complejidad; pide longitud, listas de contraseñas prohibidas y un segundo factor.

La longitud vence a la complejidad: las matemáticas de la frase de contraseña

Cuatro palabras al azar de una lista de 7.776 — la lista diceware que recomienda la EFF — dan 7776^4 = 3,7 × 10^15 combinaciones, unos 51,7 bits. Es comparable a una contraseña aleatoria de 8 caracteres del conjunto completo, pero escrita en palabras que un humano sí puede recordar. Hasta una lista más conservadora de 2.048 palabras rinde 11 bits por palabra: 44 bits en cuatro palabras.

Pon Pr3tty! al lado de correct-horse-battery-staple. Las dos parecen defendibles. La primera son 7 caracteres de un conjunto de 95 — en el papel unos 46 bits —, pero es un adjetivo normal más un símbolo, salido del diminuto espacio de las contraseñas que obedecen la plantilla; su valor real es una fracción. La frase son 28 caracteres hechos de cuatro elecciones aleatorias independientes entre miles de palabras; como no hay patrón, el atacante no tiene atajo.

La trampa — y es real — está en la palabra aleatorio. Una frase que inventas tú, como mycatispurple, no son cuatro palabras aleatorias; es una sola frase de lenguaje natural, y los atacantes listos también modelan esas. La fuerza viene del dado, no de tu ingenio. Usa diceware o un generador que elija de forma uniforme, y aléjate de cualquier frase que ya brille en un blog o en la letra de una canción.

• Memorable: cuatro palabras conocidas se retienen mejor que quince caracteres dispersos.
• Larga: la longitud en bruto bloquea la fuerza bruta offline antes de que importe nada más.
• Sin patrón: las elecciones uniformes y aleatorias no le dejan plantilla al atacante.
• Escala: cinco palabras aleatorias rondan los 64,6 bits y siguen siendo memorables.

El peligro real es reutilizar contraseñas

Ninguna de esas cuentas de entropía te protege si la misma contraseña guarda diez cuentas. Las filtraciones no son raras; son rutina, y les pasan a empresas cuidadosas con equipos de seguridad competentes. Cuando se filtra una base de datos con hashes, se descifran offline — primero con diccionario, luego mutaciones —, y la contraseña que usaste cae en texto plano.

Los atacantes luego pasan esa lista contra todos los demás sitios que usas. Esto es el relleno de credenciales: scripts automáticos prueban cada par de usuario y contraseña filtrados contra miles de objetivos, y funciona porque la reutilización es la norma. Lo más valioso que puedes hacer no es una contraseña más lista — es una por sitio.

Esa unicidad a escala es justo lo que automatizan los gestores de contraseñas. Y ese es también el reverso: la contraseña maestra de tu gestor es el único secreto irremplazable que tienes; reutilizarla en otro sitio anula todo el modelo.

Los vectores de ataque a los que te enfrentas

• Ataque de diccionario: recorre una lista ordenada de contraseñas probables — filtradas antes, palabras, nombres, secuencias de teclado. sunshine1 lo resuelve en milisegundos.
• Fuerza bruta: prueba todas las combinaciones de un conjunto de caracteres hasta un límite de longitud. Simple y lenta, y precisamente por eso importa la tabla de arriba: a mil millones de intentos por segundo, una contraseña de 8 caracteres del conjunto completo está lista en menos de un día.
• Relleno de credenciales: automatiza los pares de usuario y contraseña filtrados contra miles de sitios. Su éxito es una medida directa de la reutilización.
• Phishing: imita una página de inicio de sesión real y le roba al humano la contraseña — o el código de doble factor —. Se salta todas las reglas de fortaleza; por eso importan un segundo factor y el autocompletado del gestor.

Fíjate en lo que falta: nadie te está atacando a ti personalmente. Estos ataques son automáticos y oportunistas; van donde la matemática es más débil y la reutilización más densa.

Cómo generan y guardan credenciales los gestores de contraseñas

Un gestor de contraseñas guarda cada credencial en una bóveda cifrada con una clave derivada de tu contraseña maestra — estirada con una función lenta como PBKDF2 o Argon2 para que adivinar la maestra offline sea difícil por diseño. La bóveda es el único hogar de tus secretos; la contraseña maestra es la clave que la abre.

La generación es donde un buen gestor gana su mantenimiento. Crea una contraseña nueva, criptográficamente aleatoria, por sitio — normalmente de 15 a 20 caracteres sobre el conjunto completo —, porque nunca tiene que memorizarlas. El ecosistema es más amplio de lo que crees: los navegadores traen gestores integrados, Bitwarden y 1Password sincronizan bóvedas cifradas por la nube, las apps estilo KeePass mantienen un archivo cifrado local. El principio es el mismo en todas partes: una clave maestra fuerte y contraseñas únicas y aleatorias para todo lo demás.

Al otro lado del formulario, un sitio responsable no guarda tu contraseña. Guarda un hash con sal mediante una función lenta y costosa en memoria — bcrypt o argon2id. Con sal significa que se mezcla un valor aleatorio por usuario, de modo que la misma contraseña en un millón de sitios genera un millón de hashes distintos; lenta significa que los intentos por segundo del atacante caen de miles de millones a unos pocos miles. Por eso una contraseña decente sobrevive a una base de datos filtrada — y una corta no; la misma conclusión que la tabla de arriba.

Qué hace distinto a un buen generador

La diferencia entre un generador de juguete y uno seguro está en de dónde sale el azar. Math.random() es un generador pseudoaleatorio sembrado desde el tiempo; es rápido, nunca pensado para secretos, y en cuanto observas bastante de su salida se puede reconstruir su estado interno — la contraseña aleatoria se vuelve predecible. Los navegadores, en cambio, exponen crypto.getRandomValues(), alimentado por la aleatoriedad criptográfica del sistema operativo: la única fuente adecuada para esta tarea.

La fuente es solo media historia. El muestreo debe ser uniforme: tomar un número aleatorio módulo la longitud del conjunto es la forma clásica de sesgar la salida; los generadores serios usan muestreo por rechazo. Y el conjunto debe ser tan amplio como puedas tolerar, porque cada clase que incluyes son bits que ganas gratis — mientras que los caracteres ambiguos como 1/l y 0/O se quitan por legibilidad, no por fortaleza.

Un generador fuerte tampoco hace nada más: sin telemetría, sin copia en un log del servidor, sin recuérdalo por mí. Una contraseña debería existir en exactamente un lugar — unos segundos en tu portapapeles y luego en la bóveda.

Genera contraseñas fuertes en Convrs

El generador de contraseñas de Convrs funciona por completo en tu navegador: elige la longitud, activa las clases de caracteres que quieras y genera varias de una vez en un solo clic. El azar viene de la API criptográfica del navegador, todo el cálculo se queda en tu dispositivo y nada se transmite, registra o almacena — la única copia de tu contraseña es la que tú mismo copias.