Hybride Verschlüsselungsschemata in der Kryptographie

Einführung

In der Welt der Kryptographie stehen wir oft vor einem Kompromiss zwischen Geschwindigkeit und Sicherheit. Symmetrische Verschlüsselungsalgorithmen wie AES sind sehr schnell und ideal für die Verschlüsselung großer Datenmengen, erfordern jedoch einen gemeinsamen geheimen Schlüssel, der sicher an Sender und Empfänger verteilt werden muss. Asymmetrische Verschlüsselungsalgorithmen wie RSA eignen sich hervorragend für den sicheren Schlüsselaustausch mithilfe eines öffentlichen/privaten Schlüsselpaares, sind jedoch rechenintensiv und zu langsam für die Verschlüsselung von Massendaten.

Die hybride Verschlüsselung löst dieses Problem, indem sie die Stärken beider Methoden kombiniert. Sie verwendet den Ansatz des „Besten aus beiden Welten“:

1. Asymmetrische Verschlüsselung wird verwendet, um einen temporären, einmaligen symmetrischen Schlüssel (oft als „Sitzungsschlüssel“ bezeichnet) sicher zu verschlüsseln und auszutauschen.
2. Symmetrische Verschlüsselung wird anschließend mit diesem Sitzungsschlüssel verwendet, um die eigentlichen, größeren Nachrichtendaten schnell und effizient zu verschlüsseln.

In diesem Lab werden Sie ein vollständiges hybrides Verschlüsselungsschema von Grund auf mit dem openssl-Kommandozeilenwerkzeug implementieren. Sie werden ein RSA-Schlüsselpaar generieren, einen zufälligen AES-Sitzungsschlüssel erstellen, RSA verwenden, um den Sitzungsschlüssel zu verschlüsseln, AES verwenden, um eine Nachricht zu verschlüsseln, und schließlich den Prozess umkehren, um die Nachricht zu entschlüsseln.

Überblick über die Hybride Verschlüsselung

In diesem Schritt werden wir kurz die Kernkonzepte überprüfen, die die hybride Verschlüsselung zu einer leistungsstarken und weit verbreiteten Technik machen. In diesem Schritt sind keine Befehle auszuführen; das Ziel ist es, eine solide konzeptionelle Grundlage zu schaffen, bevor wir mit der praktischen Arbeit beginnen.

Symmetrische Verschlüsselung (z. B. AES)

• Funktionsweise: Verwendet einen einzigen, gemeinsamen geheimen Schlüssel sowohl für die Ver- als auch für die Entschlüsselung.
• Stärke: Sehr schnell und effizient, wodurch sie perfekt für die Verschlüsselung großer Dateien oder Datenströme ist.
• Schwäche: Schlüsselverteilung. Wie erhält der Empfänger den gemeinsamen geheimen Schlüssel auf sichere Weise? Wenn ein Angreifer den Schlüssel abfängt, kann er die gesamte Kommunikation entschlüsseln.

Asymmetrische Verschlüsselung (z. B. RSA)

• Funktionsweise: Verwendet ein Schlüsselpaar: einen öffentlichen Schlüssel zur Verschlüsselung und einen privaten Schlüssel zur Entschlüsselung. Der öffentliche Schlüssel kann frei geteilt werden, während der private Schlüssel vom Besitzer geheim gehalten werden muss.
• Stärke: Löst das Problem der Schlüsselverteilung. Jeder kann Ihren öffentlichen Schlüssel verwenden, um eine Nachricht an Sie zu verschlüsseln, aber nur Sie können sie mit Ihrem privaten Schlüssel entschlüsseln.
• Schwäche: Sie ist mathematisch komplex und daher viel langsamer als die symmetrische Verschlüsselung. Für die Verschlüsselung großer Datenmengen ist sie unpraktisch.

Die Hybride Lösung

Die hybride Verschlüsselung kombiniert diese beiden Methoden, um die Sicherheit der asymmetrischen Verschlüsselung und die Geschwindigkeit der symmetrischen Verschlüsselung zu vereinen. Hier ist der typische Arbeitsablauf:

