Empreinte SHA256 : Vérifier l’intégrité d’un fichier en PHP

Dans le vaste monde du numérique, tout fichier que vous téléchargez ou partagez transite à travers de nombreux intermédiaires : serveurs, routeurs, réseaux, systèmes de stockage… À chaque étape, il existe un risque, même minime, que le fichier soit altéré, modifié ou corrompu. Cela peut être dû à une erreur technique, à une panne, ou, plus grave encore, à une tentative de manipulation malveillante.

Imaginez que vous téléchargiez une mise à jour d’un logiciel depuis un site externe. Si le fichier a été modifié par un pirate, il pourrait contenir du code malicieux. Et sans vérification, vous n’en auriez probablement jamais conscience. C’est ici qu’intervient la vérification d’intégrité.

Vérifier l’intégrité d’un fichier, c’est s’assurer que son contenu n’a pas été modifié depuis sa création. Pour cela, on utilise une empreinte numérique, aussi appelée hash. Dans cet article, vous allez découvrir en détail ce qu’est une empreinte SHA256, comment elle fonctionne, et surtout, comment l’utiliser concrètement en PHP pour vérifier l’intégrité d’un fichier.

Comprendre ce qu’est une empreinte numérique

Une empreinte numérique, aussi appelée fonction de hachage, est un outil mathématique qui permet de transformer n’importe quel fichier (texte, image, programme, etc.) en une suite de caractères unique.

On peut comparer cela à une empreinte digitale : peu importe la taille de la main (ou du fichier), l’empreinte obtenue sera toujours de même longueur et unique à chaque individu.

Prenons un exemple simple. Si vous appliquez une fonction de hachage à un texte, elle vous renverra une suite de chiffres et de lettres difficilement compréhensible, mais totalement déterministe.

Cela signifie que le même texte donnera toujours la même empreinte. En revanche, la moindre modification, même d’un seul caractère, changera totalement l’empreinte.

Exemple :

Texte : Bonjour le monde
Empreinte SHA256 : 8ddd8be4b179a529afa5f2ffae4b9858b2b97b0f6f5b1e7b9ceac44b9e6f5f7c

Texte : Bonjour le Monde
Empreinte SHA256 : 1dbcbf44e58756ad12ef82ab5f17e34f3ccaa8b1f02f6cc9db8d80ad62e7c2bb

Un simple changement de majuscule a produit une empreinte totalement différente.
C’est ce qui rend cette méthode particulièrement fiable pour détecter la moindre altération d’un fichier.

Qu’est-ce que le SHA256 ?

Le SHA256 (pour Secure Hash Algorithm 256 bits) est une fonction de hachage issue de la famille des algorithmes SHA-2, développée par la NSA et publiée par le NIST (National Institute of Standards and Technology). Elle fait partie des standards les plus utilisés dans le domaine de la sécurité informatique et de la cryptographie.

Comme son nom l’indique, le résultat d’un hachage SHA256 fait toujours 256 bits de long, soit 64 caractères hexadécimaux.
Par exemple :

d2d2d0c8c5b1bfc9a56f86a8790a9f295f3dfb91f08b0730a1af4c24e97b73cf

Cette empreinte n’est pas réversible : il est impossible de retrouver le fichier d’origine à partir de son empreinte. C’est un processus à sens unique.

Pourquoi SHA256 plutôt que MD5 ou SHA1 ?

Pendant longtemps, les fonctions MD5 et SHA1 étaient très utilisées pour vérifier les fichiers téléchargés. Mais ces algorithmes sont aujourd’hui considérés comme vulnérables, car il est possible de créer deux fichiers différents qui produisent la même empreinte (on appelle cela une collision).

Le SHA256, en revanche, est bien plus robuste. Il est utilisé par de nombreux systèmes de sécurité : HTTPS, signatures de certificats SSL, vérifications logicielles, ou encore stockage sécurisé de mots de passe.

Vérifier l’intégrité d’un fichier : le principe

La vérification d’intégrité repose sur un concept simple :

1. Le créateur du fichier calcule son empreinte SHA256 au moment de la mise à disposition.
2. Cette empreinte est publiée (souvent à côté du lien de téléchargement).
3. Lorsque vous téléchargez le fichier, vous calculez vous-même son empreinte.
4. Vous comparez les deux valeurs.
5. Si elles sont identiques, le fichier est authentique et intact.

Prenons un exemple concret :

Supposons que vous téléchargez un fichier nommé logiciel.zip, et que le site du développeur indique :

