Generador y verificador de hash de contraseñas

Calcule y verifique contraseñas con bcrypt, scrypt, Argon2id y PBKDF2 totalmente en su navegador — genere cadenas en formato PHC, compruebe una contraseña candidata frente a un hash existente y examine los parámetros que contiene. No se sube nada.
Solo para contraseñas de prueba. Las contraseñas reales de los usuarios nunca deben pegarse en ninguna página web. Esta herramienta se ejecuta por completo en su navegador — las cadenas nunca salen de su pestaña — pero una filtración real empieza con un único pegado.
coste de bcrypt (2^coste rondas)
variante de bcrypt la variante solo cambia el prefijo; el hash en sí es idéntico
N de scrypt (coste de CPU)
r / p de scrypt r =   p = tamaño de bloque 128·r bytes; memoria = 128·N·r bytes (N=214, r=8 → 16 MiB)
m de Argon2id (memoria)
t / p de Argon2id t =   p = t = pasadas; p = paralelismo (carriles)
PRF de PBKDF2
Iteraciones de PBKDF2  OWASP 2023: 600 000 para HMAC-SHA-256 (1 300 000 para SHA-1, 210 000 para SHA-384/512)
Longitud de salida (bytes)  La salida de bcrypt es fija en 23 bytes (31 caracteres base64 de bcrypt)
AlgoritmoParámetrosMemoriaLongitud de salidaTiempo (en este navegador)
bcryptcoste 124 KiB23 bytes-
scryptN=214, r=8, p=116 MiB32 bytes-
Argon2idm=19 MiB, t=2, p=119 MiB32 bytes-
PBKDF2HMAC-SHA-256, 600 000 iteraciones~032 bytes-
Hoja de parámetros (mínimos de la OWASP Password Storage Cheat Sheet, 2023)
AlgoritmoMínimoNotas
Argon2idm = 19 MiB (19 456 KiB), t = 2, p = 1preferido; dependiente de memoria
scryptN = 214, r = 8, p = 1dependiente de memoria (16 MiB como mínimo)
bcryptcoste = 10solo factor de trabajo; límite de contraseña de 72 bytes
PBKDF2-HMAC-SHA256600 000 iteracionessolo dependiente de iteraciones — apta para GPU, última opción
Los valores por defecto de esta página están en o por encima de todos los mínimos. Para producción elija primero Argon2id; si no está disponible, scrypt o bcrypt; PBKDF2 solo por motivos de cumplimiento FIPS.
Interoperabilidad con PHP — password_hash($pw, PASSWORD_BCRYPT) genera $2y$10$...: péguelo en Verificar con la contraseña candidata y esta página responde exactamente lo que respondería password_verify(). La salida de PASSWORD_ARGON2ID ($argon2id$v=19$m=65536,t=4,p=1$...) también se verifica. Las cadenas PHC de passlib, django-argon2 y del envoltorio crypto.scrypt también se analizan.
Autocomprobación
Vuelve a ejecutar el motor de la página frente a vectores públicos: la suite de pruebas de crypt_blowfish para bcrypt, cadenas de scrypt y Argon2id generadas con node/OpenSSL, los vectores de PBKDF2 de la RFC 6070 y el conjunto público de SHA-256, además de idas y vueltas generar-y-verificar en cada algoritmo y pruebas negativas (una contraseña incorrecta debe fallar, las cadenas mal formadas deben rechazarse). Nada se envía a ningún sitio.
Cálculo de hash de contraseñas explicado desde cero
En una frase: un hash de contraseña es deliberadamente lento (y preferiblemente hambriento de memoria) para que, si roban la base de datos, el atacante no pueda probar miles de millones de conjeturas por segundo — lo contrario de un hash rápido como SHA-256, que está diseñado para la velocidad.
¿Por qué no basta con SHA-256 sobre la contraseña?

SHA-256 en una GPU moderna funciona a miles de millones de conjeturas por segundo. Una contraseña de 8 caracteres tiene muy por debajo de 1013 combinaciones — horas de GPU, minutos en un equipo grande. Las funciones de cálculo de hash de contraseñas (KDF) combaten esto con parámetros de coste: bcrypt repite su núcleo 2coste veces, PBKDF2 itera HMAC cientos de miles de veces, y scrypt y Argon2id exigen además megabytes de memoria por conjetura, así que las GPU (rápidas pero pobres en memoria por núcleo) pierden su ventaja. La sal — aleatoria, guardada en claro dentro de la cadena del hash — impide las tablas arcoíris precalculadas y obliga a calcular cada conjetura de nuevo para cada usuario.

