Présentation du projet

Ce projet met en œuvre un protocole d'échange de clés hybride combinant RSA (cryptographie classique) et Kyber (cryptographie post-quantique) pour sécuriser les communications entre deux parties, Alice et Bob.

Protection contre les attaques classiques et quantiques
Utilisation de HKDF pour dériver une clé finale à partir de plusieurs secrets
Chiffrement symétrique avec AES-GCM pour la confidentialité des messages

Enjeux de la cryptographie post-quantique

Ordinateurs quantiques « casseurs » de RSA/ECC : un horizon lointain (≥ 2040–2050)
Les experts estiment qu’un ordinateur quantique universel capable de briser RSA/ECC ne sera pas réalisable avant des décennies. Un rapport de l’Académie nationale des sciences américaine (NASEM, 2019) indique que même en accélérant la transition cryptographique dès maintenant, le premier ordinateur quantique capable de casser RSA-2048 n’apparaîtrait pas avant ~2040. D’autres analyses repoussent l’échéance vers 2040–2050 du fait des défis d’ingénierie des qubits (stabilité, correction d’erreurs) (ciaonet.org). En pratique, il faudrait des milliers de qubits logiques corrigés d’erreurs pour exécuter Shor à grande échelle (par ex. ≈2500 qubits logiques pour RSA-2048, NASEM), très au-delà des capacités des machines actuelles (qui n’ont que quelques centaines de qubits physiques bruités). Ces contraintes matérielles rendent improbable une rupture quantique avant plusieurs décennies.

L’algorithme de Shor, une menace théorique conditionnée à un grand ordinateur quantique
L’algorithme de Shor permet en théorie de factoriser RSA ou de résoudre le log discret (ECC) en temps polynomial, mais seulement s’il tourne sur un ordinateur quantique universel à grande échelle. En d’autres termes, Shor n’est dangereux pour RSA/ECC que si l’on dispose d’un calculateur quantique tolérant aux fautes suffisamment puissant. Comme le soulignent les agences de cybersécurité, « cette menace pour la cryptographie provient du développement d’un ordinateur quantique tolérant aux pannes de grande taille, capable de casser les schémas à clé publique traditionnels (RSA, ECC) grâce à l’algorithme de Shor » (bsi.bund.de). À ce jour, aucun ordinateur quantique « cryptographiquement pertinent » n’existe (bsi.bund.de) – les dispositifs quantiques actuels sont trop limités – de sorte que RSA/ECC demeurent pour l’instant sûrs. L’algorithme de Shor constitue donc une menace potentielle à moyen/long terme, tributaire des progrès en informatique quantique.

Le risque du « store now, decrypt later » justifie une transition proactive
Malgré l’absence actuelle de calculateur quantique capable de casser nos chiffrements, les données sensibles échangées aujourd’hui sont menacées par la stratégie dite « store now, decrypt later ». Ce scénario, reconnu par les autorités, consiste pour un adversaire à capturer et stocker dès maintenant des communications chiffrées, dans l’attente de disposer un jour d’un ordinateur quantique pour les déchiffrer ultérieurement (bsi.bund.de). Cette perspective est jugée crédible pour les informations devant rester confidentielles longtemps (données personnelles sensibles, secrets industriels, communications gouvernementales, etc.). Un document conjoint du BSI (Allemagne) et d’autres agences (2024) classe « store-now/decrypt-later » parmi les deux menaces quantiques majeures, et en déduit qu’il faut anticiper dès à présent la migration vers des systèmes post-quantiques (bsi.bund.de). En clair, pour protéger les données d’aujourd’hui contre une décryption future, il est prudent d’adopter sans tarder des algorithmes résistants aux attaques quantiques.

Des bases mathématiques différentes pour la cryptographie post-quantique, implémentable classiquement
La cryptographie post-quantique (PQC) regroupe des algorithmes cryptographiques (typiquement de nouvelles méthodes à clé publique) fondés sur des problèmes mathématiques réputés résistants aux ordinateurs quantiques. Ces problèmes ne sont pas ceux du RSA/Log discret : ils appartiennent à d’autres familles mathématiques (par ex. problèmes de réseaux euclidiens – lattices, codes correcteurs d’erreurs, fonctions de hachage, systèmes multivariés, isogénies de courbes, etc.) (enisa.europa.eu). Le point crucial est que, contrairement à la « quantum cryptographie » (ex : QKD) nécessitant des dispositifs quantiques, les algorithmes post-quantiques s’exécutent sur du matériel classique. Ce sont des logiciels/ circuits conventionnels – intégrables dans nos ordinateurs et réseaux actuels – mais conçus pour résister aux futurs calculateurs quantiques. Comme l’explique le NIST, on développe « de nouveaux standards de chiffrement qui fonctionneront sur nos ordinateurs classiques actuels tout en résistant aux machines quantiques du futur » (nist.gov). Autrement dit, les algorithmes post-quantiques sont déployables sur les ordinateurs et processeurs d’aujourd’hui, ce qui facilite leur adoption progressive. Plusieurs grandes familles de solutions PQC (basées sur réseaux, codes, hachage, etc.) ont d’ores et déjà fait l’objet d’implémentations et d’une évaluation cryptanalytique approfondie dans le cadre du processus de standardisation internationale.

