sha256sum : vérifiez l’intégrité de vos fichiers

Vous avez déjà téléchargé un fichier, une archive ZIP ou une sauvegarde sans vraiment savoir si elle était intacte ? La commande sha256sum permet justement de vérifier l’intégrité d’un fichier en quelques secondes grâce à une empreinte numérique appelée hash SHA-256. Simple, rapide et extrêmement utile, c’est un outil incontournable sous Linux.

• Évitez d’utiliser un fichier corrompu ou modifié en apprenant à vérifier facilement son intégrité avec sha256sum.
• Comprenez enfin à quoi servent les hashes SHA-256 et pourquoi ils sont devenus indispensables sous Linux et en cybersécurité.
• Automatisez vos vérifications de fichiers avec des commandes et scripts Bash simples, même sans être expert du terminal.

Dans ce tutoriel complet sur sha256sum, vous allez apprendre à générer et vérifier des checksums, comprendre à quoi servent les hashes SHA-256, repérer les erreurs fréquentes et même automatiser des contrôles d’intégrité avec Bash. Pas besoin d’être expert en sécurité ou en terminal : tout sera expliqué étape par étape avec des exemples simples et concrets.

👉 Pour ceux qui débutent : Introduction à la cryptographie

Comprendre à quoi sert la commande sha256sum

Quand vous téléchargez un fichier sur Internet, par exemple une image ISO de Linux, une archive .zip, un script ou une sauvegarde, une question simple se pose : êtes-vous certain que ce fichier est bien celui que vous pensez avoir téléchargé ?

Il peut être incomplet, corrompu pendant le téléchargement, modifié par erreur, ou dans les pires cas remplacé par un fichier malveillant.

• C’est là qu’intervient la commande sha256sum.

sha256sum permet de calculer une sorte d’empreinte numérique d’un fichier. Cette empreinte est unique, ou presque, pour un contenu donné. Si vous modifiez ne serait-ce qu’un caractère dans un fichier texte, le résultat change complètement. Un peu comme si votre fichier avait une carte d’identité très stricte : au moindre changement, elle n’est plus valable.

👉 Wget : Télécharger depuis le terminal simplement.

Qu’est-ce qu’un hash SHA-256 ?

Un hash est une chaîne de caractères générée à partir du contenu d’un fichier ou d’un texte.

Avec SHA-256, le résultat ressemble à ceci :

b94d27b9934d3e08a52e52d7da7dabfade0f3f78c2d48923a9869d5e7f3d6c0f

Ce n’est pas très poétique, on est d’accord. Mais cette longue suite de lettres et de chiffres est très utile.

SHA-256 signifie Secure Hash Algorithm 256 bits. Pour faire simple, c’est une méthode qui prend un contenu en entrée et produit une empreinte de longueur fixe. Peu importe que votre fichier fasse 2 lignes ou 4 Go, le hash SHA-256 aura toujours la même forme.

Ce hash ne sert pas à retrouver le fichier d’origine. Ce n’est pas du chiffrement. Il sert surtout à vérifier que le fichier n’a pas changé.

Pourquoi vérifier l’intégrité d’un fichier ?

Imaginez que vous téléchargez une distribution Linux pour l’installer sur votre ordinateur. Le fichier fait plusieurs gigaoctets. Tout semble normal, mais une petite erreur s’est glissée pendant le téléchargement.

Résultat : l’installation peut échouer, ou pire, fonctionner bizarrement. Et comme toujours en informatique, “bizarrement” signifie souvent “vous allez perdre une soirée”.

Avec sha256sum, vous pouvez comparer l’empreinte de votre fichier avec celle fournie par le site officiel. Si les deux valeurs sont identiques, votre fichier est intact. Si elles sont différentes, il faut éviter de l’utiliser.

Différence entre checksum, hash et empreinte numérique

Dans certaines tutoriels, vous croiserez souvent plusieurs mots : checksum, hash, somme de contrôle, empreinte numérique.

Dans le contexte de sha256sum, vous pouvez les comprendre ainsi :

• Le hash est le résultat calculé à partir du fichier.
• La checksum, ou somme de contrôle, est une valeur utilisée pour vérifier l’intégrité d’un fichier.
• L’empreinte numérique est une image simple pour dire : “voici l’identité technique du fichier”.

Dans la pratique, pour un débutant, retenez surtout ceci : avec sha256sum, vous générez ou vérifiez une empreinte pour savoir si un fichier est bien conforme.

