Sichere Kommunikation mit RSA und AES: Verschlüsselte Nachrichtenübertragung auf dem Raspberry Pi 5

Das sichere Senden eines Schlüssels an einen Empfänger ist seit vielen Jahren ein Problem. Sender und Empfänger müssen sich auf einen Schlüssel einigen und ihn geheim halten. Befinden sie sich an unterschiedlichen Orten, müssen sie einen vertrauenswürdigen Kurier oder eine andere sichere Kommunikation verwenden, um den Schlüssel zu teilen und seine Offenlegung während der Übertragung zu verhindern. Jeder, der während der Übertragung Zugriff auf den Schlüssel hat, kann die verschlüsselten Informationen ohne Autorisierung lesen, ändern und fälschen.
 

Die Probleme der Schlüsselverteilung werden durch asymmetrische Kryptografie gelöst, auch Public-Key-Kryptografie genannt. Dieses Konzept wurde 1975 von Whitfield Diffie und Martin Hellman eingeführt. Die Public-Key-Kryptografie verwendet mathematische Verfahren, die in eine Richtung leicht, in umgekehrter Richtung jedoch extrem schwierig zu berechnen sind. Asymmetrische Kryptografie vereinfacht den Austausch von Schlüsseln über ein unsicheres Medium erheblich. Häufig verwendete asymmetrische Algorithmen sind RSA (Rivest-Shamir-Adleman) und ECC (Elliptic Curve Cryptography). RSA basiert auf der Faktorisierung großer Primzahlen, was äußerst aufwendig ist, während ECC kleinere Schlüsselgrößen und weniger Rechenaufwand verwendet.
 

AES (Advanced Encryption Standard) ist ein symmetrischer Verschlüsselungsalgorithmus, der denselben Schlüssel für Verschlüsselung und Entschlüsselung verwendet und häufig für schnelle Datenverschlüsselung eingesetzt wird, während asymmetrische Algorithmen wie RSA typischerweise für den sicheren Schlüsselaustausch verwendet werden.
 

In diesem Artikel konzentrieren wir uns darauf, RSA zusammen mit AES zu verwenden, um ein sicheres Kommunikationssystem zwischen zwei Embedded-Geräten zu implementieren.

Sichere Kommunikation zwischen zwei Stationen mit AES und RSA

Die folgenden Informationen basieren auf der Verwendung der AES-256-Chiffre im ECB-Modus und der RSA-1024-Erzeugung öffentlicher/privater Schlüssel, um eine sichere Kommunikation zwischen zwei Stationen herzustellen. Sie können dieselben Schritte auch für den AES-GCM-Modus und/oder längere RSA-Schlüsselgrößen verwenden. Im folgenden Abschnitt wird ein vollständiges Raspberry-Pi-5-Programm vorgestellt, mit dem die Kommunikation einfach eingerichtet werden kann.
 

1. Senden einer Nachricht

• Öffentlichen Schlüssel des Empfängers abrufen.

• Klartext mit der AES-256-Chiffre verschlüsseln, um Chiffretext zu erzeugen. Sie können bei Bedarf Identifikationswörter in den Klartext aufnehmen.

• AES-256-Schlüssel mit RSA verschlüsseln.

• AES-Chiffretext und den RSA-verschlüsselten Schlüssel an den Empfänger senden, z. B. per E-Mail oder über ein anderes Kommunikationsmittel.

• Der Empfänger verwendet seinen privaten Schlüssel, um den AES-256-Schlüssel zu entschlüsseln.

• Der Empfänger verwendet die AES-256-Chiffre mit dem entschlüsselten Schlüssel, um den Chiffretext zu entschlüsseln und den Klartext zu erzeugen.
 

2. Empfangen einer Nachricht

• Schlüsselpaar (öffentlichen und privaten Schlüssel) mit RSA erzeugen.

• Öffentlichen Schlüssel an die andere Station senden, z. B. per E-Mail oder über eine andere Kommunikationsform.

• RSA-verschlüsselten AES-256-Schlüssel und AES-256-Chiffretext von der anderen Station empfangen.

• AES-256-Schlüssel mit dem RSA-Entschlüsselungsalgorithmus entschlüsseln.

• Entschlüsselten AES-256-Schlüssel verwenden, um den Chiffretext zu entschlüsseln und den Klartext zu erhalten.

Vollständiges Programm zum Senden/Empfangen von Nachrichten

Dies ist ein vollständiges Programm für sichere Kommunikation. Der Benutzer erhält die Optionen, ein Schlüsselpaar zu erstellen, den von der zweiten Partei gesendeten öffentlichen Schlüssel und den Klartext einzugeben sowie den privaten Schlüssel einzugeben, um den Schlüssel und die Nachricht zu entschlüsseln.

Listing 1 zeigt den Code des Programms (RSASendReceive.py). Die Crypto-Bibliothek wird in das Programm importiert. Das Programm wird mit PuTTY über die SSH-Verbindung ausgeführt. Der Grund dafür ist, dass Daten mit PuTTY leicht kopiert und eingefügt werden können, in Thonny jedoch nicht.

Listing 1. Programm RSASendreceive.py (Auszug).

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 plain text, generate cipher text using AES-256")
    print("R Read from second party: RSA-encrypted key and cipher text to decrypt plain text")
    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 plain text: ").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 cipher text (Hex): ").replace(" ", "")
        ciphertext = bytes.fromhex(hex_input)

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

    elif mode == "X":
        break

