Exercices - Chapitre 2: Chiffrement symétrique et asymétrique

from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend
import os

def encrypt_aes_cbc(plaintext, key):
    # Assurez-vous que la clé fait 16, 24 ou 32 octets (AES-128, AES-192 ou AES-256)
    if len(key) not in [16, 24, 32]:
        raise ValueError("La clé doit faire 16, 24 ou 32 octets")
    
    # TODO: Générer un vecteur d'initialisation (IV) aléatoire de 16 octets
    iv = # À compléter
    
    # TODO: Créer le chiffreur avec l'algorithme AES, le mode CBC et l'IV
    cipher = # À compléter
    
    # TODO: Initialiser l'encryptor
    encryptor = # À compléter
    
    # Padder le texte en clair pour qu'il soit un multiple de la taille de bloc (16 octets)
    padding_length = 16 - (len(plaintext) % 16)
    padded_plaintext = plaintext + bytes([padding_length]) * padding_length
    
    # TODO: Chiffrer le texte en clair paddé
    ciphertext = # À compléter
    
    # Retourner l'IV et le texte chiffré
    return iv + ciphertext

def decrypt_aes_cbc(ciphertext, key):
    # Extraire l'IV (les 16 premiers octets)
    iv = ciphertext[:16]
    actual_ciphertext = ciphertext[16:]
    
    # TODO: Créer le chiffreur avec l'algorithme AES, le mode CBC et l'IV
    cipher = # À compléter
    
    # TODO: Initialiser le decryptor
    decryptor = # À compléter
    
    # TODO: Déchiffrer le texte
    padded_plaintext = # À compléter
    
    # Enlever le padding
    padding_length = padded_plaintext[-1]
    plaintext = padded_plaintext[:-padding_length]
    
    return plaintext

# Exemple d'utilisation
key = os.urandom(16)  # Clé aléatoire de 16 octets (AES-128)
message = b"Message secret a chiffrer avec AES"

encrypted = encrypt_aes_cbc(message, key)
decrypted = decrypt_aes_cbc(encrypted, key)

print(f"Message original: {message}")
print(f"Message déchiffré: {decrypted}")
                

Solution

Partie A : Implémentation en Python

Voici le code complété pour l'implémentation AES-CBC :

from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend
import os

def encrypt_aes_cbc(plaintext, key):
    # Assurez-vous que la clé fait 16, 24 ou 32 octets (AES-128, AES-192 ou AES-256)
    if len(key) not in [16, 24, 32]:
        raise ValueError("La clé doit faire 16, 24 ou 32 octets")
    
    # Générer un vecteur d'initialisation (IV) aléatoire de 16 octets
    iv = os.urandom(16)
    
    # Créer le chiffreur avec l'algorithme AES, le mode CBC et l'IV
    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
    
    # Initialiser l'encryptor
    encryptor = cipher.encryptor()
    
    # Padder le texte en clair pour qu'il soit un multiple de la taille de bloc (16 octets)
    padding_length = 16 - (len(plaintext) % 16)
    padded_plaintext = plaintext + bytes([padding_length]) * padding_length
    
    # Chiffrer le texte en clair paddé
    ciphertext = encryptor.update(padded_plaintext) + encryptor.finalize()
    
    # Retourner l'IV et le texte chiffré
    return iv + ciphertext

def decrypt_aes_cbc(ciphertext, key):
    # Extraire l'IV (les 16 premiers octets)
    iv = ciphertext[:16]
    actual_ciphertext = ciphertext[16:]
    
    # Créer le chiffreur avec l'algorithme AES, le mode CBC et l'IV
    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
    
    # Initialiser le decryptor
    decryptor = cipher.decryptor()
    
    # Déchiffrer le texte
    padded_plaintext = decryptor.update(actual_ciphertext) + decryptor.finalize()
    
    # Enlever le padding
    padding_length = padded_plaintext[-1]
    plaintext = padded_plaintext[:-padding_length]
    
    return plaintext

# Exemple d'utilisation
key = os.urandom(16)  # Clé aléatoire de 16 octets (AES-128)
message = b"Message secret a chiffrer avec AES"

encrypted = encrypt_aes_cbc(message, key)
decrypted = decrypt_aes_cbc(encrypted, key)

print(f"Message original: {message}")
print(f"Message déchiffré: {decrypted}")
                    

Explications :

• Nous générons un IV aléatoire de 16 octets avec os.urandom(16)
• Nous créons un objet Cipher en spécifiant l'algorithme AES, le mode CBC et l'IV
• Nous initialisons un encryptor ou decryptor à partir de cet objet
• Nous ajoutons un padding au message pour qu'il soit un multiple de la taille de bloc (16 octets)
• Nous chiffrons/déchiffrons le message et finalisons l'opération
• Pour le chiffrement, nous concaténons l'IV et le texte chiffré pour transmettre les deux ensemble
• Pour le déchiffrement, nous extrayons l'IV des 16 premiers octets avant de déchiffrer

Partie B : Analyse des modes d'opération

Comparaison ECB vs CBC :

Le mode ECB (Electronic CodeBook) :

• Chaque bloc est chiffré indépendamment avec la même clé
• Les blocs identiques du texte en clair produisent des blocs identiques du texte chiffré
• Simple à implémenter et permet le traitement parallèle

Le mode CBC (Cipher Block Chaining) :

• Chaque bloc est XORé avec le bloc chiffré précédent avant d'être chiffré
• Le premier bloc est XORé avec un vecteur d'initialisation (IV)
• Des blocs identiques du texte en clair produisent des blocs différents du texte chiffré
• Ne permet pas le traitement parallèle pour le chiffrement (mais le permet pour le déchiffrement)