Pourquoi utiliser SHA-256 plutôt que MD5 ou SHA1 ?

Vous avez peut-être déjà vu des commandes comme md5sum ou sha1sum. Elles fonctionnent sur le même principe, mais les algorithmes MD5 et SHA1 sont aujourd’hui considérés comme trop faibles pour certains usages de sécurité.

Pour vérifier rapidement qu’un fichier n’a pas été abîmé, MD5 peut encore se rencontrer. Mais pour une vérification sérieuse, notamment sur des téléchargements importants, SHA-256 est largement préférable.

En clair : si vous avez le choix, utilisez sha256sum.

👉 Pour aller plus loin, découvrez : Les types de cryptographie

Installer et utiliser sha256sum pour la première fois

Sur la plupart des distributions Linux ou macOS, sha256sum est déjà installé.

La commande fait partie des outils GNU Coreutils, présents par défaut sur Debian, Ubuntu, Fedora, Arch, Linux Mint et beaucoup d’autres systèmes.

Pour vérifier si la commande existe, ouvrez un terminal et tapez :

sha256sum --version

Si tout va bien, vous verrez une réponse indiquant la version installée.

Sur macOS, la commande peut ne pas être disponible exactement sous ce nom selon votre environnement. Vous pouvez utiliser :

shasum -a 256 fichier.txt

Mais dans ce guide, nous allons nous concentrer sur la commande sha256sum.

Générer un hash SHA-256 simplement

Commençons avec un exemple très simple. Créez un petit fichier texte :

echo "Bonjour le Créa-Blog" > exemple.txt

Cette commande crée un fichier nommé exemple.txt contenant une phrase.

Maintenant, calculons son hash SHA-256 :

sha256sum exemple.txt

Vous obtiendrez un résultat proche de ceci :

c5a72e8f9b1f1c7f4f2b2c8f7f5c85b2d8a7f8b1a6c7e9d4f3a2b1c0d9e8f7a6  exemple.txt

La première partie est le hash. La seconde partie est le nom du fichier.

La commande vous dit donc : “voici l’empreinte SHA-256 du fichier exemple.txt”.

Comprendre le résultat affiché

Le résultat de sha256sum contient généralement deux éléments :

HASH  NOM_DU_FICHIER

Par exemple :

2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824  hello.txt

Le hash est calculé uniquement à partir du contenu du fichier. Le nom du fichier est affiché pour vous aider à savoir à quoi correspond la valeur.

Cela veut dire qu’un fichier renommé peut garder le même hash si son contenu ne change pas.

Générer le hash de plusieurs fichiers

Vous pouvez aussi calculer l’empreinte de plusieurs fichiers en une seule commande.

Imaginons trois fichiers :

echo "Fichier 1" > fichier1.txt
echo "Fichier 2" > fichier2.txt
echo "Fichier 3" > fichier3.txt

Vous pouvez ensuite lancer :

sha256sum fichier1.txt fichier2.txt fichier3.txt

Le terminal affichera une ligne par fichier.

C’est pratique lorsque vous préparez une archive, une sauvegarde ou un dossier à envoyer à quelqu’un.

Enregistrer un checksum dans un fichier texte

Au lieu de simplement afficher le hash dans le terminal, vous pouvez l’enregistrer dans un fichier :

sha256sum exemple.txt > exemple.sha256

Ici, le symbole > signifie : “envoie le résultat dans un fichier”.

Le fichier exemple.sha256 contiendra quelque chose comme :

c5a72e8f9b1f1c7f4f2b2c8f7f5c85b2d8a7f8b1a6c7e9d4f3a2b1c0d9e8f7a6  exemple.txt

Ce fichier pourra ensuite être utilisé pour vérifier automatiquement l’intégrité de exemple.txt.

Vérifier l’intégrité d’un fichier avec sha256sum

Maintenant que nous savons générer un hash, voyons comment vérifier un fichier automatiquement.

Supposons que vous avez un fichier exemple.txt et son fichier de contrôle exemple.sha256.

Vous pouvez lancer :

sha256sum -c exemple.sha256

L’option -c signifie check, c’est-à-dire “vérifier”.

Si le fichier n’a pas changé, vous verrez :

exemple.txt: OK

C’est le message que l’on aime voir. Simple, efficace, presque rassurant.

Si le fichier a été modifié, vous verrez plutôt :

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

Là, le terminal vous prévient que le contenu actuel du fichier ne correspond plus au hash enregistré.

