Le chiffrement RSA est largement utilisé dans divers domaines de la sécurité
informatique.
1. Navigateurs web (HTTPS / TLS) – RSA est utilisé dans le protocole TLS/SSL pour
sécuriser les communications entre les navigateurs (Chrome, Firefox, Edge, etc.) et les
sites web en HTTPS. Il permet d’établir une connexion sécurisée en chiffrant la clé de
session échangée.
2. VPN (Réseaux Privés Virtuels) – De nombreux VPN utilisent RSA pour
l'authentification et l'échange sécurisé de clés de chiffrement symétrique, notamment
dans les protocoles OpenVPN et IPsec.
3. Emails sécurisés (PGP/GPG) – Le chiffrement PGP (Pretty Good Privacy) et GPG
(GNU Privacy Guard) utilisent RSA pour sécuriser les emails et les fichiers en
garantissant l'authenticité et la confidentialité.
4. Cartes à puce et tokens d’authentification – Les cartes bancaires, cartes d’identité
électroniques et tokens matériels (ex : YubiKey) utilisent RSA pour signer et
authentifier les utilisateurs de manière sécurisée.
5. Cryptocurrencies et Blockchain – Certaines blockchains, comme Bitcoin et
Ethereum, utilisent RSA pour la gestion des signatures numériques et l’authentification
des transactions (bien que d'autres systèmes comme ECDSA soient aussi courants).
RSA reste un des algorithmes fondamentaux en cryptographie moderne, bien qu’il soit parfois
remplacé par des méthodes plus rapides comme ECC (Elliptic Curve Cryptography).
Exemple :
Réponse :
Méthode 01 :
Méthode 02 :
Code python :
import random
import math
def egcd(a, b):
"""Algorithme d'Euclide étendu pour trouver l'inverse modulaire."""
if a == 0:
return b, 0, 1
else:
g, x, y = egcd(b % a, a)
return g, y - (b // a) * x, x
def modinv(a, m):
"""Trouve l'inverse modulaire de a modulo m."""
g, x, y = egcd(a, m)
if g != 1:
raise Exception
else:
return x % m
def is_prime(n):
"""Teste si un nombre est premier."""
if n < 2:
return False
for i in range(2, int([Link](n)) + 1):
if n % i == 0:
return False
return True
def generate_keypair():
"""Génère une paire de clés RSA avec des petits nombres premiers."""
p = 3 # Nombre premier
q = 11 # Nombre premier
n = p * q
phi = (p - 1) * (q - 1)
e = 3 # Exposant public (choisi petit pour la simplicité)
d = modinv(e, phi) # Calcul de l'exposant privé
return ((e, n), (d, n))
def encrypt(message, public_key):
"""Chiffre un message (nombre) avec la clé publique."""
e, n = public_key
return (message ** e) % n
def decrypt(ciphertext, private_key):
"""Déchiffre un message chiffré avec la clé privée."""
d, n = private_key
return (ciphertext ** d) % n
# Génération des clés
public_key, private_key = generate_keypair()
print("Clé publique:", public_key)
print("Clé privée:", private_key)
# Chiffrement
message = 5 # Un nombre simple à chiffrer
ciphertext = encrypt(message, public_key)
print("Message chiffré:", ciphertext)
# Déchiffrement
decrypted_message = decrypt(ciphertext, private_key)
print("Message déchiffré:", decrypted_message)
TP
Objectif du TP :
Simuler le chiffrement et déchiffrement d'un message de session HTTPS avec RSA.
Comprendre comment une clé de session est sécurisée avant son utilisation dans le protocole
TLS/SSL.
1️. RSA sert à sécuriser les communications HTTPS/TLS en chiffrant une clé de session.
NB :
Une clé de session est une clé temporaire utilisée pour chiffrer les données échangées entre un client
(navigateur) et un serveur en HTTPS. Elle est générée à chaque connexion et est chiffrée avec RSA pour
être transmise en toute sécurité.
2️. Dans ce TP, un serveur génère une clé de session aléatoire (128 bits) utilisée pour chiffrer
les données.
3️. Cette clé de session est chiffrée avec RSA avant d’être envoyée pour garantir qu’aucun
attaquant ne puisse la lire.
4️. Le destinataire (navigateur ou serveur) déchiffre la clé de session avec la clé privée RSA,
retrouvant ainsi la clé originale.
5️. Ensuite, cette clé est utilisée pour chiffrer la communication avec un algorithme
symétrique rapide (AES, ChaCha20, etc.).
• RSA est utilisé pour échanger en toute sécurité la clé de session entre le client et le
serveur, grâce à son chiffrement asymétrique (clé publique et privée).
• Une fois la clé de session échangée en toute sécurité avec RSA, des algorithmes
symétriques (comme AES ou ChaCha20) sont utilisés pour chiffrer et déchiffrer les
données réelles échangées, car ils sont plus rapides et efficaces que RSA pour de
grandes quantités de données.
RSA protège donc la clé de session, et l'algorithme symétrique protège les données.
Matériel requis :
• Python 3
• Bibliothèque cryptography (si besoin)
Plan du TP :
1. Générer une paire de clés RSA (clé publique & clé privée).
2. Simuler un serveur HTTPS générant une clé de session.
3. Chiffrer la clé de session avec RSA (comme dans TLS).
4. Déchiffrer la clé de session et afficher le résultat.
Etapes :
1. Le serveur génère une clé RSA (clé publique + clé privée).
2. Une clé de session HTTPS (128 bits) est créée.
3. Cette clé de session est chiffrée avec RSA (comme dans TLS).
4. Le client (ou serveur) la déchiffre pour l'utiliser en toute sécurité.
Résultat attendu :
Clé de session originale: a1b2c3d4e5f67890abcdef1234567890
Clé de session chiffrée: 5f3c8d4e7f...
Clé de session déchiffrée: a1b2c3d4e5f67890abcdef1234567890
La clé de session a été correctement chiffrée et déchiffrée !
Ce TP montre comment RSA protège une clé de session dans HTTPS
Simulation HTTPS dans un vrai navigateur
Quand on visite un site en HTTPS, voici ce qui se passe en arrière-plan :
Étape 1 : Demande de connexion (Hello)
1. Client (navigateur) envoie une requête de connexion au serveur (par exemple,
[Link]
2. Le serveur répond avec un certificat SSL/TLS qui contient la clé publique RSA du
serveur. Ce certificat est émis par une autorité de certification (CA) reconnue.
Étape 2 : Vérification du certificat
3. Le navigateur vérifie que le certificat SSL/TLS est valide et qu'il appartient bien au
serveur qu'il veut rejoindre. Si tout est valide, il passe à l'étape suivante.
Étape 3 : Génération et échange de la clé de session (RSA)
4. Client génère une clé de session symétrique aléatoire (généralement 128 bits).
5. Client chiffre cette clé avec la clé publique RSA du serveur (qui a été reçue dans le
certificat SSL/TLS) et l'envoie au serveur.
Étape 4 : Déchiffrement de la clé de session (RSA)
6. Serveur utilise sa clé privée RSA pour déchiffrer la clé de session et peut maintenant
l'utiliser pour chiffrer et déchiffrer les données envoyées entre le client et lui.
Étape 5 : Communication sécurisée (Symétrique)
7. Client et serveur utilisent désormais la clé de session pour échanger des données
chiffrées avec un algorithme symétrique rapide (comme AES).
8. Le navigateur et le serveur échangent des informations de manière sécurisée grâce à
cette clé de session, assurant la confidentialité et l'intégrité des données.
Illustrer avec un Exemple Simulé entre 2 Personnes
Imaginons deux personnes, Alice (le client) et Bob (le serveur), qui veulent échanger des
messages de manière sécurisée.
1. Alice envoie à Bob un message initial, indiquant qu'elle veut établir une communication
sécurisée. Bob lui envoie son certificat avec sa clé publique RSA.
2. Alice génère une clé de session (un nombre aléatoire), puis utilise la clé publique RSA
de Bob pour chiffrer cette clé de session et l'envoie à Bob.
3. Bob utilise sa clé privée RSA pour déchiffrer la clé de session et ainsi obtenir la clé
secrète partagée entre Alice et Bob.
4. Maintenant, Alice et Bob utilisent cette clé de session pour échanger des messages
chiffrés, assurant que personne d'autre ne puisse les lire (les données sont chiffrées avec
un algorithme symétrique comme AES).
Comment Observer Cela sur un Navigateur
Si on veut observer ce processus sur un vrai navigateur :
Étapes à suivre dans un navigateur comme Chrome ou Firefox :
1. Accède à un site HTTPS (par exemple, [Link]
2. Clique sur le cadenas à gauche de l'URL pour afficher les informations de sécurité.
3. Consulte le certificat SSL du site, où tu pourras voir la clé publique du serveur et les
informations sur l'autorité de certification qui a validé ce certificat.
4. Les échanges de la clé de session ne sont pas visibles directement, mais ils se produisent
en arrière-plan lors de l'établissement de la connexion sécurisée.
Principe général du chiffrement hybride (RSA + AES)
Sur le web (HTTPS et applications sécurisées), on utilise deux types de chiffrement ensemble
pour garantir à la fois sécurité et rapidité :
• RSA (chiffrement asymétrique) : Sécurise une petite quantité de données (comme une
clé secrète).
• AES (chiffrement symétrique) : Chiffre les vraies données avec une clé secrète.
L'idée principale est la suivante :
1. On génère une clé AES (clé secrète aléatoire).
2. On chiffre cette clé AES avec RSA (clé publique).
3. On envoie la clé AES chiffrée au serveur.
4. Le serveur déchiffre la clé AES avec RSA (clé privée).
5. Le serveur utilise AES pour chiffrer/déchiffrer les vraies données.
Pourquoi ce système ?
• RSA est trop lent pour chiffrer de gros fichiers.
• AES est rapide, mais il faut partager la clé secrète en toute sécurité.
• On combine les deux pour profiter de leurs avantages !
Exemple :
1. Navigateur :
Génère une clé AES pour chiffrer les données.
Chiffre la clé AES avec la clé publique RSA.
Envoie les données chiffrées + la clé AES chiffrée au serveur.
2. Serveur :
Déchiffre la clé AES avec sa clé privée RSA.
Déchiffre les données avec AES.
