Pour sécuriser les données en Python, un chiffrement efficace est essentiel. Dans cet article, nous allons expliquer en détail comment utiliser la bibliothèque cryptography, une puissante bibliothèque de chiffrement pour Python, en abordant à la fois les méthodes de chiffrement de base et les exemples d’applications avancées. Nous expliquerons étape par étape, de manière claire, même pour les débutants, et fournirons des exercices pratiques pour aider à renforcer votre compréhension, vous permettant ainsi d’appliquer ces concepts dans vos projets réels. À travers cet article, vous apprendrez les bases de la sécurité des données et acquerrez des compétences pratiques.
Installation de la bibliothèque cryptography
La première étape pour effectuer des opérations de chiffrement en Python est d’installer la bibliothèque cryptography. Voici comment l’installer facilement.
Préparer l’environnement
Assurez-vous que Python est installé et que l’outil de gestion des packages nécessaire (pip) est également installé.
Vérification de l’installation de Python
Exécutez la commande suivante dans le terminal ou l’invite de commande pour vérifier si Python est installé :
python --versionVérification de l’installation de pip
Exécutez la commande suivante pour vérifier si pip est installé :
pip --versionInstallation de la bibliothèque cryptography
Installez la bibliothèque cryptography en utilisant pip avec la commande suivante dans le terminal ou l’invite de commande :
pip install cryptographyVérification de l’installation
Pour vérifier si l’installation a réussi, ouvrez l’interpréteur Python et exécutez la commande suivante :
import cryptography
print(cryptography.__version__)Si l’installation a réussi, le numéro de version de la bibliothèque sera affiché. Vous avez maintenant installé cryptography.
Les bases du chiffrement symétrique
Le chiffrement symétrique utilise la même clé pour le chiffrement et le déchiffrement des données. Nous allons voir ici comment utiliser la bibliothèque cryptography pour implémenter le chiffrement symétrique.
Qu’est-ce que le chiffrement symétrique ?
Le chiffrement symétrique utilise une clé unique pour chiffrer et déchiffrer les données. La gestion de cette clé est donc essentielle. Un exemple classique de chiffrement symétrique est l’AES (Advanced Encryption Standard).
Chiffrement et déchiffrement avec AES
Voici comment chiffrer et déchiffrer des données à l’aide d’AES, étape par étape.
Importation des modules nécessaires
Commencez par importer les modules nécessaires de la bibliothèque cryptography.
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.primitives import padding
from cryptography.hazmat.backends import default_backend
import osGénération de la clé et du vecteur d’initialisation
AES nécessite une clé et un vecteur d’initialisation (IV). Nous allons générer ces éléments.
key = os.urandom(32) # Clé de 256 bits
iv = os.urandom(16) # Vecteur d'initialisation de 128 bitsAjout de padding aux données
Les données doivent être multiples de la taille du bloc. Nous allons donc ajouter un padding pour les adapter.
def pad(data):
padder = padding.PKCS7(algorithms.AES.block_size).padder()
return padder.update(data) + padder.finalize()Chiffrement des données
Maintenant, nous allons chiffrer les données.
def encrypt(data, key, iv):
cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
encryptor = cipher.encryptor()
padded_data = pad(data)
return encryptor.update(padded_data) + encryptor.finalize()Déchiffrement des données
Nous allons maintenant déchiffrer les données chiffrées.
def decrypt(encrypted_data, key, iv):
cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
decryptor = cipher.decryptor()
padded_data = decryptor.update(encrypted_data) + decryptor.finalize()
unpadder = padding.PKCS7(algorithms.AES.block_size).unpadder()
return unpadder.update(padded_data) + unpadder.finalize()Exemple d’utilisation réelle
Voici un exemple dans lequel des données en clair sont chiffrées, puis déchiffrées pour retrouver les données originales.
data = b"Voici un message secret"
encrypted_data = encrypt(data, key, iv)
print("Données chiffrées :", encrypted_data)
decrypted_data = decrypt(encrypted_data, key, iv)
print("Données déchiffrées :", decrypted_data.decode())De cette manière, vous pouvez implémenter un chiffrement symétrique avec la bibliothèque cryptography et protéger vos données.
Les bases du chiffrement asymétrique
Le chiffrement asymétrique utilise une paire de clés, une clé publique et une clé privée, pour le chiffrement et le déchiffrement. Dans cette section, nous allons voir comment utiliser la bibliothèque cryptography pour le chiffrement asymétrique.
Qu’est-ce que le chiffrement asymétrique ?
Le chiffrement asymétrique utilise deux clés distinctes : une clé publique pour le chiffrement et une clé privée pour le déchiffrement. Cela permet un échange sécurisé des données. Un exemple classique de chiffrement asymétrique est RSA (Rivest-Shamir-Adleman).
Chiffrement et déchiffrement avec RSA
Voici comment chiffrer et déchiffrer des données à l’aide de RSA.
Importation des modules nécessaires
Commencez par importer les modules nécessaires de la bibliothèque cryptography.
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serialization, hashes
from cryptography.hazmat.primitives.asymmetric import paddingGénération de la paire de clés
Générez une paire de clés publique et privée pour RSA.
private_key = rsa.generate_private_key(
public_exponent=65537,
key_size=2048,
)
public_key = private_key.public_key()Sauvegarde et lecture des clés
Voici comment sauvegarder et lire les clés publiques et privées.
# Sauvegarde de la clé privée
private_pem = private_key.private_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PrivateFormat.TraditionalOpenSSL,
encryption_algorithm=serialization.NoEncryption()
)
# Sauvegarde de la clé publique
public_pem = public_key.public_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PublicFormat.SubjectPublicKeyInfo
)
# Lecture des clés
loaded_private_key = serialization.load_pem_private_key(private_pem, password=None)
loaded_public_key = serialization.load_pem_public_key(public_pem)Chiffrement
Chiffrez les données en utilisant la clé publique.
def encrypt(data, public_key):
return public_key.encrypt(
data,
padding.OAEP(
mgf=padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None
)
)Déchiffrement
Utilisez la clé privée pour déchiffrer les données chiffrées.
def decrypt(encrypted_data, private_key):
return private_key.decrypt(
encrypted_data,
padding.OAEP(
mgf=padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None
)
)Exemple d’utilisation réelle
Voici un exemple dans lequel des données en clair sont chiffrées, puis déchiffrées pour retrouver les données originales.
data = b"Voici un message secret"
encrypted_data = encrypt(data, public_key)
print("Données chiffrées :", encrypted_data)
decrypted_data = decrypt(encrypted_data, private_key)
print("Données déchiffrées :", decrypted_data.decode())Grâce à cette méthode, vous pouvez utiliser la bibliothèque cryptography pour implémenter un chiffrement asymétrique, et échanger des données de manière sécurisée.
Les bases du hachage
Le hachage consiste à transformer des données en une valeur de hachage de longueur fixe. Cette valeur est unidirectionnelle, ce qui signifie que les données d’origine ne peuvent pas être récupérées. Nous allons voir ici comment utiliser la bibliothèque cryptography pour le hachage.
Qu’est-ce que le hachage ?
Le hachage est utilisé pour vérifier l’intégrité des données et pour stocker les mots de passe. Un exemple de fonction de hachage couramment utilisée est SHA-256 (Secure Hash Algorithm 256 bits).
Hachage avec SHA-256
Voici comment utiliser SHA-256 pour hacher des données.
Importation des modules nécessaires
Commencez par importer les modules nécessaires pour le hachage.
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.backends import default_backendHachage des données
Utilisez l’algorithme SHA-256 pour hacher les données.
def hash_data(data):
digest = hashes.Hash(hashes.SHA256(), backend=default_backend())
digest.update(data)
return digest.finalize()Exemple d’utilisation réelle
Voici un exemple où des données en clair sont hachées et où nous affichons la valeur de hachage.
data = b"Voici les données à hacher"
hashed_data = hash_data(data)
print("Données hachées :", hashed_data.hex())Utilisation de la valeur de hachage
Les valeurs de hachage peuvent être utilisées pour vérifier l’intégrité des données. Par exemple, après le téléchargement d’un fichier, vous pouvez comparer la valeur de hachage pour vous assurer que les données n’ont pas été altérées.
# Exemple de calcul de la valeur de hachage d'un fichier
def hash_file(file_path):
digest = hashes.Hash(hashes.SHA256(), backend=default_backend())
with open(file_path, 'rb') as f:
while chunk := f.read(8192):
digest.update(chunk)
return digest.finalize()
# Calcul de la valeur de hachage du fichier et affichage
file_path = 'path/to/your/file'
file_hash = hash_file(file_path)
print("Valeur de hachage du fichier :", file_hash.hex())De cette manière, vous pouvez utiliser la bibliothèque cryptography pour hacher les données et vérifier leur intégrité. Le hachage joue un rôle crucial dans le stockage sécurisé des mots de passe et dans la vérification de l’intégrité des données.
Génération des clés privée et publique
La génération d’une paire de clés privée et publique est une étape importante dans le chiffrement asymétrique. Dans cette section, nous expliquons comment générer une paire de clés avec la bibliothèque cryptography et comment les sauvegarder et les lire.
Génération d’une paire de clés RSA
Nous allons utiliser l’algorithme RSA pour générer une paire de clés publique et privée.
Importation des modules nécessaires
Commencez par importer les modules nécessaires pour générer les clés.
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serializationGénération de la paire de clés
Générez une paire de clés avec l’algorithme RSA.
private_key = rsa.generate_private_key(
public_exponent=65537,
key_size=2048,
)
public_key = private_key.public_key()Sauvegarde des clés
Sauvegardez les clés générées dans des fichiers séparés.
# Sauvegarde de la clé privée
with open("private_key.pem", "wb") as private_file:
private_file.write(private_key.private_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PrivateFormat.TraditionalOpenSSL,
encryption_algorithm=serialization.NoEncryption()
))
# Sauvegarde de la clé publique
with open("public_key.pem", "wb") as public_file:
public_file.write(public_key.public_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PublicFormat.SubjectPublicKeyInfo
))Lecture des clés
Lisez les clés à partir des fichiers sauvegardés.
# Lecture de la clé privée
with open("private_key.pem", "rb") as private_file:
loaded_private_key = serialization.load_pem_private_key(
private_file.read(),
password=None,
)
# Lecture de la clé publique
with open("public_key.pem", "rb") as public_file:
loaded_public_key = serialization.load_pem_public_key(
public_file.read()
)Exemple d’utilisation réelle
Voici un exemple qui utilise la paire de clés pour chiffrer et déchiffrer des données.
from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.primitives import hashes
# Chiffrement des données
def encrypt(data, public_key):
return public_key.encrypt(
data,
padding.OAEP(
mgf=padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None
)
)
# Déchiffrement des données
def decrypt(encrypted_data, private_key):
return private_key.decrypt(
encrypted_data,
padding.OAEP(
mgf=padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None
)
)
# Exemple de chiffrement et de déchiffrement
data = b"Voici un message secret"
encrypted_data = encrypt(data, loaded_public_key)
print("Données chiffrées :", encrypted_data)
decrypted_data = decrypt(encrypted_data, loaded_private_key)
print("Données déchiffrées :", decrypted_data.decode())De cette manière, vous pouvez utiliser la bibliothèque cryptography pour générer des paires de clés privées et publiques et les utiliser pour sécuriser les données dans vos projets.
Applications pratiques du chiffrement et du déchiffrement
Nous allons maintenant vous montrer comment utiliser cryptography pour le chiffrement et le déchiffrement dans un contexte de projet réel. Nous allons explorer des exemples d’utilisation du chiffrement symétrique (AES) et du chiffrement asymétrique (RSA).
Chiffrement et déchiffrement avec le chiffrement symétrique
Importation des modules nécessaires
Commencez par importer les modules nécessaires pour le chiffrement symétrique.
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.primitives import padding
from cryptography.hazmat.backends import default_backend
import osGénération de la clé et du vecteur d’initialisation
Générez la clé et le vecteur d’initialisation pour AES.
key = os.urandom(32) # Clé de 256 bits
iv = os.urandom(16) # Vecteur d'initialisation de 128 bitsAjout de padding aux données
Ajoutez un padding aux données pour les adapter à la taille du bloc.
def pad(data):
padder = padding.PKCS7(algorithms.AES.block_size).padder()
return padder.update(data) + padder.finalize()Chiffrement des données
Chiffrez les données après leur avoir ajouté le padding.
def encrypt(data, key, iv):
cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
encryptor = cipher.encryptor()
padded_data = pad(data)
return encryptor.update(padded_data) + encryptor.finalize()Déchiffrement des données
Déchiffrez les données et enlevez le padding.
def decrypt(encrypted_data, key, iv):
cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
decryptor = cipher.decryptor()
padded_data = decryptor.update(encrypted_data) + decryptor.finalize()
unpadder = padding.PKCS7(algorithms.AES.block_size).unpadder()
return unpadder.update(padded_data) + unpadder.finalize()Exemple d’utilisation réelle
Voici un exemple où des données en clair sont chiffrées et déchiffrées pour revenir aux données originales.
data = b"Voici un message secret"
encrypted_data = encrypt(data, key, iv)
print("Données chiffrées :", encrypted_data)
decrypted_data = decrypt(encrypted_data, key, iv)
print("Données déchiffrées :", decrypted_data.decode())Chiffrement et déchiffrement avec le chiffrement asymétrique
Importation des modules nécessaires
Ensuite, nous allons importer les modules nécessaires pour le chiffrement asymétrique.
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serialization, hashes
from cryptography.hazmat.primitives.asymmetric import paddingGénération de la paire de clés
Générez une paire de clés avec RSA.
private_key = rsa.generate_private_key(
public_exponent=65537,
key_size=2048,
)
public_key = private_key.public_key()Chiffrement des données
Chiffrez les données en utilisant la clé publique.
def encrypt(data, public_key):
return public_key.encrypt(
data,
padding.OAEP(
mgf=padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None
)
)Déchiffrement des données
Déchiffrez les données avec la clé privée.
def decrypt(encrypted_data, private_key):
return private_key.decrypt(
encrypted_data,
padding.OAEP(
mgf=padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None
)
)Exemple d’utilisation réelle
Voici un exemple où des données en clair sont chiffrées et déchiffrées pour revenir aux données originales.
data = b"Voici un message secret"
encrypted_data = encrypt(data, public_key)
print("Données chiffrées :", encrypted_data)
decrypted_data = decrypt(encrypted_data, private_key)
print("Données déchiffrées :", decrypted_data.decode())Grâce à cette méthode, vous pouvez utiliser la bibliothèque cryptography pour implémenter le chiffrement asymétrique dans vos projets et garantir des communications sécurisées.
Résumé
Dans cet article, nous avons exploré en détail les techniques de chiffrement avec la bibliothèque cryptography de Python. Nous avons vu les concepts fondamentaux du chiffrement symétrique, du chiffrement asymétrique et du hachage, ainsi que des exemples pratiques pour vous aider à appliquer ces connaissances dans vos projets. En maîtrisant ces techniques, vous serez en mesure de renforcer la sécurité de vos données et de vos projets. Utilisez la bibliothèque cryptography pour mettre en œuvre des mesures de sécurité fiables et protéger vos données de manière optimale.
Exemples avancés et exercices
Dans cette section, nous allons présenter des exemples avancés d’utilisation de la bibliothèque cryptography et des exercices pratiques pour approfondir votre compréhension des techniques de chiffrement.
Exemple 1 : Application de chat chiffrée
Nous allons montrer un exemple d’application de chat qui permet d’échanger des messages chiffrés de manière sécurisée.
Chiffrement et déchiffrement des messages
Dans cette application de chat, nous devons chiffrer les messages avant de les envoyer et les déchiffrer lorsqu’ils sont reçus.
# Chiffrement du message
def encrypt_message(message, public_key):
return encrypt(message.encode(), public_key)
# Déchiffrement du message
def decrypt_message(encrypted_message, private_key):
return decrypt(encrypted_message, private_key).decode()
# Exemple d'utilisation
message = "Bonjour, voici un message secret"
encrypted_message = encrypt_message(message, public_key)
print("Message chiffré :", encrypted_message)
decrypted_message = decrypt_message(encrypted_message, private_key)
print("Message déchiffré :", decrypted_message)Exemple 2 : Système de partage de fichiers sécurisé
Nous allons maintenant voir un exemple de système de partage de fichiers sécurisé où les fichiers sont chiffrés avant d’être partagés et déchiffrés par le destinataire.
Chiffrement et déchiffrement des fichiers
Avant de partager un fichier, il faut le chiffrer. Le destinataire peut alors le déchiffrer pour accéder au contenu original.
# Chiffrement du fichier
def encrypt_file(file_path, key, iv):
with open(file_path, 'rb') as file:
file_data = file.read()
encrypted_data = encrypt(file_data, key, iv)
with open(file_path + '.enc', 'wb') as file:
file.write(encrypted_data)
# Déchiffrement du fichier
def decrypt_file(encrypted_file_path, key, iv):
with open(encrypted_file_path, 'rb') as file:
encrypted_data = file.read()
decrypted_data = decrypt(encrypted_data, key, iv)
with open(encrypted_file_path.replace('.enc', ''), 'wb') as file:
file.write(decrypted_data)
# Exemple d'utilisation
encrypt_file('document_partagé.pdf', key, iv)
decrypt_file('document_partagé.pdf.enc', key, iv)Exercice 1 : Système de gestion de mots de passe avec chiffrement symétrique
Dans cet exercice, vous allez implémenter un système de gestion de mots de passe sécurisé, où les mots de passe sont chiffrés avant d’être stockés et peuvent être déchiffrés lorsque nécessaire.
- Créez une fonction qui prend un mot de passe utilisateur et le chiffre avec AES.
- Enregistrez le mot de passe chiffré et créez une fonction pour le déchiffrer lorsque cela est nécessaire.
Exercice 2 : Système de message sécurisé avec chiffrement asymétrique
Dans cet exercice, vous allez implémenter un système de message sécurisé où les messages sont chiffrés avec une clé publique et déchiffrés avec la clé privée correspondante.
- Générez une paire de clés publique et privée RSA.
- Créez une fonction pour chiffrer un message avec la clé publique.
- Créez une fonction pour déchiffrer un message chiffré avec la clé privée.
Exercice 3 : Détection de modifications de fichiers avec hachage
Dans cet exercice, vous allez implémenter un système de détection des modifications de fichiers en utilisant la fonction de hachage SHA-256.
- Créez une fonction pour calculer la valeur de hachage d’un fichier.
- Après avoir modifié un fichier, calculez à nouveau sa valeur de hachage et vérifiez si elle a changé.
Ces exemples avancés et exercices vous aideront à maîtriser l’utilisation de la bibliothèque cryptography et à approfondir vos connaissances sur les techniques de chiffrement et de sécurité des données.
Conclusion
Dans cet article, nous avons exploré en profondeur les différentes techniques de chiffrement avec la bibliothèque cryptography de Python. Nous avons abordé le chiffrement symétrique et asymétrique, le hachage et fourni des exemples pratiques pour vous aider à les implémenter dans vos projets. En maîtrisant ces compétences, vous serez en mesure de renforcer la sécurité des données dans vos projets. L’importance de la sécurité des données ne cesse de croître et la bibliothèque cryptography vous permettra de mettre en œuvre des solutions de sécurité fiables et efficaces.