Cómo verificar la integridad de una ISO en Windows usando checksums y firmas GPG

Mucha gente descarga imágenes ISO de sistemas operativos como Windows o software pesado, las graba a un USB y se pone a instalar sin pararse a pensar si ese archivo es realmente legítimo o si se ha corrompido por el camino. Hasta que un día aparece un error extraño… o peor, un malware escondido en una ISO tocada por manos ajenas.

Si te has fijado alguna vez en las páginas oficiales de descargas, verás que casi siempre aparecen datos como SHA256, MD5, SHA1 o incluso ficheros .sig junto a los enlaces de las imágenes ISO. Su función no es decorativa: están ahí para que verifiques la integridad y la autenticidad de lo que te bajas. El problema es que muchas veces, al pulsar en el icono de “Verificar” o en el enlace del checksum, se abre una página con un montón de texto y números y uno se queda pensando: “¿Y ahora qué hago yo con esto?”. Vamos a desliarlo con calma, sobre todo centrándonos en cómo hacerlo desde Windows.

¿Qué es un checksum y por qué te debería importar?

Cuando descargas una ISO, lo primero que necesitas comprobar es la integridad del archivo, es decir, que el fichero que ha llegado a tu disco duro es exactamente el mismo que el que el desarrollador puso en su servidor, byte por byte, sin corrupción durante la descarga ni modificaciones malintencionadas.

Para eso se usan las funciones hash criptográficas. Son algoritmos que, a partir de un fichero de cualquier tamaño, generan una cadena alfanumérica de longitud fija (por ejemplo, 64 caracteres hexadecimales en SHA-256). Entre los más habituales están:

• MD5 (obsoleto para seguridad, pero aún se ve en algunos sitios).
• SHA-1 (también considerado débil hoy en día).
• SHA-256, SHA-384, SHA-512 (familia SHA-2, la recomendada hoy día).
• Otros menos comunes en este contexto como RIPEMD160 o MACTripleDES.

La idea es sencilla: el desarrollador publica el hash de la ISO (por ejemplo el SHA-256 de la imagen oficial) en su página web o en un archivo de sumas, y tú, en tu máquina, calculas el hash del fichero que te has descargado. Si ambas cadenas coinciden, el archivo tiene la misma integridad que el original. Si no, algo va mal.

Dónde encontrar los checksums de una ISO

Dependiendo del proyecto, los desarrolladores publican los hash de sus imágenes ISO de formas ligeramente distintas, pero todas se basan en el mismo principio: tú calculas el hash localmente y lo comparas con el valor oficial.

Lo más típico es que junto al enlace de descarga de la ISO encuentres enlaces como “SHA256SUMS”, “sha256.txt”, “MD5SUMS”, “Checksums” o un icono de verificación. Cuando haces clic, suele pasar una de estas cosas:

• Se descarga un archivo de texto (por ejemplo, SHA256SUMS) que contiene múltiples líneas con hash y nombres de ISO.
• Se abre una página o pestaña del navegador mostrando una larga línea de caracteres alfanuméricos al lado del nombre del fichero ISO.
• En algunas distribuciones, como Fedora o Debian, verás además archivos de firma como SHA256SUMS.sign o .sig, que sirven para autenticar esos hashes con GPG.

En el caso concreto de algunas distribuciones como Fedora, la documentación dice cosas del tipo “descarga el archivo de checksum en la misma carpeta que la imagen ISO”. Eso significa que debes guardar el archivo SHA256SUMS (o similar) en el mismo directorio donde tienes la ISO, aunque al pulsar el enlace lo veas como una página web: simplemente haz clic derecho y “Guardar como…” o utiliza la opción de descarga del navegador.

Verificar una ISO en Windows con PowerShell (Get-FileHash)

Desde Windows 10 en adelante lo tienes bastante fácil: PowerShell incluye de serie el comando Get-FileHash, que calcula el hash de cualquier archivo sin instalar nada extra. Es la forma más directa de verificar tu ISO desde Windows.