Empreinte SHA256 : 5f70bf18a0860b7bcb0f1f58e3d07a3f69372c6f9ebbbdf8f4c3ec72cf8a42b4

Après le téléchargement, vous calculez vous-même l’empreinte de logiciel.zip. Si le résultat est exactement le même, vous pouvez être sûr que le fichier n’a pas été modifié pendant le transfert. Sinon, il a été altéré.

Vérifier un fichier en ligne de commande

Avant de passer à PHP, voyons comment cela fonctionne dans un environnement standard (Linux, macOS ou Windows). Cette étape permet de comprendre la logique de base.

Sous Linux ou macOS :

Ouvrez un terminal et tapez :

sha256sum fichier.zip

Le terminal renverra l’empreinte SHA256 du fichier.

Sous Windows :

Depuis PowerShell, tapez :

Get-FileHash .\fichier.zip -Algorithm SHA256

Dans les deux cas, le résultat sera une longue suite hexadécimale. Vous pouvez la copier et la comparer avec celle du site d’origine.

Si les deux valeurs sont identiques, l’intégrité du fichier est confirmée. Sinon, vous devez supprimer immédiatement le fichier et ne pas l’utiliser.

Générer et vérifier une empreinte SHA256 en PHP

Maintenant que vous comprenez le principe, voyons comment faire la même chose en PHP, ce qui est très utile dans un site web, une API ou une application interne.

PHP dispose d’une fonction native appelée hash_file(), qui permet de générer une empreinte pour un fichier en utilisant l’algorithme de votre choix.

Exemple simple :

<?php
$fichier = 'monfichier.zip';
$empreinte = hash_file('sha256', $fichier);
echo "Empreinte SHA256 du fichier : " . $empreinte;

Le résultat sera une chaîne de 64 caractères représentant l’empreinte SHA256 du fichier.

Si vous voulez vérifier l’intégrité d’un fichier téléchargé, vous pouvez comparer cette empreinte à celle fournie par le créateur :

<?php
$fichier = 'monfichier.zip';
$empreinte_attendue = '5f70bf18a0860b7bcb0f1f58e3d07a3f69372c6f9ebbbdf8f4c3ec72cf8a42b4';

$empreinte_actuelle = hash_file('sha256', $fichier);

if ($empreinte_actuelle === $empreinte_attendue) {
    echo "Le fichier est authentique et intact.";
} else {
    echo "Attention : le fichier a été modifié ou corrompu.";
}

Comparer des empreintes SHA256 en PHP : cas pratiques

Jusqu’ici, nous avons vu comment générer une empreinte SHA256 et la comparer à une valeur de référence.

Mais dans un projet concret, cette opération s’intègre souvent dans un processus automatisé : téléchargement de fichiers, vérification avant traitement, ou encore contrôle d’intégrité après transfert. Prenons plusieurs cas typiques.

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 ?

a) Vérifier automatiquement un fichier téléchargé

Imaginons que vous développez un petit script PHP qui télécharge un fichier depuis une URL, puis vérifie qu’il est intact avant de le stocker localement.

<?php
$url = 'https://exemple.com/logiciel.zip';
$fichier_local = 'logiciel.zip';
$empreinte_attendue = '5f70bf18a0860b7bcb0f1f58e3d07a3f69372c6f9ebbbdf8f4c3ec72cf8a42b4';

// Téléchargement du fichier
file_put_contents($fichier_local, file_get_contents($url));

// Calcul de l’empreinte du fichier téléchargé
$empreinte_actuelle = hash_file('sha256', $fichier_local);

// Comparaison des empreintes
if ($empreinte_actuelle === $empreinte_attendue) {
    echo "Le fichier téléchargé est valide et intègre.";
} else {
    echo "Le fichier semble altéré. Supprimez-le et réessayez.";
}

Ce script illustre le fonctionnement de base :

1. Le fichier est téléchargé depuis une source distante.
2. Une empreinte est générée localement.
3. Elle est comparée à la valeur d’origine.

Cela garantit que le fichier n’a pas été modifié pendant son transfert ou remplacé par un autre.

b) Vérifier plusieurs fichiers à la suite

Dans certaines situations (sauvegardes, mises à jour, fichiers clients, etc.), vous pouvez avoir plusieurs fichiers à contrôler. Voici un exemple permettant de comparer plusieurs empreintes contenues dans un tableau associatif :

