Hachage sécurisé avec Python Hashlib

Ce tutoriel vous apprendra à créer des hachages sécurisés à l’aide des fonctionnalités intégrées du module hashlib de Python.

Il peut être utile de comprendre l’importance du hachage et de savoir comment calculer par programme des hachages sécurisés, même si vous ne travaillez pas dans le domaine de la sécurité des applications. Mais pourquoi ?

Lorsque vous travaillez sur des projets Python, vous rencontrez probablement des cas où vous êtes préoccupé par le stockage de mots de passe et d’autres informations sensibles dans des bases de données ou des fichiers de code source. Dans de tels cas, il est plus sûr d’exécuter l’algorithme de hachage sur les informations sensibles et de stocker le hachage au lieu de l’information.

Dans ce guide, nous verrons ce qu’est le hachage et en quoi il diffère du chiffrement. Nous examinerons également les propriétés des fonctions de hachage sécurisées. Ensuite, nous utiliserons des algorithmes de hachage courants pour calculer le hachage d’un texte en clair en Python. Pour ce faire, nous utiliserons le module intégré hashlib.

Pour tout cela et bien plus encore, commençons !

Qu’est-ce que le hachage ?

Le processus de hachage prend en compte une chaîne de messages et produit un résultat de longueur fixe appelé hachage. Cela signifie que la longueur du résultat du hachage pour un algorithme de hachage donné est fixe, quelle que soit la longueur de l’entrée. Mais quelle est la différence avec le cryptage ?

Dans le cas du cryptage, le message ou le texte en clair est crypté à l’aide d’un algorithme de cryptage qui produit un résultat crypté. Nous pouvons ensuite exécuter l’algorithme de décryptage sur le résultat crypté pour récupérer la chaîne du message.

Cependant, le hachage fonctionne différemment. Nous venons d’apprendre que le processus de cryptage est inversible, c’est-à-dire que vous pouvez passer du message crypté au message non crypté et vice versa.

Contrairement au cryptage, le hachage n’est pas un processus inversible, ce qui signifie qu’il n’est pas possible de passer du hachage au message d’entrée.

Propriétés des fonctions de hachage

Passons rapidement en revue certaines propriétés auxquelles les fonctions de hachage doivent satisfaire :

• Déterministe: les fonctions de hachage sont déterministes. Étant donné un message m, le hachage de m est toujours le même.
• Résistante à la préimage: nous avons déjà abordé ce point lorsque nous avons dit que le hachage n’est pas une opération inversible. La propriété de résistance à la préimage indique qu’il est impossible de trouver le message m à partir du hachage de sortie.
• Résistance aux collisions: il doit être difficile (ou infaisable sur le plan informatique) de trouver deux chaînes de messages différentes m1 et m2 de sorte que le hachage de m1 soit égal à celui de m2. Cette propriété est appelée résistance aux collisions.
• Deuxièmement, la résistance aux préimages: cela signifie qu’étant donné un message m1 et le hachage correspondant m2, il est impossible de trouver un autre message m2 tel que hash(m1) = hash(m2).

Le module hashlib de Python

Le module Python hashlib intégré fournit des implémentations de plusieurs algorithmes de hachage et de résumé de message, notamment les algorithmes SHA et MD5.

Pour utiliser les constructeurs et les fonctions intégrées du module Python hashlib, vous pouvez l’importer dans votre environnement de travail comme suit :

import hashlib

Le module hashlib fournit les constantes algorithms_available et algorithms_guaranteed, qui désignent l’ensemble des algorithmes dont les implémentations sont respectivement disponibles et garanties sur une plateforme.

Par conséquent, algorithmes_garantis est un sous-ensemble d'algorithmes_disponibles.

Démarrez une REPL Python, importez hashlib et accédez aux constantes algorithmes_disponibles et algorithmes_garantis:

>>> hashlib.algorithms_available

# Sortie
{'md5', 'md5-sha1', 'sha3_256', 'shake_128', 'sha384', 'sha512_256', 'sha512', 'md4', 
'shake_256', 'whirlpool', 'sha1', 'sha3_512', 'sha3_384', 'sha256', 'ripemd160', 'mdc2', 
'sha512_224', 'blake2s', 'blake2b', 'sha3_224', 'sm3', 'sha224' }

>>> hashlib.algorithms_guaranteed