Pourquoi ECB est déconseillé :

Le mode ECB est généralement déconseillé pour les applications réelles pour plusieurs raisons :

1. Pas de diffusion : Des blocs identiques du texte en clair produisent des blocs identiques du texte chiffré, ce qui révèle des motifs dans les données. Cela peut être particulièrement problématique pour les données structurées ou les images.
2. Vulnérabilité aux attaques de réarrangement : Comme chaque bloc est chiffré indépendamment, un attaquant peut réorganiser, supprimer ou rejouer des blocs sans que cela ne soit détecté.
3. Manque d'intégrité : ECB ne fournit aucune garantie d'intégrité, ce qui signifie qu'un attaquant peut modifier les données chiffrées sans que cela ne soit nécessairement détecté.

Illustration classique des problèmes d'ECB : lorsqu'on chiffre une image en mode ECB, les motifs de l'image originale restent souvent visibles dans l'image chiffrée, contrairement au mode CBC où l'image chiffrée apparaît comme un bruit aléatoire.

Partie C : Vecteur d'initialisation (IV)

Importance de l'IV dans le mode CBC :

Le vecteur d'initialisation (IV) joue un rôle crucial dans le mode CBC pour plusieurs raisons :

1. Randomisation : L'IV introduit de l'aléa dans le processus de chiffrement, garantissant que même si le même message est chiffré plusieurs fois avec la même clé, les textes chiffrés seront différents.
2. Prévention des attaques par motif : Sans IV ou avec un IV constant, des messages commençant par les mêmes blocs produiraient des débuts de textes chiffrés identiques, révélant des informations sur les données.
3. Chaînage initial : L'IV sert de "bloc précédent" fictif pour le premier bloc de données, permettant de démarrer le processus de chaînage.

Conséquences de la réutilisation d'IV :

Si le même IV est réutilisé pour chiffrer plusieurs messages avec la même clé, plusieurs problèmes de sécurité se posent :

1. Perte de l'indistinguabilité : Si deux messages commencent par le même contenu, les premiers blocs chiffrés seront identiques, révélant cette similarité.
2. Vulnérabilité aux attaques différentielles : Un attaquant peut déduire des informations sur les différences entre deux messages en comparant leurs textes chiffrés.
3. Révélation de XOR des clairs : Si deux messages différents M₁ et M₂ sont chiffrés avec la même clé et le même IV, il devient possible de calculer M₁ ⊕ M₂ à partir des textes chiffrés, ce qui peut révéler des informations significatives.

Exemple concret des risques :

Supposons que nous ayons deux messages M₁ et M₂ chiffrés avec la même clé et le même IV en mode CBC :

1. Premier bloc de C₁ = E(M₁ ⊕ IV)
2. Premier bloc de C₂ = E(M₂ ⊕ IV)

Si un attaquant connaît M₁ et observe C₁ et C₂, il peut retrouver M₂ sans connaître la clé :

1. Calculer IV ⊕ M₁ à partir de M₁ et C₁
2. Utiliser cette valeur avec C₂ pour retrouver M₂

Bonnes pratiques :

Pour éviter ces problèmes, il est essentiel de :

1. Utiliser un IV unique (jamais réutilisé) pour chaque message chiffré avec la même clé
2. Générer l'IV de manière cryptographiquement aléatoire
3. Transmettre l'IV avec le message chiffré (il n'a pas besoin d'être secret, seulement unique)

Solution

Partie A : Simulation d'un échange de clés

import random

def is_prime(n, k=5):
    """Test de primalité de Miller-Rabin"""
    if n <= 1 or n == 4:
        return False
    if n <= 3:
        return True
    
    # Trouver r et d tels que n-1 = 2^r * d, avec d impair
    d = n - 1
    r = 0
    while d % 2 == 0:
        d //= 2
        r += 1
    
    # Témoin de primalité
    for _ in range(k):
        a = random.randint(2, n - 2)
        x = pow(a, d, n)
        if x == 1 or x == n - 1:
            continue
        for _ in range(r - 1):
            x = pow(x, 2, n)
            if x == n - 1:
                break
        else:
            return False
    return True

def generate_prime(bits):
    """Génère un nombre premier aléatoire de la taille spécifiée en bits"""
    while True:
        # Générer un nombre aléatoire de la taille spécifiée
        p = random.getrandbits(bits)
        # Assurer qu'il est impair
        p |= 1
        # Vérifier s'il est premier
        if is_prime(p):
            return p

