Kit cyber - Chapitre 9 : Hachage des mots de passe

Au départ, les mots de passe étaient souvent stockés directement dans des fichiers ou bases de données. Cela signifiait que toute personne qui y accédait pouvait lire directement la liste complète des mots de passe des utilisateurs. Ce mode de stockage représentait un risque énorme : une fuite suffisait à compromettre la sécurité de milliers de comptes.

Pour pallier ce problème, les informaticiens ont mis au point une méthode consistant à transformer les mots de passe en une suite de caractères incompréhensible : c’est le hachage. Le principe est ancien, et s’inspire de techniques cryptographiques utilisées dès les débuts de l’informatique moderne, dans les années 1970.

Un mot de passe n’est donc plus stocké tel quel : il passe à travers une fonction mathématique dite de hachage, qui produit toujours la même « empreinte » (hash) unique pour une entrée donnée. Par exemple, le mot « bonjour » sera toujours transformé en la même empreinte (une longue chaîne de chiffres et de lettres), mais il est quasiment impossible de retrouver directement le mot original à partir de cette empreinte.
Aujourd’hui, le hachage est devenu la norme dans la cybersécurité. Il ne s’agit plus seulement de cacher les mots de passe, mais de rendre leur récupération extrêmement difficile, même en cas de fuite de données.

Un algorithme de hachage transforme une donnée (ici un mot de passe) en une empreinte de longueur fixe — une chaîne de caractères apparemment aléatoire. Plusieurs caractéristiques importantes définissent la qualité et l’usage d’un bon algorithme de hachage :

• Déterminisme : une même entrée donne toujours la même empreinte. Ainsi, si on hache “monMotDePasse”, on obtiendra systématiquement la même chaîne de sortie.
• Taille de sortie fixe : quelle que soit la longueur du mot de passe d’entrée, l’empreinte produite a toujours la même longueur (par ex. 256 bits pour SHA-256). Cela facilite le stockage et la comparaison.
• Fonction à sens unique (préimage difficile) : on doit pouvoir calculer facilement l’empreinte à partir de l’entrée, mais il doit être pratiquement impossible de retrouver l’entrée originelle à partir de l’empreinte seule. C’est ce qu’on appelle la résistance à la préimage.
• Résistance à la seconde préimage : il doit être extrêmement difficile de trouver, pour un message donné, un autre message différent qui produise la même empreinte.
• Résistance aux collisions : une collision se produit lorsque deux entrées différentes donnent la même empreinte. Un bon algorithme rend ces collisions très rares et difficilement trouvables. (Attention : pour tout algorithme de hachage de longueur finie, des collisions existent en théorie, mais la sécurité repose sur la difficulté pratique de les trouver.)
• Effet avalanche : un petit changement dans l’entrée (changer une lettre, une majuscule) doit provoquer un changement massif et apparemment aléatoire dans l’empreinte. Cela empêche d’inférer l’entrée à partir de la sortie.

Le but de cet exercice va être de modifier le programme de la carte émettrice, afin que le mot de passe ne soit plus envoyé en clair, mais que seule son empreinte (hash) soit échangée et sauvegardée. Le coffre-fort devra ensuite comparer le mot de passe haché reçu par radio à l’empreinte stockée : s’ils correspondent, il ouvre le verrou.
La première étape de l'exercice consiste à implémenter une fonction de hachage. Cette fonction doit prendre en paramètre le message que l'on veut hacher (ici les mots de passe), et renvoyer une autre chaîne de caractères, le hash (empreinte) du message. 

Cette fonction va donc devoir transformer le message d'entrée en empreinte, tout en respectant les aspects vus plus haut :

1. Choisir une graine de départ : On initialise une variable h (la future empreinte), avec une valeur non nulle, appelée graine (seed). En effet, si on commençait à zéro, certains calculs seraient trop prévisibles. La graine sert donc à initialiser le mélange et à rendre le résultat moins prévisible.
2. Convertir chaque caractère en nombre : Pour traiter le message, on transforme chaque lettre en nombre unique. Pour cela, on utilise la fonction Python ord, qui donne l'ordinal de la lettre, c'est-à-dire un numéro unique pour chaque caractère (son code dans la table utilisée par l’ordinateur). Pour utiliser la fonction ord, il faut, dans la section Python de l’interface, encapsuler la lettre à convertir en nombre par ord : par exemple : ord(c), avec c le caractère que l’on veut convertir.
3. Mélanger avec addition : On ajoute la valeur numérique de la lettre au hash courant. Cela permet d'injecter l'information de la lettre dans le calcul, en modifiant h.
4. Diffuser avec multiplication : On multiplie le résultat par un nombre fixe, de préférence grand et "bizarre" (un nombre premier par exemple : 37). Cette multiplication permet de mieux diffuser le hash, c'est-à-dire qu'un petit changement dans le message va produire une variation plus importante dans le hash. Il s'agit d'une première étape de l'effet avalanche.
5. Réduire avec modulo : On applique un modulo (le reste de la division euclidienne) pour limiter la taille du résultat. Par exemple, effectuer un modulo 100000000 permet de garder uniquement 8 chiffres. Cette étape est cruciale, car elle permet de perdre de l'information, et ainsi de rendre beaucoup plus difficile l'inversion du hash vers le message d'origine.
   

Si tu es bloqué :

• Vérifie que tu appelles exactement la même fonction de hachage pour le mot de passe enregistré dans le coffre-fort et pour le mot de passe reçu par radio.
• Assure-toi que tu compares bien hash_reçu avec hash_stocké, et non un hash avec le mot de passe en clair

Le nouveau programme de la carte coffre-fort va être exactement le même que celui du chapitre 7. Seulement, on ne va pas stocker le mot de passe, mais son hash. De cette manière, la carte coffre-fort compare non plus le mot de passe reçu à celui stocké, mais elle compare le hash reçu au hash stocké. Ainsi, même si les données de la carte coffre-fort fuitent, le mot de passe n’est pas révélé.


Si tu es bloqué :

• Affiche l’empreinte du mot de passe de la carte émettrice, copie-le et mets-le à la place du mot de passe en clair dans le programme de la carte coffre-fort.

Téléverse les programmes de ce chapitre sur la carte coffre-fort et la carte émettrice. Choisis un mot de passe, calcule et stocke son empreinte dans le coffre-fort, puis envoie ce mot de passe haché depuis la carte émettrice : le servomoteur doit s’ouvrir. Si tu reprends le programme de la carte émettrice du chapitre 7, et que tu envoies le mot de passe en clair et non son empreinte, le coffre-fort ne s’ouvre plus, car le coffre-fort ne connaît que l’empreinte, pas le mot de passe original.

Grâce à cette expérience, on comprend que :

• le coffre ne connaît pas le mot de passe, seulement son empreinte (le hash) ;
• cela permet de limiter les risques si le contenu du coffre fuit ;
• mais attention : sans protection supplémentaire, comme le salage (non abordé ici), il est assez facile de retrouver le mot de passe original en testant toutes les combinaisons jusqu’à tomber sur la bonne empreinte.

Pour aller plus loin :

• Chercher les mots-clés « hachage de mot de passe », « SHA-256 » ou « bcrypt » pour découvrir des algorithmes réellement utilisés dans les services en ligne.
• Se renseigner sur le salage (salting) et son impact sur les attaques brute-force