Generador de hash y suma de verificación
Obtén MD5, SHA-1, SHA-256, SHA-384 y SHA-512 para texto y archivos al mismo tiempo. Verifica un archivo descargado contra su suma de verificación oficial para asegurarte de que no haya sido manipulado. Todo local, nada sale de tu navegador.
- Algoritmos
- MD5 · SHA-1/256/384/512
- Motor
- Web Crypto API
- Privacidad
- 100% local
- Entrada
- Texto / archivo
Arrastra un archivo aquí, o haz clic para buscar
Los bytes del archivo se leen localmente para calcular las sumas de verificación — no se sube nada. Funciona con instaladores, imágenes de disco y archivos comprimidos.
CARACTERÍSTICAS
Los cinco hashes en una sola página
Desde huellas rápidas hasta firmas seguras — cada hash que necesites para desarrolladores, operaciones y verificación de descargas.
Cinco algoritmos
MD5, SHA-1, SHA-256, SHA-384 y SHA-512 se muestran juntos con sus longitudes de bits de salida — no más cambiar entre herramientas.
Cálculo en tiempo real
Hashes de texto mientras escribes, sin necesidad de pulsar botón. Resultados en espaciado monoespaciado — haz clic en una fila para copiar.
Verificación de integridad de archivos
Arrastra un instalador, imagen de disco o archivo comprimido y compáralo con la suma de verificación oficial para confirmar una descarga sin manipulaciones.
Local, sin subida
La familia SHA utiliza la Web Crypto API integrada del navegador. El texto y los archivos nunca salen de tu máquina — el contenido sensible está seguro.
Coherente con UTF-8
El texto se convierte en un hash como bytes UTF-8, por lo que los resultados coinciden exactamente con md5sum, md5() de PHP y hashlib de Python.
Copiar con un clic
Copia cada hash individualmente, o todos en formato de suma de comprobación estándar listo para pegar en un terminal.
Qué debes saber sobre los hashes
La idea es sencilla, pero usar el adecuado para una tarea equivocada es un fallo de seguridad real.
¿Qué son exactamente MD5 y SHA-1?
MD5 (Algoritmo de Resumen de Mensajes 5) fue diseñado por Ronald Rivest en el MIT y publicado en 1992 como RFC 1321, generando un resumen fijo de 128 bits (32 caracteres hexadecimales) como sucesor de MD4. SHA-1 fue diseñado por la Agencia de Seguridad Nacional de los Estados Unidos y publicado en 1995 como estándar federal FIPS 180-1, generando 160 bits. Ambos se convirtieron en los algoritmos hash más usados en las dos décadas siguientes: para sumas de comprobación de archivos, almacenamiento de contraseñas, firmas digitales e IDs de confirmación de Git. Ten en cuenta que siguen generando resúmenes correctos hoy en día; "inseguro" significa que su resistencia a colisiones ha sido rota, no que su salida sea errónea.
¿Son lo mismo el hashing, el cifrado y la codificación?
No, resuelven problemas diferentes. La codificación (como Base64 o codificación URL) es una transformación de formato reversible que cualquiera puede revertir, sin ofrecer seguridad. El cifrado es reversible con una clave: el texto plano se convierte en texto cifrado y la clave correcta lo descifra. El hashing es unidireccional, no tiene clave y no se puede recuperar el original a partir del resumen; se usa para huellas digitales, comprobaciones de integridad y firmas. Dos ideas erróneas comunes: tratar Base64 como "cifrado", y decir que una contraseña fue "cifrada con MD5"; eso es hashing, y además una forma insegura de almacenar contraseñas.
¿Por qué no se puede revertir un hash al original?
Un hash es una función unidireccional: la entrada de cualquier longitud se comprime en un resumen de longitud fija, descartando la mayor parte de la información. Al igual que no se puede reconstruir una frase a partir del recuento de sus palabras, no se puede derivar el original del resumen. Los algoritmos seguros están diseñados específicamente para hacer que dicha reversión sea computacionalmente inviable.
¿Siguen siendo útiles MD5 y SHA-1?
Para comprobar si un archivo se corrompió accidentalmente durante el envío: sí, cualquier cambio de byte extra virtually siempre modifica el MD5. Pero nunca para seguridad: existen ataques prácticos de colisión para ambos (los investigadores pueden crear dos archivos diferentes con el mismo MD5 bajo su control). Usa SHA-256 o superior para contraseñas, firmas y certificados.
¿Por qué mi hash es diferente al de otra herramienta para el mismo texto?
Tres causas habituales: ① diferente codificación de caracteres (esta herramienta siempre usa UTF-8; herramientas antiguas pueden usar GBK o Latin-1); ② un salto de línea final: el comando echo añade uno por defecto (usa echo -n); ③ un espacio extra o un carácter invisible al copiar. Los hashes son sensibles a cada byte individual, así que un byte de diferencia cambia el resultado completamente.
¿Por qué no se pueden almacenar las contraseñas como MD5/SHA-256 en texto plano?
Los hashes habituales son rápidos. Con una tabla de hashes filtrada, los atacantes pueden probar miles de millones de conjeturas por segundo, y las tablas arcoíris buscan instantáneamente contraseñas comunes. Las contraseñas necesitan algoritmos deliberadamente lentos y resistentes al consumo de memoria (bcrypt, scrypt, Argon2) con una sal única por contraseña, haciendo que la fuerza bruta sea prohibitivamente cara.
¿Cómo verifico la integridad de un archivo descargado?
Busca la suma de verificación publicada en el sitio oficial (normalmente SHA-256), arrastra el archivo descargado hasta la pestaña "Suma de verificación de archivo" aquí y pega el valor oficial en el cuadro que aparece encima de los resultados. La herramienta detecta el algoritmo según la longitud del valor y marca la fila correspondiente en verde cuando los bytes del archivo coinciden exactamente con el publicado; en rojo indica corrupción o manipulación por un intermediario — no ejecutes el archivo.
¿Cuál de los cinco algoritmos debes usar
Elige según el escenario. Los algoritmos más nuevos generan resúmenes más largos, son más resistentes a ataques y su cálculo tiene un costo ligeramente mayor.
| Algoritmo | Fecha de introducción | Longitud de salida | Seguridad | Uso típico |
|---|---|---|---|---|
| MD5 | 1992 | 128 bits (32 caracteres) | Roto; colisiones son prácticas | Huellas digitales no relacionadas con seguridad, deduplicación, compatibilidad con sistemas heredados |
| SHA-1 | 1995 | 160 bits (40 caracteres) | Colisiones son prácticas desde 2017 | IDs de historial de Git y otros sistemas heredados; no se recomienda para nuevos usos relacionados con seguridad |
| SHA-256 | 2001 | 256 bits (64 caracteres) | Seguro hoy en día | Sumas de verificación de archivos, firmas, certificados TLS, cadenas de bloques — el valor predeterminado universal |
| SHA-384 | 2001 | 384 bits (96 caracteres) | Seguro | SHA-512 truncado para reglamentaciones que requieren 384 bits |
| SHA-512 | 2001 | 512 bits (128 caracteres) | Seguro | Firmas de alta confianza; a menudo más rápido que SHA-256 en CPUs de 64 bits |
"Seguro" significa que no existe hasta la fecha ningún ataque de colisión público práctico. Para almacenamiento de contraseñas usa bcrypt/Argon2 independientemente del hash elegido.
Sumas de verificación: cómo verificar realmente un archivo descargado
Para qué sirve esa cadena MD5 o SHA-256 en una página de descarga, cómo compararla y con qué compararla — todo en una sola sección.
¿Por qué verificarla en absoluto
El archivo en tu disco no es necesariamente el archivo que está en el servidor. Una comparación de suma de verificación de diez segundos protege contra tres tipos de problemas:
Los archivos grandes con descargas reanudables y redes inestables suelen adquirir bytes extraños; solucionar un instalador roto lleva mucho más tiempo que diez segundos.
Muchas descargas provienen realmente de espejos o CDNs, donde el desfase de sincronización o fallos de caché pueden entregar una versión obsoleta — o la mitad del archivo.
Cuando una fuente de descarga se ve comprometida o una red pública es secuestrada, los archivos pueden tener una puerta trasera. En 2016 el sitio de Linux Mint fue hackeado y sus enlaces de descarga se sustituyeron por un ISO con puerta trasera — la primera respuesta del proyecto fue instar a todos a verificar la suma de verificación.
¿Qué es una suma de verificación
El publicador calcula la suma de verificación del archivo en su servidor y publica el resultado en la página de descarga; después de descargarlo, tú la calculas localmente nuevamente. Si las dos cadenas coinciden carácter por carácter, los bytes del archivo son exactamente los que lanzó el publicador — ni están dañados ni manipulados. La comprobación es sensible a cada byte: con cambiar un solo byte, el valor cambia completamente. En términos generales, las sumas de verificación también incluyen esquemas más simples como CRC32 que solo detectan daños accidentales, mientras que los hashes criptográficos como MD5/SHA resisten además la falsificación deliberada.
Verifica un archivo en tres pasos
-
1
Obtén la suma de verificación oficial
En la página de descarga, busca el valor MD5 / SHA-256 publicado (a menudo etiquetado como "checksum" o incluido como archivo compañero .sha256) y copia toda la cadena.
-
2
Arrastra el archivo y pégalo
Cambia a la pestaña "Suma de verificación de archivos" superior, arrastra el archivo descargado y pega la suma de verificación en el cuadro superior de los resultados.
-
3
Lee el veredicto por color
La herramienta detecta el algoritmo por la longitud del valor: verde significa que el archivo coincide exactamente con la versión oficial y es seguro de usar; rojo significa que podría estar dañado o manipulado — no lo ejecutes.
Leyendo las sumas de verificación en sitios oficiales
Las páginas de descarga muestran las sumas de verificación en muchos formatos, pero todas se reducen a dos elementos: el valor del hash y el nombre del archivo. Estas tres estructuras son las más comunes — al pegar, toma solo la parte del hash (esta herramienta ignora espacios y saltos de línea automáticamente):
# 1. Línea única: solo el valor
a0570aa01532917be820a37994710cf09b6eba198bf9543c27be938c5f09e60a
# 2. Formato sha256sum: valor + dos espacios + nombre de archivo (un manifiesto SHA256SUMS tiene muchas líneas como esta)
a0570aa01532917be820a37994710cf09b6eba198bf9543c27be938c5f09e60a ubuntu-24.04.iso
# 3. Formato BSD: Algoritmo (nombre de archivo) = valor
SHA256 (ubuntu-24.04.iso) = a0570aa01532917be820a37994710cf09b6eba198bf9543c27be938c5f09e60aMD5 o SHA-256
Verifica lo que ofrezca el sitio oficial, pero si puedes elegir: MD5 es totalmente suficiente contra daños accidentales en tránsito (cualquier cambio fortuito casi siempre altera el MD5). Contra la manipulación deliberada — software de seguridad, certificados, paquetes firmados — necesitas SHA-256 o uno más fuerte, porque los ataques de colisión prácticos permiten a los atacantes crear dos archivos distintos con el mismo MD5. Esa historia se explica en la "historia de seguridad" más abajo.
Verificando desde la línea de comandos en su lugar
En Linux y macOS, las herramientas de sumas de verificación aceptan -c para comprobar un manifiesto completo automáticamente — no se necesita comparación manual. Los comandos integrados de Windows solo calculan el valor, que tú debes comparar luego con la cadena oficial por tu cuenta.
| Entorno | Comando de verificación |
|---|---|
| Linux | sha256sum -c SHA256SUMS (comprueba cada archivo listado en el manifiesto) |
| macOS | shasum -a 256 -c checksum.txt |
| Verificación rápida de un valor único | echo "valor-oficial nombre-de-archivo" | sha256sum -c - (muestra OK si tiene éxito) |
| Windows | Calcula con Get-FileHash <archivo> -Algorithm SHA256, luego compara con el valor oficial |
Breve historia de seguridad: cómo se rompió MD5
MD5 no falló de la noche a la mañana — desde la primera brecha en el mundo académico hasta los certificados falsificados en la práctica, tardó dos décadas.
-
1992
Se publica MD5
Ronald Rivest lanzó MD5 en el RFC 1321. Rápido, sencillo de implementar y que siempre genera un resumen de 128 bits, se convirtió rápidamente en el estándar de facto para sumas de comprobación de archivos y almacenamiento de contraseñas, y se consideraba criptográficamente seguro.
-
2004
El equipo de Wang Xiaoyun revela colisiones completas de MD5
En CRYPTO 2004, un equipo dirigido por la matemática china Wang Xiaoyun demostró un ataque de colisión completo contra MD5: construyó dos archivos con contenidos diferentes pero el mismo hash (inicialmente en aproximadamente una hora en un supercomputador IBM P690; las mejoras posteriores lo redujeron a segundos en hardware común). La resistencia a colisiones prometida por MD5 desapareció; la ovación de pie que siguió se convirtió en uno de los momentos más famosos de la criptografía.
-
2008
Certificados falsos llegan a Internet real
Marc Stevens, Alexander Sotirov y otros utilizaron una colisión con prefijo elegido para falsificar un certificado de CA intermedia confiado por los navegadores: certificados con prefijos diferentes llevaban la misma firma. Un atacante podía emitir ahora certificados HTTPS «válidos» para cualquier sitio falso. Las autoridades de certificación dejaron de emitir certificados MD5 poco después.
-
2012
Malware Flame ataca Windows mediante MD5
El malware Flame patrocinado por un estado utilizó una colisión MD5 para hacer que la autoridad de licencias de servidor terminal de Microsoft firmara un certificado de código-signado falso, permitiéndose propagar por Oriente Medio disfrazado de una actualización firmada por Microsoft. Fue el primer ataque en el mundo real que utilizó una colisión MD5; Microsoft revocó el certificado con un parche de emergencia.
-
2017
SHAttered: SHA-1 cae
Google y el instituto holandés CWI (Marc Stevens et al.) publicaron dos archivos PDF diferentes con un hash SHA-1 idéntico — a un coste de aproximadamente 6500 años de CPU y 110 años de GPU. Los navegadores dejaron de confiar en los certificados SHA-1 poco después, y las plataformas Git aceleraron su migración alejándose de él. La era de los 160 bits había terminado.
Matiz importante: un ataque de colisión no «rompe» el hash de ningún archivo existente — construye dos archivos específicos que hacen hash al mismo valor. Pero para firmas y certificados, eso ya es suficiente para una falsificación fatal.
Hashing desde la línea de comandos
Cuando un navegador no está a mano, cada sistema operativo incluye un comando integrado (se muestra SHA-256).
| Entorno | Comando |
|---|---|
| Linux / macOS | sha256sum filename (en macOS: shasum -a 256 filename) |
| Windows PowerShell | Get-FileHash filename -Algorithm SHA256 |
| Windows CMD | certutil -hashfile filename SHA256 |
Hashing en código
Ejemplos mínimos en cuatro lenguajes comunes cuando escribes scripts o integras APIs.
async function sha256Hex(data) {
const bytes = typeof data === "string"
? new TextEncoder().encode(data)
: new Uint8Array(data);
const digest = await crypto.subtle.digest("SHA-256", bytes);
return [...new Uint8Array(digest)]
.map((b) => b.toString(16).padStart(2, "0"))
.join("");
}
// Text
console.log(await sha256Hex("hello"));
// Files: digest accepts an ArrayBuffer directly
const buf = await file.arrayBuffer();
console.log(await sha256Hex(buf));
La API Web Crypto nativa del navegador solo admite la familia SHA y requiere HTTPS o localhost; MD5 necesita una librería de terceros.
echo hash('sha256', 'hello'); // 64 hex characters
echo md5('hello'); // same as hash('md5', 'hello')
// Streamed: hashes the file without loading it into memory
echo hash_file('sha256', 'setup.exe');
hash() y hash_file() admiten md5, sha1, sha256, sha512 y más; el hashing de archivos se transmite en flujo, por lo que utiliza poca memoria.
import hashlib
print(hashlib.sha256(b"hello").hexdigest())
print(hashlib.md5(b"hello").hexdigest())
# Large files: streamed, low memory (Python 3.11+)
with open("setup.exe", "rb") as f:
print(hashlib.file_digest(f, "sha256").hexdigest())
La librería estándar hashlib no requiere instalación; usa file_digest() para hashes en flujo de archivos grandes (Python 3.1+).
use sha2::{Digest, Sha256};
use md5::Md5;
// Text
println!("{:x}", Sha256::digest(b"hello"));
println!("{:x}", Md5::digest(b"hello"));
// Large files: streamed, low memory
let mut file = std::fs::File::open("setup.exe")?;
let mut hasher = Sha256::new();
std::io::copy(&mut file, &mut hasher)?;
println!("{:x}", hasher.finalize());
El hashing no está en la librería estándar; añade las crates RustCrypto sha2 y md-5 en Cargo.toml. Con la característica std activada, io::copy transmite archivos en flujo hacia el hasher.
Preguntas frecuentes
¿Se han subido mi texto y mis archivos?
No. Todo se calcula dentro de tu navegador: las llamadas a la familia SHA usan la API Web Crypto integrada, y MD5 se ejecuta en el JavaScript de la página. La herramienta sigue funcionando sin conexión a la red — pruébalo con un archivo sensible.
¿Por qué el texto vacío aún tiene un hash?
Los algoritmos hash definen una salida fija única incluso para cero bytes. El MD5 de una cadena vacía es d41d8cd98f00b204e9800998ecf8427e y su SHA-256 empieza por e3b0c442. Esta herramienta simplemente oculta los resultados cuando la entrada está vacía para que no los copies por error.
¿Puede calcular hashes de archivos de cualquier tamaño?
Depende de la memoria disponible del navegador: los instaladores y las imágenes de disco de unos cientos de MB suelen funcionar bien. Los archivos se cargan en la memoria de una sola pasada, por lo que para archivos de varios GB es mejor usar herramientas de línea de comandos (sha256sum, certutil).
¿Por qué los hashes tienen longitudes diferentes?
La longitud la determina el algoritmo: MD5 tiene 32 caracteres hexadecimales, SHA-1 40, SHA-256 64 y SHA-512 128. Hay dos caracteres hexadecimales por byte — y la longitud es independiente del tamaño de la entrada: un archivo de un byte y un archivo de varios GB devuelven 64 caracteres con SHA-256.
¿Puedo usarlo para firmar APIs?
Sí. Muchas plataformas abiertas firman las solicitudes hashing «parámetros + secreto» con MD5 o SHA-256. Esta herramienta es genial para comprobar un valor de firma durante la depuración; en producción, calcula los hashes en la librería de tu lenguaje del servidor y nunca insertes el secreto en el código del frontend.
¿Cómo comparo una suma de comprobación con esta herramienta?
Cambia a la pestaña «Suma de comprobación de archivos», arrastra el archivo y pega la suma de comprobación del sitio oficial en el cuadro encima de los resultados. La herramienta detecta automáticamente el algoritmo por su longitud (32 caracteres MD5, 40 SHA-1, 64 SHA-256, 96 SHA-384, 128 SHA-512): la fila coincidente se pone verde con la nota «Aprobado» cuando concuerdan, y roja cuando no. Las mayúsculas, espacios alrededor y saltos de línea se ignoran automáticamente.
Herramientas relacionadas
Otras herramientas de codificación, criptografía y contraseñas.
Codificar / Decodificar Base64
Convertir entre binario y texto — útil para Data URIs y depuración de autenticación básica HTTP.
Generador de contraseñas
Generar contraseñas fuertes y aleatorias — las contraseñas deben ser aleatorias y únicas, no «encriptadas» con un hash.
Comprobador de fortaleza de contraseñas
Comprueba si una contraseña es suficientemente larga y aleatoria, y si ha aparecido en filtraciones conocidas.