sha256sum: Verifica la Integridad de tus Archivos

¿Alguna vez has descargado un archivo, un archivo ZIP o una copia de seguridad sin saber realmente si estaba intacto?

El comando sha256sum permite verificar la integridad de archivos en unos pocos segundos gracias a una huella digital llamada hash SHA-256. Simple, rápido y extremadamente útil, es una herramienta imprescindible en Linux.

• Evita utilizar un archivo corrupto o modificado aprendiendo a verificar fácilmente su integridad con sha256sum.
• Comprende por fin para qué sirven los hashes SHA-256 y por qué se han vuelto indispensables en Linux y en ciberseguridad.
• Automatiza tus verificaciones de archivos con comandos y scripts Bash simples, incluso sin ser experto de la terminal.

En este tutorial completo sobre sha256sum, aprenderás a generar y verificar checksums, comprender para qué sirven los hashes SHA-256, detectar errores frecuentes e incluso automatizar controles de integridad con Bash. No es necesario ser un experto en seguridad o en la terminal: todo se explicará paso a paso con ejemplos simples y concretos.

👉 Para los que empiezan: Introducción a la criptografía

Comprender para qué sirve el comando sha256sum

Cuando descargas un archivo de Internet, por ejemplo, una imagen ISO de Linux, un archivo .zip, un script o una copia de seguridad, surge una pregunta simple: ¿estás seguro de que este archivo es el que crees haber descargado? Puede estar incompleto, haberse corrompido durante la descarga, modificado por error o, en el peor de los casos, reemplazado por un archivo malicioso.

Aquí es donde interviene el comando sha256sum.

sha256sum permite calcular una especie de huella digital de un archivo. Esta huella es única, o casi, para un contenido dado. Si modificas aunque sea un solo carácter en un archivo de texto, el resultado cambia por completo. Un poco como si tu archivo tuviera un documento de identidad muy estricto: al menor cambio, ya no es válido.

👉 Wget: descargar desde la terminal de forma sencilla.

¿Qué es un hash SHA-256?

Un hash es una cadena de caracteres generada a partir del contenido de un archivo o de un texto. Con SHA-256, el resultado se ve así: b94d27b9934d3e08a52e52d7da7dabfade0f3f78c2d48923a9869d5e7f3d6c0f. Esta larga secuencia de letras y números es muy útil.

SHA-256 significa Algoritmo de Hash Seguro de 256 bits (Secure Hash Algorithm 256 bits). En pocas palabras, es un método que toma un contenido de entrada y produce una huella de longitud fija. No importa si tu archivo tiene 2 líneas o 4 GB, el hash SHA-256 siempre tendrá la misma forma.

Este hash no sirve para recuperar el archivo original. No es cifrado. Sirve principalmente para verificar que el archivo no ha cambiado.

¿Por qué verificar la integridad de un archivo?

Imagina que descargas una distribución de Linux para instalarla en tu computadora. El archivo pesa varios gigabytes. Todo parece normal, pero se ha colado un pequeño error durante la descarga. Resultado: la instalación puede fallar o, peor aún, funcionar de forma extraña.

Y como siempre en informática, “extrañamente” a menudo significa “vas a perder una tarde entera”. Con sha256sum, puedes comparar la huella de tu archivo con la proporcionada por el sitio web oficial. Si los dos valores son idénticos, tu archivo está intacto. Si son diferentes, debes evitar utilizarlo.

Diferencia entre checksum, hash y huella digital

En algunos tutoriales, te cruzarás a menudo con varias palabras: checksum, hash, suma de comprobación, huella digital. En el contexto de sha256sum, puedes entenderlas así:

• El hash es el resultado calculado a partir del archivo.
• La checksum, o suma de comprobación, es un valor utilizado para verificar la integridad de un archivo.
• La huella digital es una imagen simple para decir: “aquí está la identidad técnica del archivo”.

En la práctica, para empezar, recuerda sobre todo esto: con sha256sum, generas o verificas una huella para saber si un archivo está conforme.

¿Por qué utilizar SHA-256 en lugar de MD5 o SHA1?

