Generador y verificador de hash Bcrypt

Genera y verifica hashes de contraseña adaptativos en tu navegador. Usa PBKDF2-SHA256 mediante Web Crypto como alternativa en JS puro para pruebas tipo bcrypt.

Actualizado

Share:
Home/Security Tools/PBKDF2 Hash Generator & Verifier

PBKDF2 Hash Generator & Verifier

Generate and verify adaptive password hashes directly in your browser. Uses PBKDF2-SHA256 via the Web Crypto API as a pure-JS fallback for bcrypt-style testing and learning.

Running in PBKDF2 fallback mode

The bcryptjs package is not installed, so true bcrypt isn’t available client-side. This tool substitutes PBKDF2-SHA256 (Web Crypto) with an adaptive cost factor mapped from the familiar bcrypt “rounds” parameter. Output format: $pbkdf2-sha256$rounds$salt$hash.

Generate Hash

1,024,000 iterations
4 (fast)10 (recommended)14 (slow)

Security Notes

Never run client-side hashing for real authentication.

This tool is for testing, learning, and generating reference hashes only. Production password hashing must happen on the server, behind rate limits, with a vetted library (bcrypt, argon2, scrypt). The client can never be trusted to enforce cost factors or keep the plaintext out of attackers’ hands.

Why bcrypt (and bcrypt-style KDFs)?

  • Adaptive cost: the rounds factor lets you increase work as hardware gets faster, without changing the algorithm.
  • Salt built-in: every hash embeds a unique random salt, so identical passwords still produce different hashes and rainbow tables are useless.
  • GPU/ASIC-resistant: bcrypt’s memory-access pattern (and argon2’s explicit memory hardness) makes massively parallel cracking expensive compared to plain SHA-256.
  • Slow by design: a legitimate login tolerates 100 ms of work, but an attacker trying billions of guesses cannot.

Preguntas Frecuentes

¿Es esto bcrypt real?

No — bcryptjs no está instalado, por lo que la herramienta recurre a PBKDF2-SHA256 a través de Web Crypto. Es un KDF adaptativo con sal y un factor de coste configurable, ideal para pruebas y aprendizaje.

¿Qué hace el control deslizante de rondas?

Las rondas son el factor de coste; se asignan a iteraciones de PBKDF2 mediante 2^rondas x 1000. Cada ronda duplica el trabajo, manteniendo los hashes fuertes a medida que mejora el hardware.

¿Puedo usar esto para autenticación real?

No. Nunca generes hashes de contraseñas del lado del cliente para autenticación real. Genera el hash en el servidor con una biblioteca contrastada (bcrypt, argon2id, scrypt) detrás de una limitación de tasa.

¿Es gratuito el Bcrypt Hash Generator & Verifier?

Sí, el Bcrypt Hash Generator & Verifier es 100% gratuito, sin registro, sin tarifas ocultas y sin límites de uso. Todo el procesamiento ocurre localmente en tu navegador, garantizando una privacidad total.

¿Están seguros mis datos con esta herramienta?

Por supuesto. El Bcrypt Hash Generator & Verifier procesa todo del lado del cliente en tu navegador. No se sube ni se almacena ningún dato en ningún servidor. Tu contenido permanece privado en tu dispositivo en todo momento.

¿Funciona el Bcrypt Hash Generator & Verifier en dispositivos móviles?

Sí, el Bcrypt Hash Generator & Verifier es totalmente adaptable y funciona en smartphones y tablets. Puedes usarlo en cualquier dispositivo con un navegador web moderno, sin necesidad de descargar ninguna aplicación.

¿Necesito crear una cuenta para usar esta herramienta?

No se necesita ninguna cuenta ni registro. Solo abre el Bcrypt Hash Generator & Verifier en tu navegador y empieza a usarlo de inmediato. No hay muros de registro ni restricciones de uso.

¿Cómo uso el Bcrypt Hash Generator & Verifier?

Solo introduce tu entrada en el campo correspondiente, ajusta la configuración a tu gusto y la herramienta la procesará al instante. Luego puedes copiar el resultado al portapapeles o descargarlo.

¿Qué navegadores son compatibles?

El Bcrypt Hash Generator & Verifier funciona en todos los navegadores modernos, incluidos Chrome, Firefox, Safari, Edge y Opera. Para una mejor experiencia, usa la última versión de tu navegador preferido.

¿Cuál es la diferencia entre bcrypt y PBKDF2?

