ToolActToolAct

Herramienta de Verificación de Hash de Archivo

Calcula hashes MD5, SHA-1, SHA-256, SHA-384, SHA-512 para archivos

Subir Archivo

Arrastra y suelta el archivo aquí

Soporta cualquier tipo y tamaño de archivo

Seleccionar Algoritmo Hash
MD5
128 bits
SHA-1
160 bits
SHA-256
256 bits
SHA-384
384 bits
SHA-512
512 bits
Verificar Suma

¿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

  1. Arrastra un archivo al área de carga o haz clic en el botón 'Seleccionar archivo'
  2. Marca los algoritmos hash que deseas calcular (selección múltiple)
  3. Haz clic en el botón 'Calcular hash' para iniciar
  4. Tras el cálculo, copia los valores hash individualmente o todos a la vez
  5. 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

Calcular varios resúmenes de archivo desde una sola subidaArrastra un archivo y elige MD5 (128 bits), SHA-1 (160 bits), SHA-256 (256 bits), SHA-384 (384 bits) y SHA-512 (512 bits) en cualquier combinación para generar hashes localmente con feedback de progreso. El archivo se lee en memoria y se pasa a crypto.subtle.digest (familia SHA) o a una rutina MD5 en JavaScript dentro del navegador, así que el contenido binario nunca sale del dispositivo y es apto para firmware propietario, builds internas o artefactos sin publicar.
Verificar un checksum publicado contra los algoritmos seleccionadosPega un hash esperado antes o después del cálculo y la página identificará el algoritmo coincidente cuando uno de los valores generados iguale la cadena de comparación. La coincidencia se realiza en hex minúscula normalizada, así que un resumen en mayúsculas del publicador y uno generado localmente en minúsculas se alinean sin necesidad de reescribir manualmente.
Usar hashes más robustos para decisiones de confianzaMD5 y SHA-1 son útiles para verificaciones heredadas y detección de duplicados (ambos tienen ataques de colisión publicados), pero SHA-256 o superior es la opción más segura para verificación de descargas y evidencia de manipulación. SHA-256 produce un resumen hex de 64 caracteres sin colisiones conocidas, y SHA-384/512 elevan el listón para pipelines de lanzamiento de alta confianza. Para artefactos de gran tamaño, BLAKE3 es cada vez más común porque es entre tres y cuatro veces más rápido que SHA-256 en CPUs modernas (rendimiento sostenido en el rango de GB/s) manteniendo un diseño de árbol de Merkle que admite lecturas de flujo verificadas, aunque los selectores por algoritmo de esta herramienta aún cubren la familia SHA que la mayoría de publicadores distribuyen.
Hash de cada parte de un archivo dividido por separadoLas descargas grandes a menudo llegan en partes .001, .002 o .zipx con un hash por parte (normalmente SHA-1 o SHA-256). Hashea cada parte contra la lista publicada por el proveedor antes de unirlas, porque una sola pieza desajustada rompe el archivo recompuesto — esta página permite ejecutar el mismo algoritmo sobre todas las partes sin subirlas. Cada parte se lee en memoria en el navegador antes de hashear, así que el techo práctico es lo que el heap de la pestaña pueda retener; para partes que superen ese límite, recurre a una herramienta de escritorio (sha256sum, certutil -hashfile, Get-FileHash) que streamee desde disco.
Usar el campo de comparación para coincidencias sin distinción de mayúsculasAlgunos publicadores distribuyen hex en mayúsculas, otros en minúsculas. Pega el valor esperado una vez y la página compara por identidad de algoritmo y caso normalizado, por lo que no es necesario escribir manualmente el caso para una verificación limpia — el mismo resumen en 'A591A6...' y 'a591a6...' produce una coincidencia exitosa.

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.