Tal vez ya hayas visto comandos como md5sum o sha1sum: funcionan con el mismo principio, pero MD5 y SHA1 se consideran hoy demasiado débiles para usos de seguridad. La regla práctica es simple: si tiene la opción, utilice sha256sum (más abajo verá la comparación en detalle).

👉 Para ir más allá, descubre cómo funcionan los hashes en criptografía.

Instalar y utilizar sha256sum por primera vez

En la mayoría de distribuciones GNU/Linux, sha256sum ya está disponible por defecto como parte de las herramientas GNU Coreutils, presentes en Debian, Ubuntu, Fedora, Arch, Linux Mint y muchos otros sistemas. Para verificar si el comando existe, abre una terminal y escribe:

sha256sum --version

Si todo va bien, verás una respuesta indicando la versión instalada. En macOS el equivalente habitual no es sha256sum, sino shasum indicando el algoritmo SHA-256 de forma explícita:

shasum -a 256 archivo.txt

Si instalas GNU Coreutils en macOS, el binario puede quedar disponible como sha256sum o con prefijo GNU, según el método de instalación. En esta guía nos centraremos en sha256sum para sistemas GNU/Linux, indicando los equivalentes cuando el comportamiento cambie por plataforma.

sha256sum en Windows: el equivalente nativo

Windows no incluye el comando sha256sum, pero ofrece dos formas nativas de calcular el mismo hash SHA-256, sin instalar nada.

Desde PowerShell, usa Get-FileHash:

Get-FileHash archivo.iso -Algorithm SHA256

Devuelve el algoritmo, el hash y la ruta del archivo. El hash aparece en mayúsculas, pero la comparación con el valor oficial es indiferente a mayúsculas y minúsculas: lo que importa es que la secuencia coincida.

Desde el Símbolo del sistema (CMD), usa certutil:

certutil -hashfile archivo.iso SHA256

Ambos cumplen la misma función que sha256sum en Linux: generar la huella para compararla manualmente contra la publicada en la fuente oficial. Si tu caso concreto es validar una imagen de instalación en Windows, lo detallamos paso a paso en verificar la autenticidad de una imagen ISO de Microsoft.

Generar un hash SHA-256 de forma sencilla

Comencemos con un ejemplo muy simple. Crea un pequeño archivo de texto:

echo "Hola EsGeeks" > ejemplo.txt

Este comando crea un archivo llamado ejemplo.txt que contiene una frase. Ahora, calculemos su hash SHA-256:

sha256sum ejemplo.txt

Obtendrás un resultado similar a este:

07273b0f355cb72fbf97528d0148910d1f32059708c119d0b8ed8b6d6fa9b0c9  ejemplo.txt

La primera parte es el hash. La segunda parte es el nombre del archivo. Por lo tanto, el comando te dice: “aquí está la huella SHA-256 del archivo ejemplo.txt“.

Comprender el resultado mostrado

El hash se calcula únicamente a partir del contenido del archivo, no de su nombre. Por eso el resultado muestra dos elementos —el hash y el nombre—: el nombre solo está ahí para indicar a qué valor corresponde cada huella.

Esto tiene una consecuencia práctica: si renombras un archivo sin tocar su contenido, su hash SHA-256 no cambia. Y al revés, si modificas el contenido, el hash cambia aunque el archivo conserve el mismo nombre.

Generar el hash de varios archivos

También puedes calcular la huella de varios archivos en un solo comando. Imaginemos tres archivos:

echo "Archivo 1" > archivo1.txt
echo "Archivo 2" > archivo2.txt
echo "Archivo 3" > archivo3.txt

Luego puedes ejecutar:

sha256sum archivo1.txt archivo2.txt archivo3.txt

La terminal mostrará una línea por archivo. Es práctico cuando preparas un archivo comprimido, una copia de seguridad o una carpeta para enviar a alguien.

Guardar un checksum en un archivo de texto

En lugar de mostrar simplemente el hash en la terminal, puedes guardarlo en un archivo:

sha256sum ejemplo.txt > ejemplo.sha256

Aquí, el símbolo > significa: “envía el resultado a un archivo”.

El archivo ejemplo.sha256 contendrá algo como:

07273b0f355cb72fbf97528d0148910d1f32059708c119d0b8ed8b6d6fa9b0c9  ejemplo.txt

Este archivo podrá ser utilizado luego para verificar automáticamente la integridad de ejemplo.txt.

Verificar la integridad de un archivo con sha256sum

Ahora que sabemos generar un hash, veamos cómo verificar un archivo automáticamente. Supongamos que tienes un archivo ejemplo.txt y su archivo de control ejemplo.sha256. Puedes ejecutar:

sha256sum -c ejemplo.sha256

La opción -c significa check, es decir, “verificar”. Si el archivo no ha cambiado, verás:

ejemplo.txt: OK

Si el archivo ha sido modificado, verás en cambio:

ejemplo.txt: FAILED
sha256sum: WARNING: 1 computed checksum did NOT match

En ese caso, la terminal te advierte que el contenido actual del archivo ya no coincide con el hash guardado.

Comparar dos hashes con sha256sum

A veces, los sitios web solo te dan un hash para copiar, sin un archivo .sha256. En este caso, puedes calcular tú mismo el hash del archivo descargado:

sha256sum mi-archivo.iso

Luego comparas el resultado con el indicado en el sitio oficial. Es necesario que las dos cadenas sean estrictamente idénticas. Incluso una sola letra diferente es suficiente para invalidar la verificación.

Pequeño consejo: no compares solo el principio y el final. Es tentador, pero no es una verdadera verificación. Copia los dos valores en un editor de texto si es necesario, o utiliza una herramienta de comparación.

Existen también calculadoras de SHA-256 en línea, pero desde EsGeeks desaconsejamos usarlas con archivos sensibles o confidenciales: subir el contenido a un servicio de terceros expone el archivo innecesariamente. El comando local trabaja sin conexión y no envía nada a ningún lado, así que para cualquier material privado es siempre la opción correcta.

Verificar una imagen ISO de Linux o macOS antes de la instalación

Este es probablemente uno de los casos más comunes. Por ejemplo, descargas la imagen ubuntu-26.04-desktop-amd64.iso desde la página oficial de Ubuntu, en releases.ubuntu.com/26.04/. Ahí mismo, junto a la ISO, el sitio publica un archivo de checksum llamado SHA256SUMS (acompañado de su firma SHA256SUMS.gpg).

El flujo correcto en un entorno de seguridad separa dos pasos: primero autenticar el archivo de checksums (¿lo firmó realmente Ubuntu?) y después comprobar la integridad de la ISO contra ese checksum. Coloca la ISO, el SHA256SUMS y el SHA256SUMS.gpg en la misma carpeta.

Primero, autentica el archivo de checksums con su firma GPG. Si es la primera vez, necesitas importar la clave de firma de Ubuntu desde el keyserver oficial (solo se hace una vez):

gpg --keyid-format long --keyserver hkp://keyserver.ubuntu.com --recv-keys 0x843938DF228D22F7B3742BC0D94AA3F0EFE21092

Sin este paso, gpg --verify fallaría con Can't check signature: No public key. Con la clave importada, verifica la firma:

gpg --keyid-format long --verify SHA256SUMS.gpg SHA256SUMS

Una respuesta Good signature from "Ubuntu CD Image Automatic Signing Key" confirma que el SHA256SUMS es auténtico. Verás también un aviso de que la clave no está certificada con una firma de confianza: es normal y solo indica que no has firmado personalmente esa clave.

Este es exactamente el flujo que documenta el propio equipo de seguridad de Ubuntu para la verificación oficial de integridad de imágenes de Ubuntu.

Una vez autenticado el checksum, comprueba la integridad de la ISO:

sha256sum -c SHA256SUMS

Si el archivo SHA256SUMS contiene varias imágenes ISO, es posible que veas varias líneas. Si solo has descargado una imagen, algunas líneas pueden indicar que hay archivos que no se encuentran. Esto no es necesariamente grave: simplemente significa que no tienes todos los archivos listados. Para comprobar solo los archivos que sí tienes, sin esos avisos, usa --ignore-missing:

sha256sum -c --ignore-missing SHA256SUMS