Standardisation NIST : Kyber, Dilithium et autres algorithmes post-quantiques robustes
Consciente de ces enjeux, l’agence NIST (États-Unis) a lancé dès 2016 un processus de standardisation de la cryptographie post-quantique. Après plusieurs tours d’évaluation ouverts à la communauté scientifique, le NIST a annoncé en 2022 la sélection d’un premier ensemble de quatre algorithmes PQ robustes qui serviront de nouveaux standards (cyber.gouv.fr). Parmi eux figurent CRYSTALS-Kyber (schéma d’établissement de clé à base de réseaux euclidiens) et CRYSTALS-Dilithium (schéma de signature numérique à base de réseaux) – deux propositions conjuguant sécurité conjecturale quantique et bonnes performances. Les deux autres lauréats initiaux sont FALCON (signature sur réseaux) et SPHINCS+ (signature basée sur les fonctions de hachage) (cyber.gouv.fr). En 2023–2024, le NIST a publié les premiers projets de normes (FIPS 203, 204, 205) consacrés à ces algorithmes et prévoit d’en standardiser d’autres d’ici peu (nist.gov, bsi.bund.de). Des organismes internationaux et gouvernements appuient cette transition – par ex. l’ANSSI en France encourage dès maintenant l’hybridation et l’expérimentation de solutions post-quantiques, surtout pour les produits devant protéger des données au-delà de 2030 (cyber.gouv.fr). En résumé, la migration vers des algorithmes post-quantiques est en cours : elle s’appuie sur de nouveaux fondements mathématiques éprouvés académiquement, implémentables sur nos infrastructures actuelles, et en voie de normalisation par des institutions comme le NIST.

Fonctionnement général du protocole

Génération des paires de clés RSA et Kyber pour Alice et Bob
Échange des clés publiques
Encapsulation de secrets avec RSA et Kyber (dans les deux sens)
Dérivation d'une clé finale commune avec HKDF
Chiffrement/déchiffrement des messages avec AES-GCM

[À compléter : Décrivez chaque étape, les fichiers échangés, la synchronisation, etc.]

Détail des fonctions principales

Génération et export des clés

La sécurité du protocole repose sur la génération de paires de clés robustes pour chaque participant (Alice et Bob), à la fois pour l'algorithme classique RSA et pour l'algorithme post-quantique Kyber.

RSA

Génération de la paire de clés : chaque utilisateur génère une clé privée RSA et en déduit la clé publique.
Export : la clé publique est exportée dans le dossier de l'autre participant pour permettre l'échange sécurisé.


# Génération d'une paire de clés RSA pour Bob
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serialization

rsa_private = rsa.generate_private_key(public_exponent=65537, key_size=2048)
# Sauvegarde de la clé privée
with open("bob_rsa_private.pem", "wb") as f:
    f.write(rsa_private.private_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PrivateFormat.PKCS8,
        encryption_algorithm=serialization.NoEncryption()
    ))
# Export de la clé publique dans le dossier d'Alice
with open(r"C:\Users\zoran\Documents\Projet_Crypto\Alice\bob_rsa_public.pem", "wb") as f:
    f.write(rsa_private.public_key().public_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PublicFormat.SubjectPublicKeyInfo
    ))

Kyber (version pédagogique simplifiée)

Génération de la paire de clés : chaque utilisateur génère une clé publique et une clé secrète Kyber.
Export : la clé publique Kyber est également exportée dans le dossier de l'autre participant.


# Génération d'une paire de clés Kyber pour Bob
import simple_kyber512

pk, sk = simple_kyber512.keygen()
# Sauvegarde des clés
with open("bob_kyber_pk.bin", "wb") as f:
    f.write(pk)
with open("bob_kyber_sk.bin", "wb") as f:
    f.write(sk)