Bcrypt y PBKDF2 son ambas funciones de hashing de contraseñas adaptativas y con sal, pero están construidas de forma distinta. Bcrypt se basa en el cifrado Blowfish y su factor de coste controla cuántas rondas de configuración de clave ejecuta, lo que además hace que use una cantidad fija de memoria. PBKDF2, por su parte, simplemente repite un hash subyacente como HMAC-SHA256 muchas veces, así que su coste se define mediante un número de iteraciones en lugar de un número de rondas logarítmico. Ambas comparten las cualidades que importan para el almacenamiento de contraseñas: una sal única, un factor de trabajo ajustable y una lentitud deliberada. PBKDF2 está aprobado por FIPS y viene integrado en la Web Crypto API del navegador, que es justo la razón por la que esta herramienta lo usa como sustituto. Genera un hash arriba y observa cómo cada paso del control de rondas duplica el trabajo, igual que hace el factor de coste de bcrypt.

¿Por qué la misma contraseña produce un hash distinto cada vez?

Cada vez que generas un hash, la herramienta crea una nueva sal aleatoria de 16 bytes usando el crypto.getRandomValues del navegador, y luego mezcla esa sal en la derivación. Como la sal es diferente en cada ejecución, dos contraseñas idénticas producen dos cadenas de salida completamente distintas. Esto es intencionado y es una de las propiedades más importantes del almacenamiento seguro de contraseñas: significa que un atacante no puede saber que dos usuarios eligieron la misma contraseña, y neutraliza las tablas rainbow precalculadas, ya que tendrían que reconstruirse para cada sal única. La sal no es un secreto, así que se guarda directamente dentro de la cadena del hash, en el segmento de la sal, lo que permite que la verificación reutilice ese mismo valor más adelante. Genera la misma contraseña dos veces arriba para ver dos hashes distintos que aun así verifican correctamente.

¿Cómo funciona la verificación de contraseñas sin almacenar la contraseña original?

La verificación nunca necesita tener la contraseña original guardada; solo necesita el hash almacenado. Cuando pegas una contraseña y un hash existente en la pestaña Verificar, la herramienta lee el factor de coste y la sal directamente de la cadena del hash, ya que ambos van codificados dentro de ella. Después vuelve a ejecutar exactamente la misma derivación sobre la contraseña que escribiste y compara el resultado recién calculado con el valor almacenado. Si coinciden, la contraseña es correcta. La comparación utiliza una verificación de tiempo constante que siempre examina cada byte, de modo que un atacante no puede aprender nada midiendo cuánto tarda en rechazarse un intento erróneo. Este es el mismo flujo que usa un sistema de inicio de sesión real: se almacenan los hashes, no las contraseñas en texto plano. Pruébalo generando un hash y luego pegándolo de nuevo en la pestaña Verificar para confirmar que coincide.

¿Cómo elijo el factor de coste adecuado para el hashing de contraseñas?

El factor de coste determina cuánto trabajo requiere cada hash, y el valor adecuado es un equilibrio entre seguridad y velocidad de inicio de sesión. Aquí el control de rondas va de 4 a 14, y se traduce en iteraciones de PBKDF2 según 2 elevado a las rondas, multiplicado por 1000, de modo que cada ronda adicional duplica el esfuerzo. La ronda 10 es un valor por defecto razonable, con aproximadamente un millón de iteraciones; valores más bajos como 4 sirven bien para demostraciones rápidas, mientras que 14 es intencionadamente pesado. Una regla práctica habitual es elegir el coste más alto que tu servidor pueda absorber manteniendo un único inicio de sesión legítimo por debajo de unos 100 milisegundos, ya que los inicios de sesión lentos frustran a los usuarios, pero los hashes rápidos favorecen a los atacantes. Como la función es adaptativa, puedes aumentar el coste más adelante a medida que mejora el hardware. Mueve el control deslizante arriba y observa el indicador de tiempo para sentir ese equilibrio.

¿Por qué se consideran inseguros MD5 y SHA-256 para el hashing de contraseñas?

MD5 y SHA-256 son funciones de hash rápidas y de propósito general, y precisamente esa velocidad es el problema cuando se trata de contraseñas. Una GPU moderna puede calcular miles de millones de hashes MD5 o SHA-256 sin modificar por segundo, así que si una base de datos se filtra, un atacante puede probar listas de palabras enormes contra los hashes robados casi al instante. Además, no incorporan sal, lo que significa que contraseñas idénticas comparten hashes idénticos y las tablas rainbow precalculadas las descifran en cuestión de segundos. Las funciones adaptativas como bcrypt, scrypt, argon2 y el PBKDF2 usado aquí cambian esa ecuación: añaden una sal única y un factor de coste ajustable que hace que cada intento sea deliberadamente costoso, de modo que un único inicio de sesión sigue siendo rápido pero el descifrado masivo se vuelve poco práctico. Esta herramienta te permite experimentar directamente con ese factor de coste y ver cómo un hashing lento y con sal cambia la economía de un ataque.

Embed This Tool

Add a free, live version of this widget to your own website or blog post — it runs entirely in your visitors' browsers, with a credit link back to The Toolbox.