También puedes crear un archivo .sha256 dedicado que contenga solo la línea que corresponde a tu ISO.

Ten en cuenta que cada versión de Ubuntu tiene su propio hash: descarga siempre el SHA256SUMS correspondiente a la misma versión exacta de tu imagen, o la verificación fallará aunque el archivo esté intacto.

Utilizar sha256sum en situaciones concretas

sha256sum no está reservado a los administradores de sistemas que gestionan servidores. Puedes utilizarlo en casos muy cotidianos. Por ejemplo, antes de enviar un archivo comprimido importante:

sha256sum proyecto-cliente.zip > proyecto-cliente.zip.sha256

Luego envías los dos archivos: el archivo comprimido y su checksum. La persona que recibe el archivo puede verificar que el archivo comprimido no se ha dañado durante la transferencia.

Otro ejemplo: controlar una copia de seguridad.

sha256sum respaldo.tar.gz > respaldo.tar.gz.sha256

Más adelante, podrás verificar que la copia de seguridad sigue intacta:

sha256sum -c respaldo.tar.gz.sha256

Es un pequeño hábito que puede evitar grandes sudores fríos.

Las opciones útiles del comando sha256sum

El comando sha256sum es bastante simple. Para empezar, unas pocas opciones son más que suficientes.

La opción -c

Es la opción más importante para la verificación:

sha256sum -c archivo.sha256

Lee el hash guardado en el archivo .sha256, recalcula la huella del archivo en cuestión y luego compara los dos valores.

La opción –ignore-missing

Esta opción solo se usa en la verificación. Permite ignorar los archivos que aparecen listados en el archivo de checksums pero que no existen en el directorio actual:

sha256sum -c --ignore-missing SHA256SUMS

Es especialmente útil cuando un archivo como SHA256SUMS contiene checksums de varias descargas, pero solo has bajado una parte de ellas.

La opción –quiet

Si verificas muchos archivos, la visualización puede ser larga. La opción --quiet permite no mostrar los archivos que son correctos.

sha256sum -c checksums.sha256 --quiet

Solo verás los posibles problemas.

La opción –status

Esta opción no muestra nada en la terminal. Es especialmente útil en los scripts.

sha256sum -c checksums.sha256 --status

Si la verificación tiene éxito, el comando devuelve un código de éxito. Si falla, devuelve un código de error. Para un humano, no es muy explícito. Para un script Bash, es perfecto. Ejemplo:

if sha256sum -c checksums.sha256 --status; then
  echo "Todos los archivos son válidos."
else
  echo "Atención: al menos un archivo ha sido modificado."
fi

Aquí, el script prueba directamente el resultado del comando.

La opción –strict

--strict hace que la verificación termine con un estado distinto de cero si encuentra líneas de checksums con formato incorrecto:

sha256sum -c checksums.sha256 --strict

Es útil cuando el archivo de checksums se genera, distribuye o procesa de forma automatizada y se quiere detectar no solo discrepancias de hash, sino también errores de formato en el propio archivo.

Diferencias entre SHA256, MD5 y SHA1

Históricamente, MD5 y SHA-1 se han utilizado mucho para generar huellas de archivos, pero ambos dejaron de ser adecuados cuando existe un adversario capaz de preparar entradas maliciosas.

El problema no es detectar una corrupción accidental, sino resistir un ataque de colisión o una manipulación deliberada —algo que con SHA-1 dejó de ser teórico desde la primera colisión práctica demostrada contra SHA-1.

Esto no significa que cada comparación histórica con MD5 o SHA-1 sea inútil, pero sí que no deben elegirse para verificar nada donde la seguridad importe de verdad. En pocas palabras:

• MD5 es rápido y compatible con casi cualquier sistema, pero está obsoleto para seguridad por su debilidad frente a colisiones.
• SHA-1 ofrece más bits de salida que MD5, pero tampoco debe considerarse seguro frente a manipulación maliciosa; su uso criptográfico está cada vez más desaconsejado y NIST recomienda migrar hacia SHA-2 o SHA-3.
• SHA-256 pertenece a la familia SHA-2 y sigue siendo una opción común y apropiada para verificar integridad en flujos actuales, siempre que el checksum provenga de una fuente confiable o esté autenticado mediante firma.