Comparer deux hashes manuellement

Parfois, les sites vous donnent seulement un hash à copier, sans fichier .sha256.

Dans ce cas, vous pouvez calculer vous-même le hash du fichier téléchargé :

sha256sum mon-fichier.iso

Puis vous comparez le résultat avec celui indiqué sur le site officiel.

Il faut que les deux chaînes soient strictement identiques. Même une seule lettre différente suffit à invalider la vérification.

Petit conseil : ne comparez pas seulement le début et la fin. C’est tentant, mais ce n’est pas une vraie vérification. Copiez les deux valeurs dans un éditeur de texte si besoin, ou utilisez un outil de comparaison.

Vérifier une image ISO Linux ou macOS avant installation

C’est probablement l’un des cas les plus courants.

Vous téléchargez par exemple un fichier :

ubuntu.iso

Le site officiel fournit aussi un fichier de checksum, souvent nommé :

SHA256SUMS

Placez les deux fichiers dans le même dossier, puis lancez :

sha256sum -c SHA256SUMS

Si le fichier SHA256SUMS contient plusieurs images ISO, vous pouvez voir plusieurs lignes. Si vous n’avez téléchargé qu’une seule image, certaines lignes peuvent indiquer que des fichiers sont introuvables.

Ce n’est pas forcément grave : cela signifie simplement que vous n’avez pas tous les fichiers listés.

Pour vérifier uniquement votre fichier, vous pouvez créer un fichier .sha256 dédié contenant seulement la ligne qui correspond à votre ISO.

Utiliser sha256sum dans des situations concrètes

sha256sum n’est pas réservé aux administrateurs système qui parlent à leurs serveurs. Vous pouvez l’utiliser dans des cas très simples.

Des formations informatique pour tous !

Débutant ou curieux ? Apprenez le développement web, le référencement, le webmarketing, la bureautique, à maîtriser vos appareils Apple et bien plus encore…

Formateur indépendant, professionnel du web depuis 2006, je vous accompagne pas à pas et en cours particulier, que vous soyez débutant ou que vous souhaitiez progresser. En visio, à votre rythme, et toujours avec pédagogie.

Découvrez mes formations Qui suis-je ?

Par exemple, avant d’envoyer une archive importante :

sha256sum projet-client.zip > projet-client.zip.sha256

Vous envoyez ensuite les deux fichiers : l’archive et son checksum. La personne qui reçoit le fichier peut vérifier que l’archive n’a pas été abîmée pendant le transfert.

Autre exemple : contrôler une sauvegarde.

sha256sum sauvegarde.tar.gz > sauvegarde.tar.gz.sha256

Plus tard, vous pourrez vérifier que la sauvegarde est toujours intacte :

sha256sum -c sauvegarde.tar.gz.sha256

C’est une petite habitude qui peut éviter de grosses sueurs froides.

Les options utiles de la commande sha256sum

La commande sha256sum reste assez simple. Pour débuter, quelques options suffisent largement.

L’option -c

C’est l’option la plus importante pour la vérification :

sha256sum -c fichier.sha256

Elle lit le hash enregistré dans le fichier .sha256, recalcule l’empreinte du fichier concerné, puis compare les deux valeurs.

L’option --quiet

Si vous vérifiez beaucoup de fichiers, l’affichage peut devenir long. L’option --quiet permet de ne pas afficher les fichiers qui sont corrects.

sha256sum -c checksums.sha256 --quiet

Vous ne verrez que les problèmes éventuels.

L’option --status

Cette option n’affiche rien dans le terminal. Elle est surtout utile dans les scripts.

sha256sum -c checksums.sha256 --status

Si la vérification réussit, la commande renvoie un code de succès. Si elle échoue, elle renvoie un code d’erreur. Pour un humain, ce n’est pas très parlant. Pour un script Bash, c’est parfait.

Exemple :

if sha256sum -c checksums.sha256 --status; then
    echo "Tous les fichiers sont valides."
else
    echo "Attention : au moins un fichier a été modifié."
fi

Ici, le script teste directement le résultat de la commande.

Différences entre SHA256, MD5 et SHA1

Historiquement, MD5 et SHA1 ont été très utilisés pour générer des empreintes de fichiers. Le problème, c’est qu’ils ne sont plus considérés comme suffisamment robustes pour les usages de sécurité modernes.

