Hachage et intégrité des données

Vous avez déjà rencontré le hachage sans y prêter attention : l'empreinte SHA-256 comparée au moment de télécharger Kali, les « hachages » de mots de passe dans le fichier /etc/shadow… Derrière ces usages se cache un outil mathématique simple dans son principe et précieux dans ses applications. Cette leçon ouvre le chapitre sur la cryptographie appliquée, sans mathématiques compliquées.

Dans les chapitres précédents, la cryptographie est apparue plusieurs fois comme une promesse (« HTTPS chiffre les échanges », « le mot de passe n'est pas stocké en clair »). Il est temps de comprendre ce qui se cache derrière, en commençant par le concept le plus utilisé : la fonction de hachage.

Qu'est-ce qu'une fonction de hachage ?

Une fonction de hachage prend n'importe quelle donnée (un mot, un document, un film de plusieurs gigaoctets) et produit une empreinte de taille fixe : une suite de caractères hexadécimaux qui sert d'identifiant de la donnée. Avec SHA-256, l'empreinte fait toujours 256 bits, soit 64 caractères hexadécimaux, que l'entrée fasse un octet ou un téraoctet.

L'analogie la plus parlante est l'empreinte digitale : elle identifie une personne sans permettre de la reconstituer. De la même façon, l'empreinte d'un fichier l'identifie, mais on ne peut pas retrouver le fichier à partir de son empreinte.

Les propriétés qui font sa valeur

• Déterministe : la même entrée donne toujours la même empreinte.
• Rapide à calculer pour n'importe quelle entrée.
• À sens unique : partant de l'empreinte, il est impossible en pratique de retrouver la donnée d'origine.
• Effet d'avalanche : changer un seul caractère de l'entrée modifie complètement l'empreinte.
• Résistante aux collisions : il est impossible en pratique de trouver deux données différentes ayant la même empreinte.

Cette dernière propriété est cruciale. Une fonction dont on a trouvé des collisions n'est plus fiable pour la sécurité. C'est le cas de MD5 et de SHA-1 : ils sont considérés comme cassés pour les usages où l'on doit garantir qu'on ne peut pas fabriquer deux contenus de même empreinte (signatures, certificats). On leur préfère les fonctions de la famille SHA-2 (comme SHA-256) ou SHA-3. Vous croiserez encore MD5 pour de simples contrôles anti-erreur de transfert : il ne faut jamais s'en servir dans un contexte de sécurité.

Voir l'effet d'avalanche

Dans un terminal Linux ou macOS :

echo -n "bonjour" | sha256sum
echo -n "Bonjour" | sha256sum
echo -n "bonjour " | sha256sum

Sous macOS, remplacez sha256sum par shasum -a 256. L'option -n évite d'ajouter un retour à la ligne, qui changerait l'empreinte. Vous obtenez trois empreintes de 64 caractères complètement différentes, alors que les trois entrées ne diffèrent que d'une majuscule ou d'un espace. Aucune ressemblance entre elles ne permet de deviner que les entrées sont proches : c'est l'effet d'avalanche.

Premier usage : vérifier l'intégrité

L'intégrité signifie qu'une donnée n'a pas été modifiée, par accident (erreur de transfert, disque défectueux) ou volontairement. Le principe est simple : on calcule l'empreinte au départ, on la conserve ou la publie, et on recalcule à l'arrivée. Si les deux concordent, le fichier est identique.

sha256sum fichier.iso > empreintes.txt     # enregistrer
sha256sum -c empreintes.txt                  # vérifier plus tard

La commande -c (check) relit le fichier d'empreintes et répond « OK » ou « ÉCHEC » pour chaque fichier. C'est ainsi qu'on contrôle un téléchargement ou qu'on surveille des fichiers sensibles : les outils de détection d'intrusion sur machine calculent des empreintes de fichiers critiques et alertent quand l'une change sans raison.

Deuxième usage : stocker des mots de passe

Le fichier /etc/shadow et les bases de données des sites web ne conservent pas les mots de passe, mais leur empreinte. Quand vous vous connectez, le système hache le mot de passe saisi et compare avec l'empreinte enregistrée. Ainsi, si la base fuite, les mots de passe ne sont pas directement lisibles. Mais attention : hacher ne suffit pas, et la façon de le faire est essentielle.

Trois problèmes se posent si l'on se contente d'une fonction rapide comme SHA-256 :

1. Les mots de passe courants : un attaquant qui possède une base de données fuitée peut calculer l'empreinte de millions de mots de passe probables et les comparer. Comme la fonction est rapide, il en teste énormément par seconde.
2. Les tables précalculées (rainbow tables) : des listes d'empreintes déjà calculées permettent de retrouver instantanément des mots de passe courants.
3. Les doublons : deux utilisateurs avec le même mot de passe auraient la même empreinte, ce qui se repère aisément.

Les réponses, standard dans les systèmes sérieux :

• Le sel (salt) : une valeur aléatoire unique par utilisateur, mélangée au mot de passe avant le hachage, et stockée avec l'empreinte. Deux utilisateurs avec le même mot de passe ont des empreintes différentes, et les tables précalculées deviennent inutilisables.
• Des fonctions volontairement lentes et coûteuses, conçues pour le stockage de mots de passe : Argon2, scrypt, bcrypt ou PBKDF2. Elles rendent chaque essai très coûteux : sans impact pour un utilisateur qui se connecte une fois, mais prohibitif pour quelqu'un qui doit en tester des milliards.

Une ligne de /etc/shadow a justement cette forme : un champ commençant par $, suivi de l'identifiant de l'algorithme, du sel et de l'empreinte. Pour un développeur, la règle est simple : n'inventez jamais votre propre méthode, utilisez la fonction de hachage de mots de passe fournie par votre langage ou votre cadre applicatif. Pour un utilisateur, elle rejoint ce que vous avez appris dans le premier cours : un mot de passe long, unique et généré par un gestionnaire reste la meilleure défense, même si la base de données est volée.

Troisième usage : au cœur d'autres mécanismes

• Les signatures numériques signent l'empreinte d'un document plutôt que le document entier.
• Les certificats TLS (leçon 3) reposent sur des signatures d'empreintes.
• La détection de doublons et l'identification de fichiers : les analystes comparent l'empreinte d'un fichier à des bases de fichiers connus pour savoir s'il a déjà été vu.
• Les chaînes de blocs et les systèmes de versions (comme Git) s'appuient sur l'enchaînement d'empreintes.

À vous de jouer

1. Créez un fichier message.txt contenant une phrase. Calculez son empreinte SHA-256 et enregistrez-la dans empreintes.txt.
2. Vérifiez-la avec sha256sum -c empreintes.txt : le résultat doit être « OK ».
3. Modifiez un seul caractère du fichier et relancez la vérification. Que se passe-t-il ?
4. Comparez la longueur d'une empreinte MD5 (md5sum message.txt) à celle d'une empreinte SHA-256. Laquelle est la plus longue ?
5. Réflexion : pourquoi stocker l'empreinte dans le même dossier que le fichier ne protège-t-il pas contre un attaquant qui modifie les deux ?

Le hachage garantit qu'une donnée n'a pas changé, mais il ne la cache pas. Pour garder un contenu secret, on le chiffre. C'est l'objet de la leçon suivante.