Generador de Hash
Soporta algoritmos MD5, SHA-1, SHA-256, SHA-384, SHA-512
Pega arriba un hash conocido — los resultados de abajo se actualizan en vivo. Se ignoran espacios, comillas exteriores y mayúsculas/minúsculas al comparar.
¿Qué es un Hash?
Un hash es un algoritmo que mapea datos de longitud arbitraria a un resumen de longitud fija. La misma entrada siempre produce la misma salida, mientras que un pequeño cambio en la entrada produce una salida completamente diferente, y es imposible revertir un valor hash a los datos originales. Los algoritmos hash comunes incluyen MD5, SHA-1, SHA-256, SHA-384 y SHA-512, ampliamente utilizados en verificación de integridad de datos, almacenamiento de contraseñas y firmas digitales. Las funciones hash deben entenderse según el objetivo: verificación de integridad, identificación rápida o seguridad. MD5 y SHA-1 siguen apareciendo en sumas antiguas, pero son débiles para decisiones modernas de confianza; SHA-256 o algoritmos superiores suelen preferirse. Un hash no es cifrado: no puede descifrarse, pero entradas débiles o predecibles pueden adivinarse con diccionarios o ataques precalculados.
Cómo usar
Cómo usar
- Escribe o pega el texto que quieres hashear en el campo de entrada
- Marca los algoritmos hash que quieras generar (selección múltiple)
- Haz clic en 'Calcular Hash' para calcular
- Haz clic en 'Copiar' para guardar un hash o en 'Copiar Todo' para todos los resultados
Notas sobre el hashing
- Los valores hash son huellas digitales deterministas: cambiar un solo byte en la entrada produce un resultado distinto.
- Usa SHA-256 o algoritmos más robustos para comprobaciones de integridad cuando la seguridad importa, y evita MD5/SHA-1 en nuevos flujos de seguridad.
Casos de uso
Principio técnico
Una función hash criptográfica mapea una entrada de longitud arbitraria a un resumen de longitud fija, con tres propiedades de seguridad: resistencia a preimagen (difícil de invertir), resistencia a segunda preimagen (difícil encontrar una entrada diferente con el mismo resumen) y resistencia a colisiones (difícil encontrar dos entradas cualesquiera con el mismo resumen). MD5 (Rivest 1991, RFC 1321), SHA-1 (NIST FIPS 180-1, 1995) y la familia SHA-2 (FIPS 180-4, 2012) son todas construcciones Merkle-Damgård: la entrada se rellena hasta un múltiplo del tamaño de bloque, luego se itera a través de una función de compresión unidireccional. El tamaño de bloque es de 512 bits para MD5, SHA-1 y SHA-256, y 1024 bits para SHA-512. Tamaños de resumen: 128 / 160 / 256 / 384 / 512 bits respectivamente.
MD5 (Rivest 1991) es un hash de 128 bits, 64 rondas de un cuarto de ronda con cuatro palabras de encadenamiento de 32 bits (A, B, C, D), constantes derivadas de la función seno (sin significado de seguridad, solo para romper la simetría). Ataques de colisión: Wang et al. 2004 redujo la búsqueda de colisiones MD5 a 2⁴⁰ evaluaciones de hash (rutas diferenciales calculadas a mano); Stevens 2009 escribió una herramienta de colisión de prefijo elegido; el malware Flame 2012 usó un ataque novedoso de prefijo elegido para falsificar un certificado de firma de código de Microsoft, marcando el primer exploit de colisión MD5 conocido en la naturaleza. Hoy, una colisión MD5 cuesta menos de un dólar en CPU y milisegundos en GPU. Usa SHA-256 para cualquier nuevo protocolo.
SHA-1 (FIPS 180-1, obsoleto según NIST en 2011 tras FIPS 180-4) es un hash de 160 bits con 80 rondas y cinco palabras de encadenamiento de 32 bits. El ataque SHAttered (Stevens et al., febrero de 2017) produjo la primera colisión práctica de SHA-1, costando ~6.500 años de CPU y 110 años de GPU. Para 2020, las colisiones de prefijo elegido eran prácticas por ~$45.000 de tiempo de GPU, y para 2025 el costo de colisión en hardware commodity está bien por debajo de $10.000. Git migró de SHA-1 a SHA-256 en 2020; los certificados HTTPS no han podido usar SHA-1 desde 2017. La salida de colisión de prefijo elegido SHAttered ('SHAttered.pdf' y 'SHAttered2.pdf') es el vector de prueba estándar: sus resúmenes SHA-1 coinciden pero los contenidos difieren.
SHA-2 (FIPS 180-4, 2012) cubre seis hashes: los sucesores de SHA-1 SHA-224, SHA-256, SHA-384, SHA-512 más dos variantes truncadas SHA-512/256 y SHA-512/224. Internamente SHA-256 usa seis funciones lógicas (Ch, Maj, Σ0, Σ1, σ0, σ1) con 64 constantes de ronda K[t] = ⌊∛(primeros 32 bits de la parte fraccionaria del t-ésimo primo)⌋ — la construcción de raíz cúbica del primo es puramente estética, sin papel de seguridad. SHA-256 ha sido el caballo de batalla desde ~2010 y es el estándar de facto para TLS 1.3 (RFC 8446), la prueba de trabajo de Bitcoin (hasta las discusiones de cambio de 2025) y la mayoría del almacenamiento con direccionamiento por contenido. SHA-512/256 es más rápido en hardware de 64 bits porque usa palabras de 64 bits y ejecuta la compresión de SHA-512, luego trunca.
SHA-3 (FIPS 202, 2014) y Keccak (la presentación original) usan una estructura fundamentalmente diferente: la construcción de esponja Keccak-f[1600] con un estado de 1600 bits, alternando fases de absorción/extrusión. SHA-3 tiene los mismos tamaños de resumen que SHA-2 pero resiste el ataque de extensión de longitud que afecta a los hashes Merkle-Damgård — una propiedad útil al hashear un MAC de prefijo secreto. BLAKE2 (RFC 7693) es más rápido que SHA-256 en software y es lo que usan WireGuard, Argon2 y varios protocolos modernos.
Esta página ejecuta SHA-1, SHA-256, SHA-384 y SHA-512 en el navegador mediante SubtleCrypto.digest (que llama al código nativo de la plataforma — OpenSSL/BoringSSL en Chromium, NSS en Firefox, el equivalente en Safari), y recurre a una implementación pura en JS de MD5 porque SubtleCrypto no expone MD5 (según la API W3C Web Crypto, MD5 está en estado 'recommend-only'). Para 10 MB de datos, SHA-256 en V8 se ejecuta a ~400 MB/s en un portátil moderno, mientras que MD5 en JS puro se ejecuta a ~100-150 MB/s — la familia SHA de Web Crypto es 3-4 veces más rápida que cualquier implementación pura en JS, razón por la cual la página enruta SHA-1+ a través de la interfaz nativa.
- MD5 (Rivest 1991, RFC 1321): resumen de 128 bits, bloque de 512 bits, 64 rondas, Merkle-Damgård. Roto por colisiones desde Wang 2004 (2⁴⁰ de trabajo) y roto por prefijo elegido en Flame 2012 — nunca usar para código nuevo, pero aún válido para checksums sin seguridad, ETags, huellas de contenido o claves de caché.
- SHA-1 (FIPS 180-1, 1995; obsoleto según FIPS 180-4, 2011): resumen de 160 bits. La colisión SHAttered (Stevens et al., feb. 2017) costó ~6.500 años de CPU; las colisiones de prefijo elegido ahora están por debajo de $10K. Git migró a SHA-256 en 2020; CA/Browser Forum prohibió SHA-1 en certificados HTTPS en 2017.
- SHA-256 (FIPS 180-4): resumen de 256 bits, 64 rondas de Ch/Maj/Σ0/Σ1/σ0/σ1, 64 constantes de ronda K[t] derivadas de ∛(parte fraccionaria del primo). Caballo de batalla para TLS 1.3 (RFC 8446), la mayoría del almacenamiento con direccionamiento por contenido y la minería de Bitcoin. El nivel de seguridad de 256 bits proporciona ~128 bits de resistencia a colisiones.
- SHA-384/SHA-512 (FIPS 180-4): SHA-512 usa palabras de 64 bits, 80 rondas, bloque de 1024 bits. Aproximadamente 1,5-2 veces más rápido que SHA-256 en hardware de 64 bits. SHA-384 es simplemente SHA-512 truncado a 384 bits; SHA-512/256 es SHA-512 truncado a 256 bits y proporciona mejor resistencia a la extensión de longitud que SHA-256.
- SHA-3 (FIPS 202, 2014) / Keccak: construcción de esponja con permutación Keccak-f[1600], tasas de 1088/832/576 bits para SHA3-256/384/512. Resiste ataques de extensión de longitud que afectan a los hashes Merkle-Damgård — útil para MACs de prefijo secreto.
- BLAKE2 (RFC 7693) y BLAKE3 son hashes rápidos modernos; BLAKE2s es la derivación típica de clave MAC, BLAKE2b es lo que usan WireGuard y muchos protocolos, y BLAKE3 añade un árbol Merkle para hashing paralelo. No está en Web Crypto hasta 2025, por lo que esta página no los expone.
- API Web Crypto (W3C): SubtleCrypto.digest('SHA-256', data) devuelve un Promise<ArrayBuffer> calculado por el código nativo de la plataforma. ~400 MB/s en V8 para SHA-256, ~100-150 MB/s para MD5 en JS puro — la brecha de 3-4 veces es la razón por la que la página enruta SHA-1+ a través de SubtleCrypto.
- Advertencia de extensión de longitud: H(secret || message) es falsificable para cualquier hash Merkle-Damgård (MD5, SHA-1, SHA-2) si el atacante conoce el resumen y la longitud del mensaje. HMAC (RFC 2104) y SHA-3 evitan esto. Para MACs usar HMAC-SHA-256 o KMAC; para hashes de entrada no confiable el resumen raw es suficiente.
Ejemplos
Vector de prueba FIPS 180-2: cadena vacía y 'abc'
Entrada: '' (vacío, 0 bytes)
MD5: d41d8cd98f00b204e9800998ecf8427e (32 caracteres hex)
SHA-1: da39a3ee5e6b4b0d3255bfef95601890afd80709 (40 caracteres hex)
SHA-256: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 (64 caracteres hex)
SHA-512: cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e
Entrada: 'abc' (3 bytes, el vector de prueba canónico de FIPS)
MD5: 900150983cd24fb0d6963f7d28e17f72
SHA-1: a9993e364706816aba3e25717850c26c9cd0d89d
SHA-256: ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad
SHA-512: ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f
La longitud de cada salida es fija según el algoritmo (MD5 128 bit, SHA-1 160 bit,
SHA-256 256 bit, SHA-512 512 bit), independientemente de la longitud de entrada.Vector de prueba FIPS 180-2 de 56 bytes (multibloque)
Entrada: 'abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq' (56 bytes)
SHA-256: 248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1
SHA-512: 8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018
50d1c9ef3504cabb287a00833cf81a7e (128 caracteres hex - se muestran los primeros 64,
el digest es de 64 bytes / 1024 bits)
Este vector de 56 bytes abarca dos bloques de 512 bits de SHA-256 y ejercita
el message schedule (expansión sigma_0 / sigma_1 de las palabras 16..63).
Es la entrada de referencia NIST CAVP para SHA-256 y la forma canónica
de confirmar que el bucle del message schedule está implementado correctamente.
Si coincide, el padding de bloques, el agregado de longitud y la suma del estado final
funcionan correctamente. SHA-512 utiliza la misma estructura Merkle-Damgard sobre
un tamaño de palabra de 64 bits y un schedule de 80 pasos, por lo que la misma entrada
de 56 bytes produce un digest de 128 caracteres hex.Efecto avalancha y trampa de codificación
Entrada: '' (vacío) MD5: d41d8cd98f00b204e9800998ecf8427e
Entrada: 'a' (un byte) MD5: 0cc175b9c0f1b6a831c399e269772661
Añadir un solo byte cambia cada bit de salida - esa es la propiedad
avalancha. Lo mismo sucede con las mayúsculas/minúsculas (a -> A cambia 0x61 a 0x41, un bit
en la posición 0x20) y con los espacios al final. Ten en cuenta también que el mismo
texto visible con y sin un '\n' al final o un BOM UTF-8
(0xEF 0xBB 0xBF) genera un digest distinto, por lo que para coincidir con un
checksum publicado se requiere coincidir con la secuencia exacta de bytes, no con los
caracteres visibles. Los navegadores y Node pasan las cadenas por TextEncoder
primero para hacer los bytes de entrada deterministas; un MD5 en JS que reciba una cadena
directamente produce hashes incorrectos para entradas no ASCII.Verificar la integridad del texto pegado con un resumen
Entrada: 'The quick brown fox jumps over the lazy dog'
MD5: 9e107d9d372bb6826bd81d3542a419d6
SHA-1: 2fd4e1c67a2d28fced849ee1bb76e7391b93eb12
SHA-256: d7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592
Pega en esta página el texto que quieras verificar (un fragmento de
configuración, un extracto de log o una respuesta de API), marca SHA-256
para generar el resumen y copia el resumen publicado al portapapeles;
luego haz clic en 'Comparar' en la fila del resultado. Cualquier carácter
distinto - incluyendo saltos de línea invisibles y espacios finales -
produce un resumen completamente diferente. Esta página procesa la
entrada como UTF-8, así que confirma que ambas partes usen la misma
codificación y los mismos finales de línea antes de comparar.Preguntas frecuentes
¿Qué algoritmos soporta esta herramienta?
Normalmente MD5, SHA-1, SHA-256, SHA-384, SHA-512 y a veces SHA-3 / RIPEMD-160. SHA-256 es la elección moderna estándar; MD5 y SHA-1 solo deberían usarse para checksums no relacionados con seguridad.
¿Hashear es lo mismo que cifrar?
No. El hash es de un solo sentido: dado el hash, no hay algoritmo para recuperar la entrada original (salvo fuerza bruta sobre un espacio de entrada pequeño). El cifrado es reversible con una clave. Usa hash para huellas digitales y comprobaciones de integridad, y cifrado para confidencialidad.
¿Dónde se hashea la entrada?
Todo el hash se ejecuta en tu navegador mediante la Web Crypto API o implementaciones JS puras. Nada se envía a un servidor. Puedes confirmarlo viendo la pestaña de Red mientras pegas la entrada.
¿Por qué la misma entrada produce un hash distinto en otro sitio?
Las diferencias suelen venir del preprocesado de la entrada: finales de línea (CRLF vs LF), espacios al final, codificación (UTF-8 vs UTF-16) o una herramienta que añade un salto de línea automáticamente. Los algoritmos en sí son deterministas en todas las implementaciones.
¿Puedo invertir un hash?
Matemáticamente no. En la práctica, las entradas cortas de un conjunto pequeño (contraseñas comunes, palabras de diccionario, números cortos) pueden buscarse en tablas rainbow precalculadas. Para cualquier cosa sensible, ese es justamente el sentido del salting y de usar un hash lento como bcrypt o Argon2: esta herramienta no los sustituye.
¿Debería hashear contraseñas con esta herramienta?
No. SHA-256 por sí solo es muchísimo demasiado rápido para almacenar contraseñas. Usa bcrypt, scrypt o Argon2 con sal por usuario y un factor de trabajo ajustado. Los hashes de la familia SHA son correctos para integridad de archivos, direccionamiento por contenido y entradas para firma; no para contraseñas.
¿Por qué los hashes tienen longitudes distintas?
Cada algoritmo tiene un tamaño de digest fijo: MD5 son 128 bits (32 hex), SHA-1 son 160 bits (40 hex), SHA-256 son 256 bits (64 hex) y SHA-512 son 512 bits (128 hex). Cuanto más largo, más resistente a colisiones, pero el hash ocupa más.
Herramientas relacionadas
Encriptador/Desencriptador AES
Herramienta de cifrado/descifrado AES en línea. Soporta AES-128/192/256, modos CBC/GCM/ECB, padding PKCS7. Procesamiento local en navegador, protege la privacidad de datos.
Modificador de MD5 de Archivo
Herramienta de modificación MD5 en línea para cambiar el MD5 del archivo añadiendo datos aleatorios. Procesamiento por lotes hasta 5 archivos, procesamiento local protege la privacidad.
Herramienta de Cifrado y Descifrado DES
Herramienta online de cifrado y descifrado DES/3DES. Soporta modos ECB, CBC con relleno PKCS7. Todo se procesa en tu navegador, nada se sube a servidores externos.
Herramienta de Verificación MD5 de Archivo
Herramienta de suma de verificación MD5 de archivos en línea gratuita para calcular valores hash MD5. Verifica integridad de archivos, detecta manipulación, asegura archivos descargados.
Herramienta de Análisis JWT
Analizador JWT en línea gratuito para decodificar y verificar JSON Web Tokens. Visualiza contenido de Header y Payload, depura problemas de autenticación API.
Herramienta de Verificación de Hash de Archivo
Calculadora de hash de archivos en línea gratuita soportando MD5, SHA-1, SHA-256, SHA-512 y más. Calcula hashes de archivos con un clic, verifica integridad.