# Export de la clé publique dans le dossier d'Alice
import os
alice_dir = r"C:\Users\zoran\Documents\Projet_Crypto\Alice"
os.makedirs(alice_dir, exist_ok=True)
with open(os.path.join(alice_dir, "bob_kyber_pk.bin"), "wb") as f:
    f.write(pk)

Résumé : Chaque participant dispose ainsi de ses propres clés privées (RSA et Kyber) et exporte ses clés publiques dans le dossier de l'autre, permettant à chacun de chiffrer des secrets à destination de l'autre.

keygen() (Kyber) : génère une paire de clés publique/privée pour Kyber
export_keys_if_needed() : exporte la clé publique dans le dossier de l'autre partie

Encapsulation et décapsulation

L'encapsulation permet à une partie (ex : Bob) de générer un secret partagé, de le chiffrer avec la clé publique de l'autre (ex : Alice), puis de lui transmettre ce secret chiffré. La décapsulation permet à Alice de retrouver ce secret à l'aide de sa clé privée. Ce mécanisme est réalisé à la fois pour RSA (classique) et Kyber (post-quantique).

RSA

Encapsulation : Bob génère une clé symétrique aléatoire (par exemple 32 octets), puis la chiffre avec la clé publique RSA d'Alice à l'aide du schéma OAEP.
Décapsulation : Alice utilise sa clé privée RSA pour déchiffrer le secret reçu et retrouver la même clé symétrique.


# Encapsulation RSA (Bob)
from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.primitives import hashes
import os

K_RSA_to_alice = os.urandom(32)  # Génère un secret aléatoire
C_RSA_to_alice = alice_rsa_public.encrypt(
    K_RSA_to_alice,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)
# Bob envoie C_RSA_to_alice à Alice

# Décapsulation RSA (Alice)
K_RSA_from_bob = alice_rsa_private.decrypt(
    C_RSA_to_alice,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)
# Alice retrouve le même secret K_RSA_to_alice

Avantage : RSA est bien connu et robuste contre les attaques classiques, mais vulnérable à un attaquant quantique. D'où l'intérêt de l'associer à Kyber.

Kyber (version pédagogique simplifiée)

Encapsulation : Bob utilise la clé publique Kyber d'Alice pour encapsuler un secret partagé, produisant un chiffré (u_comp) et une clé partagée K_Kyber_to_alice.
Décapsulation : Alice utilise sa clé privée Kyber pour décapsuler le chiffré reçu et retrouver la même clé partagée.


# Encapsulation Kyber (Bob)
import simple_kyber512

C_Kyber_to_alice, K_Kyber_to_alice = simple_kyber512.encapsulate(alice_kyber_pk)
# Bob envoie C_Kyber_to_alice à Alice

# Décapsulation Kyber (Alice)
K_Kyber_from_bob = simple_kyber512.decapsulate(C_Kyber_to_alice, alice_kyber_sk)
# Alice retrouve le même secret K_Kyber_to_alice

Avantage : Kyber repose sur des problèmes difficiles même pour un ordinateur quantique (lattices), ce qui garantit la sécurité post-quantique du protocole.

Résumé : Les deux encapsulations sont réalisées dans les deux sens (Alice→Bob et Bob→Alice), puis les secrets obtenus sont combinés via HKDF pour obtenir une clé finale commune.

encapsulate(pk_bytes) : encapsule une clé partagée avec la clé publique Kyber
decapsulate(u_comp_bytes, sk_bytes) : récupère la clé partagée à partir du chiffré et de la clé secrète

Dérivation de la clé finale

Après l'encapsulation et la décapsulation des secrets RSA et Kyber dans les deux sens (Alice→Bob et Bob→Alice), chaque partie possède quatre secrets :

K_RSA_to_alice : secret généré par Bob, chiffré pour Alice (RSA)
K_Kyber_to_alice : secret généré par Bob, encapsulé pour Alice (Kyber)
K_RSA_to_bob : secret généré par Alice, chiffré pour Bob (RSA)
K_Kyber_to_bob : secret généré par Alice, encapsulé pour Bob (Kyber)

Pour obtenir une clé de session commune, ces quatre secrets sont concaténés dans le même ordre par Alice et Bob, puis passés à une fonction de dérivation de clé (HKDF avec SHA-256). Cela garantit que la clé finale (K_final) est identique pour les deux parties, tout en étant robuste contre les attaques classiques et quantiques.


# Dérivation de la clé finale commune avec HKDF (extrait des scripts Alice/Bob)
from cryptography.hazmat.primitives.kdf.hkdf import HKDF
from cryptography.hazmat.primitives import hashes