# Sortie
{'md5', 'shake_256', 'sha3_256', 'shake_128', 'blake2b', 'sha3_224', 'sha3_384', 
'sha384', 'sha256', 'sha1', 'sha3_512', 'sha512', 'blake2s', 'sha224'}

Nous constatons que algorithmes_garantis est bien un sous-ensemble de algorithmes_disponibles

Créer des objets de hachage en Python

Nous allons maintenant apprendre à créer des objets de hachage en Python. Nous allons calculer le hachage SHA256 d’une chaîne de messages en utilisant les méthodes suivantes :

• Le constructeur générique new()
• Constructeurs spécifiques aux algorithmes

Utilisation du constructeur new()

Initialisons la chaîne de messages:

>>> message = "Geekflare is awesome !"

Pour instancier l’objet hash, nous pouvons utiliser le constructeur new() et passer le nom de l’algorithme comme indiqué :

>>> sha256_hash = hashlib.new("SHA256")

Nous pouvons maintenant appeler la méthode update() sur l’objet hash avec la chaîne de message comme argument :

>>> sha256_hash.update(message)

Si vous le faites, vous rencontrerez une erreur car les algorithmes de hachage ne peuvent fonctionner qu’avec des chaînes d’octets.

Traceback (dernier appel le plus récent) :
 File "<stdin>", line 1, in <module>
TypeError : Les objets Unicode doivent être encodés avant le hachage

Pour obtenir la chaîne encodée, vous pouvez appeler la méthode encode() sur la chaîne de la méthode, puis l’utiliser dans l’appel de la méthode update(). Ensuite, vous pouvez appeler la méthode hexdigest() pour obtenir le hachage sha256 correspondant à la chaîne de message.

sha256_hash.update(message.encode())
sha256_hash.hexdigest()
# Output:'b360c77de704ad8f02af963d7da9b3bb4e0da6b81fceb4c1b36723e9d6d9de3d'

Au lieu d’encoder la chaîne de messages à l’aide de la méthode encode(), vous pouvez également la définir comme une chaîne d’octets en la préfixant par b, comme suit :

message = b "Geekflare est génial !"
sha256_hash.update(message)
sha256_hash.hexdigest()
# Sortie : 'b360c77de704ad8f02af963d7da9b3bb4e0da6b81fceb4c1b36723e9d6d9de3d'

Le hachage obtenu est identique au hachage précédent, ce qui confirme la nature déterministe des fonctions de hachage.

En outre, un petit changement dans la chaîne de messages devrait entraîner une modification radicale du hachage (également connu sous le nom d’”effet d’avalanche”).

Pour le vérifier, remplaçons le “a” de “awesome” par “A” et calculons le hachage :

message = "Geekflare is Awesome !"
h1 = hashlib.new("SHA256")
h1.update(message.encode())
h1.hexdigest()
# Sortie : '3c67f334cc598912dc66464f77acb71d88cfd6c8cba8e64a7b749d093c1a53ab'

Nous constatons que le hachage change complètement.

Utilisation du constructeur spécifique à l’algorithme

Dans l’exemple précédent, nous avons utilisé le constructeur générique new() et passé “SHA256” comme nom d’algorithme pour créer l’objet de hachage.

Au lieu de cela, nous pouvons également utiliser le constructeur sha256() comme indiqué :

sha256_hash = hashlib.sha256()
message="Geekflare is awesome !"
sha256_hash.update(message.encode())
sha256_hash.hexdigest()
# Output : 'b360c77de704ad8f02af963d7da9b3bb4e0da6b81fceb4c1b36723e9d6d9de3d'

Le hachage obtenu est identique à celui que nous avons obtenu précédemment pour la chaîne de messages “Geekflare is awesome !”.

Exploration des attributs des objets de hachage

Les objets de hachage possèdent quelques attributs utiles :

• L’attribut digest_size indique la taille du condensé en octets. Par exemple, l’algorithme SHA256 renvoie un hachage de 256 bits, ce qui équivaut à 32 octets
• L’attribut block_size fait référence à la taille du bloc utilisé dans l’algorithme de hachage.
• L’attribut name est le nom de l’algorithme que nous pouvons utiliser dans le constructeur new(). La recherche de la valeur de cet attribut peut être utile lorsque les objets de hachage n’ont pas de noms descriptifs.

Nous pouvons vérifier ces attributs pour l’objet sha256_hash que nous avons créé précédemment :

