Hachage avec SHA-256 en Cryptographie

Introduction

Bienvenue dans le monde de la cryptographie ! Dans ce laboratoire, vous acquerrez une expérience pratique avec l'un des concepts les plus fondamentaux de la sécurité moderne : le hachage cryptographique. Plus spécifiquement, nous travaillerons avec l'algorithme SHA-256.

Une fonction de hachage cryptographique est un algorithme mathématique qui prend une entrée (ou « message ») de n'importe quelle taille et produit une chaîne d'octets de taille fixe. Ce résultat est généralement un « condensat » (digest) ou un « hash ». SHA-256, par exemple, produit toujours un hash de 256 bits (32 octets).

Ces fonctions possèdent plusieurs propriétés importantes :

• Déterministe : La même entrée produira toujours la même sortie.
• À sens unique (One-way) : Il est pratiquement impossible de calculer inversement la fonction pour retrouver l'entrée originale à partir de son hash.
• Effet d'avalanche (Avalanche Effect) : Un petit changement dans l'entrée (comme modifier un seul caractère) produira un hash de sortie radicalement différent.

Tout au long de ce laboratoire, vous utiliserez l'outil en ligne de commande openssl et un script Python simple pour explorer ces propriétés et comprendre comment le hachage est utilisé dans des scénarios réels tels que la vérification de l'intégrité des fichiers et la sécurisation des mots de passe.

Propriétés de la Fonction de Hachage

Dans cette étape, vous utiliserez l'outil en ligne de commande openssl pour explorer deux propriétés fondamentales des fonctions de hachage : le déterminisme et l'effet d'avalanche. Une fonction est déterministe si la même entrée produit toujours la même sortie. L'effet d'avalanche signifie qu'un minuscule changement dans l'entrée entraîne un hash de sortie complètement différent.

Premièrement, générons un hash SHA-256 pour la chaîne "hello". Nous utiliserons la commande echo pour transmettre la chaîne à openssl.

echo -n "hello" | openssl dgst -sha256

L'option -n dans echo est importante ; elle empêche echo d'ajouter un caractère de nouvelle ligne à la fin de la chaîne, ce qui modifierait le hash résultant.

Vous devriez voir un résultat similaire à ceci :

SHA2-256(stdin)= 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824

Maintenant, exécutons exactement la même commande à nouveau pour démontrer la propriété déterministe.

echo -n "hello" | openssl dgst -sha256

Remarquez que la sortie est identique. Cela confirme que pour la même entrée, le hash SHA-256 est toujours le même.

SHA2-256(stdin)= 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824

Ensuite, démontrons l'effet d'avalanche. Nous allons apporter un changement très minime à notre chaîne d'entrée — en changeant "hello" en "Hello" (avec un 'H' majuscule).

echo -n "Hello" | openssl dgst -sha256

Observez le nouveau hash :

SHA2-256(stdin)= 185f8db32271fe25f561a6fc938b2e264306ec304eda518007d1764826381969

Comparez ce hash à celui de "hello". Même si un seul bit de l'entrée a été modifié (la casse de la première lettre), le hash résultant est complètement différent. C'est l'effet d'avalanche en action et c'est une caractéristique essentielle pour une fonction de hachage sécurisée.

Calculer le Hachage d'un Fichier

Dans cette étape, vous allez calculer le hash SHA-256 d'un fichier texte. C'est une pratique courante utilisée pour vérifier l'intégrité des fichiers. Lorsque vous téléchargez un fichier depuis Internet, les sites web fournissent souvent une somme de contrôle (un hash) afin que vous puissiez vérifier que le fichier n'a pas été corrompu pendant le téléchargement ou falsifié.

Le script de configuration pour ce laboratoire a déjà créé un fichier nommé message.txt dans votre répertoire actuel (~/project). Premièrement, visualisons son contenu à l'aide de la commande cat.

cat message.txt

Vous verrez le contenu suivant :

This is a secret message.

Maintenant, calculons le hash SHA-256 de ce fichier. La syntaxe est similaire à celle que vous avez utilisée précédemment, mais au lieu de rediriger l'entrée (piping), vous fournissez le nom du fichier comme argument à la commande openssl dgst.

openssl dgst -sha256 message.txt

La commande traitera le fichier et affichera son hash SHA-256. La sortie ressemblera à ceci :

SHA2-256(message.txt)= 6432f513cfd40d47c8584494c0524468257e50dc1a0422f73becac85189543f8

Ce hash sert d'empreinte numérique unique pour le contenu actuel de message.txt. Si quelqu'un modifie ne serait-ce qu'un seul caractère dans le fichier, le hash changera complètement, comme vous le verrez dans une étape ultérieure.

Générer Plusieurs Hachages

Dans cette étape, vous pratiquerez davantage la génération de hashes SHA-256 pour différentes entrées textuelles (strings). Cela renforcera votre compréhension de la manière dont toute entrée unique produit un hash unique. Nous continuerons à utiliser la commande echo -n redirigée vers openssl pour nous assurer que nous ne hachons que la chaîne elle-même, sans aucun caractère supplémentaire.

Premièrement, générons le hash pour la chaîne "labex".

echo -n "labex" | openssl dgst -sha256

La sortie sera le hash SHA-256 pour "labex" :

SHA2-256(stdin)= 679e75b679886c5eaf8aaab88ddfc0181e6dae14cff346db8ba398bd7b2e31fe

Ensuite, essayons une chaîne différente, "crypto", pour voir son hash unique.

echo -n "crypto" | openssl dgst -sha256

