Generador de hash de contraseñas
Funciona por completo en tu navegador: no se sube nada. Aun así, no pegues nunca una contraseña que uses de verdad: genera hashes para datos de prueba, seeds y demos, no para credenciales reales.
Verificar un hash
Cómo funciona
Escribe una contraseña, elige un algoritmo, ajusta sus parámetros de coste y obtén la cadena de hash que guardarías en una base de datos, además de cuántos milisegundos tardó en tu equipo. Ese tiempo es el número que de verdad decide lo difícil que es romper el hash.
Cuatro algoritmos, un mismo propósito. Son funciones de hash de contraseñas, lentas a propósito, y no son lo mismo que los resúmenes de uso general (MD5, SHA-256) del Generador de hash de este sitio. Una GPU procesa miles de millones de intentos de SHA-256 por segundo, así que un resumen simple de una contraseña no protege nada; estos cuatro están diseñados para resistir justo eso. • bcrypt: la opción pragmática desde 1999, que sigue siendo válida. Un factor de coste de 4 a 16 fija el trabajo, y cada paso duplica el tiempo. OWASP sugiere 10 o más; 12 es un valor habitual en producción. La salida es la conocida cadena autónoma `$2b$12$…`. • Argon2id: ganador del Password Hashing Competition de 2015 y hoy la primera recomendación. A diferencia de bcrypt, exige mucha memoria, así que ajustas la memoria (KiB), las iteraciones y el paralelismo hasta que a la GPU del atacante se le acabe la RAM y no solo los ciclos de reloj. • scrypt: la otra opción que exige memoria, muy usada en criptomonedas y en sistemas antiguos. El coste N es una potencia de dos; r y p controlan el tamaño de bloque y el paralelismo. • PBKDF2-SHA256: el más antiguo y el más débil de los cuatro, pero el que exigen muchos regímenes de cumplimiento (FIPS). No exige memoria, así que depende por completo del número de iteraciones, y la cifra de OWASP de 2023 es 600.000.
Cada hash lleva un salt aleatorio, así que calcular la misma contraseña dos veces da dos cadenas distintas. Es correcto y esperado, y es lo que impide que los atacantes precalculen tablas arcoíris.
Verificar toma un hash bcrypt o Argon2 y una contraseña candidata y te dice si coinciden. Solo esos dos formatos se pueden verificar a partir del hash, porque solo ellos llevan sus parámetros y su salt dentro de la cadena. scrypt y PBKDF2 no tienen una forma codificada estándar, así que esta herramienta devuelve su hash y su salt por separado y los parámetros los tienes que guardar tú.
Todo se ejecuta dentro de la pestaña de tu navegador sin ninguna petición de red, incluidas las implementaciones en WebAssembly de bcrypt y Argon2. Aun así, trata cualquier herramienta web como no fiable para credenciales reales: úsala para datos de prueba, seeds de bases de datos, demos y para aprender, y deja que la librería de tu propia aplicación calcule el hash de las contraseñas reales de los usuarios.
Preguntas frecuentes
¿Qué algoritmo de hash de contraseñas debo usar?
- Argon2id, si tu lenguaje tiene un binding mantenido, porque exige memoria y es la primera opción actual de OWASP. bcrypt es un segundo puesto perfectamente respetable y está disponible en todas partes; usa un coste de 10–12. Elige PBKDF2 solo cuando lo exija un régimen de cumplimiento (FIPS), y en ese caso usa al menos 600.000 iteraciones.
¿Qué factor de coste de bcrypt debo elegir?
- Uno lo bastante alto para que calcular el hash tarde unos 250–500 ms en tu hardware de producción, el presupuesto de latencia habitual de un inicio de sesión. El tiempo que se muestra tras cada hash te permite calibrar: sube el coste hasta llegar a ese rango. Cada +1 duplica el trabajo, así que el coste 12 es cuatro veces más lento que el 10.
¿Por qué el hash es distinto cada vez que calculo el de la misma contraseña?
- Porque se genera un salt aleatorio nuevo para cada hash. Es justo lo que quieres: contraseñas idénticas producen hashes guardados distintos, así que un atacante no puede detectar contraseñas repetidas ni usar tablas arcoíris precalculadas. La verificación sigue funcionando, porque el salt va dentro de la cadena bcrypt o Argon2.
¿Puedo verificar un hash bcrypt aquí?
- Sí. Pega el hash y la contraseña candidata en la sección Verificar. Funciona con bcrypt ($2a$/$2b$/$2y$) y con Argon2 ($argon2id$ y compañía), porque esas cadenas llevan su algoritmo, sus parámetros y su salt. Los hashes scrypt y PBKDF2 no se pueden verificar solo con el hash, porque sus parámetros viven fuera de la cadena.
¿Es un problema el límite de 72 bytes de bcrypt?
- Pocas veces, pero conviene saberlo: bcrypt ignora en silencio todo lo que pase de los primeros 72 bytes de una contraseña, así que las frases de contraseña muy largas se truncan en la práctica. Tenlo en cuenta si aceptas frases largas o si aplicas un HMAC a las contraseñas antes de bcrypt. Argon2id y scrypt no tienen ese límite.
¿Es seguro escribir aquí una contraseña real?
- Mejor que no. El cálculo se hace por completo en tu navegador y esta página no hace ninguna petición de red, algo que puedes comprobar en la pestaña Red de las herramientas para desarrolladores, pero el consejo sincero para cualquier herramienta de hash en línea es no meter en ella las credenciales que usas de verdad. Úsala para datos de prueba, seeds y para aprender, y deja que la librería de tu backend calcule el hash de las contraseñas reales.
¿En qué se diferencia del Generador de hash?
- En la velocidad, y es el punto clave. El Generador de hash produce resúmenes rápidos de uso general (MD5, SHA-1, SHA-256, BLAKE) para checksums e integridad, que es la herramienta equivocada para contraseñas justamente porque una GPU prueba miles de millones por segundo. Esta herramienta implementa funciones de derivación de claves lentas, con salt y ajustables, hechas para resistir eso.
Cuánto tarda un ataque sin conexión, según el algoritmo y la contraseña
Tiempo que necesita una sola GPU de gama alta (clase RTX 4090) para recorrer todo el espacio de claves (la mitad, de media). Lo importante es el contraste: la misma contraseña es trivial con un resumen rápido y desesperante con una KDF bien ajustada. Romper hashes es trivialmente paralelizable, así que divide por el número de GPU que alquile el atacante.
| Contraseña | SHA-256 (sin salt) | bcrypt coste 10 | bcrypt coste 12 | Argon2id (19 MiB, t=2) |
|---|---|---|---|---|
| password123 (está en todos los diccionarios) | instantáneo | instantáneo | instantáneo | instantáneo |
| 8 caracteres, solo minúsculas | 2 segundos | 3 días | 12 días | 3 meses |
| 8 caracteres, mayúsculas y minúsculas + cifras | 3 minutos | 35 años | 140 años | 1400 años |
| 10 caracteres, mayúsculas y minúsculas + cifras | 8 días | > 100.000 años | > 400.000 años | millones de años |
| 12 caracteres, ASCII completo | 8 años | astronómico | astronómico | astronómico |
| 4 palabras aleatorias (diceware) | 1 año | > 1 millón de años | astronómico | astronómico |
Cifras de orden de magnitud, no predicciones: las tasas suponen ~2×10¹⁰ SHA-256/s, ~2×10⁵ bcrypt de coste 10/s y ~3×10³ Argon2id/s en una GPU moderna, según benchmarks publicados de Hashcat. Dos matices que importan más que las cifras exactas: una contraseña que aparece en una lista de filtraciones cae al instante, sea cual sea el algoritmo, y estos son tiempos sin conexión, que suponen que el atacante ya robó tu base de datos.
Comparación de algoritmos de hash de contraseñas
Los cuatro llevan salt y son ajustables. "Exige memoria" significa que el atacante necesita RAM por cada intento, que es lo que frena el cracking con GPU y ASIC.
| Algoritmo | Año | Exige memoria | Cadena autónoma | Ajustes recomendados |
|---|---|---|---|---|
| Argon2id | 2015 | Sí | Sí ($argon2id$…) | 19 MiB de memoria, 2 iteraciones, paralelismo 1 (mínimo de OWASP) |
| scrypt | 2009 | Sí | No | N = 2^17, r = 8, p = 1 (mínimo de OWASP) |
| bcrypt | 1999 | No | Sí ($2b$…) | Factor de coste 10 o más; límite de 72 bytes en la contraseña |
| PBKDF2-SHA256 | 2000 | No | No | 600.000 iteraciones (OWASP 2023); úsalo solo si FIPS lo exige |
| MD5 / SHA-256 (simples) | 1992 / 2001 | No | No | Nunca para contraseñas: miles de millones de intentos por segundo en una GPU |
Los ajustes siguen la Password Storage Cheat Sheet de OWASP. Súbelos hasta que calcular el hash tarde 250–500 ms en tu propio hardware de producción.