KDF = HKDF(
    algorithm=hashes.SHA256(),
    length=32,
    salt=None,
    info=b"KEM_RSA+Kyber",
)
K_final = KDF.derive(
    K_RSA_to_alice + K_Kyber_to_alice + K_RSA_to_bob + K_Kyber_to_bob
)
# K_final est la clé symétrique commune utilisée pour AES-GCM

Points importants :

L'ordre de concaténation des secrets doit être strictement identique pour Alice et Bob, sinon la clé finale sera différente.
HKDF (HMAC-based Key Derivation Function) permet de "mélanger" plusieurs secrets pour produire une clé unique, même si l'un des secrets est compromis.
La clé finale K_final n'est jamais transmise : elle est dérivée localement par chaque partie à partir des secrets échangés.

Utilisation : Cette clé K_final sert ensuite à chiffrer/déchiffrer les messages échangés entre Alice et Bob via AES-GCM, assurant la confidentialité et l'intégrité des communications.

Chiffrement symétrique

Une fois la clé finale K_final dérivée, Alice et Bob peuvent échanger des messages chiffrés en toute sécurité. Le chiffrement symétrique utilisé ici est AES-GCM (Galois/Counter Mode), qui offre à la fois la confidentialité et l'intégrité des messages.

Chiffrement : Le message est chiffré avec AESGCM en utilisant K_final comme clé et un nonce aléatoire de 12 octets. Le résultat (nonce + ciphertext) est envoyé à l'autre partie.
Déchiffrement : Le destinataire lit le nonce et le ciphertext, puis utilise AESGCM avec la même clé K_final pour retrouver le message original.


# Chiffrement d'un message (extrait des interfaces Alice/Bob)
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
import os

aesgcm = AESGCM(K_final)
nonce = os.urandom(12)
ciphertext = aesgcm.encrypt(nonce, b"Message secret", None)
# Envoi : écrire nonce + ciphertext dans un fichier partagé

# Déchiffrement d'un message reçu
aesgcm = AESGCM(K_final)
# Lire nonce (12 octets) et ciphertext depuis le fichier
plaintext = aesgcm.decrypt(nonce, ciphertext, None)
# plaintext contient le message original

Avantages d'AES-GCM :

Le mode GCM assure la confidentialité et l'intégrité du message (authentification intégrée).
Le nonce doit être unique pour chaque message chiffré avec la même clé.
Le schéma est simple à utiliser et très performant.

Dans le projet : Les messages sont échangés via des fichiers (ex : message_aesgcm_from_alice.bin), chaque fichier contenant d'abord le nonce puis le ciphertext. Les interfaces graphiques Alice/Bob automatisent ce processus pour l'utilisateur.

Rapport d'étude : Échange de Clé Hybride RSA + Kyber (KEM)

Introduction

Ce rapport détaille mathématiquement et numériquement le protocole d'échange de clé hybride RSA + Kyber, avec exemples chiffrés, calculs étape par étape, et explications pédagogiques. Les deux parties (Alice et Bob) peuvent initier la procédure, qui est totalement symétrique.

Remarque sur l'encapsulation

Dans ce protocole hybride, l'encapsulation KEM est réalisée à la fois avec Kyber et avec RSA. Cela signifie que, tout comme pour Kyber, une clé symétrique aléatoire est générée puis encapsulée (chiffrée) à l'aide de la clé publique RSA du destinataire. Cette encapsulation RSA consiste à chiffrer la clé symétrique $ K_{RSA} $ avec la clé publique $(e, n)$ :

C_{RSA} = K_{RSA}^e \mod n

Le destinataire décapsule (décrypte) la clé symétrique à l'aide de sa clé privée $ d $ :

K_{RSA} = C_{RSA}^d \mod n

Ainsi, le protocole utilise deux KEM indépendants :

Un KEM classique basé sur RSA (encapsulation/décapsulation de $ K_{RSA} $)
Un KEM post-quantique basé sur Kyber (encapsulation/décapsulation de $ K_{Kyber} $)

Les deux clés symétriques issues de ces encapsulations sont ensuite fusionnées via la KDF pour obtenir la clé finale $ K_{\text{final}} $.

Étape 1 — Génération des clés RSA (par Alice ou par Bob)

Génération de clés RSA :