Los pasos básicos serían:

1. Asegúrate de tener la ISO completada en tu disco (por ejemplo, C:\Descargas\linux.iso).
2. Abre PowerShell (puedes buscar “PowerShell” en el menú Inicio).
3. Ejecuta un comando como:
   Get-FileHash C:\Descargas\linux.iso

Por defecto, Get-FileHash usa SHA-256, que es lo que la mayoría de proyectos modernos publican como referencia. Verás una salida con tres columnas (Algorithm, Hash, Path) y una larga cadena de caracteres alfanuméricos en la columna Hash.

Si el proyecto ha publicado el hash en otro algoritmo, puedes indicarlo explícitamente con el parámetro -Algorithm:

• Get-FileHash C:\ruta\archivo.iso -Algorithm MD5
• Get-FileHash C:\ruta\archivo.iso -Algorithm SHA1
• Get-FileHash C:\ruta\archivo.iso -Algorithm SHA256
• Get-FileHash C:\ruta\archivo.iso -Algorithm SHA384
• Get-FileHash C:\ruta\archivo.iso -Algorithm SHA512
• Get-FileHash C:\ruta\archivo.iso -Algorithm RIPEMD160

El cálculo de hash puede tardar desde unos segundos hasta bastante más, según el tamaño de la ISO, la velocidad del disco y del procesador, pero es normal que una ISO grande haga trabajar al equipo un rato.

Una vez tengas tu valor, toca compararlo con el hash oficial publicado en la web. Si son idénticos (cada dígito, sin una sola diferencia), puedes asumir que la integridad es correcta y el archivo no se ha corrompido ni alterado. Si no coinciden, borra la ISO y vuelve a descargarla desde una fuente fiable.

Herramientas de terceros en Windows: 7-Zip y compañía

Si no te apetece usar PowerShell o trabajas en un sistema donde no puedes utilizarlo cómodamente, puedes tirar de herramientas de terceros como 7-Zip, que además de comprimir archivos sirve para calcular sumas hash de forma gráfica.

Tras instalar 7-Zip desde su web oficial, verás una opción nueva en el menú contextual de Windows. Para calcular el hash de una ISO:

• Haz clic derecho sobre el archivo ISO.
• En el menú, entra en 7-Zip → CRC SHA.
• Elige el algoritmo que te interese: CRC-32, CRC-64, SHA-1 o SHA-256.

La herramienta mostrará una ventana con el valor calculado. Después solo tienes que compararlo con el hash publicado en la página de descargas de la distribución o del fabricante. Siempre que puedas, elige SHA-256 frente a SHA-1, porque ofrece mucha más seguridad frente a colisiones y ataques.

Verificación en Linux: md5sum, sha1sum, sha256sum

Aunque aquí nos centramos en Windows, viene bien saber que en cualquier distro Linux moderna tienes de serie herramientas como md5sum, sha1sum o sha256sum, que funcionan de forma similar a Get-FileHash pero desde la terminal de Unix.

El uso es muy directo: ejecutas algo como sha256sum /ruta/al/archivo.iso, esperas a que calcule el valor, y comparas la cadena obtenida con el hash ofrecido por el desarrollador. También puedes usar la opción -c para que la utilidad lea un fichero de sumas (por ejemplo, SHA256SUMS) y compruebe automáticamente si las ISO presentes en el directorio coinciden.

De la integridad a la autenticidad: por qué los hashes no bastan

Hasta ahora solo hemos hablado de integridad, pero hay un problema importante: un atacante que comprometa el servidor de descargas podría reemplazar las ISO legítimas por versiones trojanizadas y, acto seguido, actualizar también los hashes publicados para que coincidan con sus ISOs maliciosas.

