Vérifier l'intégrité d'un fichier : checksums et signatures GPG

Un fichier téléchargé peut être corrompu pendant le transfert, ou substitué par un attaquant. La vérification de l’intégrité est un réflexe de base en administration Linux : avant d’installer un outil, de restaurer un backup ou de déployer une configuration critique, on vérifie que le fichier est exactement celui attendu.

Il existe deux niveaux de vérification différents que ce guide distingue clairement.

Ce que vous allez apprendre

Générer le checksum sha256 d’un fichier avec sha256sum
Vérifier un fichier contre un fichier de checksums fourni par la source
Comprendre les différences entre md5, sha1, sha256 et sha512
Comparer deux fichiers par leur hash pour vérifier qu’ils sont identiques
Vérifier une signature GPG détachée (.sig ou .asc)
Importer une clé GPG publique depuis un serveur de clés ou une URL

Intégrité vs authenticité : deux niveaux différents

Vérification	Ce qu’on vérifie	Outil	Protège contre
Intégrité	Le fichier n’a pas été altéré	`sha256sum -c`	Corruption réseau, erreur de transfert
Authenticité	Le fichier vient bien de l’auteur attendu	`gpg --verify`	Substitution malveillante, attaque MITM

Un checksum seul ne prouve pas l’authenticité : si un attaquant remplace le fichier ET le checksum sur un site compromis, la vérification sha256 passera quand même. Pour l’authenticité, seule la signature GPG donne une garantie réelle.

`sha256sum` — vérifier l’intégrité

Générer le checksum d’un fichier

sha256sum archive.tar.gz

a3f8c9d1e2b4567890abcdef1234567890abcdef1234567890abcdef12345678  archive.tar.gz

Vérifier contre un checksum fourni

La plupart des projets sérieux publient un fichier .sha256 ou SHA256SUMS à côté des archives.

# Télécharger le fichier et son checksum
wget https://example.com/projet-1.0.tar.gz
wget https://example.com/projet-1.0.tar.gz.sha256

# Vérifier
sha256sum -c projet-1.0.tar.gz.sha256

projet-1.0.tar.gz: OK

Si le fichier est altéré :

projet-1.0.tar.gz: FAILED
sha256sum: WARNING: 1 computed checksum did NOT match

Vérifier depuis un fichier SHA256SUMS multi-entrées

Les distributions publient souvent un seul fichier pour toutes les images :

wget https://example.com/SHA256SUMS
sha256sum -c SHA256SUMS 2>/dev/null | grep projet-1.0

sha256sum -c ignore automatiquement les entrées dont les fichiers n’existent pas localement, ou vous pouvez filtrer avec grep.

Si vous n’avez pas de fichier .sha256 mais juste une ligne copiée depuis un site :

echo "a3f8c9...12345678  archive.tar.gz" | sha256sum -c

Les deux espaces entre le hash et le nom de fichier sont obligatoires (sha256sum utilise ce format).

Choisir le bon algorithme

Algorithme	Commande	Longueur	Usage recommandé
MD5	`md5sum`	128 bits	Éviter — cassé cryptographiquement depuis 2004
SHA-1	`sha1sum`	160 bits	Déprécié — attaques pratiques démontrées (SHAttered)
SHA-256	`sha256sum`	256 bits	Standard actuel — utiliser par défaut
SHA-512	`sha512sum`	512 bits	Fichiers très critiques, archives de gros backups

sha256sum est le choix correct dans tous les contextes courants d’administration Linux (2026).

md5sum reste utile uniquement pour vérifier rapidement qu’un transfert n’est pas corrompu dans un contexte interne sans enjeu de sécurité — par exemple comparer deux copies d’un fichier sur un réseau local de confiance.

Comparer deux fichiers par leur hash

sha256sum fichier-original.tar.gz fichier-copie.tar.gz

a3f8c9d1...  fichier-original.tar.gz
a3f8c9d1...  fichier-copie.tar.gz

Si les deux hashes sont identiques, les fichiers sont bit-à-bit identiques — même si leur nom ou leur date de modification diffèrent.

Script de vérification de cohérence

#!/bin/bash
SRC=$(sha256sum "$1" | cut -d' ' -f1)
DST=$(sha256sum "$2" | cut -d' ' -f1)

if [ "$SRC" = "$DST" ]; then
  echo "Fichiers identiques : $1"
else
  echo "DIFFÉRENCE DÉTECTÉE : $1 ≠ $2" >&2
  exit 1
fi

`gpg` — vérifier une signature

La signature GPG prouve que le fichier a été signé par la clé privée d’un auteur que vous avez choisi de faire confiance. C’est la vérification nécessaire pour les paquets, les images de distributions et les outils dont l’authenticité est critique.

Workflow complet