Choix des deux nombres premiers : $p = 5,\quad q = 11$
Calcul du module : $n = p \times q = 5 \times 11 = 55$
Calcul de la fonction d’Euler : $\varphi(n) = (p - 1)(q - 1) = 4 \times 10 = 40$
Choix de l’exposant public $ e = 3 $, avec $ \gcd(3, 40) = 1 $
Calcul de la clé privée $ d $, tel que : $e \cdot d \equiv 1 \mod \varphi(n) \Rightarrow 3 \cdot d \equiv 1 \mod 40$
Par test ou algorithme d’Euclide étendu : $d = 27,\quad \text{car } 3 \cdot 27 = 81 \equiv 1 \mod 40$

Clés générées :

Clé publique : $ (e = 3,\ n = 55) $
Clé privée : $ (d = 27,\ n = 55) $

Étape 2 — Encapsulation RSA (par Bob)

Dans le protocole hybride, l'encapsulation KEM sur RSA consiste à générer une clé symétrique aléatoire $ K_{RSA} $ (par exemple, un entier ou une suite d'octets), puis à la chiffrer avec la clé publique RSA du destinataire.

Bob génère une clé symétrique aléatoire : $K_{RSA} = 13$
Il encapsule cette clé en la chiffrant avec la clé publique d’Alice $(e, n)$ : $C_{RSA} = K_{RSA}^e \mod n = 13^3 \mod 55$
Calcul détaillé : $13^3 = 2197,\quad 2197 \mod 55 = 2197 - 55 \times 39 = 52$
Résultat de l'encapsulation : $C_{RSA} = 52$
Bob envoie $ C_{RSA} $ à Alice. Cette valeur est l'encapsulation RSA de la clé symétrique $ K_{RSA} $.

Étape 3 — Décapsulation RSA (par Alice)

Alice reçoit l'encapsulation $ C_{RSA} = 52 $.
Elle utilise sa clé privée $(d, n)$ pour décapsuler (décrypter) la clé symétrique : $K_{RSA} = C_{RSA}^d \mod n = 52^{27} \mod 55$
Calcul détaillé par exponentiation modulaire rapide : $52^2 = 2704 \mod 55 = 9 $$ $$ 52^4 = 9^2 = 81 \mod 55 = 26 $$ $$ 52^8 = 26^2 = 676 \mod 55 = 16 $$ $$ 52^{16} = 16^2 = 256 \mod 55 = 36$
Décomposition de 27 : $27 = 16 + 8 + 2 + 1 \Rightarrow 52^{27} = 52^{16} \cdot 52^8 \cdot 52^2 \cdot 52 \mod 55$
Calcul : $36 \cdot 16 = 576 \mod 55 = 26 $$ $$ 26 \cdot 9 = 234 \mod 55 = 14 $$ $$ 14 \cdot 52 = 728 \mod 55 = 13$
Résultat de la décapsulation : $K_{RSA} = 13$
Alice retrouve ainsi la clé symétrique générée par Bob.

Étape 4 — Génération et encapsulation Kyber (exemple simplifié)

Paramètres simplifiés :

Modulo : $ q = 17 $
Vecteurs et matrices : dimension $ 2 $

Génération de la clé publique d'Alice :

Clé privée : $ \mathbf{s} = \begin{bmatrix} 3 \\ 4 \end{bmatrix} $
Bruit : $ \mathbf{e} = \begin{bmatrix} 1 \\ 2 \end{bmatrix} $
Matrice publique : $\mathbf{A} = \begin{bmatrix} 6 & 7 \\ 5 & 9 \end{bmatrix}$
Calcul de la clé publique : $\mathbf{t} = \mathbf{A} \cdot \mathbf{s} + \mathbf{e} \mod q $$ $$ \mathbf{t} = \begin{bmatrix} 6 & 7 \\ 5 & 9 \end{bmatrix} \cdot \begin{bmatrix} 3 \\ 4 \end{bmatrix} + \begin{bmatrix} 1 \\ 2 \end{bmatrix} = \begin{bmatrix} 18 + 28 + 1 \\ 15 + 36 + 2 \end{bmatrix} = \begin{bmatrix} 47 \\ 53 \end{bmatrix} \mod 17 = \begin{bmatrix} 13 \\ 2 \end{bmatrix}$

Encapsulation par Bob :

