Les programmeurs Python utilisent le hachage pour transformer les données d’entrée en une valeur de taille fixe. Cette valeur représente les données de manière unique, et la technique de hachage facilite la transmission et le stockage de diverses formes de données en toute sécurité.
Le hachage protège les données contre l’accès non autorisé et la falsification. Il s’agit d’un ingrédient essentiel dans les cas d’utilisation de l’intégrité et de la sécurité des données.
Cet article explore tout ce que vous devez savoir sur le hachage dans Python. Il se penche sur les utilisations du hachage et met en évidence les différents algorithmes de hachage qui rendent votre code plus efficace, plus sûr et plus fiable.
Qu’est-ce que le hachage dans Python ?
Le hachage convertit les données d’entrée, telles qu’une chaîne de caractères, un fichier ou un objet, en une chaîne d’octets de taille fixe. Le hachage ou le condensé représente l’entrée de manière unique et reproductible.
Le hachage joue un rôle important dans la détection des manipulations de données et le renforcement de la sécurité. Il permet de calculer une valeur de hachage pour un fichier, un message ou tout autre élément de données. Une application stocke le hachage en toute sécurité afin de vérifier ultérieurement que les données n’ont pas été altérées.
L’une des utilisations les plus courantes du hachage en matière de sécurité est le stockage des mots de passe. Le hachage est une alternative viable au stockage des mots de passe en texte clair dans une base de données. Lorsqu’un utilisateur saisit son mot de passe, le système le hache avant de le stocker dans la base de données. Si un pirate accède à la base de données, il constatera que le mot de passe est difficile à voler.
Les fonctions de hachage de Python rendent tout cela possible. Ces fonctions mathématiques permettent à une application de manipuler des données sous forme de valeurs de hachage.
Comment créer une fonction de hachage efficace
Pour être efficace et sûre, une fonction de hachage doit répondre aux critères suivants :
- Déterministe – Pour une même entrée, la fonction doit toujours renvoyer la même sortie.
- Efficace – La fonction doit être efficace en termes de calcul lorsqu’elle calcule la valeur de hachage d’une entrée donnée.
- Résistante aux collisions – La fonction doit minimiser le risque que deux entrées produisent la même valeur de hachage.
- Uniforme – Les résultats de la fonction doivent être répartis uniformément dans l’ensemble des valeurs de hachage possibles.
- Non inversable – Il est peu probable qu’un ordinateur puisse calculer la valeur d’entrée de la fonction à partir de la valeur de hachage.
- Non prévisible – Il doit être difficile de prédire les résultats de la fonction à partir d’un ensemble d’entrées.
- Sensible aux modifications des données d’entrée – La fonction doit être sensible aux différences mineures des données d’entrée. De légères modifications doivent entraîner une grande différence dans la valeur de hachage obtenue.
Cas d’utilisation du hachage
Une fois que vous disposez d’une fonction de hachage adéquate présentant toutes ces caractéristiques, vous pouvez l’appliquer à différents cas d’utilisation. Les fonctions de hachage fonctionnent bien pour :
- Stockage des mots de passe – Le hachage est l’une des meilleures façons de stocker les mots de passe des utilisateurs dans les systèmes modernes. Python combine plusieurs modules pour hacher et sécuriser les mots de passe avant de les stocker dans une base de données.
- Mise en cache – Le hachage stocke la sortie d’une fonction pour gagner du temps lors d’un appel ultérieur.
- Récupération de données – Python utilise une table de hachage avec une structure de données dictionnaire intégrée pour récupérer rapidement des valeurs par clé.
- Signatures numériques – Le hachage peut vérifier l’authenticité des messages comportant des signatures numériques.
- Vérifications de l’intégrité des fichiers – Le hachage peut vérifier l’intégrité d’un fichier lors de son transfert et de son téléchargement.
Fonction de hachage intégrée à Python
La fonction de hachage intégrée de Python, hash(), renvoie une valeur entière représentant l’objet d’entrée. Le code utilise ensuite la valeur de hachage obtenue pour déterminer l’emplacement de l’objet dans la table de hachage. Cette table de hachage est une structure de données qui met en œuvre des dictionnaires et des ensembles.
Le code ci-dessous illustre le fonctionnement de la fonction hash():
my_string = "hello world"
# Calculate the hash value of the string
hash_value = hash(my_string)
# Print the string and its hash value
print("String: ", my_string)
print("Hash value: ", hash_value)Si nous enregistrons ce code dans un fichier nommé hash.py, nous pouvons l’exécuter (et voir la sortie) comme suit :
% python3 hash.py
String: hello world
Hash value: 2213812294562653681Exécutons-le à nouveau :
% python3 hash.py
String: hello world
Hash value: -631897764808734609La valeur de hachage est différente lorsqu’elle est invoquée une deuxième fois parce que les versions récentes de Python (versions 3.3 et supérieures) appliquent par défaut une graine de hachage aléatoire pour cette fonction. La graine change à chaque invocation de Python. Au sein d’une même instance, les résultats seront identiques.
Par exemple, plaçons ce code dans notre fichier hash.py:
my_string = "hello world"
# Calculate 2 hash values of the string
hash_value1 = hash(my_string)
hash_value2 = hash(my_string)
# Print the string and its hash values
print("String: ", my_string)
print("Hash value 1: ", hash_value1)
print("Hash value 2: ", hash_value2)Lorsqu’il est exécuté, nous obtenons quelque chose comme ceci :
String: hello world
Hash value 1: -7779434013116951864
Hash value 2: -7779434013116951864Limites du hachage
Bien que la fonction de hachage de Python soit prometteuse pour divers cas d’utilisation, ses limites la rendent inadaptée à des fins de sécurité. Voici comment :
- Attaques par collision – Une collision se produit lorsque deux entrées différentes produisent la même valeur de hachage. Un pirate pourrait utiliser la même méthode pour contourner les mesures de sécurité qui reposent sur les valeurs de hachage pour l’authentification ou les contrôles d’intégrité des données.
- Taille d’entrée limitée – Étant donné que les fonctions de hachage produisent une sortie de taille fixe quelle que soit la taille de l’entrée, une entrée de taille supérieure à la sortie de la fonction de hachage peut provoquer une collision.
- Prévisibilité – Une fonction de hachage doit être déterministe, c’est-à-dire qu’elle doit produire le même résultat chaque fois que vous fournissez la même entrée. Les attaquants peuvent tirer parti de cette faiblesse en compilant à l’avance les valeurs de hachage pour de nombreuses entrées, puis en les comparant aux valeurs de hachage de la cible pour trouver une correspondance. Ce processus est appelé attaque « rainbow table ».
Pour prévenir les attaques et assurer la sécurité de vos données, utilisez des algorithmes de hachage sécurisés conçus pour résister à de telles vulnérabilités.
Utilisation de hashlib pour le hachage sécurisé en Python
Au lieu d’utiliser la version intégrée de Python hash(), utilisez hashlib pour un hachage plus sûr. Ce module Python offre une variété d’algorithmes de hachage pour hacher les données en toute sécurité. Ces algorithmes comprennent MD5, SHA-1 et la famille plus sécurisée SHA-2, y compris SHA-256, SHA-384, SHA-512, et d’autres.
MD5
L’algorithme cryptographique MD5, largement utilisé, révèle une valeur de hachage de 128 bits. Utilisez le code ci-dessous pour générer un hachage MD5 à l’aide du constructeur md5 de la hashlib:
import hashlib
text = "Hello World"
hash_object = hashlib.md5(text.encode())
print(hash_object.hexdigest())La sortie du code ci-dessus (dans notre fichier hash.py ) sera cohérente d’une invocation à l’autre :
b10a8db164e0754105b7a99be72e3fe5
Remarque : la méthode hexdigest() dans le code ci-dessus renvoie le hachage dans un format hexadécimal sûr pour toute présentation non binaire (comme le courrier électronique).
SHA-1
La fonction de hachage SHA-1 sécurise les données en créant une valeur de hachage de 160 bits. Utilisez le code ci-dessous avec le constructeur sha1 pour le hachage SHA-1 du module hashlib:
import hashlib
text = "Hello World"
hash_object = hashlib.sha1(text.encode())
print(hash_object.hexdigest())La sortie du code ci-dessus :
0a4d55a8d778e5022fab701977c5d840bbc486d0
SHA-256
Il existe plusieurs options de hachage dans la famille SHA-2. Le constructeur de hashlib SHA-256 génère une version plus sûre de cette famille avec une valeur de hachage de 256 bits.
Les programmeurs utilisent souvent SHA-256 pour la cryptographie, comme les signatures numériques ou les codes d’authentification des messages. Le code ci-dessous montre comment générer un hachage SHA-256 :
import hashlib
text = "Hello World"
hash_object = hashlib.sha256(text.encode())
print(hash_object.hexdigest())La sortie du code ci-dessus :
a591a6d40bf420404a011733cfb7b190d62c65bf0bcda32b57b277d9ad9f146e
SHA-384
SHA-384 est une valeur de hachage de 384 bits. Les programmeurs utilisent souvent la fonction SHA-384 dans les applications nécessitant une plus grande sécurité des données.
Sur la base des exemples précédents, vous pouvez probablement deviner qu’il s’agit d’une instruction qui génère un hachage SHA-384 :
hash_object = hashlib.sha384(text.encode())SHA-512
SHA-512 est le membre le plus sûr de la famille SHA-2. Il produit une valeur de hachage de 512 bits. Les programmeurs l’utilisent pour des applications à haut débit, telles que la vérification de l’intégrité des données. Le code ci-dessous montre comment générer un hachage SHA-512 avec le module hashlib de Python :
hash_object = hashlib.sha512(text.encode())Comment choisir un algorithme de hachage
Étant donné que ces algorithmes diffèrent, choisissez votre algorithme de hachage en fonction de votre cas d’utilisation et de ses exigences en matière de sécurité. Voici quelques étapes à suivre :
- Comprendre le cas d’ utilisation – Votre cas d’utilisation détermine le type d’algorithme à utiliser. Par exemple, lorsque vous stockez des données sensibles telles que des mots de passe, votre algorithme de hachage doit vous protéger contre les attaques par force brute.
- Tenez compte de vos exigences de sécurité – Les exigences de sécurité de votre cas d’utilisation dépendent du type de données que vous avez l’intention de stocker et déterminent le type d’algorithme à choisir. Par exemple, un algorithme de hachage robuste est préférable pour le stockage d’informations très sensibles.
- Recherchez les algorithmes de hachage disponibles – Explorez chaque type de hachage pour comprendre ses forces et ses faiblesses. Ces informations vous aideront à sélectionner la meilleure option pour votre cas d’utilisation.
- Évaluez l’algorithme de hachage sélectionné – Une fois que vous avez choisi un algorithme de hachage, évaluez s’il répond à vos exigences de sécurité. Ce processus peut impliquer de le tester contre des attaques ou des vulnérabilités connues.
- Mettre en œuvre et tester l’algorithme de hachage – Enfin, mettez en œuvre et testez l’algorithme de manière approfondie pour vous assurer qu’il fonctionne correctement et en toute sécurité.
Comment utiliser le hachage pour le stockage des mots de passe
Le hachage présente un excellent potentiel pour le stockage des mots de passe, un élément essentiel de la cybersécurité.
Idéalement, l’application hache et stocke les mots de passe dans une base de données sécurisée afin d’empêcher les accès non autorisés et les violations de données. Cependant, le hachage seul peut ne pas suffire à protéger les informations. Les mots de passe hachés restent sensibles aux attaques par force brute et par dictionnaire. Les pirates utilisent couramment ces pratiques pour deviner les mots de passe et obtenir un accès non autorisé aux comptes.
Une façon plus sûre d’utiliser le hachage pour le stockage des mots de passe consiste à utiliser la technique du salage. Le salage consiste à ajouter des chaînes ou des caractères uniques et aléatoires à chaque mot de passe avant de le hacher. Le sel est propre à chaque mot de passe et l’application le stocke avec le mot de passe haché dans la base de données.
Chaque fois qu’un utilisateur se connecte, l’application récupère le sel dans la base de données, l’ajoute au mot de passe saisi et procède ensuite au hachage de la combinaison du sel et du mot de passe.
Si un pirate accède à la base de données, il doit calculer le hachage pour chaque mot de passe et chaque valeur de sel possible. Le salage rend ces attaques plus complexes, c’est donc une technique utile pour décourager les attaques par dictionnaire.
Le module secrets de Python facilite le salage. Ce module génère des sels aléatoires, stocke les mots de passe en toute sécurité et gère les jetons et les clés cryptographiques.
Le code ci-dessous utilise la bibliothèque hashlib et le module secrets pour sécuriser davantage les mots de passe des utilisateurs :
import hashlib
import secrets
# Generate a random salt using the secrets module
salt = secrets.token_hex(16)
# Get the user's password from input
password = input("Enter your password: ")
# Hash the password using the salt and the SHA-256 algorithm
hash_object = hashlib.sha256((password + salt).encode())
# Get the hexadecimal representation of the hash
hash_hex = hash_object.hexdigest()
# Store the salt and hash_hex in your databaseComment utiliser le hachage pour vérifier l’intégrité des données
Le hachage permet également de vérifier l’intégrité des données et de protéger les données transmises contre la modification et l’altération. Cette technique en quatre étapes utilise une fonction de hachage cryptographique pour donner au fichier une valeur de hachage unique.
Tout d’abord, sélectionnez la fonction de hachage appropriée et utilisez-la pour générer une valeur de hachage pour les données d’entrée. Stockez cette valeur de hachage, puis utilisez-la à des fins de comparaison en cas de besoin. Lorsque vous devez vérifier l’intégrité des données, l’application génère la valeur de hachage des données actuelles à l’aide de la même fonction de hachage. Ensuite, l’application compare la nouvelle valeur de hachage à la valeur stockée pour s’assurer qu’elles sont identiques. Si c’est le cas, les données ne sont pas corrompues.
La valeur hachée est unique, et même un changement minime dans les données d’entrée déclenche une valeur de hachage sensiblement différente. Il est donc facile de détecter tout changement ou modification non autorisé des données transmises.
Les étapes ci-dessous illustrent l’utilisation d’une fonction de hachage pour les contrôles d’intégrité des données.
Étape 1 : Importer le module hashlib
import hashlibÉtape 2 : Utiliser un algorithme de hachage hashlib
def generate_hash(file_path):
# Open the file in binary mode
with open(file_path, "rb") as f:
# Read the contents of the file
contents = f.read()
# Generate the SHA-256 hash of the contents
hash_object = hashlib.sha256(contents)
# Return the hexadecimal representation of the hash
return hash_object.hexdigest()Étape 3 : Appeler la fonction et passer le chemin d’accès au fichier
file_path = "path/to/my/file.txt"
hash_value = generate_hash(file_path)
print(hash_value)Étape 4 : Générer des hachages pour le fichier original et le fichier transmis ou modifié
# Generate the hash of the original file
original_file_path = "path/to/my/file.txt"
original_file_hash = generate_hash(original_file_path)
# Transmit or modify the file (for example, by copying it to a different location)
transmitted_file_path = "path/to/transmitted/file.txt"
# Generate the hash of the transmitted file
transmitted_file_hash = generate_hash(transmitted_file_path)Étape 5 : Comparer les deux hachages
if original_file_hash == transmitted_file_hash:
print("The file has not been tampered with")
else:
print("The file has been tampered with")Résumé
Le hachage est un outil précieux pour l’intégrité des données et la sécurité des mots de passe. Vous tirez le meilleur parti d’une fonction de hachage lorsque vous mettez en œuvre des techniques de hachage sécurisées, telles que l’utilisation du module hashlib et le salage.
Ces techniques permettent d’éviter les attaques rainbow, les attaques par collision et d’autres failles de sécurité affectant le hachage. Les programmeurs utilisent souvent ces techniques avec les fonctions de hachage en Python pour garantir l’intégrité des données des fichiers et stocker les mots de passe en toute sécurité.
Maintenant que vous en savez plus sur les techniques de hachage en Python, utilisez-les pour améliorer la sécurité de votre propre application. Explorez d’autres articles sur Python sur le blog de Kinsta pour développer votre expertise, puis envisagez de déployer votre prochaine application Python sur la plateforme d’hébergement d’applications de Kinsta.
Steve Bonisteel est un rédacteur technique chez Kinsta qui a commencé sa carrière d'écrivain en tant que journaliste de presse écrite, chassant les ambulances et les camions de pompiers. Il couvre les technologies similaires à l'Internet depuis la fin des années 1990.
Laisser un commentaire