Es decir, si solo te fías del checksum, no tienes la garantía de quién ha generado esa ISO, solo estás comprobando que lo que tú tienes coincide con lo que hay en la web. Si la web está comprometida, el hash también.

Por eso se introducen las firmas digitales GPG (o PGP). Estas firmas se calculan no solo sobre las ISO, sino muy a menudo sobre los ficheros que contienen los hashes (por ejemplo, SHA256SUMS.sign firmando el archivo SHA256SUMS). De esta manera, puedes verificar no solo que el archivo no ha cambiado, sino que ha sido firmado con la clave privada de los desarrolladores que tú previamente has validado como de confianza.

Cómo funcionan las firmas GPG para imágenes ISO

GnuPG (GPG) implementa criptografía asimétrica basada en pares de claves: una clave privada que solo posee el desarrollador y una clave pública que cualquiera puede descargar. Cuando el desarrollador firma un archivo, en realidad lo que se cifra (o firma) es el hash del fichero, no el fichero entero, porque sería demasiado pesado.

Para distribuciones como Arch Linux, Debian o Fedora, te encontrarás a menudo pares de archivos del estilo:

• archlinux-xxxx.iso → la imagen.
• archlinux-xxxx.iso.sig → firma GPG de esa ISO.
• O bien SHA256SUMS y SHA256SUMS.sign, donde se firma el fichero que contiene varios hashes.

El procedimiento estándar sería:

1. Descargar la ISO y su archivo de firma (.sig o .sign).
2. Obtener la clave pública del proyecto desde una fuente fiable (servidor de claves oficial, página del desarrollador, keyring del proyecto, etc.).
3. Usar GPG para verificar que la firma realmente corresponde al archivo y que ha sido generada por esa clave.

Aunque el ejemplo práctico suele hacerse en Linux, los conceptos son exactamente los mismos si luego gestionas las ISO en Windows: primero compruebas la firma GPG del hash y después calculas el hash localmente con PowerShell o 7-Zip.

Ejemplo práctico de firmas GPG con una ISO

Imagina que descargas una imagen de Arch Linux junto con su firma:

• archlinux-2016.03.01-dual.iso
• archlinux-2016.03.01-dual.iso.sig

En un sistema con GnuPG instalado, podrías lanzar algo como:

gpg --verify archlinux-2016.03.01-dual.iso.sig archlinux-2016.03.01-dual.iso

Lo habitual la primera vez es que GPG responda algo parecido a “Imposible comprobar la firma: No public key”. Eso quiere decir que no tienes la clave pública del desarrollador en tu keyring local. El propio mensaje de GPG te dirá el ID de la clave (por ejemplo, 9741E8AC).

El siguiente paso es importar la clave pública desde un servidor de claves confiable, o desde la web oficial del proyecto, por ejemplo:

gpg --keyserver pgpkeys.mit.edu --recv-key 9741E8AC

Al hacerlo, GPG mostrará algo como “clave pública importada” con el nombre y correo de la persona o proyecto (por ejemplo, un desarrollador de Arch). Después, repites el comando de verificación:

gpg --verify archlinux-2016.03.01-dual.iso.sig archlinux-2016.03.01-dual.iso

Esta vez, deberías ver un mensaje de “Firma correcta” indicando que la firma coincide con la clave pública descargada. GPG avisará seguramente con un texto del estilo “esta clave no está certificada por una firma de confianza”, lo cual significa que tu anillo de confianza todavía no sabe si esa persona es quien dice ser. Es una advertencia de confianza, no un error de integridad.

Para estar totalmente seguro, podrías ir a la web oficial de la distribución y comprobar que el fingerprint de la clave pública que has importado coincide con el que el proyecto declara como oficial. Una vez verificado eso, ya sabes que las firmas GPG validan que la ISO viene realmente del desarrollador.

Checksums y firmas para ISOs de Microsoft en Windows