Vecteur aléatoire : $ \mathbf{r} = \begin{bmatrix} 2 \\ 1 \end{bmatrix} $
Bruit $ \mathbf{e}_1 = \begin{bmatrix} 1 \\ 1 \end{bmatrix} $, $ e_2 = 2 $
Clé à encapsuler : $ K = 3 $
Calcul de : $\mathbf{u} = \mathbf{A} \cdot \mathbf{r} + \mathbf{e}_1 \mod q $$ $$ \mathbf{u} = \begin{bmatrix} 6 & 7 \\ 5 & 9 \end{bmatrix} \cdot \begin{bmatrix} 2 \\ 1 \end{bmatrix} + \begin{bmatrix} 1 \\ 1 \end{bmatrix} = \begin{bmatrix} 12 + 7 + 1 \\ 10 + 9 + 1 \end{bmatrix} = \begin{bmatrix} 20 \\ 20 \end{bmatrix} \mod 17 = \begin{bmatrix} 3 \\ 3 \end{bmatrix}$
Calcul de : $v = \mathbf{t}^T \cdot \mathbf{r} + e_2 + K \mod q $$ $$ v = [13\quad 2] \cdot \begin{bmatrix} 2 \\ 1 \end{bmatrix} + 2 + 3 = 13 \times 2 + 2 \times 1 + 5 = 26 + 2 + 5 = 33 \mod 17 = 16$

Décapsulation par Alice :

Reçoit : $ \mathbf{u}, v $
Calcule : $\mathbf{u}^T \cdot \mathbf{s} = [3\quad 3] \cdot \begin{bmatrix} 3 \\ 4 \end{bmatrix} = 3 \times 3 + 3 \times 4 = 9 + 12 = 21 \mod 17 = 4$
Retrouve : $v - \mathbf{u}^T \cdot \mathbf{s} = 16 - 4 = 12 \mod 17$
Soustraction du bruit : $K = (v - \mathbf{u}^T \cdot \mathbf{s} - e_2) \mod 17 = (12 - 2) \mod 17 = 10 \mod 17 = 10$ (Remarque : en vrai, $ K $ est recodé avec decode(), ici c’est illustratif.)

Étape 5 — Fusion via KDF (HKDF-SHA256)

Concaténation des clés pour la KDF :

$ K_{RSA \rightarrow Alice} $ : 73a14453b96e54a32fbc4a8d67870e62ba43a935a79bf269861179b2fc695028
$ K_{Kyber \rightarrow Alice} $ : 2f0fd1e89b8de1d57292742ec380ea47066e307ad645f5bc3adad8a06ff58608
$ K_{RSA \rightarrow Bob} $ : 82de42be5d948f40870bc81fadf1959a8c28e140d88d00f7a2442c133b2cca34
$ K_{Kyber \rightarrow Bob} $ : fcb5f40df9be6bae66c1d77a6c15968866a9e6cbd7314ca432b019d17392f6f4

On concatène les clés dans l'ordre suivant (en notation hexadécimale) :

\text{Concat} = K_{RSA \rightarrow Alice} \| K_{Kyber \rightarrow Alice} \| K_{RSA \rightarrow Bob} \| K_{Kyber \rightarrow Bob}

concat = (
    bytes.fromhex("73a14453b96e54a32fbc4a8d67870e62ba43a935a79bf269861179b2fc695028") +
    bytes.fromhex("2f0fd1e89b8de1d57292742ec380ea47066e307ad645f5bc3adad8a06ff58608") +
    bytes.fromhex("82de42be5d948f40870bc81fadf1959a8c28e140d88d00f7a2442c133b2cca34") +
    bytes.fromhex("fcb5f40df9be6bae66c1d77a6c15968866a9e6cbd7314ca432b019d17392f6f4")
)

Calcul de la KDF (HKDF-SHA256) :

K_{\text{final}} = \text{HKDF}_{\text{SHA256}}(\text{Concat}, \text{length}=32)

Valeur obtenue dans la démo :

K_final : b759b7c6a96735788d9c1426448cedf653063ca530dcce6f9f3eae04aa1392ea

Étape 6 — Utilisation de la clé finale pour AES-GCM

Supposons que l'on souhaite chiffrer le message "Bonjour Bob" avec un nonce d'exemple :

Nonce : 00112233445566778899aabb (12 octets)
Message : "Bonjour Bob"

from cryptography.hazmat.primitives.ciphers.aead import AESGCM

key = bytes.fromhex("b759b7c6a96735788d9c1426448cedf653063ca530dcce6f9f3eae04aa1392ea")
nonce = bytes.fromhex("00112233445566778899aabb")
message = b"Bonjour Bob"

aesgcm = AESGCM(key)
ciphertext = aesgcm.encrypt(nonce, message, None)
print(ciphertext.hex())

Remarque : Le résultat du chiffrement dépendra du message, du nonce et de la clé.

Résumé des étapes numériques

