Krypto-Demo mit xinux-crypt.py

Krypto-Demo mit xinux-crypt.py

In dieser Übung wird eine vollständige Kommunikation zwischen zwei Rechnern simuliert. Beide Teilnehmer führen dieselben Schritte durch – aber in unterschiedlicher Reihenfolge. Es werden asymmetrische Schlüssel, digitale Signaturen, Diffie-Hellman Key Exchange und symmetrische Verschlüsselung mit Hash-Prüfung demonstriert.

Das Script macht kein Netzwerk – alle Dateien liegen im aktuellen Verzeichnis. Die Übertragung erfolgt manuell per wget.

Vorbereitung

Auf beiden Rechnern:

pip install cryptography

Das Script herunterladen:

wget http://<Trainer-IP>:8000/xinux-crypt.py

Arbeitsverzeichnis anlegen und wechseln:

mkdir ~/krypto && cd ~/krypto

HTTP-Server starten (Terminal 1 – bleibt offen):

python3 -m http.server 8000

Alle weiteren Befehle im Terminal 2 ausführen.

Schritt 1 – Asymmetrisches Schlüsselpaar generieren

Auf beiden Rechnern:

python3 xinux-crypt.py --gen-asym-keys

Datei	Inhalt	Sichtbarkeit
priv.pem	RSA Private Key	Geheim – niemals weitergeben!
pub.pem	RSA Public Key	Öffentlich – wird von der Gegenseite geholt

Der Public Key wird im Terminal angezeigt – das ist der BEGIN PUBLIC KEY Block. Dieser Wert ist nicht geheim und kann offen übertragen werden.

Schritt 2 – Public Key holen

Jeder holt den Public Key der Gegenseite. Wichtig: mit -O umbenennen, damit der eigene pub.pem nicht überschrieben wird.

Alice holt Bob's Public Key:

wget http://<Bob-IP>:8000/pub.pem -O bob_pub.pem

Bob holt Alice's Public Key:

wget http://<Alice-IP>:8000/pub.pem -O alice_pub.pem

Schritt 3 – Namen signieren

Jeder signiert seinen eigenen Namen mit seinem Private Key:

Alice:

python3 xinux-crypt.py --sign Alice

Bob:

python3 xinux-crypt.py --sign Bob

Die Datei signatur.bin enthält die digitale Signatur. Sie beweist: Nur wer den passenden Private Key besitzt konnte diese Signatur erzeugen.

Schritt 4 – Signatur holen

Jeder holt die Signatur der Gegenseite – wieder mit -O umbenennen:

Alice holt Bob's Signatur:

wget http://<Bob-IP>:8000/signatur.bin -O bob_signatur.bin

Bob holt Alice's Signatur:

wget http://<Alice-IP>:8000/signatur.bin -O alice_signatur.bin

Schritt 5 – Signatur prüfen

Das Script liest die Dateien <Name>_pub.pem und <Name>_signatur.bin und prüft ob die Signatur zum angegebenen Namen passt.

Alice prüft Bob:

python3 xinux-crypt.py --verify Bob

Bob prüft Alice:

python3 xinux-crypt.py --verify Alice

Bei Erfolg erscheint:

✓ AUTHENTIFIZIERT: 'Alice'

Das bedeutet: Die Gegenseite besitzt den passenden Private Key zu dem Public Key den wir haben. Die Identität ist bestätigt.

Frage an die Teilnehmer: Was passiert wenn man --verify mit dem falschen Namen aufruft?

Schritt 6 – Diffie-Hellman Key Exchange

Diffie-Hellman ermöglicht es, ein gemeinsames Geheimnis zu berechnen – ohne dieses Geheimnis jemals zu übertragen.

Schritt 6a – Alice initiiert

Alice erzeugt die DH-Parameter und ihren Public Value:

python3 xinux-crypt.py --dh-init

Datei	Inhalt
dh_priv.pem	Alice's DH Private Key (bleibt lokal!)
dh_params.json	p, g und Alice's DH Public Value → wird übertragen