No solo las distribuciones Linux necesitan verificación: las imágenes ISO de Windows, SQL Server, Office y otros productos de Microsoft también deberían comprobarse, especialmente cuando se reutilizan viejas copias que pasan de mano en mano o se descargan desde repositorios no oficiales.

Microsoft ofrece descargas desde su Centro de descarga y portales de licencias por volumen. Para las versiones recientes (por ejemplo Windows 11), suele publicar tablas con hash oficiales por idioma y edición y recomienda validarlos tras la descarga. El problema es que muchas veces, en empresas y también en casa, la gente:

• No guarda los hashes originales cuando descarga una ISO.
• No siempre descarga desde el portal oficial, sino desde recursos compartidos o páginas de terceros.
• Reutiliza ISOs antiguas sin comprobar si han sido alteradas.

El riesgo es evidente: un tercero puede inyectar malware, cracks u otras sorpresas en una ISO modificada, que luego se instala con toda la tranquilidad del mundo en un servidor de producción o en el portátil personal.

Uso de PowerShell y bases de datos de hash para ISOs de Microsoft

La parte de cálculo del hash es idéntica a lo que ya hemos visto: usas Get-FileHash sobre la ISO de Windows o SQL Server y obtienes su SHA-256 (u otro algoritmo):

Get-FileHash -Path "H:\\ISO\\WINDOWS\\Windows\\win_10.iso" -Algorithm SHA256

Lo que cambia es cómo compruebas ese hash cuando ya no tienes a mano la tabla oficial de Microsoft. Aquí entran en juego proyectos como files.rg-adguard.net, que mantiene una base de datos enorme de hashes de ISOs oficiales de Microsoft (según su propia descripción, cientos de terabytes de datos).

El funcionamiento es sencillo: copias el hash calculado con PowerShell, vas a la pestaña “Search” del sitio y lo pegas en la barra de búsqueda. Si el hash corresponde a una ISO oficial, el sistema te devuelve el nombre y versión exactos de la imagen. Si no aparece nada, es muy probable que la fuente no sea legítima o que la ISO haya sido modificada.

Automatizar verificación en Windows con la herramienta Check-ISO

Cuando tienes que comprobar muchas imágenes, repetir el proceso de Get-FileHash + búsqueda web se vuelve pesado. Para eso se creó Check-ISO, una herramienta open source pensada precisamente para validar ISOs de productos Microsoft de forma más cómoda y automatizada.

Check-ISO está disponible en varios formatos: ejecutable (.exe), script de PowerShell (.ps1) y app en Microsoft Store. La idea es que sea accesible tanto para administradores de sistemas como para técnicos o responsables de seguridad que manejan ISOs a diario.

Su uso básico consiste en:

• Lanzar la herramienta desde Windows.
• Seleccionar el archivo ISO que quieres comprobar.
• Elegir el algoritmo de hash (normalmente SHA-256).
• Pulsar en “Check ISO” y esperar a que calcule el hash y lo compare con su base de datos de referencias.

Si la imagen es auténtica, el nombre aparecerá en verde, indicando que coincide con una ISO oficial de Microsoft. Si no se encuentra en la base de datos o hay discrepancias, se mostrará un mensaje en rojo avisando de que no ha sido posible verificarla.

En cuanto a la descarga, tienes dos vías principales:

• Microsoft Store: buscas “Check ISO” y la instalas. No requiere permisos de administrador, la fuente ha pasado por la revisión de Microsoft y se actualiza automáticamente.
• GitHub: desde el repositorio del proyecto puedes descargar el código fuente en .ps1 o una versión portátil en .exe firmada, y revisar el código si quieres auditar lo que hace.

Con algo tan sencillo como esto, se reduce muchísimo la tentación de usar ISOs de origen dudoso o “que tenía guardadas desde hace años por ahí”, sin saber realmente de dónde salieron.

Firmas GPG, hash y anillos de confianza