Das folgende Menü wird angezeigt, wenn das Programm ausgeführt wird:

while True:

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

    print("P Read second party's public key, read plain text, generate cipher text using AES-256")

    print("R Read from second party: RSA encrypted key and cipher text to decrypt plain text")

    print("X to Exit")

    print()

    mode = input("Mode: ")

Die Auswahl der Option G erzeugt ein RSA-Schlüsselpaar mit der durch KEY_SIZE festgelegten Schlüssellänge. KEY_SIZE ist auf 1024 gesetzt, kann aber für höhere Sicherheit erhöht werden. Sowohl der erzeugte öffentliche als auch der private Schlüssel werden im PEM-Format auf dem Bildschirm angezeigt, sodass sie bei späterem Bedarf kopiert und eingefügt werden können.
 

Bei Auswahl der Option P wird der Benutzer zunächst aufgefordert, den öffentlichen Schlüssel im PEM-Format einzugeben. Dies ist der von der anderen Station gesendete öffentliche Schlüssel. Anschließend wird der Klartext über die Tastatur eingelesen und ein 32-Byte-AES-256-Schlüssel erzeugt. Der Klartext wird mit der AES-256-Chiffre verschlüsselt. Danach wird der AES-256-Schlüssel mit RSA verschlüsselt. Der verschlüsselte Chiffretext und der verschlüsselte AES-256-Schlüssel werden auf dem Bildschirm angezeigt, sodass sie bei späterem Bedarf kopiert und eingefügt werden können.
 

Bei Auswahl der Option R wird der Benutzer aufgefordert, den privaten Schlüssel und den verschlüsselten AES-256-Schlüssel einzugeben. Der AES-Schlüssel wird mit dem privaten Schlüssel entschlüsselt. Anschließend wird der Chiffretext mit der AES-256-Chiffre und dem entschlüsselten Schlüssel entschlüsselt. Der resultierende Klartext wird auf dem Bildschirm angezeigt.
 

Wichtige Ausgaben des Programms werden mit rot gefärbten Überschriften angezeigt, sodass sie leicht zu erkennen sind.
 

Schließlich beendet die Auswahl von X das Programm.
 

Bild 1 bis Bild 3 zeigen Beispielausführungen des Programms mit verschiedenen Optionen.

Fallstudie: geheime und sichere Kommunikation

In dieser Fallstudie nehmen wir an, dass Mary eine sichere und geheime Nachricht an John senden möchte. Nehmen wir außerdem an, dass beide einen Raspberry Pi 5 besitzen und das Programm RSASendReceive.py geladen haben (Listing 1). Das Verfahren ist wie folgt:
 

• John erstellt ein Schlüsselpaar, indem er im Programm die Option G auswählt (Bild 4), und sendet seinen öffentlichen Schlüssel an Mary, z. B. per E-Mail oder über eine andere verfügbare Kommunikationsmethode.

• Mary wählt die Option P, schreibt ihre geheime Nachricht als Klartext, erzeugt mit AES-256 Chiffretext, erzeugt einen verschlüsselten AES-256-Schlüssel und einen RSA-verschlüsselten AES-Schlüssel (Bild 5). Mary kann im Voraus mit John vereinbaren, z. B. Datum und/oder Uhrzeit (oder einen Zähler) am Anfang ihres Klartexts einzufügen, um sicherzustellen, dass John weiß, dass die Nachricht von ihr stammt.

• Mary sendet den Chiffretext und den verschlüsselten AES-256-Schlüssel an John, z. B. per E-Mail oder über ein anderes Kommunikationsmittel.

• John wählt die Option R, um den AES-256-Schlüssel zu entschlüsseln und schließlich den Chiffretext zu entschlüsseln, um den lesbaren Klartext zu erzeugen (Bild 6).

Dieser Artikel hat gezeigt, wie sichere Kommunikation in der Praxis durch eine Kombination aus asymmetrischer und symmetrischer Kryptografie implementiert werden kann. Durch die Verwendung von RSA für den Schlüsselaustausch und AES-256 für die Datenverschlüsselung lässt sich eine zuverlässige und effiziente Methode zur Übertragung vertraulicher Informationen zwischen Embedded-Geräten erreichen. Die Raspberry-Pi-5-Implementierung zeigt, dass selbst relativ einfache Systeme moderne kryptografische Verfahren mit unkomplizierter Software unterstützen können. Obwohl das Beispiel der Einfachheit halber AES im ECB-Modus und RSA-1024 verwendet, kann derselbe Ansatz auf sicherere Konfigurationen wie AES-GCM und größere Schlüsselgrößen erweitert werden, sodass er für eine Vielzahl von Embedded- und IoT-Anwendungen geeignet ist.

Fragen oder Kommentare?

Haben Sie Fragen oder Kommentare zu diesem Artikel? Schreiben Sie den Autoren unter d.ibrahim@btinternet.com oder an Elektor unter redaktion@elektor.de.

Anmerkung der Redaktion: Dieser Artikel (260216-01) ist ein Auszug aus dem Buch Practical Microcontroller Cryptography (Elektor, 2026). Er wurde formatiert und leicht überarbeitet, um den Konventionen und dem Seitenlayout von Elektor zu entsprechen.