<?php
$fichiers = [
    'archive1.zip' => 'a7c5fdb2e2e3f9a56e2fa33c4a84e74d68f334d10e9b6b2dbb5014d71f73b807',
    'archive2.zip' => 'b51f3f81acb0d90e79c2a0a64df54d236b08a4acb71cb221e4a0152d2b9e6d4c',
    'archive3.zip' => 'c9b2ff71d9e3edbd8893a561c0dfefc36a39f0c43e6b4b3f3ad73ab8c5236c5b'
];

foreach ($fichiers as $nom => $empreinte_attendue) {
    if (!file_exists($nom)) {
        echo "Fichier $nom introuvable.<br>";
        continue;
    }

    $empreinte_actuelle = hash_file('sha256', $nom);

    if ($empreinte_actuelle === $empreinte_attendue) {
        echo "$nom : fichier vérifié avec succès.<br>";
    } else {
        echo "$nom : fichier corrompu ou modifié.<br>";
    }
}

Ce script montre comment intégrer la vérification d’intégrité dans une routine PHP, utile pour contrôler régulièrement les fichiers critiques d’un site ou d’un serveur.

Comment gérer les gros fichiers efficacement

Lorsque vous manipulez de gros fichiers (plusieurs centaines de Mo, voire plusieurs Go), il est important d’éviter de les charger entièrement en mémoire. Heureusement, PHP propose une alternative : le calcul incrémental via hash_init(), hash_update(), et hash_final().

Exemple :

<?php
$fichier = 'video_hd.mp4';

// Ouverture du fichier en lecture binaire
$handle = fopen($fichier, 'rb');
$context = hash_init('sha256');

// Lecture par blocs de 8 Mo
while (!feof($handle)) {
    $data = fread($handle, 8192 * 1024);
    hash_update($context, $data);
}

fclose($handle);
$empreinte = hash_final($context);

echo "Empreinte SHA256 : " . $empreinte;

Ce code lit le fichier morceau par morceau, sans le charger en entier en mémoire.
C’est la méthode recommandée pour les fichiers volumineux, notamment dans les systèmes de sauvegarde ou les applications de transfert sécurisé.

Empreinte SHA256 : vérification et sécurité

Jusqu’ici, nous avons abordé le hachage comme un moyen de vérifier l’intégrité.
Mais le SHA256 joue un rôle plus large dans la sécurité des données.

En effet, dans le monde de la cryptographie, le SHA256 n’est pas seulement un outil de contrôle. Il constitue aussi la base de nombreux mécanismes comme les signatures numériques, les certificats SSL, et les blockchains.

Lorsqu’un site web affiche une empreinte SHA256 pour un fichier, cela permet de :

• garantir que le fichier n’a pas été modifié ;
• prouver que le fichier vient bien de l’auteur indiqué ;
• éviter l’exécution de logiciels falsifiés.

Cependant, il faut comprendre que le SHA256 seul ne garantit pas l’authenticité, uniquement l’intégrité. Si un pirate remplace à la fois le fichier et l’empreinte publiée, la vérification échouera à détecter la fraude. C’est pour cette raison que les éditeurs de logiciels utilisent souvent une signature numérique (clé publique/clé privée) pour compléter le processus.

Vérifier l’intégrité d’un fichier uploadé sur votre site

Un autre usage fréquent du SHA256 en PHP concerne la vérification d’intégrité des fichiers uploadés par les utilisateurs. Par exemple, si vos utilisateurs envoient des documents, vous pouvez calculer une empreinte au moment du dépôt et la comparer à une valeur stockée en base de données.

<?php
if (isset($_FILES['fichier'])) {
    $nomTemp = $_FILES['fichier']['tmp_name'];
    $empreinte = hash_file('sha256', $nomTemp);

    echo "Empreinte du fichier envoyé : " . $empreinte;

    // Exemple : stockage en base
    // $pdo->prepare("INSERT INTO uploads (filename, sha256) VALUES (?, ?)")
    //     ->execute([$_FILES['fichier']['name'], $empreinte]);
}

Cette méthode vous permet de détecter les doublons, les modifications, ou même de vérifier l’origine d’un fichier en cas de contestation. C’est un outil simple mais très puissant pour renforcer la confiance dans vos échanges de fichiers.

Erreurs fréquentes à éviter

Même si la fonction hash_file() semble simple, certaines erreurs sont fréquentes lorsqu’on débute :

1. Comparer des empreintes mal formatées.
   Assurez-vous que les deux empreintes (attendue et calculée) sont bien en minuscules et sans espaces.
2. Oublier de vérifier la lecture du fichier.
   Si hash_file() ne trouve pas le fichier ou ne peut pas le lire, elle renverra false. Il faut donc toujours tester le retour avant comparaison.