Detrás de esas firmas GPG que ves junto a muchas ISO hay todo un ecosistema de claves públicas, claves privadas y anillos de confianza. Aunque como usuario final no necesitas dominar cada detalle, entender lo básico ayuda a interpretar los avisos de GPG correctamente.

En tu sistema, GPG mantiene un keyring con las claves públicas de los desarrolladores y entidades en las que confías (o al menos, que has importado). Puedes listar tus claves con comandos como gpg --list-keys. Cada clave tiene un identificador, unas fechas de validez y uno o varios uid con nombres y correos asociados.

El modelo de GPG se basa en que no hay una única autoridad central, sino una red de firmas: si tú confías en alguien, puedes firmar su clave; si esa persona, a su vez, ha firmado otras claves, puedes confiar en ellas indirectamente, dependiendo del nivel de “confianza” (ownertrust) que le hayas asignado.

Esto se traduce en que una misma clave puede aparecer con distinta “validez” en distintos sistemas. Por ejemplo, una clave puede figurar como:

• Absoluta: típicamente tus propias claves.
• Total: alguien en quien confías tanto como para dar por válidas las claves que esa persona firma.
• Marginal: confías un poco; si varias personas marginalmente confiables firman la misma clave, GPG puede marcarla como válida.
• Desconocida o no definida: GPG no sabe si fiarse o no; aún así, puede verificar firmas, pero te mostrará avisos.

Este sistema de confianza no cambia el hecho de que la firma sea correcta o incorrecta; lo que modifica es el nivel de aviso o comodidad con el que GPG te presenta el resultado. Para un distribuidor de sistemas o un profesor que quiera crear un anillo de confianza entre alumnos, este modelo permite construir redes donde una firma de una tercera persona se considera válida porque la firmó alguien en quien tú confías totalmente.

ISO, hashes y firmas: un ejemplo completo con Debian

Un ejemplo muy didáctico de todo este proceso combinado (checksums + firma GPG) lo ofrece Debian con sus imágenes de instalación. En su servidor de imágenes encontrarás, para cada arquitectura, varios ficheros:

• debian-xx.iso → la imagen.
• SHA256SUMS → lista de hashes SHA-256 de todas las ISOs.
• SHA256SUMS.sign → firma GPG del fichero SHA256SUMS.
• SHA512SUMS y SHA512SUMS.sign con el mismo concepto pero usando SHA-512.

La lógica que sigue Debian es muy limpia: en vez de firmar cada ISO, firma el fichero que contiene los hash de todas ellas. Esto reduce trabajo y mantiene la seguridad, siempre que valides correctamente esa firma.

El flujo sería:

1. Descargar la ISO que quieras, más SHA256SUMS y SHA256SUMS.sign (y/o los de SHA512).
2. Importar la clave pública de Debian para firmar CDs desde su keyring oficial (por ejemplo, usando gpg --keyserver keyring.debian.org --recv-keys 6294BE9B).
3. Verificar la firma con GPG:
   gpg --verify SHA256SUMS.sign SHA256SUMS
4. Si la firma es correcta, calcular el hash de tu ISO (por ejemplo con sha256sum en Linux o Get-FileHash -Algorithm SHA256 en Windows) y compararlo con la línea correspondiente en el fichero SHA256SUMS.

Si todo cuadra, tienes garantizado que ni el fichero de hashes ni la ISO han sido modificados desde que Debian generó y firmó esos datos. El aviso de que la clave “no está certificada por una firma de confianza” solo te recuerda que tu keyring aún no tiene una cadena de confianza configurada hacia esa clave, pero no invalida la corrección matemática de la firma.

Integridad y autenticidad en la instalación de paquetes (APT Secure)

La filosofía detrás de las verificaciones de ISO es la misma que usa Debian (y otras distros) para proteger la instalación de paquetes con APT Secure. En vez de ISO, aquí hablamos de repositorios, ficheros de índices y paquetes .deb.