1. Der Absender (Alice) möchte eine sichere Nachricht an den Empfänger (Bob) senden.
2. Alice generiert einen neuen, zufälligen symmetrischen Sitzungsschlüssel.
3. Alice verschlüsselt ihre eigentliche Nachricht mit diesem schnellen symmetrischen Sitzungsschlüssel.
4. Alice erhält Bobs öffentlichen Schlüssel. Sie verwendet ihn, um nur den kleinen symmetrischen Sitzungsschlüssel zu verschlüsseln.
5. Alice sendet sowohl die symmetrisch verschlüsselte Nachricht als auch den asymmetrisch verschlüsselten Sitzungsschlüssel an Bob.
6. Bob empfängt die beiden Elemente. Er verwendet zuerst seinen privaten Schlüssel, um den verschlüsselten Sitzungsschlüssel zu entschlüsseln.
7. Nachdem Bob den ursprünglichen symmetrischen Sitzungsschlüssel erhalten hat, verwendet er diesen, um die eigentliche Nachricht schnell zu entschlüsseln.

Dieser Prozess stellt sicher, dass die Massendaten effizient verschlüsselt werden und der für diese Verschlüsselung verwendete Schlüssel mit maximaler Sicherheit ausgetauscht wird. In den folgenden Schritten werden wir genau diesen Arbeitsablauf implementieren.

RSA- und AES-Schlüssel generieren

In diesem Schritt generieren wir die beiden Schlüsselsätze, die für unser hybrides Verschlüsselungsschema erforderlich sind: ein RSA-Schlüsselpaar (öffentlich und privat) für den asymmetrischen Teil und einen zufälligen Sitzungsschlüssel für den symmetrischen Teil (AES). Alle Operationen werden im Verzeichnis ~/project durchgeführt.

Zuerst generieren wir einen 2048-Bit RSA-Privatschlüssel. Dieser Schlüssel muss vom Empfänger geheim gehalten werden.

openssl genpkey -algorithm RSA -out private_key.pem -pkeyopt rsa_keygen_bits:2048

Sie werden einige Ausgaben sehen, während der Schlüssel generiert wird. Als Nächstes müssen wir den entsprechenden öffentlichen Schlüssel aus dem gerade erstellten privaten Schlüssel extrahieren. Dieser öffentliche Schlüssel kann mit jedem geteilt werden, der Ihnen eine verschlüsselte Nachricht senden möchte.

openssl rsa -pubout -in private_key.pem -out public_key.pem

Der Befehl gibt writing RSA key aus.

Nun erstellen wir einen zufälligen 256-Bit (32-Byte) Sitzungsschlüssel. Dieser Schlüssel wird mit dem AES-Algorithmus verwendet, um unsere eigentlichen Daten zu verschlüsseln. Wir verwenden openssl rand, um kryptografisch starke Zufallsdaten zu generieren und sie zur einfacheren Handhabung in Base64 zu kodieren.

openssl rand -base64 32 > session_key.key

Listen wir die Dateien in unserem Verzeichnis auf, um die gerade erstellten Schlüssel zu sehen.

ls -l

Sie sollten die drei gerade generierten Schlüsseldateien zusammen mit der in der Einrichtung erstellten Datei message.txt sehen.

-rw-rw-r-- 1 labex labex   57 Oct 20 15:12 message.txt
-rw------- 1 labex labex 1704 Oct 20 15:14 private_key.pem
-rw-rw-r-- 1 labex labex  451 Oct 20 15:14 public_key.pem
-rw-rw-r-- 1 labex labex   45 Oct 20 15:14 session_key.key

Sitzungsschlüssel mit RSA verschlüsseln

In diesem Schritt führen wir einen kritischen Teil des hybriden Verschlüsselungsprozesses durch: die Verschlüsselung des symmetrischen Sitzungsschlüssels. Um sicherzustellen, dass nur der vorgesehene Empfänger den Sitzungsschlüssel verwenden kann, verschlüsseln wir ihn mit seinem RSA-öffentlichen Schlüssel.

