Bien sûr, je vais repartir de zéro et te guider étape par étape pour comprendre la
cryptographie de manière simple et pratique en Python. On va commencer avec les
concepts de base et avancer progressivement. Ce cours sera structuré, avec des
explications claires, des exemples pratiques et des exercices.
Leçon 1 : Introduction à la Cryptographie
La cryptographie est une méthode utilisée pour sécuriser l’information afin que seules les
personnes autorisées puissent y accéder. Elle repose sur deux types de mécanismes
principaux :
1. Cryptographie symétrique : Utilise une seule clé pour chiffrer et déchiffrer les
données.
2. Cryptographie asymétrique : Utilise une paire de clés : une clé publique pour
chiffrer et une clé privée pour déchiffrer.
Nous allons commencer avec la cryptographie symétrique.
Objectif :
• Comprendre ce que sont les clés et pourquoi elles sont nécessaires.
• Apprendre à chiffrer et déchiffrer des données avec une clé symétrique.
Leçon 2 : Cryptographie Symétrique avec AES
AES (Advanced Encryption Standard) est un algorithme de chiffrement symétrique très
utilisé pour sécuriser des données sensibles. AES prend des blocs de données et les chiffre
à l’aide d’une clé.
Étape 1 : Installer les Bibliothèques Nécessaires
Pour utiliser AES en Python, tu peux utiliser la bibliothèque pycryptodome. Si tu ne l’as pas
encore installée, voici la commande :
pip install pycryptodome
Étape 2 : Utilisation d’AES avec une clé symétrique
Nous allons utiliser une clé secrète pour chiffrer et déchiffrer des données. AES prend des
blocs de taille 128 bits (16 octets), donc il faut que le texte à chiffrer soit d’une taille qui soit
un multiple de 16. Si ce n’est pas le cas, nous devons ajouter des “données de remplissage”
(padding) pour que la taille soit correcte.
Exemple de Chiffrement avec AES en mode ECB
Le mode ECB (Electronic Codebook) est le mode le plus simple d’AES, mais il n’est pas
sécurisé pour des données répétitives. Cependant, il permet de comprendre les bases du
chiffrement.
from [Link] import AES
from [Link] import pad, unpad
import os
# Générer une clé aléatoire de 16 octets (128 bits)
key = [Link](16)
# Message à chiffrer
message = b"Bonjour le monde!" # 16 octets, taille compatible avec AES
# Créer un objet AES en mode ECB
cipher = [Link](key, AES.MODE_ECB)
# Ajouter un padding pour que la taille soit un multiple de 16
padded_message = pad(message, AES.block_size)
# Chiffrer le message
ciphertext = [Link](padded_message)
# Déchiffrer le message
decipher = [Link](key, AES.MODE_ECB)
decrypted_message = unpad([Link](ciphertext), AES.block_size)
# Afficher les résultats
print(f"Message chiffré : {ciphertext}")
print(f"Message déchiffré : {decrypted_message.decode()}")
Explications :
1. [Link](16) : Génère une clé aléatoire de 128 bits (16 octets), qui sera
utilisée pour chiffrer et déchiffrer.
2. pad() : Ajoute des données de remplissage au message pour qu’il soit un
multiple de 16 octets, la taille de bloc de AES.
3. [Link](key, AES.MODE_ECB) : Crée un objet de chiffrement AES avec la
clé et le mode ECB.
4. unpad() : Retire les données de remplissage après le déchiffrement.
Leçon 3 : La Cryptographie Asymétrique avec RSA
La cryptographie asymétrique utilise deux clés distinctes : une clé publique et une clé privée.
La clé publique sert à chiffrer, et la clé privée sert à déchiffrer.
Exemple de Chiffrement RSA en Python
Nous allons maintenant explorer le chiffrement avec RSA, un algorithme asymétrique très
populaire.
from [Link] import RSA
from [Link] import PKCS1_OAEP
import binascii
# Générer une paire de clés RSA
key = [Link](2048)
# Clé publique et privée
private_key = key
public_key = [Link]()
# Chiffrer un message avec la clé publique
cipher_rsa = PKCS1_OAEP.new(public_key)
message = b"Message secret RSA!"
ciphertext = cipher_rsa.encrypt(message)
# Déchiffrer le message avec la clé privée
decrypt_rsa = PKCS1_OAEP.new(private_key)
decrypted_data = decrypt_rsa.decrypt(ciphertext)
# Afficher les résultats
print(f"Message chiffré (RSA) : {[Link](ciphertext)}")
print(f"Message déchiffré (RSA) : {decrypted_data.decode()}")
Explications :
1. [Link](2048) : Génère une paire de clés RSA de 2048 bits.
2. PKCS1_OAEP : Un mode de remplissage sécurisé pour RSA.
3. Clé publique et privée : La clé publique est utilisée pour chiffrer, et la clé
privée pour déchiffrer.
4. [Link]() : Convertit le message chiffré en une forme lisible.
Leçon 4 : Les Fonctions de Hachage (SHA-256)
Les fonctions de hachage sont utilisées pour générer une empreinte unique d’un message.
Une fonction de hachage produit toujours une sortie de taille fixe, quel que soit la taille du
message d’entrée.
Exemple de Hachage avec SHA-256
from [Link] import SHA256
# Créer un objet SHA256
hash_object = [Link]()
# Message à hacher
message = b"Texte à hacher"
# Hacher le message
hash_object.update(message)
# Obtenir l'empreinte
hashed_data = hash_object.hexdigest()
# Afficher l'empreinte
print(f"Empreinte SHA-256 : {hashed_data}")
Explications :
1. [Link]() : Crée un nouvel objet SHA-256.
2. update() : Met à jour l’objet avec les données à hacher.
3. hexdigest() : Retourne l’empreinte sous forme de chaîne hexadécimale.
Exercice 1 :
Objectif : Implémenter un chiffrement/déchiffrement avec AES en utilisant un message de
taille variable.
1. Demander à l’utilisateur un message à chiffrer.
2. Générer une clé de 128 bits aléatoire.
3. Chiffrer le message avec AES en mode ECB.
4. Déchiffrer le message et afficher le résultat.
Corrigé :
import os
from [Link] import AES
from [Link] import pad, unpad
# Demander à l'utilisateur de saisir un message
message = input("Entrez votre message à chiffrer : ").encode()
# Générer une clé de 128 bits (16 octets)
key = [Link](16)
# Créer un objet AES en mode ECB
cipher = [Link](key, AES.MODE_ECB)
# Ajouter un padding pour que la taille soit un multiple de 16
padded_message = pad(message, AES.block_size)
# Chiffrer le message
ciphertext = [Link](padded_message)
# Déchiffrer le message
decipher = [Link](key, AES.MODE_ECB)
decrypted_message = unpad([Link](ciphertext), AES.block_size)
# Afficher les résultats
print(f"Texte chiffré : {ciphertext}")
print(f"Texte déchiffré : {decrypted_message.decode()}")
Exercice 2 :
Objectif : Utiliser RSA pour chiffrer et déchiffrer un message.
1. Générer une paire de clés RSA (2048 bits).
2. Chiffrer un message avec la clé publique.
3. Déchiffrer le message avec la clé privée.
Corrigé :
from [Link] import RSA
from [Link] import PKCS1_OAEP
import binascii
# Générer une paire de clés RSA
key = [Link](2048)
# Clé publique et privée
private_key = key
public_key = [Link]()
# Chiffrer le message
cipher_rsa = PKCS1_OAEP.new(public_key)
message = b"Message secret RSA!"
ciphertext = cipher_rsa.encrypt(message)
# Déchiffrer le message
decrypt_rsa = PKCS1_OAEP.new(private_key)
decrypted_data = decrypt_rsa.decrypt(ciphertext)
# Afficher les résultats
print(f"Texte chiffré : {[Link](ciphertext)}")
print(f"Texte déchiffré : {decrypted_data.decode()}")
Conclusion :
Ce cours t’a permis d’explorer les bases de la cryptographie en Python avec des exemples
pratiques. Tu as appris à chiffrer et déchiffrer des données avec AES (cryptographie
symétrique) et RSA (cryptographie asymétrique), ainsi qu’à utiliser des fonctions de hachage
pour vérifier l’intégrité des données.
À partir de ces bases, tu peux continuer à explorer des techniques plus avancées de
cryptographie, comme l’utilisation de clés de taille plus grande ou l’implémentation de modes
de chiffrement plus sécurisés comme CBC ou GCM.