APT se apoya en GPG para garantizar que los metadatos de los repositorios (como el fichero Release o InRelease) están firmados por claves de confianza almacenadas en /etc/apt/trusted.gpg y en ficheros .gpg dentro de /etc/apt/trusted.gpg.d/. La herramienta clásica para gestionar esas claves es apt-key, que permite listarlas, añadir nuevas o eliminar las que ya no se usen.

Un fichero Release contiene, entre otras cosas, los hashes de los archivos Packages (y sus variantes comprimidas) de cada sección y arquitectura del repositorio, con MD5, SHA1 y SHA256. Cuando haces un apt update, tu sistema descarga Release (o InRelease, que combina Release y su firma en un solo archivo) y comprueba que su firma GPG es válida con alguna de las claves de confianza. Después, verifica que los ficheros Packages descargados coinciden con los hashes listados en Release y, a su vez, que cada paquete .deb coincide con el hash interno declarado en Packages.

Este sistema en cascada consigue que, aunque alguien intentara meter mano a un paquete concreto, tendría que falsificar toda la cadena de firmas y hashes asociada, algo muy difícil si no controla las claves privadas del archivo. Lo que haces manualmente para verificar una ISO con SHA256SUMS y SHA256SUMS.sign, APT lo hace automáticamente cada vez que actualizas o instalas.

Un ejemplo práctico de esto en el mundo real es la adición del repositorio de VirtualBox en Debian. Para que APT acepte sin protestar los paquetes de ese repositorio, no basta con añadir la línea “deb https://ift.tt/2ZsQDHd buster contrib” al sources.list; también tienes que importar las claves públicas de Oracle para que APT pueda validar las firmas de Release/InRelease de ese repositorio. Solo entonces podrás hacer un apt update y apt install virtualbox-6.1 con las garantías criptográficas en regla.

Criptografía simétrica y asimétrica en otros contextos: ejemplo SSH

La combinación de cifrado simétrico y asimétrico que hemos visto con GPG y APT tiene su paralelismo en otros protocolos muy usados, como SSH. Aunque no está directamente ligado a la verificación de ISO, ilustra muy bien por qué ambos tipos de criptografía se combinan.

En SSH, al establecer una conexión, servidor y cliente negocian algoritmos compatibles y usan criptografía asimétrica (por ejemplo, Diffie-Hellman y claves de host) para acordar una clave simétrica compartida. Esa clave se utilizará después para cifrar todo el tráfico de la sesión, porque el cifrado simétrico es mucho más eficiente para grandes volúmenes de datos.

La autenticación de usuario puede hacerse por contraseña (que viaja dentro del túnel cifrado) o mediante par de claves pública/privada, donde el servidor desafía al cliente cifrando un mensaje con la clave pública del usuario y este lo descifra con su clave privada. En el lado del cliente, el fichero ~/.ssh/known_hosts guarda las claves de los servidores a los que ya se ha conectado, para poder detectar si un host key cambia de forma sospechosa (posible ataque man-in-the-middle).

La idea de fondo es la misma que con las ISOs: primero estableces un canal seguro, luego te aseguras de quién está al otro lado y, por último, confías en que lo que recibes no ha sido manipulado en tránsito.

Visto todo el panorama, se entiende mejor por qué cada ISO importante que descargues debería pasar siempre por dos filtros: verificación de hash para comprobar integridad y, cuando el proyecto lo ofrezca, verificación de firma GPG para asegurar autenticidad. Aunque al principio parezca un pequeño engorro, una vez que te acostumbras a usar PowerShell, 7-Zip o herramientas como Check-ISO, y sabes interpretar los mensajes de GPG, se convierte en un paso rápido que te ahorra muchos problemas y te permite dormir bastante más tranquilo cuando reinstalas o despliegas sistemas. Comparte la información para que más personas conozcan del tema.

from Actualidad Gadget https://ift.tt/HcJsRIO
via IFTTT