Genera un hash SHA-256, MD5, SHA-1, SHA-512 o SHA-3 de cualquier texto, o pega una suma publicada y verifícala. Los ocho algoritmos a la vez.
Se procesa tal cual lo escribes: un espacio final, una mayúscula o un salto de línea cambian el hash por completo.
Escribe un texto arriba y todos los algoritmos se rellenan a la vez.
| Algoritmo | Bits | Hash |
|---|---|---|
| MD5 | 128 | — |
| SHA-1 | 160 | — |
| SHA-256 | 256 | — |
| SHA-384 | 384 | — |
| SHA-512 | 512 | — |
| SHA3-256 | 256 | — |
| SHA3-384 | 384 | — |
| SHA3-512 | 512 | — |
El tamaño de bloque es el bloque de la función de compresión en MD5 y en las familias SHA-1 y SHA-2, y la tasa de la esponja en SHA-3. Fuentes: RFC 1321, FIPS 180-4 y FIPS 202.
| Algoritmo | Estándar | Construcción | Bloque o tasa | Estado |
|---|---|---|---|---|
| MD5 | RFC 1321 | Merkle–Damgård | 512 | Roto desde 2004 |
| SHA-1 | FIPS 180-4 | Merkle–Damgård | 512 | Roto desde 2017 |
| SHA-256 | FIPS 180-4 | Merkle–Damgård | 512 | Sin colisión publicada |
| SHA-384 | FIPS 180-4 | Merkle–Damgård | 1024 | Sin colisión publicada |
| SHA-512 | FIPS 180-4 | Merkle–Damgård | 1024 | Sin colisión publicada |
| SHA3-256 | FIPS 202 | Esponja | 1088 | Sin colisión publicada |
| SHA3-384 | FIPS 202 | Esponja | 832 | Sin colisión publicada |
| SHA3-512 | FIPS 202 | Esponja | 576 | Sin colisión publicada |
También podrías encontrar útiles estas calculadoras
Qué claves AES, RSA, ECC y hash tienen la misma fuerza.
Entropía, resistencia a intentos y tiempo de descifrado
Texto a binario, hex, decimal u octal — y de vuelta, en UTF-8 real
Genera UUID v4, v6, v7, ULID y NanoID en lote — o decodifica uno.
Pega cualquier texto y esta página devuelve sus hashes MD5, SHA-1, SHA-256, SHA-384, SHA-512, SHA3-256, SHA3-384 y SHA3-512 juntos, en hexadecimal o en Base64. Cambia a Verificar y compara tu texto con una suma de verificación que pegues, que es la razón real por la que casi todo el mundo calcula un hash. Todo se ejecuta en tu navegador: el texto no sale de tu equipo.
Una función hash convierte una entrada de cualquier longitud en un valor de longitud fija llamado hash o resumen, y la misma entrada produce siempre el mismo resultado. Tres propiedades la hacen criptográfica: es unidireccional, así que no se puede recuperar la entrada a partir del hash; resiste colisiones, así que dos entradas no deberían compartir hash; y tiene el efecto avalancha, así que cambiar un solo bit de la entrada cambia cerca de la mitad de los bits de salida. SHA-256 devuelve 256 bits, escritos como 64 caracteres hexadecimales, tanto si le das una letra como un gigabyte. Ese tamaño fijo es lo que convierte al hash en una huella útil: comparar dos hashes es inmediato, mientras que comparar dos archivos exigiría transferirlos.
La forma de todo hash
Descargas un instalador, el proyecto publica una línea SHA-256 y Verificar te dice si coinciden antes de que ejecutes nada.
Una persona desarrolladora resume un cuerpo JSON en Base64 para una cabecera de firma y comprueba el valor byte a byte contra el que calculó el servidor.
Calcula el hash de un archivo de configuración en dos máquinas y compara los hashes en vez de hacer un diff por un enlace lento o a través de una red aislada.
Una versión antigua solo publicó un MD5. Puedes comprobarlo frente a corrupción accidental sabiendo, por el aviso en pantalla, que no demuestra nada frente a una manipulación.
Comparar SHA-1 con SHA-256 y SHA3-256 sobre datos reales muestra el cambio de longitud que tendrá que absorber una columna de base de datos o un campo de protocolo.
Calcula el hash de una frase, cambia una letra y observa cómo cambia entero: la forma más rápida de entender por qué no existen las coincidencias parciales.
Quien publica un programa publica también el hash de la versión; tú calculas el de tu descarga y comparas. Si un espejo te sirvió un archivo modificado, los hashes difieren. Es la única comprobación de integridad que no exige confiar en la red, solo en el valor publicado.
Las copias de seguridad, las cachés y los clientes de sincronización comparan hashes en vez de contenidos. Dos archivos con el mismo SHA-256 se tratan como el mismo archivo, así que el sistema puede ahorrarse transferirlos, guardarlos o volver a indexarlos.
Los algoritmos de firma operan sobre un hash de tamaño fijo, no sobre los megabytes que hay detrás. Por eso un hash roto rompe el esquema de firma que hay encima: SHAttered produjo dos PDF con un mismo hash SHA-1, así que una sola firma amparaba a los dos.
Git nombra cada commit, árbol y blob por su hash; los registros de contenedores e IPFS hacen lo mismo. El identificador se deriva del contenido, así que un byte distinto produce otra dirección en vez de sobrescribir la anterior en silencio.
CRC-32 y Adler-32 detectan corrupción accidental de forma barata y se pueden falsificar a propósito en un momento. Úsalos para errores de transmisión; usa SHA-256 o SHA-3 cuando alguien pueda querer que el hash colisione.
MD5 perdió la resistencia a colisiones en 2004 y SHA-1 en 2017. Saber qué estándar define un algoritmo y cuándo se rompió es la diferencia entre una suma heredada y una vulnerabilidad viva.
Una función hash convierte una entrada de cualquier longitud en un resumen de longitud fija, de forma determinista: la misma entrada da siempre el mismo resultado. Un hash criptográfico añade tres garantías: no se puede retroceder del hash a la entrada, no se pueden encontrar dos entradas con el mismo hash y cambiar un bit de la entrada cambia cerca de la mitad de los bits de salida. SHA-256 devuelve siempre 256 bits, tanto si la entrada es una palabra como si es una película.
No, y nada puede hacerlo: un hash no es cifrado y no tiene clave. Un resumen descarta información, porque entradas ilimitadas se proyectan sobre un número fijo de salidas, así que el original no se puede recuperar ni siquiera en teoría. Las páginas que anuncian «descifrar MD5» buscan tu hash en una tabla de hashes ya calculados, lo que solo funciona con entradas que alguien procesó antes, como contraseñas comunes y cadenas cortas.
No. La NIST SP 800-63B establece que las contraseñas «SHALL be salted and hashed using a suitable password hashing scheme» —deben llevar sal y procesarse con un esquema de hash de contraseñas adecuado— y remite a los esquemas de la SP 800-132: PBKDF2, bcrypt, scrypt o Argon2, con un factor de coste tan alto como tolere tu verificador. SHA-256 y SHA-512 son rápidos por diseño, que es justo la propiedad que un almacén de contraseñas no debe tener: una GPU moderna prueba miles de millones de conjeturas SHA-256 por segundo.
No para nada relacionado con la seguridad. Las colisiones de MD5 se publicaron en 2004 y hoy se calculan en segundos con hardware corriente, así que un atacante puede producir dos archivos distintos con el mismo MD5. Sigue valiendo como comprobación barata frente a corrupción accidental —una descarga truncada, un bit invertido— donde nadie intenta engañarte. Allí donde un adversario pueda influir en la entrada, usa SHA-256 o SHA-3.
Ambos vienen de FIPS 180-4 y se diferencian en el tamaño del hash y en la anchura de palabra interna. SHA-256 produce 256 bits con palabras de 32 bits sobre bloques de 512 bits; SHA-512 produce 512 bits con palabras de 64 bits sobre bloques de 1.024 bits, lo que lo hace más rápido que SHA-256 en procesadores de 64 bits pese a la salida más larga. Ninguno está roto; elige SHA-256 salvo que quieras específicamente el margen mayor o la velocidad en hardware de 64 bits.
SHA-3 es la familia estandarizada en FIPS 202 en 2015, construida sobre la esponja Keccak en vez del diseño Merkle–Damgård que hay detrás de MD5, SHA-1 y SHA-2. Existe como alternativa estructuralmente distinta, no porque SHA-2 sea débil: SHA-2 sigue sin romperse y sigue siendo la opción por defecto casi en todas partes. Elige SHA-3 cuando quieras un diseño que no comparta la genealogía de SHA-2 o cuando una especificación lo pida.
Es el efecto avalancha, y es un requisito de diseño deliberado. Un hash seguro busca invertir cerca de la mitad de los bits de salida ante cualquier cambio de un bit en la entrada, de modo que el hash no revele nada sobre el parecido entre dos entradas. Por eso tampoco existen las coincidencias parciales: el modo Verificar indica en qué carácter difieren dos hashes, pero esa posición no dice nada sobre lo próximas que estaban las entradas.
Ejecuta el algoritmo del autor sobre el archivo y compara los hashes carácter a carácter. En macOS o Linux es shasum -a 256 archivo, y en Windows CertUtil -hashfile archivo SHA256. Después pega el valor publicado y el tuyo en Verificar, que los compara e indica el primer carácter distinto. Y algo esencial: la suma publicada tiene que venir de una fuente en la que confíes, porque una suma alojada junto a una descarga manipulada no demuestra nada.
No. El cifrado es reversible con una clave y protege la confidencialidad; el hash es unidireccional, no tiene clave y sirve para detectar cambios. «Cifrar con MD5» es un error de categoría que aparece en tutoriales antiguos: MD5 no tiene clave y no produce nada que se pueda descifrar. Si necesitas recuperar los datos, necesitas cifrado, no un hash.
Una colisión son dos entradas distintas que producen el mismo hash. Las colisiones existen necesariamente, porque un hash proyecta entradas ilimitadas sobre un número fijo de salidas; la cuestión de seguridad es si alguien puede encontrar una. El coste genérico ronda las 2^128 operaciones para un hash de 256 bits —la cota del cumpleaños—, pero MD5 y SHA-1 tienen ataques publicados mucho más baratos, y por eso esta página indica el año en que se rompió cada uno en vez de una cota que ya no se cumple.
Los dos codifican bytes idénticos con densidades distintas. El hexadecimal gasta dos caracteres por byte; Base64 gasta cuatro caracteres por cada tres bytes y rellena el resultado hasta un múltiplo de cuatro. Un hash SHA-256 son 32 bytes, así que son 64 caracteres hexadecimales o 44 caracteres Base64, de los cuales el último es relleno. Verificar acepta cualquiera de las dos escrituras y compara en el formato que pegues.
Sí, todos ellos. El hash opera sobre bytes, así que «Hello» y «hello» se diferencian en exactamente un byte y producen hashes totalmente ajenos entre sí, y un espacio o un salto de línea copiado junto a una suma es el motivo más frecuente de que una verificación falle. Dos de los ejemplos de arriba lo demuestran con el mismo hash esperado y una sola mayúscula de diferencia.
Una sal es un valor aleatorio que se guarda junto al hash de una contraseña y se mezcla antes de calcularlo, para que dos personas con la misma contraseña tengan valores distintos y las tablas precalculadas no sirvan. Esta página no añade nada: procesa exactamente los bytes que escribes, que es lo que hace falta para sumas de verificación y firmas. La sal pertenece al almacenamiento de contraseñas, donde es un requisito de un esquema de hash de contraseñas y no un añadido sobre un hash simple.
SHA-256 para casi todo: no está roto, tiene soporte universal y es el valor por defecto en TLS, Git y los gestores de paquetes. Usa SHA-512 cuando quieras un margen mayor o más rendimiento en CPU de 64 bits, y SHA3-256 cuando una especificación lo pida o quieras una construcción sin relación con SHA-2. Usa MD5 y SHA-1 solo para leer sumas que ya existen, nunca para crear nuevas.