Los cuatro algoritmos de esta página
AlgoritmoAñoDurezaFormato de firmaCuidado con
bcrypt1999CPU (2coste preparaciones de clave)$2b$12$ + sal de 22 caracteres + hash de 31 caractereslímite de contraseña de 72 bytes (todo lo que pase de 72 se ignora en silencio); el byte NUL termina la contraseña en la implementación original en C
PBKDF22000 (RFC 2898/8018)CPU (iteraciones)$pbkdf2-sha256$i=600000$ + sal + hash (estilo passlib)sin coste de memoria — a las GPU y los ASIC les encanta; solo se puede ajustar el número de iteraciones
scrypt2009 (RFC 7914)CPU + memoria (128·N·r bytes)$scrypt$ln=14,r=8,p=1$ + sal + hashN debe ser una potencia de dos; la memoria crece linealmente con r
Argon2id2015 (ganador del PHC, RFC 9106)CPU + memoria (m KiB, t pasadas)$argon2id$v=19$m=19456,t=2,p=1$ + sal + hashArgon2i (independiente de los datos) frente a Argon2d (dependiente de los datos) frente a Argon2id (híbrido) — elija siempre id salvo que sepa por qué no
Dureza de memoria frente a dureza de cómputo

Una GPU tiene miles de núcleos, pero cada núcleo tiene acceso a muy poca memoria rápida. Un KDF que necesita 19 MiB de conjunto de trabajo por conjetura limita al atacante al número de conjeturas paralelas que le permitan sus fragmentos de 19 MiB de memoria — por eso Argon2id con 19 MiB puede ser más fuerte en la práctica que bcrypt con coste 15, pese a tardar menos tiempo real en su portátil. PBKDF2 no tiene respuesta a esto: su único mando es el número de iteraciones, y el silicio escala eso linealmente.

Lectura de una cadena PHC

El formato modular-crypt / PHC es autodescriptivo: en $argon2id$v=19$m=19456,t=2,p=1$ICEiIyQlJicoKSorLC0uLw$WTGpK4hf... los campos son el algoritmo, la versión, los parámetros (m = memoria en KiB, t = pasadas, p = carriles), la sal en base64 y el hash en base64. bcrypt es anterior al estándar y usa su forma compacta propia: variante $2b$, coste 12, y después la sal y el hash en el alfabeto base64 propio de bcrypt (./A-Za-z0-9). La verificación de esta página acepta todos estos formatos y muestra los campos analizados — pegue cualquier hash que encuentre y vea en qué se descompone.

Errores habituales
  • Hash rápido para contraseñas. Las columnas de contraseñas con MD5/SHA-1/SHA-256 caen ante GPU de consumo a miles de millones de conjeturas por segundo. Use el Generador de hash para archivos y datos; use los algoritmos de esta página para contraseñas.
  • Compartir una sal. Una sola sal para todos los usuarios significa que contraseñas iguales tienen hashes iguales y vuelven las tablas arcoíris. Cada hash de aquí recibe una sal aleatoria nueva de 16 bytes.
  • Ignorar los 72 bytes de bcrypt. "a"*100 y "a"*72 dan el mismo hash — la cola se descarta. Esta página avisa en el cuadro de entrada cuando la contraseña supera los 72 bytes. Argon2 no tiene ese límite.
  • Comparar hashes con == en su propio código. La verificación debe ser de tiempo constante; el motor de la página lo hace internamente (recalcula y compara los bytes guardados), pero si copia el enfoque, use una comparación de tiempo constante.
  • Ajustar parámetros en una máquina de desarrollo rápida. Apunte a unos 250–500 ms de cálculo en el hardware medio de sus usuarios de producción, no en su estación de trabajo. El botón de Comparar muestra lo que este navegador experimenta realmente.
  • Recalcular el hash en cada comprobación de inicio de sesión. Verifique primero; recalcule (p. ej., para subir el coste) solo tras una verificación correcta, y guarde la cadena nueva. La función de PHP password_needs_rehash() existe precisamente para esto.
Preguntas frecuentes

¿Cuál debo elegir? Argon2id con al menos los mínimos de la OWASP. Si el entorno de ejecución no lo ofrece: scrypt, y después bcrypt (con un coste que haga que el cálculo tarde ≥250 ms). PBKDF2 solo cuando la certificación lo exija.

¿Por qué aparece una sal aleatoria en la cadena de salida? La sal no es un secreto — se guarda en claro dentro de la cadena PHC a propósito, así que la verificación solo necesita la cadena y la contraseña candidata. Su función es la unicidad, no el secreto.

¿Importa la variante ($2a$ / $2b$ / $2y$)? Para contraseñas ASCII producen hashes idénticos; $2a$ es el original de los años noventa, $2b$ corrigió un raro fallo de extensión de signo (2014), $2y$ es la marca de PHP de que la corrección está presente. La verificación acepta las tres.

¿Cuánto debe tardar un hash? Aproximadamente de 250 a 500 ms por inicio de sesión en hardware de servidor. Por debajo de 100 ms, el craqueo sin conexión es barato; por encima de 1 s, los usuarios se quejan antes de que mejore la seguridad.

¿Puedo verificar un hash generado en otro lugar? Sí — péguelo y facilite la contraseña candidata. Formatos conocidos que funcionan: password_hash de PHP (bcrypt $2y$ y Argon2id), passlib de Python, el hasher argon2 de django, y el formato de cadena scrypt de la herramienta scrypt de Tarsnap.

¿Qué hace el botón de «comparar»? Calcula el hash de la contraseña actual una vez con cada algoritmo, con los parámetros por defecto de la página, e informa del tiempo real en este navegador — una idea de las diferencias de coste, no una medición rigurosa.