Wir verwenden den Befehl openssl pkeyutl, ein Dienstprogramm für Operationen mit öffentlichen Schlüsseln. Wir werden es verwenden, um die Datei session_key.key mit dem public_key.pem zu verschlüsseln.

Führen Sie den folgenden Befehl aus:

openssl pkeyutl -encrypt -pubin -inkey public_key.pem -in session_key.key -out encrypted_session_key.bin

Lassen Sie uns diesen Befehl aufschlüsseln:

• pkeyutl: Das Dienstprogramm für öffentliche Schlüssel.
• -encrypt: Gibt an, dass wir eine Verschlüsselungsoperation durchführen möchten.
• -pubin: Zeigt an, dass der Eingabeschlüssel (-inkey) ein öffentlicher Schlüssel ist.
• -inkey public_key.pem: Gibt den zu verwendenden öffentlichen Schlüssel für die Verschlüsselung an.
• -in session_key.key: Die zu verschlüsselnde Eingabedatei (unser AES-Sitzungsschlüssel).
• -out encrypted_session_key.bin: Die Ausgabedatei, in der der verschlüsselte Schlüssel gespeichert wird.

Dieser Befehl erstellt eine neue Datei, encrypted_session_key.bin, die den Sitzungsschlüssel in verschlüsselter Form enthält. Diese Datei kann nun sicher übertragen werden, da nur der Besitzer des entsprechenden privaten Schlüssels sie entschlüsseln kann.

Überprüfen wir die neu erstellte Datei:

ls -l encrypted_session_key.bin

Sie sehen die Binärdatei, die den verschlüsselten Schlüssel enthält.

-rw-rw-r-- 1 labex labex 256 Oct 20 15:14 encrypted_session_key.bin

Daten mit AES verschlüsseln

Nachdem wir unseren Sitzungsschlüssel gesichert haben, können wir den ursprünglichen, unverschlüsselten Sitzungsschlüssel verwenden, um unsere Hauptdatendatei, message.txt, schnell zu verschlüsseln. Für diese Aufgabe verwenden wir den symmetrischen Cipher AES-256-CBC.

Der Befehl openssl enc erfordert, dass der Schlüssel (Key) und der Initialisierungsvektor (IV) im Hexadezimalformat angegeben werden. Unser session_key.key liegt in Base64 vor, daher müssen wir es zuerst dekodieren und in Hex umwandeln. Wir werden auch einen zufälligen IV generieren. Wir speichern beides zur Vereinfachung in Umgebungsvariablen.

Konvertieren Sie zuerst den Sitzungsschlüssel und speichern Sie ihn in der Variablen AES_KEY:

export AES_KEY=$(cat session_key.key | base64 -d | xxd -p -c 32)

Als Nächstes generieren wir einen zufälligen 128-Bit (16-Byte) IV und speichern ihn in der Variablen AES_IV. Ein IV wird verwendet, um sicherzustellen, dass die mehrfache Verschlüsselung desselben Klartextes zu unterschiedlichen Chiffretexten führt.

export AES_IV=$(openssl rand -hex 16)

Mit dem vorbereiteten Schlüssel und IV können wir nun message.txt mit openssl enc verschlüsseln:

openssl enc -aes-256-cbc -in message.txt -out encrypted_message.dat -K $AES_KEY -iv $AES_IV

Lassen Sie uns die Befehlsoptionen überprüfen:

• -aes-256-cbc: Gibt den AES-256 Cipher im CBC-Modus an.
• -in message.txt: Die Eingabedatei der Daten.
• -out encrypted_message.dat: Die Ausgabedatei für die verschlüsselten Daten.
• -K $AES_KEY: Der Verschlüsselungsschlüssel im Hex-Format (Großbuchstabe K).
• -iv $AES_IV: Der Initialisierungsvektor im Hex-Format.

An dieser Stelle würde der Sender encrypted_message.dat, encrypted_session_key.bin und den IV ($AES_IV) verpacken, um sie an den Empfänger zu senden. Für dieses Lab haben wir alle Dateien in unserem Verzeichnis, bereit für den Entschlüsselungsschritt.