def find_primitive_root(p):
    """Trouve une racine primitive modulo p (version simplifiée)"""
    if p == 2:
        return 1
    
    # Facteurs premiers de p-1
    factors = []
    phi = p - 1
    for i in range(2, int(phi**0.5) + 1):
        if phi % i == 0:
            factors.append(i)
            while phi % i == 0:
                phi //= i
    if phi > 1:
        factors.append(phi)
    
    # Trouver une racine primitive
    for g in range(2, p):
        is_primitive = True
        for factor in factors:
            if pow(g, (p - 1) // factor, p) == 1:
                is_primitive = False
                break
        if is_primitive:
            return g
    
    return None

def diffie_hellman():
    # Pour l'exemple, utilisons des valeurs plus petites
    # Dans la pratique, on utiliserait bits=2048 ou plus
    bits = 64
    
    # Étape 1 : Définir un nombre premier p et une base g
    p = generate_prime(bits)
    g = find_primitive_root(p)
    
    print(f"Paramètres publics:")
    print(f"p = {p}")
    print(f"g = {g}")
    
    # Étape 2 : Alice et Bob génèrent leurs secrets
    alice_secret = random.randint(1, p-2)
    bob_secret = random.randint(1, p-2)
    
    print(f"\nSecrets privés:")
    print(f"Secret d'Alice: {alice_secret}")
    print(f"Secret de Bob: {bob_secret}")
    
    # Étape 3 : Calcul des valeurs publiques
    alice_public = pow(g, alice_secret, p)
    bob_public = pow(g, bob_secret, p)
    
    print(f"\nValeurs publiques échangées:")
    print(f"Valeur publique d'Alice: {alice_public}")
    print(f"Valeur publique de Bob: {bob_public}")
    
    # Étape 4 : Calcul de la clé secrète partagée
    alice_shared_key = pow(bob_public, alice_secret, p)
    bob_shared_key = pow(alice_public, bob_secret, p)
    
    print(f"\nClés secrètes partagées calculées:")
    print(f"Clé calculée par Alice: {alice_shared_key}")
    print(f"Clé calculée par Bob: {bob_shared_key}")
    
    # Étape 5 : Vérification
    if alice_shared_key == bob_shared_key:
        print("\nSuccès ! Alice et Bob ont calculé la même clé secrète partagée.")
    else:
        print("\nErreur ! Les clés calculées sont différentes.")
    
    return alice_shared_key

# Exécution de la simulation
shared_key = diffie_hellman()
                    

Explications mathématiques :

L'échange Diffie-Hellman repose sur les propriétés suivantes :

1. Alice calcule \( A = g^a \mod p \) et envoie A à Bob
2. Bob calcule \( B = g^b \mod p \) et envoie B à Alice
3. Alice calcule la clé partagée \( K_A = B^a \mod p = (g^b)^a \mod p = g^{ba} \mod p \)
4. Bob calcule la clé partagée \( K_B = A^b \mod p = (g^a)^b \mod p = g^{ab} \mod p \)
5. Comme \( g^{ab} = g^{ba} \), Alice et Bob obtiennent la même clé partagée

Partie B : Analyse de sécurité

La sécurité de l'échange de clés Diffie-Hellman repose sur la difficulté du problème du logarithme discret.

Problème du logarithme discret :

Étant donné un nombre premier p, une base g, et une valeur \( h = g^x \mod p \), trouver x est considéré comme un problème difficile lorsque p est suffisamment grand.

Dans le contexte de Diffie-Hellman :

• L'attaquant observe p, g, A (= \( g^a \mod p \)) et B (= \( g^b \mod p \))
• Pour obtenir la clé secrète \( g^{ab} \mod p \), l'attaquant devrait soit :
• Calculer a à partir de A, puis calculer \( B^a \mod p \), ou
• Calculer b à partir de B, puis calculer \( A^b \mod p \)
• Les deux approches nécessitent de résoudre un logarithme discret

Pourquoi c'est difficile :

Pour les grands nombres premiers (généralement 2048 bits ou plus dans les applications réelles), il n'existe pas d'algorithme efficace connu pour résoudre le problème du logarithme discret. Les meilleurs algorithmes connus ont une complexité sous-exponentielle, ce qui les rend impraticables pour des valeurs suffisamment grandes.

Cette difficulté mathématique garantit que même si un attaquant intercepte toutes les communications, il ne peut pas facilement déterminer la clé secrète partagée.

Partie C : Vulnérabilité à l'attaque de l'homme du milieu

Fonctionnement de l'attaque de l'homme du milieu (MITM) :

1. Alice envoie sa valeur publique \( A = g^a \mod p \) à Bob
2. L'attaquant Mallory intercepte cette valeur et l'empêche d'atteindre Bob
3. Mallory génère son propre secret m₁ et envoie \( M_1 = g^{m_1} \mod p \) à Bob, en prétendant que c'est la valeur d'Alice
4. Bob répond avec sa valeur publique \( B = g^b \mod p \)
5. Mallory intercepte cette valeur et génère un second secret m₂
6. Mallory envoie \( M_2 = g^{m_2} \mod p \) à Alice, en prétendant que c'est la valeur de Bob
7. Alice calcule une clé partagée \( K_A = M_2^a \mod p = g^{m_2 \cdot a} \mod p \) avec Mallory (pensant que c'est avec Bob)
8. Bob calcule une clé partagée \( K_B = M_1^b \mod p = g^{m_1 \cdot b} \mod p \) avec Mallory (pensant que c'est avec Alice)
9. Mallory peut maintenant déchiffrer, lire, modifier et rechiffrer tous les messages entre Alice et Bob

Cette attaque fonctionne parce que le protocole Diffie-Hellman de base ne fournit pas d'authentification des parties.

Solutions pour contrer cette attaque :

1. Authentification des clés publiques :
   • Utiliser des certificats numériques pour authentifier les clés publiques
   • Mettre en œuvre un protocole comme TLS (Transport Layer Security) qui combine Diffie-Hellman avec une infrastructure à clés publiques (PKI)
2. Diffie-Hellman authentifié :
   • Station-to-Station (STS) protocol : Extension de DH qui inclut des signatures numériques
   • SIGMA (SIGn-and-MAc) : Utilisé dans le protocole IKE (Internet Key Exchange)
3. Vérification hors bande :
   • Signal Protocol : Utilise un "safety number" que les utilisateurs peuvent comparer hors bande
   • PGP : Empreintes digitales des clés que les utilisateurs peuvent vérifier via un canal différent
4. Password-Authenticated Key Exchange (PAKE) :
   • SPEKE (Simple Password Exponential Key Exchange)
   • J-PAKE (Password Authenticated Key Exchange by Juggling)
   • Permet l'authentification et l'échange de clés basés sur un mot de passe partagé préalablement

Exemple simplifié de Diffie-Hellman authentifié :

from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import hashes

# Génération de paires de clés RSA pour l'authentification
def generate_rsa_keys():
    private_key = rsa.generate_private_key(
        public_exponent=65537,
        key_size=2048
    )
    public_key = private_key.public_key()
    return private_key, public_key

# Simulation de Diffie-Hellman authentifié
def authenticated_diffie_hellman():
    # Paramètres Diffie-Hellman
    p = 23  # Petit nombre premier pour l'exemple
    g = 5   # Générateur
    
    # Génération des clés RSA
    alice_private, alice_public = generate_rsa_keys()
    bob_private, bob_public = generate_rsa_keys()
    
    # Alice et Bob échangent leurs clés publiques RSA par un canal sécurisé ou PKI
    
    # Étape 1: Alice génère son secret et sa valeur publique DH
    a = 6  # Secret d'Alice
    A = pow(g, a, p)  # Valeur publique d'Alice
    
    # Alice signe sa valeur publique DH
    alice_signature = alice_private.sign(
        str(A).encode(),
        padding.PSS(
            mgf=padding.MGF1(hashes.SHA256()),
            salt_length=padding.PSS.MAX_LENGTH
        ),
        hashes.SHA256()
    )
    
    # Alice envoie (A, alice_signature) à Bob
    
    # Étape 2: Bob vérifie la signature d'Alice
    try:
        alice_public.verify(
            alice_signature,
            str(A).encode(),
            padding.PSS(
                mgf=padding.MGF1(hashes.SHA256()),
                salt_length=padding.PSS.MAX_LENGTH
            ),
            hashes.SHA256()
        )
        print("Bob: Signature d'Alice vérifiée.")
    except:
        print("Bob: Signature d'Alice invalide!")
        return
    
    # Bob génère son secret et sa valeur publique DH
    b = 15  # Secret de Bob
    B = pow(g, b, p)  # Valeur publique de Bob
    
    # Bob signe sa valeur publique DH
    bob_signature = bob_private.sign(
        str(B).encode(),
        padding.PSS(
            mgf=padding.MGF1(hashes.SHA256()),
            salt_length=padding.PSS.MAX_LENGTH
        ),
        hashes.SHA256()
    )
    
    # Bob envoie (B, bob_signature) à Alice
    
    # Étape 3: Alice vérifie la signature de Bob
    try:
        bob_public.verify(
            bob_signature,
            str(B).encode(),
            padding.PSS(
                mgf=padding.MGF1(hashes.SHA256()),
                salt_length=padding.PSS.MAX_LENGTH
            ),
            hashes.SHA256()
        )
        print("Alice: Signature de Bob vérifiée.")
    except:
        print("Alice: Signature de Bob invalide!")
        return
    
    # Étape 4: Calcul des clés partagées
    alice_shared_key = pow(B, a, p)
    bob_shared_key = pow(A, b, p)
    
    print(f"Clé partagée calculée par Alice: {alice_shared_key}")
    print(f"Clé partagée calculée par Bob: {bob_shared_key}")
    
    if alice_shared_key == bob_shared_key:
        print("Échange de clés authentifié réussi!")
    else:
        print("Erreur dans l'échange de clés.")

# Exécution de la simulation
# Note: Ce code est simplifié pour l'illustration et n'est pas destiné à une utilisation en production
authenticated_diffie_hellman()
                    

Solution

Partie A : Génération de clés et chiffrement/déchiffrement

import random
import math

def is_prime(n, k=5):
    """Test de primalité de Miller-Rabin"""
    if n <= 1 or n == 4:
        return False
    if n <= 3:
        return True
    
    # Trouver r et d tels que n-1 = 2^r * d, avec d impair
    d = n - 1
    r = 0
    while d % 2 == 0:
        d //= 2
        r += 1
    
    # Témoin de primalité
    for _ in range(k):
        a = random.randint(2, n - 2)
        x = pow(a, d, n)
        if x == 1 or x == n - 1:
            continue
        for _ in range(r - 1):
            x = pow(x, 2, n)
            if x == n - 1:
                break
        else:
            return False
    return True

def generate_prime(bits):
    """Génère un nombre premier de la taille spécifiée en bits"""
    while True:
        p = random.getrandbits(bits)
        # Assurez-vous que p est impair
        p |= 1
        if is_prime(p):
            return p

def extended_gcd(a, b):
    """Calcule le PGCD étendu de a et b"""
    if a == 0:
        return b, 0, 1
    else:
        gcd, x, y = extended_gcd(b % a, a)
        return gcd, y - (b // a) * x, x

def modinv(a, m):
    """Calcule l'inverse modulaire de a modulo m"""
    gcd, x, y = extended_gcd(a, m)
    if gcd != 1:
        raise Exception('Inverse modulaire inexistant')
    else:
        return x % m

def generate_rsa_keys(bits=8):
    """Génère une paire de clés RSA
    
    Pour l'exemple, nous utilisons une petite taille de bits.
    Dans une application réelle, utilisez au moins 2048 bits.
    """
    # Étape 1: Générer deux nombres premiers distincts p et q
    p = generate_prime(bits)
    q = generate_prime(bits)
    while p == q:
        q = generate_prime(bits)
    
    # Étape 2: Calculer n = p * q
    n = p * q
    
    # Étape 3: Calculer φ(n) = (p-1) * (q-1)
    phi = (p - 1) * (q - 1)
    
    # Étape 4: Choisir un entier e tel que 1 < e < φ(n) et gcd(e, φ(n)) = 1
    e = 65537  # Valeur courante pour e (nombre premier de Fermat)
    while math.gcd(e, phi) != 1:
        e = random.randrange(2, phi)
    
    # Étape 5: Calculer d tel que d * e ≡ 1 (mod φ(n))
    d = modinv(e, phi)
    
    # Clé publique: (n, e), Clé privée: (n, d)
    public_key = (n, e)
    private_key = (n, d)
    
    return public_key, private_key, p, q

def rsa_encrypt(message, public_key):
    """Chiffre un message avec la clé publique RSA"""
    n, e = public_key
    # Assurez-vous que le message est un entier et < n
    if isinstance(message, str):
        # Convertir la chaîne en nombre (simplifié)
        message = int.from_bytes(message.encode(), 'big')
    if message >= n:
        raise ValueError("Le message est trop grand pour cette clé")
    
    # Chiffrement: c = m^e mod n
    ciphertext = pow(message, e, n)
    return ciphertext

def rsa_decrypt(ciphertext, private_key):
    """Déchiffre un message avec la clé privée RSA"""
    n, d = private_key
    # Déchiffrement: m = c^d mod n
    message = pow(ciphertext, d, n)
    return message

# Exemple d'utilisation avec de petits nombres
public_key, private_key, p, q = generate_rsa_keys(8)
n, e = public_key
n_d, d = private_key

print(f"Généré p={p}, q={q}, n={n}, φ(n)={(p-1)*(q-1)}, e={e}, d={d}")
print(f"Clé publique: (n={n}, e={e})")
print(f"Clé privée: (n={n}, d={d})")

# Pour l'exemple, utilisons un petit nombre comme message
original_message = 42
print(f"\nMessage original: {original_message}")

# Chiffrement
encrypted = rsa_encrypt(original_message, public_key)
print(f"Message chiffré: {encrypted}")

# Déchiffrement
decrypted = rsa_decrypt(encrypted, private_key)
print(f"Message déchiffré: {decrypted}")

# Vérifions que le déchiffrement redonne bien le message original
if decrypted == original_message:
    print("Le déchiffrement a réussi !")
else:
    print("Erreur dans le déchiffrement.")

# Exemple avec une chaîne de caractères (limité par la taille de la clé)
try:
    message_text = "RSA"
    print(f"\nMessage texte: '{message_text}'")
    
    encrypted_text = rsa_encrypt(message_text, public_key)
    print(f"Message chiffré: {encrypted_text}")
    
    decrypted_number = rsa_decrypt(encrypted_text, private_key)
    # Convertir le nombre en texte (nécessite de connaître la longueur)
    decrypted_text = decrypted_number.to_bytes((decrypted_number.bit_length() + 7) // 8, 'big').decode()
    print(f"Message déchiffré: '{decrypted_text}'")
except ValueError as e:
    print(f"Erreur: {e} (Essayez avec une clé plus grande)")
                    

Explications :

1. Génération de clés RSA :
   • Choisir deux grands nombres premiers distincts p et q
   • Calculer n = p × q
   • Calculer φ(n) = (p - 1) × (q - 1)
   • Choisir e tel que 1 < e < φ(n) et gcd(e, φ(n)) = 1
   • Calculer d tel que d × e ≡ 1 (mod φ(n))
   • La clé publique est (n, e) et la clé privée est (n, d)
2. Chiffrement RSA :
   • Pour un message m (< n), le texte chiffré c est : c = m^e mod n
3. Déchiffrement RSA :
   • Pour un texte chiffré c, le message déchiffré m est : m = c^d mod n

Dans ce code, nous utilisons des nombres de petite taille (8 bits) pour illustrer le principe. Dans les applications réelles, on utiliserait des nombres bien plus grands (typiquement 2048 bits ou plus).

Partie B : Sécurité de RSA

La factorisation et la sécurité de RSA :

La sécurité de RSA repose principalement sur la difficulté de factoriser le module n (le produit des deux grands nombres premiers p et q) en ses facteurs premiers.

Voici pourquoi la factorisation est cruciale :

1. La clé publique RSA contient n et e, mais pas p, q ou φ(n)
2. Pour calculer la clé privée d, on a besoin de φ(n), qui est (p-1)(q-1)
3. Si un attaquant peut factoriser n pour obtenir p et q, il peut calculer φ(n) puis d
4. Avec d, l'attaquant peut déchiffrer tous les messages chiffrés avec la clé publique correspondante

Taille de clé recommandée :

En 2023, la taille de clé RSA recommandée est d'au moins 2048 bits, et 3072 bits ou 4096 bits pour les applications nécessitant une sécurité à long terme.

Raisons de ces recommandations :

1. Avancées en factorisation : Les algorithmes de factorisation comme le crible algébrique (NFS) continuent de s'améliorer
2. Augmentation de la puissance de calcul : La loi de Moore et les calculs distribués rendent les attaques plus pratiques
3. Durée de vie des secrets : Certaines données doivent rester confidentielles pendant des décennies
4. Menace quantique : L'algorithme de Shor, s'il était implémenté sur un ordinateur quantique suffisamment puissant, pourrait factoriser efficacement de grands nombres, compromettant RSA

Historique et projections :

• En 1977 (création de RSA) : 512 bits étaient considérés comme sûrs
• En 1999 : RSA-512 a été factorisé
• En 2009 : RSA-768 a été factorisé
• Actuellement : RSA-1024 est considéré comme potentiellement vulnérable aux organisations disposant de ressources importantes
• Future : On estime que RSA-2048 restera sécurisé contre les attaques classiques au moins jusqu'en 2030

Partie C : Signature numérique avec RSA

Principe de la signature RSA :

La signature numérique RSA utilise le principe inverse du chiffrement :

1. Dans le chiffrement, on utilise la clé publique pour chiffrer et la clé privée pour déchiffrer
2. Dans la signature, on utilise la clé privée pour "signer" (créer la signature) et la clé publique pour vérifier

Étapes de la signature RSA :

1. Calculer le hachage (hash) du message à signer
2. Chiffrer ce hachage avec la clé privée (c'est la signature)
3. Envoyer le message original et la signature

Étapes de la vérification :

1. Calculer le hachage du message reçu
2. Déchiffrer la signature avec la clé publique
3. Comparer les deux valeurs : si elles sont identiques, la signature est valide

L'utilisation d'une fonction de hachage est importante car :

• Elle réduit la taille des données à signer (efficacité)
• Elle garantit l'intégrité du message
• Elle permet de signer des messages de taille arbitraire

Implémentation d'un exemple de signature RSA :

import hashlib

def calculate_hash(message):
    """Calcule le hash SHA-256 d'un message"""
    if isinstance(message, str):
        message = message.encode()
    return int.from_bytes(hashlib.sha256(message).digest(), 'big')

def rsa_sign(message, private_key):
    """Signe un message avec la clé privée RSA"""
    n, d = private_key
    
    # Calculer le hash du message
    message_hash = calculate_hash(message)
    
    # Signer le hash (m^d mod n)
    signature = pow(message_hash, d, n)
    
    return signature

def rsa_verify_signature(message, signature, public_key):
    """Vérifie une signature RSA avec la clé publique"""
    n, e = public_key
    
    # Calculer le hash du message
    message_hash = calculate_hash(message)
    
    # Vérifier la signature (s^e mod n doit être égal au hash)
    decrypted_hash = pow(signature, e, n)
    
    return decrypted_hash == message_hash

# Utiliser les clés générées précédemment
public_key, private_key, p, q = generate_rsa_keys(16)  # Utiliser des clés plus grandes
n, e = public_key
n_d, d = private_key

print(f"Clé publique: (n={n}, e={e})")
print(f"Clé privée: (n={n}, d={d})")

# Message à signer
message = "Ce message doit être authentifié"
print(f"\nMessage à signer: '{message}'")

# Créer la signature
signature = rsa_sign(message, private_key)
print(f"Signature: {signature}")

# Vérifier la signature
is_valid = rsa_verify_signature(message, signature, public_key)
print(f"Signature valide: {is_valid}")

# Vérifier avec un message modifié
modified_message = "Ce message a été modifié"
is_valid = rsa_verify_signature(modified_message, signature, public_key)
print(f"Signature valide pour le message modifié: {is_valid}")

# Note: Pour des applications réelles, utilisez des bibliothèques
# cryptographiques établies comme cryptography, PyCryptodome,
# ou des modules natifs comme rsa ou pyOpenSSL.
                    

Remarques importantes sur la signature RSA en pratique :

1. Padding : Dans les implémentations réelles, on utilise des schémas de padding comme PKCS#1 v1.5 ou PSS pour éviter diverses attaques.
2. Fonctions de hachage : On utilise des fonctions de hachage résistantes aux collisions comme SHA-256, SHA-384 ou SHA-512.
3. Performance : Pour améliorer les performances, on peut utiliser le théorème des restes chinois pour accélérer les opérations avec la clé privée.
4. Sécurité : Protéger la clé privée est crucial ; toute fuite compromettrait l'authenticité des signatures.
5. Bibliothèques : Dans un environnement de production, il faut utiliser des bibliothèques cryptographiques éprouvées et bien maintenues plutôt que de réimplémenter les algorithmes.

Exemple d'utilisation de la bibliothèque cryptography pour la signature RSA en Python :

from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import hashes
from cryptography.exceptions import InvalidSignature

# Génération des clés
private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048
)
public_key = private_key.public_key()

# Message à signer
message = b"Ce message doit être authentifié"

# Création de la signature
signature = private_key.sign(
    message,
    padding.PSS(
        mgf=padding.MGF1(hashes.SHA256()),
        salt_length=padding.PSS.MAX_LENGTH
    ),
    hashes.SHA256()
)

# Vérification de la signature
try:
    public_key.verify(
        signature,
        message,
        padding.PSS(
            mgf=padding.MGF1(hashes.SHA256()),
            salt_length=padding.PSS.MAX_LENGTH
        ),
        hashes.SHA256()
    )
    print("La signature est valide.")
except InvalidSignature:
    print("La signature est invalide.")

# Tentative de vérification avec un message modifié
modified_message = b"Ce message a été modifié"
try:
    public_key.verify(
        signature,
        modified_message,
        padding.PSS(
            mgf=padding.MGF1(hashes.SHA256()),
            salt_length=padding.PSS.MAX_LENGTH
        ),
        hashes.SHA256()
    )
    print("La signature est valide pour le message modifié.")
except InvalidSignature:
    print("La signature est invalide pour le message modifié, comme attendu.")
                    

Solution

Partie A : Conception d'un système hybride

Conception d'un système de communication sécurisée hybride AES-RSA :

1. Configuration initiale :

• Alice et Bob génèrent chacun leur paire de clés RSA (publique et privée)
• Ils échangent leurs clés publiques de manière authentifiée (via certificats, échange direct, etc.)
• Ils stockent en sécurité leurs clés privées

2. Établissement de la communication (Alice envoie un message à Bob) :

1. Alice génère une clé symétrique AES aléatoire à usage unique (clé de session)
2. Alice chiffre son message avec cette clé AES (ex: AES-256-GCM)
3. Alice chiffre la clé AES avec la clé publique RSA de Bob
4. Alice envoie à Bob :
   • Le message chiffré avec AES
   • La clé AES chiffrée avec RSA
   • Les paramètres nécessaires (IV, nonce, tags d'authentification)

3. Réception et déchiffrement (Bob reçoit le message d'Alice) :

1. Bob déchiffre la clé AES chiffrée en utilisant sa clé privée RSA
2. Bob utilise la clé AES récupérée pour déchiffrer le message
3. Bob vérifie l'intégrité du message (si un mode authentifié comme GCM est utilisé)

4. Réponse (Bob répond à Alice) :

1. Bob peut soit :
   • Utiliser la même clé AES pour sa réponse (si la communication est continue)
   • Générer une nouvelle clé AES à usage unique pour sa réponse (meilleure sécurité)
2. Bob chiffre sa réponse avec la clé AES
3. Bob chiffre cette clé AES avec la clé publique RSA d'Alice
4. Bob envoie les mêmes types d'informations qu'Alice

5. Considérations supplémentaires :

• Signature : Pour l'authenticité, les messages peuvent être signés avec la clé privée RSA de l'expéditeur
• Rotation des clés : Pour les communications prolongées, de nouvelles clés AES devraient être générées régulièrement
• Forward secrecy : Pour une sécurité optimale, des protocoles comme Diffie-Hellman éphémère peuvent être utilisés pour générer les clés de session
• Horodatage/Numérotation : Pour se protéger contre les attaques par rejeu

Cette approche combine efficacement :

• La rapidité et l'efficacité du chiffrement symétrique (AES) pour les données volumineuses
• La sécurité et la facilité de gestion des clés du chiffrement asymétrique (RSA)
• L'authenticité et l'intégrité via des modes authentifiés et/ou des signatures numériques

Partie B : Implémentation partielle

Implémentation en Python de l'envoi d'un message hybride :

from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.primitives import hashes, hmac
from cryptography.hazmat.backends import default_backend
import os

def hybrid_encrypt(message, recipient_public_key):
    """
    Chiffre un message en utilisant un système hybride AES-RSA
    
    Args:
        message: Le message à chiffrer (bytes ou str)
        recipient_public_key: La clé publique RSA du destinataire
    
    Returns:
        Un tuple contenant (message_chiffré, clé_AES_chiffrée, iv)
    """
    # Convertir le message en bytes si nécessaire
    if isinstance(message, str):
        message = message.encode('utf-8')
    
    # 1. Générer une clé AES aléatoire (256 bits)
    aes_key = os.urandom(32)
    
    # 2. Générer un vecteur d'initialisation aléatoire
    iv = os.urandom(16)
    
    # 3. Chiffrer le message avec AES-CBC
    padded_message = pad_message(message)
    cipher = Cipher(algorithms.AES(aes_key), modes.CBC(iv), backend=default_backend())
    encryptor = cipher.encryptor()
    encrypted_message = encryptor.update(padded_message) + encryptor.finalize()
    
    # 4. Chiffrer la clé AES avec la clé publique RSA du destinataire
    encrypted_aes_key = recipient_public_key.encrypt(
        aes_key,
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA256()),
            algorithm=hashes.SHA256(),
            label=None
        )
    )
    
    # 5. Générer un code d'authentification (HMAC) pour l'intégrité
    h = hmac.HMAC(aes_key, hashes.SHA256(), backend=default_backend())
    h.update(encrypted_message)
    h.update(iv)
    mac = h.finalize()
    
    # Retourner toutes les informations nécessaires pour le déchiffrement
    return {
        'encrypted_message': encrypted_message,
        'encrypted_aes_key': encrypted_aes_key,
        'iv': iv,
        'mac': mac
    }

def pad_message(message):
    """Ajoute un padding au message pour qu'il soit un multiple de 16 octets"""
    padding_length = 16 - (len(message) % 16)
    padding = bytes([padding_length]) * padding_length
    return message + padding

def hybrid_decrypt(encrypted_data, recipient_private_key):
    """
    Déchiffre un message chiffré avec le système hybride AES-RSA
    
    Args:
        encrypted_data: Les données retournées par hybrid_encrypt
        recipient_private_key: La clé privée RSA du destinataire
    
    Returns:
        Le message original déchiffré
    """
    # 1. Extraire les composants
    encrypted_message = encrypted_data['encrypted_message']
    encrypted_aes_key = encrypted_data['encrypted_aes_key']
    iv = encrypted_data['iv']
    received_mac = encrypted_data['mac']
    
    # 2. Déchiffrer la clé AES avec la clé privée RSA
    aes_key = recipient_private_key.decrypt(
        encrypted_aes_key,
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA256()),
            algorithm=hashes.SHA256(),
            label=None
        )
    )
    
    # 3. Vérifier l'intégrité avec HMAC
    h = hmac.HMAC(aes_key, hashes.SHA256(), backend=default_backend())
    h.update(encrypted_message)
    h.update(iv)
    try:
        h.verify(received_mac)
    except Exception:
        raise ValueError("L'intégrité du message est compromise")
    
    # 4. Déchiffrer le message avec AES-CBC
    cipher = Cipher(algorithms.AES(aes_key), modes.CBC(iv), backend=default_backend())
    decryptor = cipher.decryptor()
    padded_message = decryptor.update(encrypted_message) + decryptor.finalize()
    
    # 5. Enlever le padding
    padding_length = padded_message[-1]
    message = padded_message[:-padding_length]
    
    return message

# Exemple d'utilisation
def hybrid_encryption_example():
    # Génération des clés RSA
    private_key = rsa.generate_private_key(
        public_exponent=65537,
        key_size=2048
    )
    public_key = private_key.public_key()
    
    # Message à chiffrer
    message = "Ce message est chiffré en utilisant un système hybride AES-RSA"
    print(f"Message original: {message}")
    
    # Chiffrement hybride
    encrypted_data = hybrid_encrypt(message, public_key)
    
    # Déchiffrement hybride
    decrypted_message = hybrid_decrypt(encrypted_data, private_key)
    
    # Affichage du résultat
    print(f"Message déchiffré: {decrypted_message.decode('utf-8')}")
    
    # Vérification
    assert message == decrypted_message.decode('utf-8'), "Le déchiffrement a échoué"
    print("Vérification réussie : le message déchiffré correspond au message original")

# Exécution de l'exemple
# hybrid_encryption_example()
                    

Explications :

1. La fonction hybrid_encrypt :
   • Génère une clé AES-256 aléatoire pour chaque message
   • Utilise AES en mode CBC avec un IV aléatoire pour chiffrer le message
   • Chiffre la clé AES avec la clé publique RSA du destinataire
   • Ajoute un HMAC pour l'intégrité et l'authenticité
   • Retourne toutes les informations nécessaires au déchiffrement
2. La fonction hybrid_decrypt :
   • Récupère la clé AES en la déchiffrant avec la clé privée RSA
   • Vérifie l'intégrité du message en recalculant le HMAC
   • Déchiffre le message avec AES-CBC
   • Enlève le padding pour obtenir le message original

Cette implémentation illustre les principes fondamentaux d'un système hybride, mais une solution de production devrait :

• Utiliser AES-GCM ou ChaCha20-Poly1305 au lieu de AES-CBC+HMAC pour une meilleure sécurité
• Implémenter une gestion d'erreurs plus complète
• Considérer l'ajout de signatures numériques
• Gérer les questions de compatibilité et d'interopérabilité

Partie C : Analyse de cas d'utilisation - PGP

Pretty Good Privacy (PGP) et son approche hybride :

PGP, créé par Phil Zimmermann en 1991, est un programme de chiffrement et de signature populaire, particulièrement pour la sécurisation des emails. Il utilise une approche hybride combinant chiffrement symétrique et asymétrique.

Composants principaux de PGP :

1. Chiffrement symétrique : Pour chiffrer le contenu des messages
2. Chiffrement asymétrique : Pour chiffrer les clés symétriques
3. Fonctions de hachage : Pour les signatures numériques et l'intégrité des données
4. Compression : Pour réduire la taille des messages avant chiffrement
5. Base64 : Pour encoder les données binaires en texte ("ASCII armor")

Algorithmes typiquement utilisés dans PGP :

• Algorithmes de chiffrement symétrique :
  • Initialement : IDEA (International Data Encryption Algorithm)
  • Versions modernes : AES (Advanced Encryption Standard)
  • Autres options : 3DES, Blowfish, Twofish, Camellia
• Algorithmes de chiffrement asymétrique :
  • RSA (Rivest-Shamir-Adleman)
  • ElGamal
  • Versions récentes : ECDH et ECDSA (cryptographie sur courbes elliptiques)
• Fonctions de hachage :
  • Historiquement : MD5
  • Puis : SHA-1
  • Versions modernes : SHA-256, SHA-384, SHA-512
• Compression :
  • ZIP
  • ZLIB
  • Bzip2

Processus de chiffrement dans PGP :

1. Préparation :
   • Le message est compressé (réduisant sa taille et augmentant la résistance à l'analyse cryptographique)
2. Chiffrement symétrique :
   • Une clé symétrique aléatoire à usage unique (appelée "session key") est générée
   • Le message compressé est chiffré avec cette clé symétrique (ex: AES-256)
3. Chiffrement asymétrique :
   • La clé de session est chiffrée avec la clé publique RSA du destinataire
   • Si le message a plusieurs destinataires, la même clé de session est chiffrée séparément avec la clé publique de chaque destinataire
4. Assemblage :
   • Le message chiffré et la (ou les) clé(s) de session chiffrée(s) sont combinés
   • Les métadonnées nécessaires (algorithmes utilisés, identifiants des clés, etc.) sont ajoutées
   • L'ensemble est généralement encodé en Base64 (ASCII armor) pour la transmission par email

Processus de déchiffrement dans PGP :

1. Le destinataire utilise sa clé privée RSA pour déchiffrer la clé de session
2. La clé de session est utilisée pour déchiffrer le message
3. Le message est décompressé pour retrouver son contenu original

Signature numérique dans PGP :

PGP permet également de signer numériquement les messages :

1. Un hash du message est créé (ex: SHA-256)
2. Ce hash est chiffré avec la clé privée RSA de l'expéditeur
3. La signature (hash chiffré) est jointe au message
4. Le destinataire peut vérifier l'authenticité en déchiffrant la signature avec la clé publique de l'expéditeur et en comparant avec le hash du message reçu

Web of Trust :

Au lieu d'utiliser une autorité de certification centrale, PGP utilise un modèle décentralisé appelé "Web of Trust" :

• Les utilisateurs signent les clés publiques d'autres utilisateurs qu'ils ont vérifiées
• La confiance est transitive : si A fait confiance à B, et B certifie la clé de C, alors A peut avoir un certain niveau de confiance en C
• Ce système permet une authentification des clés sans infrastructure centralisée

Avantages de l'approche hybride dans PGP :

• Performance : Le chiffrement symétrique est bien plus rapide pour les grands volumes de données
• Sécurité : La clé symétrique à usage unique offre la propriété de "forward secrecy"
• Flexibilité : Un même message peut être envoyé à plusieurs destinataires en ne chiffrant que la petite clé symétrique avec chaque clé publique
• Évolutivité : Les algorithmes peuvent être mis à jour sans changer l'architecture globale

Implémentations modernes :

• OpenPGP : La norme ouverte basée sur PGP (RFC 4880)
• GnuPG (GPG) : Implémentation libre et largement utilisée d'OpenPGP
• PGP Corporation (acquis par Symantec puis NortonLifeLock) : Versions commerciales
• Intégrations dans les clients email : Enigmail (Thunderbird), GPGTools (Apple Mail), etc.