Bob holt die Parameter:

wget http://<Alice-IP>:8000/dh_params.json

Schritt 6b – Bob antwortet

Bob liest die Parameter, generiert seinen eigenen DH Key und berechnet das gemeinsame Geheimnis:

python3 xinux-crypt.py --dh-respond

Datei	Inhalt
dh_response.json	Bob's DH Public Value → wird übertragen
secret.bin	Gemeinsamer AES-Key (lokal berechnet)

Der AES-Key wird im Terminal angezeigt.

Alice holt Bob's Antwort:

wget http://<Bob-IP>:8000/dh_response.json

Schritt 6c – Alice berechnet das Geheimnis

python3 xinux-crypt.py --dh-finish

Alice berechnet nun denselben AES-Key wie Bob – aus Bob's Public Value und ihrem eigenen DH Private Key.

Beide vergleichen den angezeigten AES-Key – er muss identisch sein.

Das ist der Kern von Diffie-Hellman: Beide haben dasselbe Geheimnis berechnet, ohne es jemals übertragen zu haben.

Schritt 7 – Datei verschlüsseln und übertragen

Alice erstellt eine Textdatei und verschlüsselt sie:

echo "Hallo Bob, das ist geheim!" > nachricht.txt

python3 xinux-crypt.py --encrypt nachricht.txt

Datei	Inhalt
nachricht.txt.enc	IV + AES-CBC Ciphertext
nachricht.txt.sha256	SHA256-Hash des Klartexts

Der SHA256-Hash kann mit dem Systemtool verglichen werden:

sha256sum nachricht.txt

Bob holt beide Dateien:

wget http://<Alice-IP>:8000/nachricht.txt.enc

wget http://<Alice-IP>:8000/nachricht.txt.sha256

Schritt 8 – Datei entschlüsseln und Hash prüfen

Bob entschlüsselt die Datei:

python3 xinux-crypt.py --decrypt nachricht.txt.enc

Das Script:

1. entschlüsselt den Ciphertext mit dem gemeinsamen AES-Key
2. berechnet den SHA256-Hash des entschlüsselten Inhalts
3. vergleicht ihn mit dem übertragenen Hash

Bei Erfolg:

✓ INTEGRITÄT OK: Datei wurde nicht verändert!

Die entschlüsselte Datei liegt als nachricht.txt.dec vor.

Frage an die Teilnehmer: Was passiert wenn man ein Byte in der .enc Datei ändert bevor man entschlüsselt?

Übersicht der Dateien

Datei	Erzeugt von	Übertragen	Beschreibung
priv.pem	--gen-asym-keys	Nein	RSA Private Key
pub.pem	--gen-asym-keys	Ja	RSA Public Key
signatur.bin	--sign	Ja	Digitale Signatur
dh_priv.pem	--dh-init	Nein	DH Private Key
dh_params.json	--dh-init	Ja	p, g, DH Public Value
dh_response.json	--dh-respond	Ja	DH Public Value (Responder)
secret.bin	--dh-respond / --dh-finish	Nein	Gemeinsamer AES-Key
*.enc	--encrypt	Ja	Verschlüsselte Datei
*.sha256	--encrypt	Ja	SHA256-Hash des Klartexts
*.dec	--decrypt	–	Entschlüsselte Datei (lokal)

Komplette Befehlsfolge

Schritt	Alice	Bob
1	--gen-asym-keys	--gen-asym-keys
2	wget Bob/pub.pem -O bob_pub.pem	wget Alice/pub.pem -O alice_pub.pem
3	--sign Alice	--sign Bob
4	wget Bob/signatur.bin -O bob_signatur.bin	wget Alice/signatur.bin -O alice_signatur.bin
5	--verify Bob	--verify Alice
6a	--dh-init	wget Alice/dh_params.json
6b	wget Bob/dh_response.json	--dh-respond
6c	--dh-finish	–
7	--encrypt nachricht.txt	wget Alice/nachricht.txt.enc und .sha256
8	–	--decrypt nachricht.txt.enc