Salut, c'est Nico de Code Garage.
Code Garage, qu'est-ce que c'est ? C'est un site de ressources et de formation pour
les développeurs et développeuses qui veulent passer de juniors à experts en continuant
d'apprendre tous les jours.
Aujourd'hui, dans ce nouvel épisode du podcast, on va parler du hachage.
Grossièrement, le hachage, ça consiste à faire passer une donnée d'une taille arbitraire
dans une fonction qui va la transformer en une donnée d'une taille définie.
Ça peut être pour des mots de passe par exemple.
La taille de sortie est souvent plus grande que l'entrée.
Contrairement au chiffrement, une fonction de hachage est destructive, ou on parle aussi
de unilatéral, parce qu'on perd de la donnée d'origine.
Il est impossible de revenir en arrière après une fonction de hachage.
Si on simplifie le concept et qu'on prend une fonction de hachage théorique la plus
simple possible, on va dire que notre fonction prend une chaîne de caractères en entrée
et retourne sa taille.
Donc ça donnerait f de x, égal à taille de la chaîne x.
Ce qui nous donne par exemple, bonjour, ça devient 7.
La chaîne password devient 8 et chien devient 5.
Alors pourquoi est-ce qu'on utilise un hachage ?
D'abord, par exemple, pour les mots de passe.
On voit bien que dans l'exemple précédent, une fois que le mot de passe est passé dans
la fonction, il n'est plus récupérable.
Donc si on le stocke dans une base de données, il est protégé puisque à partir du chiffre
7, c'est impossible de récupérer le mot bonjour.
Donc pour l'authentification, il suffira de hacher en direct le mot de passe fourni par
l'utilisateur et de comparer au hache stocké dans la base de données.
Parce que la fonction de hachage, sa première caractéristique, c'est de toujours retourner
le même hache pour la même donnée en entrée.
Mais on s'en sert aussi pour simplifier et représenter des données.
Un hach, c'est donc une présentation simplifiée d'une donnée et il existe évidemment beaucoup
d'algorithmes de hachage différents.
Mais la bonne pratique, c'est que deux haches issus de deux données quasi similaires à
quelques bits près soient entre eux très différents.
Donc par exemple, encore un exemple théorique, le hach du mot élo serait égal à A B C
D E F.
Ok ? Alors que le hach du mot help, le mot élo mais avec un P à la fin, serait égal
à Z Y X W V.
Ça, c'est un exemple purement théorique, mais c'est pour vous dire que là on a changé
simplement une seule lettre, donc très peu de bits dans la string en entrée et pourtant
le hach en sortie est très différent.
Donc ça veut dire que la comparaison entre les haches plutôt que les données d'origine
est plus optimisée parce qu'au lieu de devoir vérifier chaque lettre petit à petit et
voir que c'est la dernière lettre qui est différente, les premiers bits du hach sont
déjà différents, donc la comparaison va beaucoup plus vite.
Et par exemple dans le cas de comparaison d'un gros fichier, évidemment le hach utilisé
sera beaucoup plus petit que l'entièreté des données contenues dans le fichier.
Donc la comparaison sera plus efficace.
C'est cette technique-là qui est utilisée pour ce qu'on appelle le checksum.
On fait un hach du fichier, on vérifie que le hach du fichier qu'on a téléchargé
est bien égal à celui qui était proposé par le site.
Ça évite de se faire avoir par une attaque par exemple Manin de Middoll qui aurait remplacé
le fichier qu'on a téléchargé.
Si le hach du fichier est le même, alors on a bien le même fichier.
Alors quelles algorithmes on utilise pour ça ? Parce que vous avez compris, le problème
avec notre fonction de la chasse simplifiée c'est les collisions.
Parce qu'en l'occurrence, le hach de Bonjour qui est égal à 7, mais le hach de BZ avec
un S à la fin est aussi égal à 7.
C'est ce qu'on appelle une collision et c'est une des problématiques du hachage.
Donc en pratique, les fonctions de hachage cryptographique génèrent des haches assez
longs, parfois plus longs que la valeur d'entrée.
Par exemple, le hach du mot Bonjour avec l'algorithme Chat256, c'est égal à 2CB4B1431B845.
C'est 15, etc., etc., pendant encore pas mal de longueur.
Alors que le hach du mot BZ avec un S toujours, c'est égal à 7, 3, B, E, E, D, 7, 4, 25,
B, D, etc., etc.
Donc la complexité d'un algorithme de hachage, ça réside dans son ratio entre le temps d'exécution
et le nombre de collisions possibles.
Par exemple, la famille d'algorithmes Chat, S, H, A, est plus rapide à s'exécuter,
mais son nombre de collisions possibles est plus élevé que d'autres algorithmes
comme B-crypte par exemple.
Donc, à moins que la contente de temps d'exécution soit une grosse problématique, il est plutôt
recommandé d'utiliser l'algorithme B-crypte pour les mots de passe par exemple.
Mais il existe aussi d'autres algorithmes encore plus rapides parce que les collisions
sont moins critiques, comme le HMD5 qui est très rapide et qui permet de faire du checksum
de manière efficace.
Le checksum, j'en ai parlé, c'est pour vérifier que deux fichiers sont bien identiques.
J'espère que cet épisode vous aura été utile et que vous en aurez appelé un petit
peu plus sur le concept de base du hachage.
Si vous aimez ce podcast et que vous avez aimé l'épisode, n'hésitez pas à laisser
cinq étoiles sur votre plateforme de podcast préférée.
Ça aide au référencement du podcast et ça soutient Code Garage, donc c'est vraiment
très cool.
Sur ce, je vous dis à la semaine prochaine pour un nouvel épisode du podcast.
Salut !