Herramienta de Verificación de Hash de Archivo
Calcula hashes MD5, SHA-1, SHA-256, SHA-384, SHA-512 para archivos
Arrastra y suelta el archivo aquí
Soporta cualquier tipo y tamaño de archivo
¿Qué es el Hash de Archivo?
Un hash de archivo convierte el contenido de un archivo en una huella de longitud fija mediante un algoritmo elegido. El mismo archivo produce siempre el mismo valor, mientras que un cambio de un solo byte puede generar un resultado totalmente distinto. Los hashes sirven para verificar descargas, comparar copias de seguridad, detectar duplicados, comprobar integridad tras una transferencia y contrastar sumas publicadas en avisos de seguridad o releases. La herramienta admite MD5, SHA-1, SHA-256, SHA-384 y SHA-512. MD5 y SHA-1 siguen apareciendo en flujos antiguos, pero no son adecuados para garantías modernas de seguridad; para integridad suele preferirse SHA-256 o superior. Un hash no puede revertirse al archivo original.
Cómo usar
Cómo usar
- Arrastra un archivo al área de carga o haz clic en el botón 'Seleccionar archivo'
- Marca los algoritmos hash que deseas calcular (selección múltiple)
- Haz clic en el botón 'Calcular hash' para iniciar
- Tras el cálculo, copia los valores hash individualmente o todos a la vez
- Para verificación, introduce un valor hash conocido en el campo de comparación
Flujo de verificación
- Calcula el hash después de que el archivo se haya descargado o copiado por completo; los archivos parciales y las interrupciones de transferencia producen valores diferentes.
- Al comparar con un checksum publicado, cópialo de la fuente oficial y asegúrate de que el algoritmo coincida exactamente.
Casos de uso
Principio técnico
Todos los digests SHA de la página se calculan a través de la W3C Web Cryptography API, expuesta en el navegador como crypto.subtle. La llamada es await crypto.subtle.digest(algorithm, buffer), donde algorithm es 'SHA-1', 'SHA-256', 'SHA-384' o 'SHA-512' (sensible a mayúsculas) y buffer es un ArrayBuffer o cualquier TypedArray. La función devuelve una Promise que resuelve a un ArrayBuffer con los bytes del digest, que la página convierte a hexadecimal en minúsculas recorriéndolo como Uint8Array y mapeando cada byte a byte.toString(16).padStart(2, '0'). SubtleCrypto solo está disponible en contextos seguros (HTTPS o localhost); SHA-1 se mantiene para compatibilidad legada, pero la especificación señala que su resistencia a colisiones está rota. MD5 no está en la especificación Web Crypto (el W3C lo omitió a propósito por los ataques de colisión), así que el MD5 de esta página lo calcula una implementación en JavaScript puro que corre íntegramente en el navegador. Para todos los algoritmos — MD5 y la familia SHA por igual — el archivo se lee como ArrayBuffer de una sola vez con FileReader.readAsArrayBuffer y se pasa a la rutina JavaScript de MD5 o a crypto.subtle.digest. Esta herramienta no ofrece un API incremental .append ni un Web Worker de respaldo, así que la memoria tiene que albergar el archivo completo: bien para descargas típicas, pero no ideal para cargas de varios GB; en ese caso es mejor una herramienta de escritorio que streamee desde disco (sha256sum, certutil -hashfile, Get-FileHash). Longitudes de digest y postura de seguridad: MD5 = 128 bits / 32 caracteres hex (RFC 1321, resistencia a colisiones rota desde Wang Xiaoyun 2004, explotado en producción por el malware Flame en 2012); SHA-1 = 160 bits / 40 caracteres hex (FIPS 180-4, colisión demostrada por SHAttered de Google en 2017 con ~9.2 ×10^18 cómputos de SHA-1, NIST planea su deprecación formal después de 2030); SHA-256 = 256 bits / 64 caracteres hex (FIPS 180-4, sin colisiones conocidas, baseline recomendado); SHA-384 y SHA-512 = 384 / 512 bits, salida truncada y completa de la familia SHA-512 (FIPS 180-4). El efecto avalancha de los hashes criptográficos hace que cambiar un solo bit de entrada altere aproximadamente la mitad de los bits de salida, por eso editar un byte produce un digest completamente distinto.
- crypto.subtle.digest(algorithm, buffer) acepta 'SHA-1', 'SHA-256', 'SHA-384', 'SHA-512' (distingue mayúsculas) y rechaza 'MD5'; requiere un contexto seguro (HTTPS o localhost) y devuelve un Promise<ArrayBuffer>.
- Codificación hex: recorre el resultado como new Uint8Array(digestBuffer) y mapea cada byte a byte.toString(16).padStart(2, '0'); compara resúmenes sin distinguir mayúsculas (normaliza con .toLowerCase()).
- MD5 está ausente de Web Crypto por diseño; esta herramienta calcula MD5 en JavaScript puro, leyendo el archivo como un único ArrayBuffer vía FileReader.readAsArrayBuffer y produciendo un digest hex de 32 caracteres en minúscula en una sola pasada.
- Perfil de memoria: la página lee el archivo completo en un único ArrayBuffer (sin API .append incremental ni descarga a Web Worker) y pasa el buffer en una sola llamada a MD5 en JavaScript o a crypto.subtle.digest. Para archivos que superan el heap disponible de la pestaña, cambia a una herramienta de escritorio (sha256sum, certutil -hashfile, Get-FileHash) que streamee desde disco.
- Tamaños de resumen (FIPS 180-4): MD5 128 bits, SHA-1 160 bits, SHA-256 256 bits, SHA-384 384 bits, SHA-512 512 bits; el número de caracteres hex es el doble del número de bytes.
- Ataques de colisión conocidos: MD5 roto por Wang 2004, explotado por Flame 2012; SHA-1 roto por SHAttered de Google 2017 (~9,2 x 10^18 ops, ~110 años-GPU); SHA-256 y superiores no tienen colisiones prácticas conocidas.
- Efecto de avalancha: un cambio de un solo bit en la entrada invierte ~50% de los bits de salida en promedio; por eso una edición de un solo byte produce un resumen hex completamente diferente y no existen coincidencias parciales de archivo.
Ejemplos
Verificar un archivo descargado contra una suma de comprobación publicada
Archivo: sample.bin (3 bytes, contenido: abc)
SHA-256 (calculado):
ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad
Línea SHA256SUMS publicada por el editor:
ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad sample.bin
Coincidencia -> la descarga está intacta, no manipulada
(Ambos valores son el vector de referencia SHA-256 FIPS 180-2 para la
entrada de 3 bytes 'abc'. En la práctica, sustituye la entrada por el archivo real;
la salida del algoritmo es determinista.)Comparación entre algoritmos sobre la misma entrada
Archivo: sample.txt (3 bytes, contenido: abc)
MD5: 900150983cd24fb0d6963f7d28e17f72
SHA-1: a9993e364706816aba3e25717850c26c9cd0d89d
SHA-256: ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad
SHA-512: ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f
Distintos algoritmos, misma entrada -> usa SHA-256 o más fuerte para verificaciones de seguridad
(MD5 es el vector de referencia RFC 1321; los demás son vectores
de referencia FIPS 180-2, todos para la entrada de 3 bytes 'abc'.)Detectar un cambio de 1 byte (efecto avalancha)
Entrada A: abc (3 bytes)
Entrada B: abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq (56 bytes)
SHA-256 de A: ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad
SHA-256 de B: 248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1
Un pequeño cambio en la entrada produce un resumen totalmente
distinto -> es el efecto avalancha en acción.
(Ambos valores son vectores de referencia SHA-256 FIPS 180-2.)Referencia en consola del navegador para verificación
// Reproducir en Node.js para comparar
$ printf 'abc' | shasum -a 256
ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad
// PowerShell en Windows
PS> 'abc' | Get-FileHash -Algorithm SHA256 | Select-Object -ExpandProperty Hash
ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad
// En la consola del navegador, usando la Web Crypto API:
// const buf = new TextEncoder().encode('abc');
// const hash = await crypto.subtle.digest('SHA-256', buf);
// -> ArrayBuffer del SHA-256 de 'abc' (vector de referencia FIPS 180-2)
Los archivos permanecen en tu navegador, nada se sube.Preguntas frecuentes
¿Qué algoritmos de hash puedo generar?
Las opciones habituales son MD5, SHA-1, SHA-224, SHA-256, SHA-384 y SHA-512. La página los calcula con la Web Crypto API del navegador (familia SHA) y JS nativo para MD5. SHA-256 es la elección recomendada hoy día para uso general.
¿Se sube el archivo a algún sitio?
No. El cálculo del hash ocurre íntegramente en tu navegador usando File API y Web Crypto. Los bytes se leen en memoria por trozos y el hash se calcula localmente; el archivo no cruza la red. Puedes verificarlo mirando la pestaña de Red mientras calculas el hash.
¿Por qué se sigue ofreciendo MD5 si está roto?
MD5 está roto para fines de seguridad (es fácil construir colisiones), pero sigue siendo el checksum de facto para comprobar que una descarga es bit a bit idéntica al original; muchos proveedores aún publican MD5 junto a SHA-256. Úsalo solo para eso, nunca para hashear contraseñas ni firmas.
¿Por qué mis hashes SHA-256 son distintos para archivos que parecen iguales?
El hash incluye cada byte, así que un solo salto de línea final, un BOM o finales de línea distintos (CRLF vs LF) cambian el hash por completo. Vuelve a descargar el original en lugar de copiar y pegar, o usa un visor binario para confirmar que ambos archivos tienen los mismos bytes.
¿Hay un límite de tamaño de archivo?
El navegador necesita memoria suficiente para leer el archivo. Los equipos de escritorio modernos manejan archivos de varios GB, pero los navegadores móviles pueden quedarse sin memoria en torno a unos cientos de MB. Para archivos muy grandes usa una herramienta de escritorio (sha256sum, certutil, Get-FileHash): leen del disco en streaming y son más rápidas.
¿Pueden dos archivos distintos producir el mismo hash?
En teoría sí (principio del palomar), pero para SHA-256 la probabilidad es astronómicamente baja. MD5 y SHA-1 tienen ataques de colisión conocidos, así que dos archivos con el mismo MD5 o SHA-1 no demuestran ser el mismo archivo. Las colisiones de SHA-256 no son factibles con los ataques conocidos.
¿Por qué mis hashes no coinciden con el publicado en la web del proveedor?
Lo más habitual: descargaste una versión localizada, firmada o reempaquetada; la página lista el hash de otra versión; o tu descarga se truncó. Vuelve a descargar con una herramienta nueva y vuelve a calcular el hash. Si la diferencia persiste, no confíes en el archivo.