En la práctica: usa sha256sum, o un algoritmo más fuerte disponible en tu entorno, cuando el propósito sea seguridad, distribución de software, verificación de imágenes ISO, copias de seguridad críticas o automatización de integridad.

Automatizar la verificación de archivos con sha256sum

Cuando hayas comprendido el principio, puedes ir más allá y automatizar tus controles. Imaginemos una carpeta documentos que contiene varios archivos importantes. Para generar los hashes de todos los archivos .txt, puedes hacer:

sha256sum documentos/*.txt > checksums.sha256

Este comando calcula el hash de todos los archivos de texto presentes en la carpeta documentos y luego guarda el resultado en checksums.sha256. Más adelante, para verificar estos archivos:

sha256sum -c checksums.sha256

Si todo es correcto, cada archivo mostrará OK. También puedes verificar todos los archivos de un directorio de manera más amplia con find:

find documentos -type f -exec sha256sum {} \; > checksums.sha256

Este comando merece una pequeña explicación.

• find documentos busca en la carpeta documentos.
• -type f indica que solo queremos los archivos.
• -exec sha256sum {} \; ejecuta sha256sum en cada archivo encontrado.

El resultado se guarda en checksums.sha256. Es un poco más avanzado, pero muy práctico.

Crear un script Bash de verificación automática

Aquí tienes un pequeño script simple para verificar archivos a partir de un archivo de checksums. Crea un archivo llamado verificar.sh:

#!/bin/bash
# Nombre del archivo que contiene los checksums
FICHIER_CHECKSUMS="checksums.sha256"

# Verificamos si el archivo existe
if [ ! -f "$FICHIER_CHECKSUMS" ]; then
  echo "Error: no se encuentra el archivo $FICHIER_CHECKSUMS."
  exit 1
fi

# Iniciamos la verificación
echo "Verificación de los archivos en curso..."
if sha256sum -c "$FICHIER_CHECKSUMS"; then
  echo "Buenas noticias: todos los archivos están intactos."
else
  echo "Atención: algunos archivos han sido modificados o faltan."
fi

Haz el script ejecutable:

chmod +x verificar.sh

Y luego ejecútalo:

./verificar.sh

Este script se mantiene simple a propósito. El objetivo es comprender la lógica: se verifica la presencia del archivo de checksums y luego se ejecuta sha256sum -c.

Los errores frecuentes con sha256sum

El hash no coincide

Si el hash no coincide, no entres en pánico de inmediato. Hay varias razones posibles. El archivo puede haber sido modificado. La descarga puede estar incompleta. Puede que estés comparando el archivo equivocado con el hash equivocado. O tal vez el archivo .sha256 no corresponda a esa versión en particular. En caso de duda, vuelve a descargar el archivo desde la fuente oficial.

No se encuentra el archivo indicado

Con sha256sum -c, el archivo .sha256 también contiene el nombre del archivo a verificar. Si renombras el archivo, la verificación falla:

sha256sum -c ejemplo.sha256

Si ejemplo.sha256 contiene ejemplo.txt, pero has renombrado el archivo a prueba.txt, sha256sum no lo encontrará. La solución es simple: vuelve a poner el nombre de archivo correcto o regenera el checksum.

Los saltos de línea pueden cambiar el hash

Para los archivos de texto, los saltos de línea a veces pueden causar problemas, especialmente entre Linux, macOS y Windows. Un archivo puede parecer idéntico visualmente, pero contener finales de línea diferentes. Resultado: el hash cambia. Es frustrante, pero lógico: sha256sum no juzga lo que ves, lee los bytes reales del archivo. Es un poco exigente, pero eso es precisamente lo que lo hace útil.

Los permisos pueden bloquear la lectura

Si no tienes derecho a leer un archivo, sha256sum no podrá calcular su hash. Puedes ver un error del tipo:

sha256sum: archivo.txt: Permission denied

En este caso, verifica los permisos con:

ls -l archivo.txt

Luego adapta los permisos si es necesario, con precaución.

Buenas prácticas para utilizar sha256sum correctamente

La primera buena práctica es obtener los checksums de una fuente oficial. Si descargas un archivo de un sitio dudoso y su hash del mismo lugar dudoso, la verificación pierde mucho interés.

Cuando sea posible, verifica también las firmas GPG. sha256sum verifica la integridad de un archivo, pero no siempre prueba por sí solo la identidad de la persona u organización que lo ha proporcionado; para eso conviene saber cifrar y descifrar archivos con GPG y validar firmas.

Para tus propios archivos importantes, guarda los checksums en un lugar confiable. Por ejemplo, si archivas una copia de seguridad, guarda también su archivo .sha256.

Por último, evita modificar los archivos después de haber generado sus hashes. Parece evidente, pero en la vida real, abrimos un archivo, corregimos una coma, guardamos… y luego nos sorprende que la verificación falle.

Mini proyecto: crear una herramienta de verificación de integridad

Para terminar, construiremos un mini-proyecto simple: un script capaz de generar y luego verificar los hashes de una carpeta. El objetivo es el siguiente: tienes una carpeta mis-archivos y deseas saber si algunos archivos cambian con el tiempo. Crea un archivo control-integridad.sh:

#!/bin/bash
# Carpeta a monitorear
DOSSIER="mis-archivos"

# Archivo donde se guardarán los hashes
FICHIER_CHECKSUMS="checksums.sha256"

# Si la carpeta no existe, detenemos el script
if [ ! -d "$DOSSIER" ]; then
  echo "Error: la carpeta $DOSSIER no existe."
  exit 1
fi

# Si el usuario escribe "init", generamos los hashes
if [ "$1" = "init" ]; then
  echo "Generación de las huellas SHA-256..."
  find "$DOSSIER" -type f -exec sha256sum {} \; > "$FICHIER_CHECKSUMS"
  echo "Archivo $FICHIER_CHECKSUMS creado con éxito."
  exit 0
fi

# Si el usuario escribe "check", verificamos los archivos
if [ "$1" = "check" ]; then
  if [ ! -f "$FICHIER_CHECKSUMS" ]; then
    echo "Error: no se encontró ningún archivo de checksums."
    echo "Ejecute primero: ./control-integridad.sh init"
    exit 1
  fi
  echo "Verificación de la integridad de los archivos..."
  sha256sum -c "$FICHIER_CHECKSUMS"
  exit 0
fi

# Mensaje de ayuda si no se da ninguna opción correcta
echo "Uso:"
echo "./control-integridad.sh init   # Generar los hashes"
echo "./control-integridad.sh check  # Verificar los archivos"

Hazlo ejecutable:

chmod +x control-integridad.sh

Luego crea una carpeta de prueba:

mkdir mis-archivos
echo "Primer documento" > mis-archivos/documento1.txt
echo "Segundo documento" > mis-archivos/documento2.txt

Inicializa las huellas:

./control-integridad.sh init

Y verifica:

./control-integridad.sh check

Ahora, modifica un archivo:

echo "Una modificación discreta" >> mis-archivos/documento1.txt

Vuelve a ejecutar la verificación:

./control-integridad.sh check

Deberías ver que documento1.txt ya no coincide con su hash original. Este pequeño proyecto es simple a propósito, pero te muestra una verdadera lógica profesional: establecer un estado de referencia y luego verificar más adelante si algo ha cambiado.

FAQ sobre sha256sum

Ir más allá después de sha256sum

Una vez que te sientas cómodo con sha256sum, puedes descubrir otros comandos similares como md5sum, sha1sum, sha512sum o incluso crear otras primitivas criptográficas con OpenSSL.

También puedes utilizar estas nociones en contextos más avanzados: despliegue de archivos en un servidor, control de copias de seguridad, verificación de archivos comprimidos, seguridad de software o automatización con Bash. Lo más importante, para empezar, es practicar.

Toma algunos archivos sin importancia, genera sus hashes, modifícalos y vuelve a verificarlos. Verás rápidamente que sha256sum se convierte en un pequeño reflejo muy útil. No es el comando más espectacular de la terminal. Pero el día en que te evite utilizar un archivo corrupto o dudoso, te alegrarás de tenerlo en tu caja de herramientas.