Cela ne signifie pas que chaque fichier vérifié avec MD5 est dangereux. Mais cela veut dire que, si vous voulez une méthode sérieuse et actuelle, SHA-256 est un meilleur choix.

Pour faire simple :

• MD5 est ancien et rapide, mais dépassé pour la sécurité.
• SHA1 est plus solide que MD5, mais lui aussi déconseillé pour les usages sensibles.
• SHA-256 est aujourd’hui un choix courant, fiable et largement utilisé.

Dans un tutoriel débutant, le conseil est simple : utilisez sha256sum quand c’est possible.

Automatiser la vérification de fichiers avec sha256sum

Lorsque vous avez compris le principe, vous pouvez aller plus loin et automatiser vos contrôles.

Imaginons un dossier documents contenant plusieurs fichiers importants. Pour générer les hashes de tous les fichiers .txt, vous pouvez faire :

sha256sum documents/*.txt > checksums.sha256

Cette commande calcule le hash de tous les fichiers texte présents dans le dossier documents, puis enregistre le résultat dans checksums.sha256.

Plus tard, pour vérifier ces fichiers :

sha256sum -c checksums.sha256

Si tout est correct, chaque fichier affichera OK.

Vous pouvez aussi vérifier tous les fichiers d’un dossier de manière plus large avec find :

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

Cette commande mérite une petite explication.

• find documents cherche dans le dossier documents.
• -type f indique que l’on veut uniquement les fichiers.
• -exec sha256sum {} \; exécute sha256sum sur chaque fichier trouvé.

Le résultat est enregistré dans checksums.sha256.

C’est un peu plus avancé, mais très pratique.

Créer un script Bash de vérification automatique

Voici un petit script simple pour vérifier des fichiers à partir d’un fichier de checksums.

Créez un fichier nommé verifier.sh :

#!/bin/bash

# Nom du fichier contenant les checksums
FICHIER_CHECKSUMS="checksums.sha256"

# On vérifie si le fichier existe
if [ ! -f "$FICHIER_CHECKSUMS" ]; then
    echo "Erreur : le fichier $FICHIER_CHECKSUMS est introuvable."
    exit 1
fi

# On lance la vérification
echo "Vérification des fichiers en cours..."

if sha256sum -c "$FICHIER_CHECKSUMS"; then
    echo "Bonne nouvelle : tous les fichiers sont intacts."
else
    echo "Attention : certains fichiers ont été modifiés ou sont manquants."
fi

Rendez le script exécutable :

chmod +x verifier.sh

Puis lancez-le :

./verifier.sh

Ce script reste volontairement simple. L’objectif est de comprendre la logique : on vérifie la présence du fichier de checksums, puis on lance sha256sum -c.

Les erreurs fréquentes avec sha256sum

Le hash ne correspond pas

Si le hash ne correspond pas, ne paniquez pas tout de suite. Plusieurs raisons sont possibles.

Le fichier a peut-être été modifié. Le téléchargement est peut-être incomplet. Vous comparez peut-être le mauvais fichier avec le mauvais hash. Ou alors le fichier .sha256 ne correspond pas à cette version précise.

Dans le doute, retéléchargez le fichier depuis la source officielle.

Le fichier indiqué est introuvable

Avec sha256sum -c, le fichier .sha256 contient aussi le nom du fichier à vérifier. Si vous renommez le fichier, la vérification échoue :

sha256sum -c exemple.sha256

Si exemple.sha256 contient exemple.txt, mais que vous avez renommé le fichier en test.txt, sha256sum ne le trouvera pas.

La solution est simple : remettez le bon nom de fichier ou régénérez le checksum.

Les retours à la ligne peuvent changer le hash

Pour les fichiers texte, les retours à la ligne peuvent parfois poser problème, notamment entre Linux, macOS et Windows.

Un fichier peut visuellement sembler identique, mais contenir des fins de ligne différentes. Résultat : le hash change.

C’est frustrant, mais logique : sha256sum ne juge pas ce que vous voyez, il lit les octets réels du fichier. Il est un peu tatillon, mais c’est précisément ce qui le rend utile.

Les permissions peuvent bloquer la lecture

Si vous n’avez pas le droit de lire un fichier, sha256sum ne pourra pas calculer son hash.

Vous pouvez voir une erreur du type :

sha256sum: fichier.txt: Permission denied

Dans ce cas, vérifiez les permissions avec :

ls -l fichier.txt

Puis adaptez les droits si nécessaire, avec prudence.

Bonnes pratiques pour utiliser sha256sum correctement

La première bonne pratique est de récupérer les checksums depuis une source officielle. Si vous téléchargez un fichier depuis un site douteux et son hash depuis le même endroit douteux, la vérification perd beaucoup d’intérêt.

Lorsque c’est possible, vérifiez aussi les signatures GPG. sha256sum vérifie l’intégrité d’un fichier, mais ne prouve pas toujours à lui seul l’identité de la personne ou de l’organisation qui l’a fourni.

Pour vos propres fichiers importants, conservez les checksums dans un endroit fiable. Par exemple, si vous archivez une sauvegarde, gardez aussi son fichier .sha256.

Enfin, évitez de modifier les fichiers après avoir généré leurs hashes. Cela paraît évident, mais dans la vraie vie, on ouvre un fichier, on corrige une virgule, on sauvegarde… et ensuite on s’étonne que la vérification échoue. Oui, même cette petite virgule compte.

Mini projet : créer un outil de vérification d’intégrité

Pour terminer, construisons un mini-projet simple : un script capable de générer puis vérifier les hashes d’un dossier.

L’objectif est le suivant : vous avez un dossier mes-fichiers, et vous voulez savoir si certains fichiers changent au fil du temps.

Créez un fichier controle-integrite.sh :

#!/bin/bash

# Dossier à surveiller
DOSSIER="mes-fichiers"

# Fichier où seront enregistrés les hashes
FICHIER_CHECKSUMS="checksums.sha256"

# Si le dossier n'existe pas, on arrête le script
if [ ! -d "$DOSSIER" ]; then
    echo "Erreur : le dossier $DOSSIER n'existe pas."
    exit 1
fi

# Si l'utilisateur tape "init", on génère les hashes
if [ "$1" = "init" ]; then
    echo "Génération des empreintes SHA-256..."
    find "$DOSSIER" -type f -exec sha256sum {} \; > "$FICHIER_CHECKSUMS"
    echo "Fichier $FICHIER_CHECKSUMS créé avec succès."
    exit 0
fi

# Si l'utilisateur tape "check", on vérifie les fichiers
if [ "$1" = "check" ]; then
    if [ ! -f "$FICHIER_CHECKSUMS" ]; then
        echo "Erreur : aucun fichier de checksums trouvé."
        echo "Lancez d'abord : ./controle-integrite.sh init"
        exit 1
    fi

    echo "Vérification de l'intégrité des fichiers..."
    sha256sum -c "$FICHIER_CHECKSUMS"
    exit 0
fi

# Message d'aide si aucune option correcte n'est donnée
echo "Utilisation :"
echo "./controle-integrite.sh init   # Générer les hashes"
echo "./controle-integrite.sh check  # Vérifier les fichiers"

Rendez-le exécutable :

chmod +x controle-integrite.sh

Créez ensuite un dossier de test :

mkdir mes-fichiers
echo "Premier document" > mes-fichiers/document1.txt
echo "Deuxième document" > mes-fichiers/document2.txt

Initialisez les empreintes :

./controle-integrite.sh init

Puis vérifiez :

./controle-integrite.sh check

Maintenant, modifiez un fichier :

echo "Une modification discrète" >> mes-fichiers/document1.txt

Relancez la vérification :

./controle-integrite.sh check

Vous devriez voir que document1.txt ne correspond plus à son hash d’origine.

Ce petit projet est volontairement simple, mais il vous montre une vraie logique professionnelle : établir un état de référence, puis vérifier plus tard si quelque chose a changé.

---

FAQ sur sha256sum

---

Aller plus loin après sha256sum

Une fois que vous êtes à l’aise avec sha256sum, vous pouvez découvrir d’autres commandes proches comme md5sum, sha1sum, sha512sum ou encore les signatures GPG.

Vous pouvez aussi utiliser ces notions dans des contextes plus avancés : déploiement de fichiers sur un serveur, contrôle de sauvegardes, vérification d’archives, sécurité logicielle ou automatisation avec Bash.

Le plus important, pour commencer, est de pratiquer. Prenez quelques fichiers sans importance, générez leurs hashes, modifiez-les, vérifiez-les à nouveau. Vous verrez rapidement que sha256sum devient un petit réflexe très utile.

Ce n’est pas la commande la plus spectaculaire du terminal. Mais le jour où elle vous évite d’utiliser un fichier corrompu ou douteux, vous serez content de l’avoir dans votre boîte à outils.