Formas de verificación de suma o hash en Windows, Linux y macOS

Cuando descargamos una ISO de un sistema operativo, el instalador de un programa o cualquier archivo grande, damos por hecho que está intacto y sin manipular. Sin embargo, durante la descarga pueden producirse errores o, peor aún, alguien podría haber sustituido el fichero original por una versión maliciosa sin que nos enteremos. Es una buena práctica de higiene digital.

Para evitar sustos, en seguridad informática se recurre desde hace décadas a las sumas de verificación o hashes. Son algo así como la huella digital de un archivo: si esa huella cambia, es que el fichero ya no es el mismo. Y lo mejor es que en Windows, Linux y macOS tenemos herramientas muy sencillas para generar y comprobar esos hashes sin necesidad de instalar nada (aunque también hay programas gráficos muy cómodos).

Qué es un hash, checksum o suma de verificación

Un hash (o suma de verificación, checksum) es el resultado de aplicar una función matemática unidireccional a un bloque de datos: un archivo, un texto, incluso un disco entero. Esa función devuelve una cadena de caracteres de longitud fija (por ejemplo, 128, 160, 256 o 512 bits) que representa de forma única ese contenido.

Si cogemos un fichero y calculamos su hash, obtendremos algo del estilo a435f6f393dda581172490eda9f683c32e495158a780b5a1de422ee77d98e908. Si volvemos a calcular el hash sobre el mismo archivo sin modificarlo, el resultado será exactamente el mismo. En cuanto cambiamos un solo bit (un carácter en un documento, un byte en una ISO…), el hash cambia por completo.

Por eso se suele comparar el hash con una huella dactilar digital: si dos archivos comparten el mismo hash, se consideran idénticos a efectos prácticos. Si los hashes difieren, es que el contenido ha cambiado, ya sea por corrupción durante la descarga, por un fallo en disco o por manipulación malintencionada.

Estas funciones son unidireccionales: a partir del hash no se puede reconstruir el archivo original de forma directa. A diferencia del cifrado, aquí no hay una “clave de descifrado” que nos devuelva los datos; el hash solo sirve para verificar integridad, no para recuperar información.

Para qué sirve verificar el hash de un archivo

La verificación de hashes se utiliza constantemente en informática, muchas veces sin que el usuario sea consciente. Es una pieza básica para garantizar integridad, autenticidad y, en algunos escenarios, confidencialidad de los datos.

El uso más común en el día a día es comprobar que un archivo descargado (una ISO de Linux, el firmware de un router, un ejecutable…) coincide con el original que ofrece el proveedor. El desarrollador publica el hash oficial (por ejemplo, un SHA-256) y nosotros calculamos el hash sobre el fichero descargado para comprobar suma de verificación; si ambos valores coinciden, podemos asumir que no ha habido errores ni manipulaciones durante la descarga.

Los hashes también se emplean para almacenar contraseñas de forma segura. En lugar de guardar la clave en texto plano, el sistema guarda su hash. Cuando el usuario se autentica, se calcula de nuevo el hash de la contraseña introducida y se compara con el almacenado. Si coinciden, se concede el acceso. Al ser funciones unidireccionales, si alguien roba la base de datos solo verá hashes, no las contraseñas originales.

En análisis forense y cadena de custodia, se calcula el hash de discos, imágenes forenses y ficheros relevantes para demostrar que no se han alterado en todo el proceso. Cuerpos y Fuerzas de Seguridad del Estado y equipos periciales recurren a funciones como MD5 y SHA-1 (aun sabiendo sus debilidades) combinadas, porque suelen ser muy rápidas de calcular incluso en volúmenes de cientos de gigas.

En redes y protocolos seguros, las funciones hash se integran en mecanismos como SSL/TLS, SSH, IPSec, PGP o HTTPS para asegurar que los datos transportados no sufren modificaciones por el camino. También son clave en la tecnología blockchain y criptomonedas: Bitcoin utiliza SHA-256 para validar transacciones, encadenar bloques y mantener la integridad de toda la cadena.

Tipos de algoritmos de hash más utilizados

Existen muchos algoritmos distintos para generar hashes, con longitudes y propiedades de seguridad diferentes. No todos son igual de recomendables hoy en día, porque algunos se han demostrado vulnerables a ataques de colisión. Algoritmos distintos tienen usos y rendimientos muy dispares.

MD5 fue durante años el rey. Genera hashes de 128 bits y se utilizó para verificar integridad de archivos y proteger contraseñas. El problema es que se han encontrado colisiones de forma práctica: es posible construir dos archivos diferentes que compartan el mismo hash MD5, lo que permite a un atacante “colar” archivos alterados sin que la verificación salte la alarma. Por eso no se considera seguro para usos criptográficos, aunque todavía se usa por su rapidez en tareas forenses o de control interno.