>>> sha256_hash.digest_size
32
>>> sha256_hash.block_size
64
>>> sha256_hash.name
'sha256'

Voyons maintenant quelques applications intéressantes du hachage à l’aide du module hashlib de Python.

Exemples pratiques de hachage

Vérification de l’intégrité des logiciels et des fichiers

En tant que développeurs, nous téléchargeons et installons des logiciels en permanence. Cela est vrai, que vous travailliez sur une distro Linux, sur Windows ou sur Mac.

Cependant, certains miroirs de logiciels ne sont pas toujours dignes de confiance. Vous pouvez trouver le hachage (ou somme de contrôle) à côté du lien de téléchargement. Vous pouvez vérifier l’intégrité du logiciel téléchargé en calculant le hachage et en le comparant au hachage officiel.

Ce principe peut également s’appliquer aux fichiers présents sur votre machine. Même le plus petit changement dans le contenu d’un fichier modifiera radicalement le hachage. Vous pouvez vérifier si un fichier a été modifié en vérifiant le hachage.

Voici un exemple simple. Créez un fichier texte ‘mon_fichier.txt’ dans le répertoire de travail et ajoutez-y du contenu.

$ cat mon_fichier.txt
Ceci est un exemple de fichier texte.
Nous allons calculer le hachage SHA256 de ce fichier texte et également
vérifier si le fichier a été modifié en
recalculant le hachage.

Vous pouvez alors ouvrir le fichier en mode lecture binaire ('rb'), lire le contenu du fichier et calculer le hachage SHA256 comme indiqué :

>>> import hashlib
>>> with open("mon_fichier.txt", "rb") as file :
... file_contents = file.read()
... sha256_hash = hashlib.sha256()
... sha256_hash.update(file_contents)
... original_hash = sha256_hash.hexdigest()

Ici, la variable original_hash est le hachage de “mon_fichier.txt” dans son état actuel.

>>> original_hash
# Sortie : '53bfd0551dc06c4515069d1f0dc715d002d451c8799add29f3e5b7328fda9f8f'

Modifiez maintenant le fichier ‘mon_fichier.txt’. Vous pouvez supprimer l’espacement supplémentaire avant le mot “going” 🙂

Calculez à nouveau le hachage et stockez-le dans la variable computed_hash.

>>> import hashlib
>>> with open("mon_fichier.txt", "rb") as file :
... file_contents = file.read()
... sha256_hash = hashlib.sha256()
... sha256_hash.update(file_contents)
... computed_hash = sha256_hash.hexdigest()

Vous pouvez ensuite ajouter une simple instruction assert qui affirme que le computed_hash est égal au original_hash.

>>> assert computed_hash == original_hash

Si le fichier est modifié (ce qui est le cas ici), vous devriez obtenir une erreur d’assertion (AssertionError) :

Traceback (dernier appel le plus récent) :
 File "<stdin>", line 1, in <module>
AssertionError

Vous pouvez utiliser le hachage pour stocker des informations sensibles, telles que des mots de passe dans des bases de données. Vous pouvez également utiliser le hachage pour l’authentification des mots de passe lors de la connexion aux bases de données. Validez le hachage du mot de passe saisi par rapport au hachage du mot de passe correct.

Conclusion

J’espère que ce tutoriel vous a aidé à apprendre à générer des hachages sécurisés avec Python. En voici les principaux enseignements :

• Le module hashlib de Python fournit des implémentations prêtes à l’emploi de plusieurs algorithmes de hachage. Vous pouvez obtenir la liste des algorithmes garantis sur votre plateforme en utilisant hashlib.algorithms_guaranteed.
• Pour créer un objet de hachage, vous pouvez utiliser le constructeur générique new() avec la syntaxe : hashlib.new("algo-name"). Vous pouvez également utiliser les constructeurs correspondant aux algorithmes de hachage spécifiques, comme par exemple : hashlib.sha256() pour le hachage SHA 256.
• Après avoir initialisé la chaîne de message à hacher et l’objet de hachage, vous pouvez appeler la méthode update() sur l’objet de hachage, puis la méthode hexdigest() pour obtenir le hachage.
• Le hachage peut s’avérer utile pour vérifier l’intégrité des artefacts logiciels et des fichiers, pour stocker des informations sensibles dans des bases de données, etc.

Ensuite, apprenez à coder un générateur de mot de passe aléatoire en Python.