Générer ou lire les clés $ K_{RSA \rightarrow Alice} $, $ K_{Kyber \rightarrow Alice} $, $ K_{RSA \rightarrow Bob} $, $ K_{Kyber \rightarrow Bob} $.
Concaténer les clés dans l'ordre indiqué.
Appliquer HKDF-SHA256 pour obtenir $ K_{\text{final}} $.
Utiliser $ K_{\text{final}} $ comme clé AES-GCM pour chiffrer/déchiffrer les messages.

Conclusion

Ce protocole hybride RSA + Kyber permet un échange de clé sécurisé, résistant aux attaques classiques et quantiques. Il est totalement symétrique : Alice ou Bob peut initier l’échange. Tous les calculs sont reproductibles et vérifiables étape par étape.

Annexe : Explication des fonctions du code

Fonctions principales de `KEM_RSA_Alice.py`

file_exists_anywhere(filename, dir1, dir2) : Vérifie si un fichier nommé filename existe dans l'un des deux dossiers dir1 ou dir2. Retourne un booléen.
read_anywhere(filename, prefer_dir, other_dir) : Ouvre et lit le fichier filename en cherchant d'abord dans prefer_dir, puis dans other_dir. Retourne le contenu binaire du fichier.
export_keys_if_needed() : Exporte la clé publique RSA et la clé publique Kyber d'Alice dans le dossier de Bob, pour permettre à Bob de les utiliser pour l'encapsulation.
Génération/chargement des clés RSA et Kyber : Génère une paire de clés RSA et une paire de clés Kyber si elles n'existent pas déjà, sinon les charge depuis les fichiers.
Récupération des clés publiques de Bob : Charge les clés publiques RSA et Kyber de Bob depuis le dossier de Bob.
Encapsulation vers Bob : Génère deux clés symétriques aléatoires, encapsule l'une avec RSA (clé publique de Bob), l'autre avec Kyber (clé publique de Bob), et sauvegarde les encapsulations et les clés.
Recherche et lecture des fichiers d'échange : Vérifie la présence de tous les fichiers nécessaires à la dérivation de la clé finale (KDF).
Décapsulation des clés reçues de Bob : Déchiffre la clé RSA reçue avec la clé privée d'Alice, décapsule la clé Kyber reçue avec la clé privée Kyber d'Alice.
KDF (HKDF) : Concatène les 4 clés (2 envoyées, 2 reçues) et applique HKDF-SHA256 pour obtenir la clé finale utilisée pour AES-GCM.
Chiffrement/déchiffrement de messages : Utilise la clé finale pour chiffrer/déchiffrer des messages avec AES-GCM.

Fonctions principales de `simple_kyber512.py` (version pédagogique)

keygen() : Génère une paire de clés Kyber (publique et privée). En version simplifiée, cela peut être des vecteurs/matrices aléatoires et du bruit.
encapsulate(pk) : Prend une clé publique Kyber, génère un vecteur aléatoire, encapsule une clé symétrique, et retourne l'encapsulation (ciphertext) et la clé partagée.
decapsulate(ciphertext, sk) : Prend l'encapsulation et la clé privée, effectue les opérations inverses pour retrouver la clé partagée.
(Dans la vraie version, il y a compression, décompression, extraction de bits, etc. Ici, la logique est illustrée avec des opérations sur de petits entiers ou vecteurs.)

Annexe : Explication détaillée du fonctionnement du code (scénario Alice ↔ Bob)

Déroulement d'un échange complet

