Lernziele

Unsere Reise heute — die Landkarte

Wir starten ganz einfach (von Hand rechenbar) und arbeiten uns Stück für Stück bis zu dem vor, was euer Browser gerade jetzt benutzt. Jeder Schritt repariert ein Problem des vorigen.

Rückblick: letzte Woche haben wir etwas kaputt gemacht — mit Absicht

Hashing war eine Einbahnstraße: Passwort rein → Hash raus → nie wieder zurück. Genau das wollten wir.

Stell dir vor: das Internet ist eine Postkarte

Deine Nachricht reist über viele fremde Stationen: WLAN-Router, Provider, Server. Jede kann mitlesen.

Der wichtigste Unterschied der ganzen Vorlesung

Hashing und Verschlüsselung werden ständig verwechselt. Merkt euch diesen einen Unterschied:

Was ist Verschlüsselung? — die vier Wörter

Verschlüsselung ist ein Safe: du legst den Klartext rein, schließt mit dem Schlüssel ab — und nur mit demselben (oder einem passenden) Schlüssel kommst du wieder ran.

Die älteste Idee: die Caesar-Verschlüsselung

Schon Julius Caesar hat sie benutzt: jeden Buchstaben um eine feste Zahl im Alphabet weiterschieben. Der Schlüssel ist diese Zahl.

Klartext:    A  B  C  D  E ... H ... L ... O ... X  Y  Z
                              ↓  ↓  ↓  ↓  ↓     ↓     ↓     ↓     ↓  ↓  ↓  (+3)
Geheimtext:  D  E  F  G  H ... K ... O ... R ... A  B  C   (X Y Z wickeln um!)

"HALLO"  →  H+3=K   A+3=D   L+3=O   L+3=O   O+3=R   →  "KDOOR"

🤔 Halt — wie würden WIR das in C umsetzen?

„Einen Buchstaben um 3 weiterschieben" — klingt nach Alphabet-Tabelle. Aber erinnert ihr euch an den Trick aus VL 8?

Kurzer Einschub: Modulo (%) ist ein Zifferblatt

Bevor wir Caesar in C schreiben: % gibt den Rest beim Teilen. Am einfachsten merkt man sich das als Uhr — die zählt auch immer im Kreis.

 0 % 12 = 0      // Mitternacht
 5 % 12 = 5
11 % 12 = 11
12 % 12 = 0     // zurück auf 0!
13 % 12 = 1     // 13 Uhr = 1 Uhr
25 % 12 = 1     // 1 Tag + 1 Stunde

Tiefer gedacht: Rest ist nicht ganz dasselbe wie Modulo

Bei positiven Zahlen merkt man keinen Unterschied. Bei negativen schon — und dann versteht man erst, was Modulo wirklich ist.

Die Idee: −3 und 23 sind auf der 26er-Uhr dieselbe Position

a == (a / b) * b + (a % b)

-3 / 26 = 0   // zu 0 hin gerundet
-3 % 26 = -3  // damit Gleichung stimmt

[0]  = …,-52,-26, 0, 26, 52,…
[23] = …,-29, -3,23, 49, 75,…

Caesar in C — überraschend kurz

Wir rechnen mit den ASCII-Werten. Der Trick: relativ zu 'A' rechnen, um 3 schieben, mit % 26 umwickeln.

#include <stdio.h>
#include <string.h>

void caesar(char text[], int schluessel) {
    for (int i = 0; text[i] != '\0'; i++) {
        char c = text[i];
        // nur Großbuchstaben A-Z verschieben
        if (c >= 'A' && c <= 'Z') {
            int pos = c - 'A';              // Buchstabe → 0..25  (A=0, B=1, …)
            pos = (pos + schluessel) % 26;   // schieben und bei Z umwickeln
            text[i] = pos + 'A';           // 0..25 → ASCII-Buchstabe zurück
        }
    }
}

int main(void) {
    char nachricht[] = "HALLO";
    caesar(nachricht, 3);    printf("%s\n", nachricht);  // → KDOOR
    caesar(nachricht, 23);   printf("%s\n", nachricht);  // → HALLO (23 = -3 zurück)
    return 0;
}

Selbst rechnen — Caesar mit Bleistift

Nehmt euch 30 Sekunden. Wir verschlüsseln und entschlüsseln — und sehen, dass wir genau dort wieder rauskommen, wo wir gestartet sind.

K (+4) → O
A (+4) → E
T (+4) → X
Z (+4) → D   // 25+4=29, %26=3 → D
E (+4) → I

"KATZE" → "OEXDI"

O (−4) → K
E (−4) → A
X (−4) → T
D (−4) → Z   // wickelt zurück
I (−4) → E

"OEXDI" → "KATZE" ✓

⚠️ Warum Caesar nichts taugt

Caesar hat ein fatales Problem: es gibt nur 25 mögliche Schlüssel. Ein Computer probiert die alle in Mikrosekunden durch.

Geheimtext: "KDOOR"
+1 → JCNNQ   +2 → IBMMP
+3 → HALLO ← ergibt Sinn!
+4 → GZKKN   +5 → FYJJM ...

Das Lieblingswerkzeug der Krypto: XOR