SHA-1, con hashes de 160 bits, también fue muy popular en firmas digitales y verificación de ficheros. Pero la comunidad criptográfica demostró colisiones reales (Google y CWI llegaron a generar dos PDF con el mismo SHA-1), así que también se ha clasificado como inseguro para trabajo serio. Algunos sistemas legados aún lo usan, pero se recomienda migrar a alternativas más robustas.

La familia SHA-2 (SHA-224, SHA-256, SHA-384, SHA-512, SHA-512/224, SHA-512/256) es el estándar de facto actual. SHA-256 (256 bits) y SHA-512 (512 bits) son los más comunes. Aunque fueron diseñados por la NSA y eso genera ciertas suspicacias en parte de la comunidad, no se conocen ataques prácticos que comprometan su seguridad como funciones de integridad. Son la opción recomendada para verificación de descargas, firmas digitales y protocolos seguros.

SHA-3 (basado en Keccak) fue elegido en un concurso público organizado por el NIST, con diseños de fuera de la NSA. Ofrece longitudes de 224, 256, 384 y 512 bits y una estructura interna diferente a SHA-2, lo que aporta diversidad criptográfica. Se considera muy seguro y es una alternativa moderna cuando queremos evitar depender únicamente de SHA-2.

BLAKE2 y derivados como BLAKE3 son algoritmos más recientes que destacan por combinar alta seguridad y gran rendimiento. BLAKE2b está optimizado para sistemas de 64 bits y BLAKE2s para arquitecturas de 8 a 32 bits. Son más rápidos que SHA-3 y, en muchos escenarios, también que SHA-2, por lo que se usan en aplicaciones que necesitan procesar grandes volúmenes de datos a toda velocidad, incluida parte del ecosistema de criptomonedas.

Cómo se puede romper un hash: colisiones y otros ataques

A nivel teórico, las funciones hash están diseñadas para que sea prácticamente imposible encontrar dos entradas distintas con el mismo resultado (colisión) o recuperar el dato original a partir del hash. En la práctica, hay varios tipos de ataques contra hashes que conviene conocer, sobre todo en el contexto de contraseñas.

El ataque de fuerza bruta consiste en generar hashes de todas las combinaciones posibles hasta dar con la que coincide con el valor que buscamos. Es muy lento si el algoritmo es robusto y la entrada es suficientemente larga y compleja, pero contra contraseñas cortas o algoritmos antiguos sigue siendo viable, sobre todo con hardware especializado (GPUs, ASIC…).

Los ataques de diccionario aprovechan listas de palabras comunes (diccionarios, contraseñas filtradas, patrones habituales) y generan sus hashes para compararlos con los robados de una base de datos. Es mucho más eficiente que probar todo el espacio posible, y por eso es tan peligroso usar claves simples, frases típicas o patrones previsibles.

Un ataque de colisión busca directamente dos entradas distintas que produzcan el mismo hash. Esto es lo que ha arruinado la reputación de MD5 y SHA-1: si se pueden fabricar archivos manipulados que mantienen el mismo hash que el original, ya no podemos confiar en esos algoritmos para garantizar integridad. En funciones modernas, encontrar colisiones de forma práctica sigue siendo inviable.

Las famosas tablas arco iris son otro enfoque: se precalculan y almacenan hashes de una cantidad masiva de posibles entradas (por ejemplo, todas las contraseñas de hasta cierto tamaño) y luego se buscan coincidencias. Ocupan mucho espacio y son costosas de generar, pero permiten acelerar brutalmente el crackeo si el sistema no aplica medidas adicionales.

Para defendernos, en el contexto de contraseñas se usan técnicas como añadir un salt (un valor aleatorio que se concatena antes de hashear) y utilizar algoritmos específicos para almacenamiento de claves (bcrypt, scrypt, Argon2…) que son deliberadamente lentos y consumen memoria, complicando mucho los ataques masivos. Si quieres profundizar en esto, consulta qué es el salt en el hash.

Generar y comprobar hashes en Linux

En Linux tenemos de serie prácticamente todo lo necesario para trabajar con hashes desde la terminal. Las utilidades de coreutils cubren MD5, SHA-1, SHA-2 y BLAKE2, y podemos añadir soporte para SHA-3 con un paquete extra en distribuciones basadas en Debian.

Para disponer de las herramientas básicas (md5sum, sha1sum, sha256sum, b2sum…), basta con tener instalado el paquete coreutils, que viene por defecto en cualquier distro medianamente moderna. Si queremos comandos específicos para SHA-3, en Debian, Ubuntu y derivadas podemos instalar libdigest-sha3-perl con:

sudo apt install coreutils
sudo apt install libdigest-sha3-perl