3. Confondre empreinte et chiffrement.
   Le SHA256 ne chiffre rien. Il crée un résumé unique du contenu, mais ne permet pas de récupérer les données d’origine.
4. Publier uniquement l’empreinte sans signature.
   Comme expliqué plus haut, une empreinte seule ne suffit pas à garantir que le fichier vient de la bonne source. Pour un niveau de sécurité supérieur, utilisez une signature PGP ou une clé publique.
5. Ne pas vérifier les chemins de fichiers.
   Dans une application web, vérifiez toujours que le fichier à hacher se trouve dans un répertoire autorisé, pour éviter les attaques de type “path traversal”.

Utiliser SHA256 pour vérifier des données brutes (chaînes)

PHP permet aussi de calculer une empreinte SHA256 sur une chaîne de texte, et non sur un fichier. C’est très utile pour stocker ou vérifier des données sensibles.

Exemple :

<?php
$texte = "Créa-Troyes est une superbe plateforme d’apprentissage !";
$hash = hash('sha256', $texte);

echo "Empreinte SHA256 du texte : " . $hash;

Ce code renverra une empreinte unique correspondant exactement à cette phrase.
Si un seul mot change, l’empreinte changera entièrement. C’est ce principe qui est utilisé pour stocker des mots de passe de manière sécurisée (avec un sel en plus, via password_hash()).

SHA256 et validation côté serveur

Une application PHP peut également comparer l’empreinte d’un fichier côté serveur à une empreinte envoyée par le client. C’est par exemple le cas lorsqu’une application web envoie un fichier et son empreinte SHA256 à une API pour vérification.

<?php
// Données reçues depuis un client
$fichier = $_FILES['upload']['tmp_name'];
$empreinte_client = $_POST['sha256'];

// Calcul local
$empreinte_serveur = hash_file('sha256', $fichier);

// Vérification
if ($empreinte_serveur === $empreinte_client) {
    echo "Fichier reçu sans altération.";
} else {
    echo "Erreur : le fichier a été modifié pendant le transfert.";
}

C’est une excellente manière de sécuriser les transferts dans des contextes où les fichiers transitent par plusieurs serveurs ou applications intermédiaires.

Quelques mots sur les autres algorithmes disponibles

PHP ne se limite pas à SHA256. Vous pouvez utiliser hash_algos() pour afficher la liste complète des algorithmes disponibles sur votre serveur :

<?php
print_r(hash_algos());

Cela affichera une liste de fonctions comme md5, sha1, sha256, sha512, ripemd160, etc. Mais en pratique, pour toute vérification d’intégrité sérieuse, le SHA256 reste le meilleur compromis entre rapidité et sécurité.

Bonnes pratiques pour vos projets PHP

Pour conclure la partie technique, voici quelques recommandations simples qui amélioreront la fiabilité de vos vérifications :

• Stockez toujours les empreintes attendues dans un format sûr (base de données ou fichier protégé).
• Comparez les empreintes avec l’opérateur === pour éviter les conversions automatiques de type.
• Nettoyez les chemins des fichiers avant de les traiter pour éviter les injections.
• Si possible, associez la vérification SHA256 à une signature numérique ou à un certificat SSL.
• Pour les fichiers sensibles, conservez un historique des empreintes sur plusieurs versions, afin de retracer les modifications.

Au-delà de SHA256

Vous savez désormais comment vérifier l’intégrité d’un fichier grâce à une empreinte SHA256, et comment le faire efficacement en PHP. Mais ce n’est que le début d’un vaste domaine qu’est la cryptographie appliquée.

Le SHA256 n’est pas un simple outil de hachage : c’est l’un des piliers des systèmes modernes de sécurité numérique. Il garantit la fiabilité des transferts de fichiers, la cohérence des sauvegardes, et participe activement à la confiance entre utilisateurs et serveurs.

Dans les prochains volets de ce grand tutoriel consacré à la cryptographie, nous explorerons les signatures numériques, les clés publiques et privées, ainsi que la vérification d’authenticité à travers des exemples concrets en PHP.

Vous verrez comment ces outils se combinent pour construire une architecture solide, capable de protéger vos applications et vos utilisateurs contre les altérations et les falsifications.

En comprenant et en maîtrisant les empreintes SHA256, vous posez la première pierre d’une pratique de développement web plus sûre, plus professionnelle et plus responsable.

Chapitre 8. OpenSSL et Signature

Alban

Fondateur de l’agence Créa-troyes.
Intervenant en Freelance.
Contactez-moi

crea-troyes.fr