Initialisation des clés :
- Alice et Bob génèrent chacun une paire de clés RSA et une paire de clés Kyber (si elles n'existent pas déjà).
- Les clés publiques sont exportées dans le dossier de l'autre partie pour permettre l'encapsulation.
Encapsulation et échange de clés :
- Chacun encapsule une clé symétrique pour l'autre avec RSA (clé publique de l'autre) et Kyber (clé publique de l'autre).
- Les encapsulations (ciphertexts) et les clés symétriques générées sont sauvegardées dans des fichiers d'échange.
Décapsulation et dérivation de la clé finale :
- Chaque partie récupère les encapsulations reçues et utilise ses clés privées pour décapsuler les clés symétriques envoyées par l'autre.
- Les 4 clés symétriques (2 envoyées, 2 reçues) sont concaténées et passées dans la KDF (HKDF-SHA256) pour obtenir la clé finale $ K_{\text{final}} $.
Échange de messages chiffrés :
- Alice et Bob peuvent maintenant s'envoyer des messages chiffrés avec AES-GCM en utilisant $ K_{\text{final}} $.
- Les messages sont écrits dans des fichiers spécifiques (message_aesgcm_from_alice.bin, message_aesgcm_from_bob.bin).
- À la réception, chaque partie lit le fichier, déchiffre le message, puis peut supprimer le fichier pour éviter les doublons ou pour des raisons de sécurité.
Gestion des fichiers d'échange :
- Avant chaque nouvel échange, le script vérifie la présence des fichiers d'échange existants.
- Si des fichiers sont présents, l'utilisateur peut choisir de les supprimer pour repartir sur un échange propre (option proposée dans le script).
- Cela évite les collisions ou l'utilisation de vieilles clés/messages.

Résumé du flux de fichiers

Clés publiques : échangées via fichiers (alice_rsa_public.pem, bob_kyber_pk.bin, etc.)
Encapsulations et clés symétriques : échangées via fichiers (C_RSA_to_bob.bin, K_Kyber_to_alice.bin, etc.)
Clé finale : stockée dans K_final.bin
Messages chiffrés : échangés via fichiers (message_aesgcm_from_alice.bin, message_aesgcm_from_bob.bin)
Suppression : possible à tout moment pour réinitialiser l'état de l'échange.

Sécurité et bonnes pratiques

La suppression des fichiers d'échange après utilisation limite les risques de réutilisation ou de fuite de clés/messages.
L'utilisateur est toujours averti de la présence de fichiers existants et peut choisir de les supprimer.
Le protocole est symétrique : Alice et Bob peuvent initier ou relancer l'échange à tout moment.

Résumé

Le code permet un échange de clé hybride sécurisé, automatisé et reproductible, avec gestion complète des fichiers d'échange et possibilité de suppression pour garantir la fraîcheur et la sécurité des échanges.

PQC Hybrid: RSA & Kyber

Présentation du projet

Enjeux de la cryptographie post-quantique

Fonctionnement général du protocole

Détail des fonctions principales

Génération et export des clés

RSA

Kyber (version pédagogique simplifiée)

Encapsulation et décapsulation

RSA

Kyber (version pédagogique simplifiée)

Dérivation de la clé finale

Chiffrement symétrique

Rapport d'étude : Échange de Clé Hybride RSA + Kyber (KEM)

Introduction

Remarque sur l'encapsulation

Étape 1 — Génération des clés RSA (par Alice ou par Bob)

Étape 2 — Encapsulation RSA (par Bob)

Étape 3 — Décapsulation RSA (par Alice)

Étape 4 — Génération et encapsulation Kyber (exemple simplifié)

Étape 5 — Fusion via KDF (HKDF-SHA256)

Étape 6 — Utilisation de la clé finale pour AES-GCM

Résumé des étapes numériques

Conclusion

Annexe : Explication des fonctions du code

Fonctions principales de `KEM_RSA_Alice.py`

Fonctions principales de `simple_kyber512.py` (version pédagogique)

Annexe : Explication détaillée du fonctionnement du code (scénario Alice ↔ Bob)

Déroulement d'un échange complet

Résumé du flux de fichiers

Sécurité et bonnes pratiques

Résumé

Pour aller plus loin

Présentation du projet

Enjeux de la cryptographie post-quantique

Fonctionnement général du protocole

Détail des fonctions principales

Génération et export des clés

RSA

Kyber (version pédagogique simplifiée)

Encapsulation et décapsulation

RSA

Kyber (version pédagogique simplifiée)

Dérivation de la clé finale

Chiffrement symétrique

Rapport d'étude : Échange de Clé Hybride RSA + Kyber (KEM)

Introduction

Remarque sur l'encapsulation

Étape 1 — Génération des clés RSA (par Alice ou par Bob)

Étape 2 — Encapsulation RSA (par Bob)

Étape 3 — Décapsulation RSA (par Alice)

Étape 4 — Génération et encapsulation Kyber (exemple simplifié)

Étape 5 — Fusion via KDF (HKDF-SHA256)

Étape 6 — Utilisation de la clé finale pour AES-GCM

Résumé des étapes numériques

Conclusion

Annexe : Explication des fonctions du code

Fonctions principales de KEM_RSA_Alice.py

Fonctions principales de simple_kyber512.py (version pédagogique)

Annexe : Explication détaillée du fonctionnement du code (scénario Alice ↔ Bob)

Déroulement d'un échange complet

Résumé du flux de fichiers

Sécurité et bonnes pratiques

Résumé

Pour aller plus loin

Fonctions principales de `KEM_RSA_Alice.py`

Fonctions principales de `simple_kyber512.py` (version pédagogique)