Supongamos que tenemos un archivo llamado geekland.txt. Para calcular su hash MD5 usaríamos:

md5sum geekland.txt

La salida mostrará algo como d41d8cd98f00b204e9800998ecf8427e geekland.txt. Si enviamos ese fichero a otra persona junto con el hash, podrá verificar la integridad con:

echo "d41d8cd98f00b204e9800998ecf8427e geekland.txt" | md5sum --check

Si la herramienta responde con “La suma coincide”, significa que el archivo que tiene es idéntico al nuestro. El mismo patrón se aplica al resto de familia shasum:

• shasum -a 1 geekland.txt para SHA-1.
• shasum -a 256 geekland.txt para SHA-256.
• shasum -a 512224 geekland.txt para SHA-512/224.

En todos los casos, para comprobar la integridad se usa el modo –check combinando el hash esperado y el nombre del archivo:

echo "e3b0c4...7852b855 geekland.txt" | shasum -a 256 --check

Para SHA-3, con el paquete comentado, disponemos del comando sha3sum. Por ejemplo, para calcular un SHA3-512 sobre nuestro archivo:

sha3sum -a 512 geekland.txt

Si queremos usar BLAKE2, basta con tirar de b2sum:

b2sum geekland.txt

La verificación, igual que antes, se hace con --check y un echo que combine el hash y el nombre del fichero.

Verificar el hash de una ISO en Linux y macOS

Cuando descargamos, por ejemplo, la imagen ubuntu-22.04.3-desktop-amd64.iso desde la web oficial, el proyecto suele publicar a su lado el hash SHA-256 correspondiente. Imaginemos que el valor anunciado es:

a435f6f393dda581172490eda9f683c32e495158a780b5a1de422ee77d98e909

En Linux podemos verificarlo con:

echo "a435f6f393dda581172490eda9f683c32e495158a780b5a1de422ee77d98e909 ubuntu-22.04.3-desktop-amd64.iso" | shasum -a 256 --check

Si la salida es “OK”, sabemos que la imagen descargada coincide con la oficial y podemos instalar tranquilos. Este mismo comando funcionará exactamente igual en macOS, ya que shasum también está disponible de serie.

Alternativamente, en macOS podemos tirar de:

• shasum -a 256 nombre_del_archivo para SHA-256.
• md5 nombre_del_archivo para MD5.

Otra opción avanzada multiplataforma es usar OpenSSL desde la terminal, por ejemplo:

openssl sha256 nombre_del_archivo

Herramientas con interfaz gráfica para hashes en Linux, Windows y macOS

No todo el mundo quiere pelearse con la consola, y para eso existen multitud de utilidades gráficas que facilitan enormemente el cálculo y la verificación de hashes, muchas de ellas gratuitas y multiplataforma.

Una de las más conocidas es QuickHash GUI, una aplicación open source disponible para Windows, Linux y macOS. Desde una ventana con varias pestañas podemos calcular hashes de texto, archivos sueltos, directorios completos, discos físicos e incluso datos codificados en Base64. Soporta algoritmos como MD5, SHA-1, SHA-2 (SHA-256, SHA-512), SHA-3 (256 bits), BLAKE2B (256 bits), xxHash y BLAKE3.

La pestaña Text permite introducir un fragmento y obtener su hash al vuelo con el algoritmo elegido. En File seleccionamos un fichero individual para calcular sus hashes. FileS procesa todos los archivos de una carpeta (incluyendo subdirectorios y opcionalmente carpetas ocultas) y muestra una lista con los valores generados.

Con Compare Two Files podemos comparar dos archivos ubicados en rutas diferentes: si los hashes coinciden, mostrará “MATCH!”; si no, “MIS-MATCH”. De forma similar, Compare Two Folders compara el contenido de dos directorios basándose en los hashes de sus archivos, no en el nombre de los mismos.

La pestaña Copy es especialmente interesante: permite copiar archivos de una ubicación a otra y, al mismo tiempo, verificar con hashes que la copia se ha realizado correctamente. Es muy útil cuando clonamos estructuras grandes y queremos estar seguros de que nada se ha estropeado en el camino.

En el mundo Linux, además, encontramos herramientas como GTKHash, pensadas como alternativa gráfica a md5sum y compañía. GTKHash calcula hashes MD5, SHA-1, SHA-2, SHA-3, BLAKE2, etc., y se integra con gestores de archivos como Caja, Nemo o Thunar mediante extensiones (caja-gtkhash, nemo-gtkhash, thunar-gtkhash), lo que permite hacer clic derecho sobre un archivo y obtener sus hashes sin salir del explorador.

Herramientas para verificar hashes en Windows (PowerShell, CertUtil y programas externos)