Überprüfen wir, ob die verschlüsselte Datendatei erstellt wurde:

ls -l encrypted_message.dat

-rw-rw-r-- 1 labex labex 64 Oct 20 15:14 encrypted_message.dat

Nachricht entschlüsseln

In diesem letzten Schritt simulieren wir die Aktionen des Empfängers. Der Empfänger hat die verschlüsselten Daten (encrypted_message.dat), den verschlüsselten Sitzungsschlüssel (encrypted_session_key.bin) und den IV erhalten. Er wird seinen geheimen privaten Schlüssel verwenden, um den Prozess umzukehren und die ursprüngliche Nachricht wiederherzustellen.

Zuerst muss der Empfänger den Sitzungsschlüssel mithilfe seines private_key.pem entschlüsseln.

openssl pkeyutl -decrypt -inkey private_key.pem -in encrypted_session_key.bin -out decrypted_session_key.key

Dieser Befehl verwendet pkeyutl mit dem Flag -decrypt und dem privaten Schlüssel, um den ursprünglichen AES-Sitzungsschlüssel wiederherzustellen und ihn in decrypted_session_key.key zu speichern.

Wir können schnell überprüfen, ob der entschlüsselte Schlüssel mit dem ursprünglichen, den wir in Schritt 2 erstellt haben, identisch ist. Der Befehl diff sollte keine Ausgabe erzeugen, wenn die Dateien gleich sind.

diff session_key.key decrypted_session_key.key

Nachdem wir nun den Sitzungsschlüssel haben, können wir die Hauptnachricht entschlüsseln. Genau wie beim Verschlüsselungsschritt müssen wir zuerst den Schlüssel in das Hex-Format konvertieren.

export DECRYPTED_AES_KEY=$(cat decrypted_session_key.key | base64 -d | xxd -p -c 32)

Verwenden Sie abschließend openssl enc mit dem Flag -d (decrypt) und geben Sie denselben Schlüssel und IV an, die für die Verschlüsselung verwendet wurden. (Die Variable $AES_IV ist in unserer Shell noch aus dem vorherigen Schritt gesetzt).

openssl enc -d -aes-256-cbc -in encrypted_message.dat -out decrypted_message.txt -K $DECRYPTED_AES_KEY -iv $AES_IV

Der Vorgang ist abgeschlossen! Die ursprüngliche Nachricht wurde wiederhergestellt und in decrypted_message.txt gespeichert. Lassen Sie uns den Inhalt anzeigen, um unseren Erfolg zu bestätigen.

cat decrypted_message.txt

Sie sollten die ursprüngliche geheime Nachricht auf Ihrem Terminal ausgegeben sehen:

This is a secret message that needs to be sent securely.

Zusammenfassung

In diesem Lab haben Sie erfolgreich einen vollständigen hybriden Verschlüsselungs- und Entschlüsselungs-Workflow mit OpenSSL implementiert. Sie haben praktische Erfahrungen mit den grundlegenden Konzepten gesammelt, die einen Großteil unserer digitalen Kommunikation absichern.

Sie haben gelernt, wie man:

• Ein RSA-Schlüsselpaar für die asymmetrische Verschlüsselung generiert.
• Einen zufälligen AES-Sitzungsschlüssel für die symmetrische Verschlüsselung erstellt.
• Den Sitzungsschlüssel mithilfe des RSA-Public-Keys sicher verschlüsselt.
• Massendaten effizient mithilfe des AES-Sitzungsschlüssels verschlüsselt.
• Den Prozess umkehrt, indem der Sitzungsschlüssel mit dem RSA-Private-Key entschlüsselt und anschließend die Daten entschlüsselt werden.

Dieser Ansatz, der das Beste aus beiden Welten vereint – die Sicherheit der asymmetrischen Kryptographie für den Schlüsselaustausch mit der Geschwindigkeit der symmetrischen Kryptographie für die Datenverschlüsselung – ist ein Eckpfeiler moderner Sicherheitsprotokolle wie TLS/SSL, die Ihre Daten täglich im Internet schützen.