Télécharger le fichier, son checksum et sa signature
Fenêtre de terminal
```
wget https://example.com/outil-1.0.tar.gz
wget https://example.com/outil-1.0.tar.gz.sha256
wget https://example.com/outil-1.0.tar.gz.sig
```
La signature peut être en format binaire (.sig) ou ASCII armored (.asc).

Importer la clé publique GPG de l’auteur

# Depuis un serveur de clés
gpg --keyserver keys.openpgp.org --recv-keys 0xABCDEF1234567890

# Depuis une URL (souvent fournie par le projet)
curl -fsSL https://example.com/release-signing-key.asc | gpg --import

L’ID de la clé ou l’empreinte est publié sur la page de téléchargement du projet.

Vérifier l’intégrité avec sha256sum
Fenêtre de terminal
```
sha256sum -c outil-1.0.tar.gz.sha256
```
Vérifier l’authenticité avec gpg
Fenêtre de terminal
```
gpg --verify outil-1.0.tar.gz.sig outil-1.0.tar.gz
```
```
gpg: Signature made Mon 08 Apr 2026 22:00:00 UTC
gpg:                using RSA key ABCDEF1234567890
gpg: Good signature from "Auteur <auteur@example.com>" [unknown]
gpg: WARNING: This key is not certified with a trusted signature!
gpg:          There is no indication that the signature belongs to the owner.
```
“Good signature” confirme que le fichier correspond à la signature.

Le WARNING est normal si vous venez d’importer la clé sans l’avoir signée vous-même. C’est le modèle de confiance GPG (Web of Trust). Pour les projets importants, vérifiez l’empreinte de la clé via plusieurs canaux (site officiel, Twitter, conférences…).

Cas pratiques courants

# Exemple : Ubuntu 24.04
wget https://releases.ubuntu.com/24.04/ubuntu-24.04-live-server-amd64.iso
wget https://releases.ubuntu.com/24.04/SHA256SUMS
wget https://releases.ubuntu.com/24.04/SHA256SUMS.gpg

# Importer la clé Ubuntu
gpg --keyserver hkp://keyserver.ubuntu.com \
    --recv-keys 0x843938DF228D22F7B3742BC0D94AA3F0EFE21092

# Vérifier la signature du fichier SHA256SUMS
gpg --verify SHA256SUMS.gpg SHA256SUMS

# Vérifier l'ISO
sha256sum -c SHA256SUMS 2>/dev/null | grep ubuntu-24.04-live-server-amd64

# Vérifier le binaire kubectl
RELEASE=$(curl -fsSL https://dl.k8s.io/release/stable.txt)
curl -LO "https://dl.k8s.io/release/${RELEASE}/bin/linux/amd64/kubectl"
curl -LO "https://dl.k8s.io/release/${RELEASE}/bin/linux/amd64/kubectl.sha256"

echo "$(cat kubectl.sha256)  kubectl" | sha256sum -c

# Générer un checksum d'un backup
sha256sum /var/backup/home-2026-04-09.tar.gz > /var/backup/home-2026-04-09.sha256

# Vérifier plus tard avant restauration
sha256sum -c /var/backup/home-2026-04-09.sha256

Stockez le fichier .sha256 dans un emplacement différent du backup pour une détection fiable de corruption.

Dépannage courant

Symptôme	Cause	Solution
`sha256sum: FAILED, open or read`	Fichier absent ou mauvais nom	Vérifier que le nom dans le .sha256 correspond exactement au fichier local
`gpg: No public key`	Clé non importée	`gpg --recv-keys <ID>` ou importation manuelle
`gpg: BAD signature`	Fichier altéré ou mauvaise signature	Le fichier est corrompu ou substitué — ne pas l’utiliser
`gpg: key not found on keyserver`	Serveur de clés indisponible	Essayer un autre serveur : `--keyserver keyserver.ubuntu.com`
Deux espaces requis dans le fichier .sha256	Format sha256sum	`echo "HASH fichier"` (deux espaces entre hash et nom)

À retenir

sha256sum fichier génère le hash. sha256sum -c fichier.sha256 vérifie.
sha256sum est le standard actuel. md5sum est cassé — n’y faire confiance que pour détecter une corruption accidentelle, jamais une altération intentionnelle.
Une signature GPG prouve l’authenticité ; un checksum seul vérifie seulement l’intégrité.
Le message “Good signature” de GPG est positif — le WARNING sur la confiance est normal pour une clé nouvellement importée.
Stocker les fichiers .sha256 ou .asc séparément des archives pour détecter les corruptions de stockage.

Prochaines étapes

Télécharger avec curl et wget Récupérer des fichiers et releases depuis la ligne de commande — avec checksum intégré.

tar avancé : backups et restauration sélective Vérifier l'intégrité d'une archive tar avant restauration — tar --compare et tar -tvf.

Synchroniser avec rsync Synchroniser des répertoires avec vérification de cohérence intégrée.

Archiver et compresser Bases de tar, gzip et zip — revenir aux fondamentaux si besoin.