En Windows disponemos de dos utilidades de línea de comandos preinstaladas que cubren de sobra las necesidades básicas: Get-FileHash (en PowerShell) y CertUtil (en cmd o PowerShell). Puedes ver cómo comprobar sumas de verificación en Windows 11.

Desde PowerShell, Get-FileHash calcula rápidamente el hash de cualquier archivo. Por defecto usa SHA-256, pero podemos indicarle otros algoritmos soportados (MD5, SHA-1, SHA-384, SHA-512, etc.) mediante el parámetro -Algorithm. Por ejemplo, para obtener el SHA512 de setup.exe:

Get-FileHash -Algorithm SHA512 .\setup.exe

Si preferimos usar CertUtil, cuya sintaxis es algo más antigua pero igual de eficaz, la forma general es:

certutil -hashfile Ruta\al\Archivo.ext SHA256

Podemos sustituir SHA256 por MD5, SHA1, SHA512 o variantes según lo que necesitemos. Esta herramienta es muy útil para integrarla en scripts de PowerShell de automatización sin depender de software de terceros. También existe verificar integridad de archivos con Sigcheck como alternativa avanzada.

Si queremos ir un paso más allá y olvidarnos de la terminal, hay soluciones como OpenHashTab, que añade una pestaña “Hashes” en la ventana de propiedades de los archivos del Explorador. Desde ahí podemos ver de un vistazo los valores MD5, SHA-1, SHA-256, SHA-512 (y otros algoritmos configurables), pegar un hash proporcionado por el proveedor en el campo “Check against” y dejar que el programa nos diga si coincide, o exportar los resultados a un archivo de texto o al portapapeles.

Otra utilidad muy popular es Hasher Lite, que funciona mediante arrastrar y soltar: soltamos uno o varios archivos en su ventana y calcula su hash con hasta diez algoritmos diferentes. Permite copiar cada resultado al portapapeles, comparar directamente con el valor que ya tengamos copiado, procesar hasta 100 ficheros a la vez en su versión gratuita y exportar las listas a texto.

También tenemos programas como HashMyFiles, MultiHasher, MD5 & SHA Checksum Utility, DeadHash, HashCalc, MD5 Hash Check, Checksum Control, Hash Generator o la veterana herramienta de Microsoft FCIV (File Checksum Integrity Verifier), todos ellos centrados en calcular y comparar hashes de forma masiva, integrarse con el menú contextual y ofrecer soporte para una amplia variedad de algoritmos.

Calcular el hash de un disco o carpeta completa

Además de sacar la huella digital de archivos individuales, existen utilidades capaces de calcular hashes de directorios completos o incluso de discos enteros. Esto es muy útil cuando queremos verificar el contenido íntegro de una unidad externa, una imagen forense o una copia de seguridad.

Una herramienta clásica para este tipo de tareas es md5deep (y su sucesor hashdeep). Permite generar sumas MD5 (y de otros algoritmos) de todos los archivos contenidos en un directorio o unidad, de forma recursiva, y guardar los resultados en un fichero de texto. Por ejemplo:

md5deep -rel F:\ > F_resultado.md5

En este comando, -r indica recursividad, -e puede mostrar tiempo estimado, -l imprime rutas relativas, y F:\ sería la unidad o ruta base. El archivo F_resultado.md5 contendrá el listado de hashes de todo el contenido.

Más tarde, podemos usar md5deep para comparar un conjunto de archivos con una lista de hashes conocida y que nos señale solo los que no coinciden. Usando la opción -X podemos detectar entradas cuyo hash ha cambiado con respecto al listado original, algo muy útil para auditar cambios en copias de seguridad o detectar manipulación.

En entorno gráfico, utilidades como GizmoHasher o la propia QuickHash permiten seleccionar unidades, carpetas o colecciones de archivos y generar/guardar sus hashes con soporte para múltiples algoritmos (MD5, CRC32, SHA-1, SHA-2, etc.), compararlos con otras listas y localizar diferencias de forma visual.

Herramientas online para generar hashes: cuándo usarlas

Existen también servicios web que permiten subir un archivo o introducir un texto y obtener su hash sin instalar nada en el equipo. Páginas como File Checksum, HTML5 File Hash Online Calculator o Defuse Online Text & File Checksum Calculator ofrecen soporte para decenas de algoritmos (MD5, SHA-1, SHA-2, SHA-3, CRC32, etc.) y son cómodas para pruebas rápidas.

La gran pega es obvia: hay que subir el archivo a un servidor externo. Aunque algunos servicios prometen no almacenar los datos, la recomendación general es usarlos solo con ficheros que no sean sensibles (nada de bases de datos, documentos privados, backups de móviles…). Para todo lo que pueda contener información importante, mejor quedarse con las herramientas locales del propio sistema operativo.