Generador y verificador de hash Argon2
Genera y verifica hashes de contraseñas con Argon2id, el estándar moderno de hash de contraseñas.
Calcular el hash de una contraseña
Escribe una contraseña: su hash aparece aquí.
Parámetros
m=19456 en el hash (KiB)
Carriles de memoria. Aquí se ejecutan uno tras otro; un servidor puede ejecutarlos en paralelo. Cambia el hash, así que usa el mismo valor que el servidor.
16 bytes aleatorios nuevos para cada hash.
Comprobar una contraseña con un hash
Una cadena PHC: $argon2id$, $argon2i$ o $argon2d$. Los parámetros se leen de ella.
Introduce una contraseña y un hash para comprobarlos.
Argon2 ganó la Password Hashing Competition y está estandarizado en el RFC 9106. Es lento y exigente en memoria a propósito, lo que encarece adivinar contraseñas con GPU. Esta página crea un hash Argon2 con los parámetros que elijas, como cadena PHC, la que guardan las bibliotecas de contraseñas ($argon2id$v=19$m=…,t=…,p=…$sal$hash), y en hexadecimal en bruto, y comprueba una contraseña con una cadena PHC existente. Se ejecuta en tu navegador, así que la contraseña nunca sale de tu dispositivo; es gratis y no requiere registro.
Cómo generar y verificar un hash Argon2
- Escribe la contraseña. El hash aparece mientras escribes, junto con lo que ha tardado en tu dispositivo.
- Elige un ajuste predefinido o configura la memoria, las iteraciones y el paralelismo como en tu servidor.
- Copia la cadena PHC, o el hash y la sal en bruto en hexadecimal.
- Para comprobar un hash guardado, pégalo junto con la contraseña en Comprobar una contraseña con un hash: verás Coincide o No coincide.
Funciones
- Argon2id (predeterminado), Argon2i y Argon2d, versión 19
- Ajustes predefinidos: mínimo de OWASP (19 MiB, t=2, p=1), poca memoria del RFC 9106 (64 MiB, t=3, p=4) y Alto (256 MiB, t=3, p=4)
- Memoria de 1 MiB a 1 GiB, de 1 a 16 iteraciones, paralelismo de 1 a 16 y longitud de hash de 4 a 128 bytes
- Una sal aleatoria de 16 bytes, o la tuya en texto, hexadecimal o Base64 (de 8 a 1024 bytes)
- La cadena PHC, además del hash y la sal en bruto en hexadecimal, cada uno con su botón Copiar
- Verifica cadenas $argon2id$, $argon2i$ y $argon2d$ (v=19 o v=16) leyendo los parámetros del propio hash
¿Es privado?
Sí. Argon2 se ejecuta en tu navegador con WebAssembly, en un proceso en segundo plano, y la sal sale del generador aleatorio seguro de tu navegador. La contraseña nunca se sube ni se guarda.
Preguntas frecuentes
¿Argon2id, Argon2i o Argon2d?
Usa Argon2id. Tanto el RFC 9106 como OWASP lo recomiendan para contraseñas: combina la resistencia de Argon2i a los ataques de canal lateral con la resistencia de Argon2d a los ataques con GPU. Elige otra variante solo para coincidir con un sistema existente.
¿Qué memoria, iteraciones y paralelismo debo usar?
El mínimo de OWASP para Argon2id es 19 MiB, 2 iteraciones y 1 carril. El RFC 9106 propone 64 MiB, 3 iteraciones y 4 carriles cuando la memoria es limitada. Más memoria es la mejor protección; auméntala hasta que un hash tarde lo que tu servidor pueda permitirse en cada inicio de sesión.
¿Argon2 o bcrypt?
Argon2id para un sistema nuevo. Los dos son lentos a propósito, pero Argon2 además necesita mucha memoria, lo que encarece los ataques con GPU, y no tiene el límite de 72 bytes por contraseña. Bcrypt es más antiguo y compatible con casi todo, y sigue siendo una opción razonable donde Argon2 no está disponible.
¿Qué es la cadena PHC $argon2id$?
Es la forma en que la implementación de referencia de Argon2 guarda un hash: variante, versión (v=19), memoria en KiB (m), iteraciones (t), carriles (p) y, después, la sal y el hash en Base64 sin relleno. Las cadenas creadas aquí son, carácter por carácter, las que escribe la biblioteca de referencia (libargon2) con los mismos datos, y crypto_pwhash_str_verify de libsodium las acepta (Argon2id y Argon2i, con un hash de 16 bytes o más).
¿Por qué no puedo usar más de 1 GiB de memoria?
El hash se calcula dentro de la pestaña del navegador, donde la memoria de WebAssembly es limitada: una sola reserva no puede llegar a 2 GiB, y los móviles a menudo rechazan mucho menos. Por eso esta página se detiene en 1 GiB, y los hashes que piden más (como la opción de 2 GiB del RFC 9106) no se pueden crear ni comprobar aquí.