Comme prévu, cela produit un hash complètement différent :

SHA2-256(stdin)= da2f073e06f78938166f247273729dfe465bf7e46105c13ce7cc651047bf0ca4

Cet exercice démontre que chaque donnée distincte, quelle que soit sa taille, possède sa propre valeur de hash unique. Cette propriété est fondamentale pour l'utilisation des hashes dans la vérification des données, les technologies de blockchain et les signatures numériques.

Démontrer la Résistance aux Collisions

Dans cette étape, vous observerez directement l'effet d'avalanche et le concept de résistance aux collisions en modifiant légèrement le fichier message.txt et en voyant comment son hash change. La résistance aux collisions signifie qu'il est extrêmement difficile de trouver deux entrées différentes qui produisent le même hash.

Premièrement, recalculons le hash du fichier original message.txt pour l'avoir frais à l'esprit.

openssl dgst -sha256 message.txt

Vous devriez revoir le hash original :

SHA2-256(message.txt)= 6432f513cfd40d47c8584494c0524468257e50dc1a0422f73becac85189543f8

Maintenant, effectuons un changement très minime dans le fichier. Nous allons ajouter un seul point . à la fin du fichier. Nous pouvons le faire facilement en utilisant la commande echo avec l'opérateur de redirection >>, qui ajoute la sortie à un fichier.

echo "." >> message.txt

Vous pouvez vérifier que le changement a été effectué en visualisant à nouveau le contenu du fichier.

cat message.txt

Vous verrez le point à la fin :

This is a secret message.
.

Maintenant, recalculons le hash du fichier modifié.

openssl dgst -sha256 message.txt

Le nouveau hash sera :

SHA2-256(message.txt)= 4106e1c985a4ee1754fff76b8bffda0c4844679885cb70758f24cd43e771daac

Comparez ce nouveau hash avec l'original. Ils sont complètement différents. Cette démonstration puissante montre qu'un changement d'un seul caractère dans un fichier entraînera un hash radicalement différent, ce qui facilite la détection de toute forme de falsification.

Créer un Hachage de Mot de Passe

Dans cette étape, vous allez dépasser l'invite de commande (command line) et écrire un script Python simple pour hacher un mot de passe. Stocker les mots de passe en texte clair est une vulnérabilité de sécurité majeure. La pratique standard consiste à stocker un hash du mot de passe à la place. Lorsqu'un utilisateur tente de se connecter, le système hache le mot de passe qu'il a saisi et le compare au hash stocké.

Le script de configuration a déjà créé un fichier vide nommé hash_password.py. Vous allez maintenant y ajouter du code en utilisant l'éditeur de texte nano.

Ouvrez le fichier avec nano :

nano hash_password.py

Maintenant, copiez et collez le code Python suivant dans l'éditeur nano :

import hashlib

## The password we want to hash
password = "mysecretpassword"

## Hash functions in Python work on bytes, not strings.
## We must encode the string into bytes first, using UTF-8.
password_bytes = password.encode('utf-8')

## Create a new SHA-256 hash object.
sha256_hash = hashlib.sha256(password_bytes)

## Get the hexadecimal representation of the hash.
hex_digest = sha256_hash.hexdigest()

print(f"The password is: {password}")
print(f"The SHA-256 hash is: {hex_digest}")

Ce script effectue les actions suivantes :

1. Importe la bibliothèque hashlib, qui fournit divers algorithmes de hachage.
2. Définit une chaîne de mot de passe.
3. Encode la chaîne en octets (bytes) en utilisant .encode('utf-8'). C'est une étape cruciale, car les fonctions de hachage opèrent sur des octets.
4. Crée un objet de hachage SHA-256 et le met à jour avec les octets du mot de passe.
5. Récupère le hash final dans un format hexadécimal lisible en utilisant .hexdigest().

Après avoir collé le code, enregistrez le fichier et quittez nano en appuyant sur Ctrl+X, puis Y, et enfin Enter.

Enfin, exécutez votre script Python depuis le terminal :

python3 hash_password.py

Le script s'exécutera et affichera le mot de passe ainsi que son hash SHA-256 correspondant :

The password is: mysecretpassword
The SHA-256 hash is: 94aefb8be78b2b7c344d11d1ba8a79ef087eceb19150881f69460b8772753263

Vous avez réussi à utiliser Python pour effectuer un hachage cryptographique, une compétence essentielle pour le développement d'applications sécurisées.

Résumé

Félicitations pour avoir terminé ce laboratoire ! Vous avez acquis une expérience pratique et concrète avec la fonction de hachage cryptographique SHA-256.

Dans ce laboratoire, vous avez appris :

• Les propriétés fondamentales des fonctions de hachage : elles sont déterministes, à sens unique (one-way) et présentent l'effet d'avalanche.
• Comment utiliser la commande openssl dgst -sha256 dans un environnement Linux pour calculer les hashes des chaînes de caractères et des fichiers.
• L'importance du hachage pour vérifier l'intégrité des fichiers et détecter toute falsification.
• Comment utiliser la bibliothèque hashlib de Python pour générer par programmation des hashes SHA-256, une tâche courante dans la sécurité des mots de passe.

Le hachage est une pierre angulaire de la cybersécurité moderne. Les compétences que vous avez pratiquées ici sont fondamentales pour comprendre des sujets plus avancés tels que les signatures numériques, les codes d'authentification de message (MACs) et la technologie blockchain. Comme prochaine étape, vous pourriez rechercher le concept de "salage" (salting) des mots de passe, qui ajoute une couche de sécurité supplémentaire au-dessus du hachage.