Copy & paste this HTML
<iframe src="https://getthetoolbox.com/embed/bcrypt-generator" title="Bcrypt Hash Generator & Verifier — The Toolbox" width="100%" height="280" style="max-width:480px;border:1px solid #e2e8f0;border-radius:12px" loading="lazy"></iframe>
<p style="font-size:12px;margin:4px 0 0"><a href="https://getthetoolbox.com/security-tools/bcrypt-generator?utm_source=embed&utm_medium=widget" target="_blank" rel="noopener">Free Bcrypt Hash Generator & Verifier</a> by The Toolbox</p>

Acerca del Generador y Verificador de Hash Bcrypt

El Generador y Verificador de Hash Bcrypt es una herramienta gratuita que funciona directamente en el navegador para crear hashes de contraseña adaptativos y con sal, así como para verificar una contraseña frente a un hash existente. Está pensada para desarrolladores que quieren entender cómo funciona el almacenamiento de contraseñas, estudiantes de seguridad que experimentan con factores de coste y programadores que necesitan un hash de referencia rápido sin necesidad de montar un backend. Todo ocurre localmente en tu dispositivo: no hay que registrarse, no se sube nada a ningún servidor y no existe límite de uso.

Conviene ser claros desde el principio: esta herramienta no genera hashes bcrypt auténticos. El paquete bcryptjs no está incluido, así que la herramienta funciona en un modo alternativo basado en PBKDF2, derivando los hashes con PBKDF2-SHA256 a través de la Web Crypto API nativa del navegador. PBKDF2 es una función de derivación de claves real y estandarizada que comparte las propiedades esenciales de bcrypt —una sal aleatoria única, un factor de coste ajustable y una lentitud deliberada—, lo que la convierte en un sustituto fiel para pruebas y aprendizaje, aunque el formato de salida sea distinto.

Cómo generar y verificar un hash

La interfaz tiene dos pestañas. En la pestaña Generar introduces una contraseña y eliges un factor de coste con el control deslizante de rondas, y luego pulsas para producir un hash. En la pestaña Verificar pegas una contraseña y un hash existente, y la herramienta te indica si coinciden.

  • Factor de coste (rondas): el control deslizante va de 4 a 14. Las rondas se traducen en iteraciones de PBKDF2 mediante la fórmula 2^rondas × 1000, así que cada paso hacia arriba duplica el trabajo. La ronda 10 es el valor recomendado por defecto (unas 1.024.000 iteraciones); 4 es rápida para demostraciones y 14 es deliberadamente lenta.
  • Sal aleatoria: cada hash incorpora una sal nueva de 16 bytes generada con crypto.getRandomValues, de modo que contraseñas idénticas siguen produciendo hashes distintos y las tablas rainbow precalculadas quedan inutilizadas.
  • Formato de salida: los hashes se emiten como $pbkdf2-sha256$rondas$sal$hash, con la sal y la clave derivada almacenadas en base64. El factor de coste viaja dentro de la propia cadena, que es como la verificación sabe cuántas iteraciones debe repetir.
  • Retroalimentación de tiempo: después de generar el hash, la herramienta muestra cuánto tardó en milisegundos, dándote una idea de cómo el factor de coste se traduce en trabajo real sobre tu hardware.

La verificación vuelve a derivar el hash a partir de la contraseña usando la sal y las rondas incrustadas en la cadena guardada, y luego lo compara mediante una comprobación de tiempo constante que no filtra información a través de la duración de la comparación.

Por qué importa el hashing adaptativo y con sal

Guardar las contraseñas en texto plano o con hashes rápidos como MD5 o SHA-256 sin modificar es peligroso, porque las GPU modernas pueden probar miles de millones de intentos por segundo. Las funciones adaptativas como bcrypt, scrypt, argon2 y PBKDF2 están diseñadas precisamente para resistir esto:

  • El coste adaptativo te permite aumentar el factor de trabajo a medida que mejora el hardware, sin cambiar el algoritmo ni migrar a los usuarios.
  • Una sal única incorporada neutraliza las tablas rainbow e impide que dos usuarios con la misma contraseña compartan el mismo hash.
  • La lentitud deliberada es precisamente el objetivo: un único inicio de sesión legítimo puede absorber sin problema 100 milisegundos de trabajo, pero ese mismo coste hace que una campaña de descifrado offline resulte enormemente cara.

Importante: esto es para aprender, no para producción

Nunca generes hashes de contraseñas en el cliente para autenticación real. No se puede confiar en que el navegador imponga un factor de coste ni en que mantenga el texto plano fuera del alcance de un atacante, y enviar la lógica de hashing al cliente la expone por completo. El almacenamiento de contraseñas en producción debe ejecutarse en el servidor, protegido por limitación de peticiones (rate limiting), usando una librería contrastada —bcrypt, argon2id o scrypt—. Trata este Generador y Verificador de Hash Bcrypt como un entorno de pruebas: un lugar para ver cómo se comportan las sales, los factores de coste y la verificación, para generar hashes de referencia desechables y para construir intuición antes de implementar el sistema real en tu backend.