Krypto-Demo mit xinux-crypt.py: Unterschied zwischen den Versionen

Aus Xinux Wiki
Zur Navigation springen Zur Suche springen
 
(22 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 1: Zeile 1:
−
==Krypto-Demo mit xinux-crypt.py ==
+
== Krypto-Demo mit xinux-crypt.py ==
  
 
In dieser Übung wird eine vollständige Kommunikation zwischen zwei Rechnern simuliert.
 
In dieser Übung wird eine vollständige Kommunikation zwischen zwei Rechnern simuliert.
Zeile 10: Zeile 10:
  
 
== Vorbereitung ==
 
== Vorbereitung ==
 +
Auf '''Bob'''
 +
 +
<code>export ALICE_IP=192.168.16.213</code>
 +
 +
Auf '''Alice'''
 +
 +
<code>export BOB_IP=192.168.16.254</code>
 +
 +
  
 
Auf '''beiden''' Rechnern:
 
Auf '''beiden''' Rechnern:
  
−
<code>pip install cryptography</code>
+
<code>sudo apt install python3-cryptography</code>
 +
 
 +
oder
  
−
Das Script herunterladen:
+
<code>sudo dnf install python3-cryptography</code>
  
−
<code>wget http://&lt;Trainer-IP&gt;:8000/xinux-crypt.py</code>
 
  
 
Arbeitsverzeichnis anlegen und wechseln:
 
Arbeitsverzeichnis anlegen und wechseln:
  
 
<code>mkdir ~/krypto && cd ~/krypto</code>
 
<code>mkdir ~/krypto && cd ~/krypto</code>
 +
 +
Das Script herunterladen:
 +
 +
<code>wget https://xinux.de/downloads/script/xinux-crypt.py</code>
 +
  
 
HTTP-Server starten (Terminal 1 – bleibt offen):
 
HTTP-Server starten (Terminal 1 – bleibt offen):
Zeile 53: Zeile 68:
 
'''Alice holt Bob's Public Key:'''
 
'''Alice holt Bob's Public Key:'''
  
−
<code>wget http://&lt;Bob-IP&gt;:8000/pub.pem -O bob_pub.pem</code>
+
<code>wget http://$BOB_IP:8000/pub.pem -O bob_pub.pem</code>
  
 
'''Bob holt Alice's Public Key:'''
 
'''Bob holt Alice's Public Key:'''
  
−
<code>wget http://&lt;Alice-IP&gt;:8000/pub.pem -O alice_pub.pem</code>
+
<code>wget http://$ALICE_IP:8000/pub.pem -O alice_pub.pem</code>
  
 
== Schritt 3 – Namen signieren ==
 
== Schritt 3 – Namen signieren ==
Zeile 80: Zeile 95:
 
'''Alice holt Bob's Signatur:'''
 
'''Alice holt Bob's Signatur:'''
  
−
<code>wget http://&lt;Bob-IP&gt;:8000/signatur.bin -O bob_signatur.bin</code>
+
<code>wget http://$BOB_IP:8000/signatur.bin -O bob_signatur.bin</code>
  
 
'''Bob holt Alice's Signatur:'''
 
'''Bob holt Alice's Signatur:'''
  
−
<code>wget http://&lt;Alice-IP&gt;:8000/signatur.bin -O alice_signatur.bin</code>
+
<code>wget http://$ALICE_IP:8000/signatur.bin -O alice_signatur.bin</code>
  
 
== Schritt 5 – Signatur prüfen ==
 
== Schritt 5 – Signatur prüfen ==
  
−
Das Script liest die Dateien <code>&lt;Name&gt;_pub.pem</code> und <code>&lt;Name&gt;_signatur.bin</code>
+
Name, Public-Key-Datei und Signatur-Datei werden explizit übergeben –
−
und prüft ob die Signatur zum angegebenen Namen passt.
+
so kann man beliebige Dateinamen verwenden ohne Verwechslungsgefahr.
  
 
'''Alice prüft Bob:'''
 
'''Alice prüft Bob:'''
  
−
<code>python3 xinux-crypt.py --verify Bob</code>
+
<code>python3 xinux-crypt.py --verify Bob bob_pub.pem bob_signatur.bin</code>
  
 
'''Bob prüft Alice:'''
 
'''Bob prüft Alice:'''
  
−
<code>python3 xinux-crypt.py --verify Alice</code>
+
<code>python3 xinux-crypt.py --verify Alice alice_pub.pem alice_signatur.bin</code>
  
 
Bei Erfolg erscheint:
 
Bei Erfolg erscheint:
Zeile 129: Zeile 144:
 
'''Bob holt die Parameter:'''
 
'''Bob holt die Parameter:'''
  
−
<code>wget http://&lt;Alice-IP&gt;:8000/dh_params.json</code>
+
<code>wget http://$ALICE_IP:8000/dh_params.json</code>
  
 
=== Schritt 6b – Bob antwortet ===
 
=== Schritt 6b – Bob antwortet ===
Zeile 135: Zeile 150:
 
'''Bob''' liest die Parameter, generiert seinen eigenen DH Key und berechnet das gemeinsame Geheimnis:
 
'''Bob''' liest die Parameter, generiert seinen eigenen DH Key und berechnet das gemeinsame Geheimnis:
  
−
<code>python3 xinux-crypt.py --dh-respond</code>
+
<code>python3 xinux-crypt.py --dh-respond dh_params.json</code>
  
 
{| class="wikitable"
 
{| class="wikitable"
Zeile 149: Zeile 164:
 
'''Alice holt Bob's Antwort:'''
 
'''Alice holt Bob's Antwort:'''
  
−
<code>wget http://&lt;Bob-IP&gt;:8000/dh_response.json</code>
+
<code>wget http://$BOB_IP:8000/dh_response.json</code>
  
 
=== Schritt 6c – Alice berechnet das Geheimnis ===
 
=== Schritt 6c – Alice berechnet das Geheimnis ===
  
−
<code>python3 xinux-crypt.py --dh-finish</code>
+
<code>python3 xinux-crypt.py --dh-finish dh_response.json</code>
  
 
Alice berechnet nun denselben AES-Key wie Bob – aus Bob's Public Value und ihrem eigenen DH Private Key.
 
Alice berechnet nun denselben AES-Key wie Bob – aus Bob's Public Value und ihrem eigenen DH Private Key.
Zeile 168: Zeile 183:
 
<code>echo "Hallo Bob, das ist geheim!" > nachricht.txt</code>
 
<code>echo "Hallo Bob, das ist geheim!" > nachricht.txt</code>
  
−
<code>python3 xinux-crypt.py --encrypt nachricht.txt</code>
+
<code>python3 xinux-crypt.py --encrypt nachricht.txt --key secret.bin</code>
  
 
{| class="wikitable"
 
{| class="wikitable"
Zeile 184: Zeile 199:
 
'''Bob holt beide Dateien:'''
 
'''Bob holt beide Dateien:'''
  
−
<code>wget http://&lt;Alice-IP&gt;:8000/nachricht.txt.enc</code>
+
<code>wget http://$ALICE_IP:8000/nachricht.txt.enc</code>
  
−
<code>wget http://&lt;Alice-IP&gt;:8000/nachricht.txt.sha256</code>
+
<code>wget http://$ALICE_IP:8000/nachricht.txt.sha256</code>
  
 
== Schritt 8 – Datei entschlüsseln und Hash prüfen ==
 
== Schritt 8 – Datei entschlüsseln und Hash prüfen ==
  
 
'''Bob''' entschlüsselt die Datei:
 
'''Bob''' entschlüsselt die Datei:
 +
<code>python3 xinux-crypt.py --decrypt nachricht.txt.enc nachricht.txt.sha256 --key secret.bin</code>
  
−
<code>python3 xinux-crypt.py --decrypt nachricht.txt.enc</code>
 
  
 
Das Script:
 
Das Script:
Zeile 232: Zeile 247:
 
| <code>*.dec</code> || --decrypt || – || Entschlüsselte Datei (lokal)
 
| <code>*.dec</code> || --decrypt || – || Entschlüsselte Datei (lokal)
 
|}
 
|}
−
 
−
== Komplette Befehlsfolge ==
 
  
 
{| class="wikitable"
 
{| class="wikitable"
Zeile 246: Zeile 259:
 
| 4 || <code>wget Bob/signatur.bin -O bob_signatur.bin</code> || <code>wget Alice/signatur.bin -O alice_signatur.bin</code>
 
| 4 || <code>wget Bob/signatur.bin -O bob_signatur.bin</code> || <code>wget Alice/signatur.bin -O alice_signatur.bin</code>
 
|-
 
|-
−
| 5 || <code>--verify Bob</code> || <code>--verify Alice</code>
+
| 5 || <code>--verify Bob bob_pub.pem bob_sig.bin</code> || <code>--verify Alice alice_pub.pem alice_sig.bin</code>
 
|-
 
|-
−
| 6a || <code>--dh-init</code> || <code>wget Alice/dh_params.json</code>
+
| 6a || <code>--dh-init</code> || <code>wget Alice/dh_params.json -O alice_dh_params.json</code>
 
|-
 
|-
−
| 6b || <code>wget Bob/dh_response.json</code> || <code>--dh-respond</code>
+
| 6b || <code>wget Bob/dh_response.json -O bob_dh_response.json</code> || <code>--dh-respond alice_dh_params.json</code>
 
|-
 
|-
−
| 6c || <code>--dh-finish</code> || –
+
| 6c || <code>--dh-finish bob_dh_response.json</code> || –
 
|-
 
|-
−
| 7 || <code>--encrypt nachricht.txt</code> || <code>wget Alice/nachricht.txt.enc</code> und <code>.sha256</code>
+
| 7 || <code>--encrypt nachricht.txt --key secret.bin</code> || <code>wget Alice/nachricht.txt.enc -O alice_nachricht.txt.enc</code> und <code>wget Alice/nachricht.txt.sha256 -O alice_nachricht.txt.sha256</code>
 
|-
 
|-
−
| 8 || – || <code>--decrypt nachricht.txt.enc</code>
+
| 8 || – || <code>--decrypt alice_nachricht.txt.enc alice_nachricht.txt.sha256 --key secret.bin</code>
 
|}
 
|}

Aktuelle Version vom 5. Mai 2026, 10:22 Uhr

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 Bob

export ALICE_IP=192.168.16.213

Auf Alice

export BOB_IP=192.168.16.254


Auf beiden Rechnern:

sudo apt install python3-cryptography

oder

sudo dnf install python3-cryptography


Arbeitsverzeichnis anlegen und wechseln:

mkdir ~/krypto && cd ~/krypto

Das Script herunterladen:

wget https://xinux.de/downloads/script/xinux-crypt.py


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

Name, Public-Key-Datei und Signatur-Datei werden explizit übergeben – so kann man beliebige Dateinamen verwenden ohne Verwechslungsgefahr.

Alice prüft Bob:

python3 xinux-crypt.py --verify Bob bob_pub.pem bob_signatur.bin

Bob prüft Alice:

python3 xinux-crypt.py --verify Alice alice_pub.pem alice_signatur.bin

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 dh_params.json

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 dh_response.json

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 --key secret.bin

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 nachricht.txt.sha256 --key secret.bin


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)
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 bob_pub.pem bob_sig.bin --verify Alice alice_pub.pem alice_sig.bin
6a --dh-init wget Alice/dh_params.json -O alice_dh_params.json
6b wget Bob/dh_response.json -O bob_dh_response.json --dh-respond alice_dh_params.json
6c --dh-finish bob_dh_response.json –
7 --encrypt nachricht.txt --key secret.bin wget Alice/nachricht.txt.enc -O alice_nachricht.txt.enc und wget Alice/nachricht.txt.sha256 -O alice_nachricht.txt.sha256
8 – --decrypt alice_nachricht.txt.enc alice_nachricht.txt.sha256 --key secret.bin
Abgerufen von „http://www.xinux.net/index.php?title=Krypto-Demo_mit_xinux-crypt.py&oldid=69529“