Communication sécurisée avec RSA et AES: Messagerie chiffrée sur Raspberry Pi 5

L’envoi sécurisé d’une clé à un destinataire est un problème ancien. L’émetteur et le récepteur doivent convenir d’une clé et la garder secrète. S’ils se trouvent à des endroits différents, ils doivent utiliser un courrier fiable ou un autre moyen de communication sécurisé pour partager la clé et éviter toute divulgation pendant la transmission. Toute personne ayant accès à la clé durant son transit peut lire, modifier et falsifier sans autorisation les informations chiffrées.

Les problèmes de distribution de clés sont résolus par la cryptographie asymétrique, aussi appelée cryptographie à clé publique. Ce concept a été introduit en 1975 par Whitfield Diffie et Martin Hellman. La cryptographie à clé publique utilise des techniques mathématiques faciles à calculer dans un sens mais extrêmement difficiles à inverser. La cryptographie asymétrique simplifie fortement l’échange de clés sur un support non sécurisé. Parmi les algorithmes asymétriques courants figurent RSA (Rivest-Shamir-Adleman) et ECC (Elliptic Curve Cryptography). RSA repose sur la factorisation de grands nombres premiers, opération extrêmement difficile, tandis qu’ECC utilise des clés plus courtes et nécessite moins de calculs.

AES (Advanced Encryption Standard) est un algorithme de chiffrement symétrique utilisant la même clé pour le chiffrement et le déchiffrement. Il est largement utilisé pour le chiffrement rapide des données, tandis que des algorithmes asymétriques comme RSA servent généralement à l’échange sécurisé de clés.

Dans cet article, nous nous concentrons sur l’utilisation conjointe de RSA et d’AES afin de mettre en œuvre un système de communication sécurisé entre deux appareils embarqués.

Communication sécurisée entre deux correspondants avec AES et RSA

Les notes ci-dessous reposent sur l’utilisation du chiffrement AES-256 en mode ECB et sur la génération de clés publique/privée RSA-1024 afin d’établir une communication sécurisée entre deux nœuds. Vous pouvez appliquer les mêmes étapes au mode AES GCM et/ou à des tailles de clés RSA plus longues si vous le souhaitez. Un programme complet pour Raspberry Pi 5 est présenté dans la section suivante afin d’établir facilement la communication.
 

1. Envoi d’un message

• Obtenir la clé publique de la seconde partie

• Chiffrer votre texte en clair avec le chiffrement AES-256 afin de générer le texte chiffré. Vous pouvez inclure des mots d’identification dans le texte en clair si vous le souhaitez

• Chiffrer votre clé AES-256 avec RSA

• Envoyer le texte AES chiffré et la clé chiffrée par RSA à la seconde partie, par ex. via email ou un autre moyen de communication

• La seconde partie utilise sa clé privée pour déchiffrer la clé AES-256

• La seconde partie utilise le chiffrement AES-256 avec la clé déchiffrée pour déchiffrer le texte chiffré et générer le texte en clair

2. Réception d’un message

Générer une clé publique et privée avec RSA

• Envoyer la clé publique à la seconde partie, par ex. via email ou un autre moyen de communication

• Recevoir de la seconde partie la clé AES-256 chiffrée par RSA et le texte AES-256 chiffré

• Déchiffrer la clé AES-256 avec l’algorithme de déchiffrement RSA

• Utiliser la clé AES-256 déchiffrée pour déchiffrer le texte chiffré et obtenir le texte en clair

Programme complet d’envoi/réception de messages

Il s’agit d’un programme complet de communication sécurisée. L’utilisateur peut créer une paire de clés privée/publique, saisir la clé publique envoyée par la seconde partie et le texte en clair, ainsi que saisir la clé privée afin de déchiffrer la clé et le message.

Le listing 1 présente le listing du programme (Programme : RSASendReceive.py). La bibliothèque Crypto est importée dans le programme. Le programme est exécuté avec PuTTY via la liaison SSH. La raison est que les données peuvent être facilement copiées et collées avec PuTTY, contrairement à Thonny.

Listing 1: Program RSASendreceive.py (Excerpt).

from Crypto.PublicKey import RSA
from Crypto.Cipher import AES, PKCS1_v1_5
from Crypto.Random import get_random_bytes
from Crypto.Util.Padding import pad
import base64

KEY_SIZE = 1024  # can be changed

def aes256_decrypt(key, ciphertext):
    cipher = AES.new(key, AES.MODE_ECB)
    padded = cipher.decrypt(ciphertext)
    pad_len = padded[-1]
    return padded[:-pad_len]

def print_red(s):
    print("\033[91m%s\033[0m" % s)

# Main program

while True:
    print("\n\nG Generate and display new public/private key")
    print("P Read second party's public key, read plaintext, generate ciphertext using AES-256")
    print("R Read from second party: RSA encrypted key and ciphertext to decrypt plaintext")
    print("X to Exit")

    mode = input("Mode: ")

    if mode == "G":
        key = RSA.generate(KEY_SIZE)
        private_pem = key.export_key()
        public_pem = key.publickey().export_key()

        print(private_pem.decode())
        print(public_pem.decode())

    elif mode == "P":
        rsa_pub_pem = input("Enter PUBLIC KEY:\n")
        rsa_pub_key = RSA.import_key(rsa_pub_pem)

        aes_key = get_random_bytes(32)
        rsa_cipher = PKCS1_v1_5.new(rsa_pub_key)
        encrypted_aes_key = rsa_cipher.encrypt(aes_key)

        plaintext = input("Enter plaintext: ").encode()
        plaintext_padded = pad(plaintext, AES.block_size)

        aes_cipher = AES.new(aes_key, AES.MODE_ECB)
        ciphertext = aes_cipher.encrypt(plaintext_padded)

        print(base64.b64encode(encrypted_aes_key).decode("utf-8"))
        print(ciphertext.hex().upper())

    elif mode == "R":

        ...

        private_pem = input("Enter PRIVATE KEY:\n")
        rsa_key = RSA.import_key(private_pem)
        cipher_rsa = PKCS1_v1_5.new(rsa_key)

        ...

        enc_b64 = input("Enter encrypted AES key (Base64): ")
        encrypted_bytes = base64.b64decode(enc_b64)

        sentinel = b"FAILED"
        aes_key = cipher_rsa.decrypt(encrypted_bytes, sentinel)

        ...

        hex_input = input("Enter ciphertext (Hex): ").replace(" ", "")
        ciphertext = bytes.fromhex(hex_input)

        decrypted = aes256_decrypt(aes_key, ciphertext)
        print(decrypted.decode("utf-8"))

    elif mode == "X":
        break
 

Le menu suivant s’affiche lors de l’exécution du programme :

while True:

    print("\n\nG Generate and display new public/private key")

    print("P Read second party's public key,read plaintext,generate ciphertext using AES-256")

    print("R Read from second party: RSA encrypted key and ciphertext to decrypt plaintext")

    print("X to Exit")

    print()

    mode = input("Mode: ")

La sélection de l’option G génère une paire de clés publique/privée RSA dont la longueur est définie par KEY_SIZE. Bien que KEY_SIZE soit réglé sur 1024, il peut être augmenté pour renforcer la sécurité. Les clés publique et privée générées sont affichées au format PEM à l’écran afin de pouvoir être copiées et collées ultérieurement si nécessaire.
 

La sélection de l’option P invite d’abord l’utilisateur à saisir la clé publique au format PEM. Il s’agit de la clé publique envoyée par la seconde partie. Ensuite, le texte en clair est saisi au clavier et une clé AES-256 de 32 octets est générée. Le texte en clair est chiffré avec AES-256. La clé AES-256 est ensuite chiffrée avec RSA. Le texte chiffré et la clé AES-256 chiffrée sont affichés à l’écran afin de pouvoir être copiés et collés ultérieurement si nécessaire.
 

La sélection de l’option R invite l’utilisateur à saisir la clé privée et la clé AES-256 chiffrée. La clé AES est déchiffrée avec la clé privée. Ensuite, le texte chiffré est déchiffré avec AES-256 à l’aide de la clé déchiffrée. Le texte en clair obtenu est affiché à l’écran. Les sorties importantes du programme sont affichées avec des titres rouges afin d’être facilement repérées.
 

Enfin, la sélection de X termine le programme.
 

Les figure 1 à 3 montrent des exemples d’exécution du programme avec différentes options.

Étude de cas : communiquer secrètement et en toute sécurité

Dans cette étude de cas, nous supposerons que Mary souhaite envoyer un message sécurisé et secret à John. Supposons également qu’ils disposent tous deux d’un Raspberry Pi 5 et qu’ils ont chargé le programme RSASendReceive.py (Listing 1). La procédure est la suivante :

• John creates a public/private key pair by selecting option G in the program (Figure 4) and sends his public key to Mary, e.g., using email or some other communication method available.

• Mary sélectionne l’option P, rédige son message secret en texte clair, génère le texte chiffré avec AES-256, génère une clé AES-256 chiffrée ainsi qu’une clé AES chiffrée par RSA (figure 5). Mary peut convenir à l’avance avec John d’inclure, par ex. la date et/ou l’heure (ou un compteur) au début de son texte en clair afin que John sache que le message provient d’elle.

• Mary envoie le texte chiffré et la clé AES-256 chiffrée à John, par ex. via email ou un autre moyen de communication.

• John sélectionne l’option R afin de déchiffrer la clé AES-256 puis le texte chiffré afin d’obtenir le texte en clair lisible (figure 6).

Cet article a montré comment mettre en œuvre en pratique une communication sécurisée à l’aide d’une combinaison de cryptographie asymétrique et symétrique. En utilisant RSA pour l’échange de clés et AES-256 pour le chiffrement des données, il est possible d’obtenir une méthode fiable et efficace de transmission d’informations confidentielles entre appareils embarqués. L’implémentation sur Raspberry Pi 5 montre que même des systèmes relativement simples peuvent prendre en charge des techniques cryptographiques modernes à l’aide d’un logiciel simple. Bien que l’exemple utilise AES en mode ECB et RSA-1024 pour des raisons de simplicité, la même approche peut être étendue à des configurations plus sûres, telles qu’AES-GCM et des tailles de clés plus grandes, ce qui la rend adaptée à un large éventail d’applications embarquées et IoT.

Questions ou commentaires ?

Envoyez un courriel à l'auteur (d.ibrahim@btinternet.com), ou contactez Elektor (redaction@elektor.fr)

Note de la rédaction : Cet article (260216-01) est un extrait de l'ouvrage Practical Microcontroller Cryptography (Elektor, 2026). Il a été mis en page et légèrement révisé afin de respecter les conventions et la mise en page d'Elektor.