XOR („exklusives Oder") vergleicht zwei Bits. Ergebnis ist 1, wenn sie verschieden sind, sonst 0. In C ist das der Operator ^.

Daten ^ Key ^ Key = Daten

Selbst rechnen — XOR Bit für Bit

Wir verschlüsseln den Buchstaben 'H' (ASCII 72 = 01001000) mit dem Schlüsselbyte 75 (01001011).

  H    01001000   (72)
  Key  01001011   (75)
  XOR  --------
       00000011   (3)

// Geheimtext-Byte = 3

       00000011   (3)
  Key  01001011   (75)
  XOR  --------
       01001000   (72 = 'H') ✓

// gleicher Key → 'H' zurück!

XOR-Verschlüsselung in C — eine Funktion für beides

Weil Ver- und Entschlüsseln dasselbe sind, brauchen wir nur eine Funktion. Wir XOR-en jedes Byte mit einem (sich wiederholenden) Schlüssel.

#include <stdio.h>
#include <string.h>

// XOR-t jedes Zeichen mit dem Schlüssel (der sich wiederholt)
void xor_crypt(char text[], int len, char key[], int keylen) {
    for (int i = 0; i < len; i++) {
        text[i] = text[i] ^ key[i % keylen];   // ^ ist XOR, % wiederholt den Key
    }
}

int main(void) {
    char nachricht[] = "Geheim";
    char key[]       = "K";

    xor_crypt(nachricht, strlen(nachricht), key, 1);  // → Zeichensalat
    xor_crypt(nachricht, strlen(nachricht), key, 1);  // → "Geheim" zurück!

    printf("%s\n", nachricht);
    return 0;
}

Warum auch unser XOR (noch) schwach ist

Ein kurzer, sich wiederholender Schlüssel hinterlässt Muster — wie bei Caesar. Aber XOR steckt eine geniale Idee in sich.

Kurzer Zwischenstand — wo stehen wir?

Wir haben zwei eigene Verschlüsselungen gebaut. Beide funktionieren — beide sind aber zu schwach. Warum eigentlich?

AES — der heutige Standard (symmetrisch)

Symmetrisch heißt: ein Schlüssel für beide Richtungen — derselbe Schlüssel ver- und entschlüsselt. Genau wie unser XOR, nur viel stärker.

AES in C — die richtige Library nutzen

Mit OpenSSL läuft AES über die EVP-Schnittstelle. Hier die Idee — Details im Labor. Kompilieren wie in VL 8: gcc datei.c -lcrypto.

#include <openssl/evp.h>
#include <openssl/rand.h>

// --- vereinfacht: Fehlerprüfung weggelassen, Logik im Fokus ---

unsigned char key[32];   // 32 Bytes = 256-Bit-Schlüssel
unsigned char iv[16];    // Initialisierungsvektor (Zufalls-Startwert)

RAND_bytes(key, 32);     // echter Zufall — wie das Salt in VL 8!
RAND_bytes(iv,  16);

EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();

// "Nimm AES mit 256-Bit-Schlüssel, mische die Blöcke (CBC)"
EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv);
EVP_EncryptUpdate(ctx, out, &len, klartext, klartext_len);
EVP_EncryptFinal_ex(ctx, out + len, &rest);
// 'out' enthält jetzt den Geheimtext

🤔 Das große Problem: wie tauscht man den Schlüssel?

Symmetrische Verschlüsselung ist toll — aber sie hat eine fiese Lücke. Denkt eine Minute darüber nach.

Die geniale Lösung: zwei Schlüssel statt einem

Asymmetrische Verschlüsselung: jeder hat ein Schlüsselpaar — einen öffentlichen (darf jeder kennen) und einen privaten (streng geheim).

Asymmetrisch — der Ablauf, Schritt für Schritt

Anna schickt Bob eine geheime Nachricht. Achtet darauf: Annas Schlüssel kommen gar nicht vor — nur Bobs.

Aber warum kann man aus „öffentlich" nicht „privat" berechnen?

Die zwei Schlüssel hängen mathematisch zusammen. Der Trick: eine Richtung ist leicht, die Rückrichtung praktisch unmöglich. Eine Einwegfunktion mit Falltür.

   61 × 53 = ?

→ 3233   (in 1 Sekunde)

  3233 = ? × ?

→ welche zwei Primzahlen?
  (ausprobieren … mühsam)

Symmetrisch vs. Asymmetrisch — wann was?

Beide haben Stärken und Schwächen. Die spannende Frage: kann man nicht beide kombinieren?

Das Beste aus beiden Welten: HTTPS

Euer Browser macht das gerade jetzt. Der Trick: asymmetrisch nur, um einmal einen symmetrischen Schlüssel zu vereinbaren — dann schnell symmetrisch weiter.

Bonus: dieselbe Technik rückwärts = digitale Signatur

Was, wenn man die Schlüssel vertauscht? Mit privat „verschlüsseln", mit öffentlich „entschlüsseln" — das beweist, wer etwas geschrieben hat.

Wo ihr Verschlüsselung jeden Tag benutzt

Ihr habt heute schon dutzendfach verschlüsselt — ohne es zu merken.

Was kann ich tun — als User & als Entwickler?

Das große Ganze — welches Werkzeug wofür?

VL 8 + VL 9 in einem Bild. Fragt euch immer zuerst: will ich die Daten je wieder lesen können?

🤔 Mini-Quiz

🤔 Mini-Quiz — Runde 2

Zusammenfassung — in einer Slide

📚 Quellen & weiterführende Literatur

Was ihr lesen/anschauen solltet, wenn ihr tiefer einsteigen wollt: