hwr-notes/Kryptografie/zusammenfassungen/kr2 - zusammenfassung.md

# Kryptographie – Zusammenfassung Vorlesung 2
_Prof. Dr. Björn Grohmann · HWR Berlin_ _Nur neuer Inhalt (ab Folie 73) – Wiederholungen aus Vorlesung 1 ausgelassen_

---

## Message Authentication Code (MAC)

Ein **MAC** (Message Authentication Code) ist ein kurzer Tag `t`, der mit einem symmetrischen Schlüssel `k` aus einer Nachricht `m` berechnet wird:

```
t = MAC(k, m)
```

MAC bietet **Integrität** und **Authentizität**, aber keine Vertraulichkeit. Sender und Empfänger teilen denselben Schlüssel.

### Angriffsvektoren auf MACs (von stark → schwach)

|Stärke|Angriff|Beschreibung|
|---|---|---|
|Stärkster|**Total Break**|Alle Systemparameter sind gebrochen; Angreifer kann für beliebige Nachricht einen MAC erzeugen|
||**Selective Forgery**|MAC für eine Nachricht erzeugbar, die _vor_ dem Angriff vom Angreifer gewählt wurde|
|Schwächster|**Existential Forgery**|MAC für _irgendeine_ Nachricht erzeugbar (auch sinnlose)|

---

## Wie man lange Nachrichten NICHT mit einem MAC versehen sollte

Mehrere naive Konstruktionen sind unsicher:

1. **Kein Schlüssel im MAC**: Angreifer kann eigene Blöcke einfügen.
2. **Alle Blöcke mit demselben Schlüssel unabhängig MACen** (`t_i = MAC(k, m_i)`): Reihenfolge der Blöcke kann vertauscht werden (Reordering-Angriff).
3. **Mit laufender Blocknummer** (`t_i = MAC(k, i || m_i)`): Blöcke aus verschiedenen Nachrichten können gemischt werden.
4. **Nachrichten-ID hinzufügen** (`t_i = MAC(k, id || i || m_i)`): Letzter Block kann weggelassen werden (Truncation-Angriff).
5. **Länge im letzten Block kodieren**: Erst dann ist die Konstruktion sicher (CBC-MAC-Variante).

---

## HMAC (Hash-MAC)

```
HMAC(k, m) = H( (k XOR opad) || H( (k XOR ipad) || m ) )
```

**H** ist eine kryptographische Hash-Funktion mit den Eigenschaften:

- Effizient zu berechnen
- Schwer zu invertieren (Einwegfunktion)
- Kollisionsresistenz: schwer, zwei Eingaben mit gleichem Hash zu finden
- Kleine Eingabeänderungen → große Ausgabeänderungen (Diffusion / Lawineneffekt)

`opad` und `ipad` sind feste Konstanten (Byte-Padding).

---

## Kombinationen von Verschlüsselung und MAC

Es gibt drei Möglichkeiten, Verschlüsselung (Enc) und MAC zu kombinieren:

|Variante|Schema|Empfehlung|
|---|---|---|
|**Encrypt-then-MAC**|`c = Enc(k₁, m)` → `t = MAC(k₂, c)`|✅ Empfohlen (z. B. TLS 1.3)|
|**MAC-then-Encrypt**|`t = MAC(k₂, m)` → `c = Enc(k₁, m \| t)`|⚠️ Problematisch (z. B. Padding-Oracle-Angriff in TLS < 1.3)|
|**Encrypt-and-MAC**|`c = Enc(k₁, m)` und `t = MAC(k₂, m)` parallel|⚠️ MAC kann Klartextinfo leaken|

**Encrypt-then-MAC** ist die sichere Variante: Der MAC schützt den Chiffretext, sodass manipulierte Ciphertexte sofort erkannt werden, bevor sie entschlüsselt werden.

---

## Authenticated Encryption with Associated Data (AEAD)

**AEAD** kombiniert Verschlüsselung und Authentifizierung in einem einzigen Algorithmus:

```
(c, t) = AEAD_Enc(k, nonce, m, aad)
m      = AEAD_Dec(k, nonce, c, t, aad)
```

- `m` = Plaintext (wird verschlüsselt **und** authentifiziert)
- `aad` = _Associated Authenticated Data_ (wird nur authentifiziert, nicht verschlüsselt, z. B. Header)
- Gibt `⊥` zurück, wenn die Authentifizierung fehlschlägt

### Beispiel: ChaCha20-Poly1305

- **ChaCha20**: Stromchiffre (Verschlüsselung)
- **Poly1305**: MAC über den Ciphertext
- Eingaben: 256-bit Key, 96-bit Nonce, Plaintext
- Weit verbreitet in TLS 1.3, SSH, WireGuard

### Beispiel: Galois Counter Mode (GCM)

- Kombiniert **CTR-Mode** (Verschlüsselung mit AES) und **GHASH** (MAC über das Galois-Feld GF(2¹²⁸))
- Standard für AES-GCM in TLS 1.3

---

## Symmetric Search over Encrypted Data

Problem: Wie kann man auf verschlüsselten Daten (z. B. in der Cloud) suchen, ohne den Schlüssel preiszugeben?

|Ansatz|Idee|Problem|
|---|---|---|
|**1. Idee**|Alice gibt Bob Wort `W` + Schlüssel `k`|Bob kennt den Schlüssel → kein Datenschutz|
|**2. Idee**|Alice gibt Bob `Enc(W)` + zugehörigen Schlüssel|Deterministisches Enc → gleiche Wörter → gleiche Ciphertexte → Häufigkeitsanalyse möglich|
|**3. Idee**|Pseudorandom Function (PRF)-basierter Index: Alice erstellt eine verschlüsselte Lookup-Tabelle. Für jedes Wort `w` wird ein Token `T = PRF(k, w)` erzeugt und der zugehörige Index verschlüsselt gespeichert.|Leakt _access pattern_ (welche Dokumente abgerufen werden)|

Die dritte Idee ist die Grundlage von **Searchable Symmetric Encryption (SSE)**. Sie erlaubt Bob, anhand eines Tokens zu suchen, ohne `k` oder `w` zu kennen.

---

## Public-Key-Kryptographie

### Das Schlüsselaustauschproblem

Bei symmetrischer Kryptographie müssen beide Parteien denselben geheimen Schlüssel kennen – aber wie tauscht man ihn sicher aus, wenn nur ein unsicherer Kanal verfügbar ist?

### Merkle Puzzle (1974)

Alice erzeugt `n` verschlüsselte Rätsel mit je einer ID und einem Schlüssel. Bob löst zufällig eines davon (brute force, O(n)). Ein Angreifer muss im Durchschnitt `n/2` Rätsel lösen (O(n)). Vorteil ist quadratisch: O(n) Aufwand für Alice/Bob, O(n²) für Angreifer. Praktisch zu ineffizient.

### Idee: Virtual Black Box (VBB) Obfuscator

Idee: Ein Programm so verschleiern, dass man es zwar ausführen, aber nicht "verstehen" kann. Ein VBB-Obfuscator würde Public-Key-Kryptographie aus einer OWF ermöglichen. **Leider existiert kein allgemeiner VBB-Obfuscator** (Barak et al. 2001 bewiesen Unmöglichkeit). Schwächere Varianten (_Indistinguishability Obfuscation_, iO) sind noch Forschungsthema.

---

## Diffie-Hellman-Schlüsselaustausch

Ermöglicht zwei Parteien, über einen öffentlichen Kanal einen gemeinsamen geheimen Schlüssel zu vereinbaren.

```
Öffentlich bekannt: Primzahl q, Generator α

Alice wählt Xₐ (geheim), sendet Yₐ = α^Xₐ mod q
Bob   wählt X_b (geheim), sendet Y_b = α^X_b mod q

Gemeinsames Geheimnis: K = α^(Xₐ·X_b) mod q
```

Sicherheit basiert auf dem **Diskreten-Logarithmus-Problem (DLP)**: Gegeben `g`, `p` und `g^a mod p`, ist es schwer, `a` zu berechnen.

---

## Das Diskrete-Logarithmus-Problem (DLP)

**Definition:**

- Gegeben: Gruppe `G`, Generator `g`, Element `y = g^x`
- Gesucht: `x = log_g(y)`

Das Berechnen von `g^x` ist effizient (schnelle Exponentiation: O(log x) Multiplikationen). Die Umkehrung (diskreter Logarithmus) ist für große Gruppen rechnerisch schwer (kein effizienter Algorithmus bekannt für klassische Computer).

---

## Einheitengruppe eines endlichen Körpers: ModP

Die Menge `ℤ_p* = {1, 2, ..., p-1}` mit Multiplikation modulo `p` (p prim) bildet eine **zyklische Gruppe** der Ordnung `p-1`.

- Es gibt einen **Generator** `g`, sodass `{g^0, g^1, ..., g^(p-2)} = ℤ_p*`
- Für Diffie-Hellman wählt man `p` und `g` so, dass die Gruppe groß genug ist (heute ≥ 2048 Bit)

**Fermat'scher kleiner Satz:**  
`a^(p-1) ≡ 1 (mod p)` für alle `a` mit `ggT(a,p) = 1`

---

## Elliptische Kurven

Elliptische Kurven bieten dieselbe Sicherheit wie ModP-Gruppen, aber mit **viel kleineren Schlüsseln**.

**Kurvendefinition** (Weierstraß-Form):

```
y² = x³ + ax + b   (über einem Körper K)
```

mit Bedingung `4a³ + 27b² ≠ 0` (keine Singularitäten).

### Gruppengesetz auf elliptischen Kurven

Punkte auf der Kurve bilden eine abelsche Gruppe mit:

- **Neutrales Element**: Punkt im Unendlichen `O`
- **Addition** `P + Q`: Schneide die Linie durch `P` und `Q` mit der Kurve; reflektiere den dritten Schnittpunkt an der x-Achse
- **Verdoppelung** `2P`: Tangente an `P`; reflektiere zweiten Schnittpunkt

### ECDLP (Elliptic Curve Discrete Logarithm Problem)
Gegeben Punkte P und Q = k·P, finde k. Gilt als schwerer als DLP in ModP → kleinere Schlüssel möglich.

Schlüssel und Verschlüsselung mit elliptischen Kurven

Öffentliche Parameter (für alle gleich):
  - Kurve (a, b, Körper)
  - Basispunkt P auf der Kurve (= Generator)
  - Ordnung n von P

Schlüsselerzeugung:
  Privater Schlüssel:  d  (zufällig, 1 ≤ d ≤ n-1)
  Öffentlicher Schlüssel:  Q = d·P  (d-mal Punktaddition)

ECDH (Diffie-Hellman auf elliptischen Kurven):
  Alice wählt a (geheim), veröffentlicht A = a·P
  Bob   wählt b (geheim), veröffentlicht B = b·P
  Gemeinsames Geheimnis:  K = a·B = b·A = (ab)·P

  → Funktioniert, weil Punktmultiplikation kommutativ ist:
    a·(b·P) = b·(a·P)

  → Angreifer sieht P, A, B, müsste aber a oder b berechnen = ECDLP

---

## RSA (Rivest–Shamir–Adleman, 1977)

### Schlüsselgenerierung

```
1. Wähle zwei große Primzahlen p, q
2. n = p · q         (öffentlich, RSA-Modulus)
3. φ(n) = (p-1)(q-1) (Eulersche Phi-Funktion, geheim)
4. Wähle e mit ggT(e, φ(n)) = 1   (öffentlicher Exponent, oft e = 65537)
5. Berechne d = e⁻¹ mod φ(n)      (privater Exponent)

Öffentlicher Schlüssel: (n, e)
Privater Schlüssel:     (n, d)
```

### Ver- und Entschlüsselung

```
Verschlüsselung: c = m^e mod n
Entschlüsselung: m = c^d mod n
```

Korrektheit folgt aus dem **Satz von Euler**: `m^(φ(n)) ≡ 1 (mod n)`, daher `m^(e·d) ≡ m (mod n)`.

---

## Das Faktorisierungsproblem

Sicherheit von RSA basiert auf der Annahme, dass es schwer ist, `n = p · q` in seine Primfaktoren zu zerlegen.

- Multiplikation `p · q → n`: effizient (O(log²n))
- Faktorisierung `n → p, q`: schwer (bester klassischer Algorithmus: Zahlkörpersieb, subexponentiell aber nicht polynomial)

**Wichtig**: Faktorisierungsproblem ≠ RSA-Sicherheit direkt. Es ist nicht bewiesen, dass Faktorisierung äquivalent zu RSA-Brechen ist, aber kein besserer Angriff ist bekannt.

---

## Wie misst man Sicherheit? (3. Ansatz: IND-CCA)

**IND-CCA** (_Indistinguishability under Chosen Ciphertext Attack_) ist das stärkste gängige Sicherheitsmodell für Public-Key-Verschlüsselung.

Erweiterung des IND-CPA-Spiels: Der Angreifer darf zusätzlich ein **Decryption Oracle** befragen (außer für den Challenge-Ciphertext).

Setup:
  Challenger erzeugt Schlüsselpaar (k_e, k_d)
  Challenger schickt öffentlichen Schlüssel k_e an Angreifer
  Challenger wählt zufälliges Bit b ∈ {0,1}

Phase 1 (vor der Challenge):
  Angreifer darf beliebige Ciphertexte c₁, c₂, ... an den
  Challenger schicken und bekommt die Entschlüsselung zurück.
  → Er hat also ein Entschlüsselungsorakel!

Challenge:
  Angreifer schickt zwei Nachrichten (M₀, M₁) an den Challenger
  Challenger verschlüsselt M_b (je nach seinem geheimen Bit)
  Angreifer bekommt den Ciphertext c zurück

Phase 2 (nach der Challenge):
  Angreifer darf weiterhin Ciphertexte entschlüsseln lassen
  ABER: er darf nicht c selbst zum Entschlüsseln schicken!

Ergebnis:
  Angreifer gibt sein Rateversuch b' aus
  Er gewinnt, wenn b' = b

Ein Schema ist **IND-CCA-sicher**, wenn kein effizienter Angreifer einen Vorteil `> negl(n)` hat.

**Naives RSA (textbook RSA) ist NICHT IND-CPA-sicher**, da es deterministisch ist. Lösung: Padding-Schemata.

---

## OAEP (Optimal Asymmetric Encryption Padding)

**OAEP** macht RSA probabilistisch und erreicht IND-CCA2-Sicherheit im Random-Oracle-Modell.

```
Eingabe: Nachricht m, zufällige Seed r

X = (m || 0...0) XOR G(r)    (G = Pseudozufallsfunktion)
Y = r XOR H(X)               (H = Hashfunktion)

RSA-Input: (X || Y)
```

**Entschlüsselung**: RSA anwenden, dann OAEP umkehren. In der Praxis: **RSA-OAEP** aus PKCS#1 v2.x.

---

### ElGamal-Verschlüsselung
Auf Diffie-Hellman basierendes Public-Key-Verfahren (Taher Elgamal, 1985).

#### Grundidee:
  Bei DH einigen sich beide Seiten auf ein gemeinsames Geheimnis.
  ElGamal nutzt das aus: Der Sender macht quasi einen "einmaligen DH"
  mit dem öffentlichen Schlüssel des Empfängers und maskiert damit
  die Nachricht.

#### Schlüsselgenerierung
  Wähle zyklische Gruppe G der Ordnung n mit Generator α
  Privater Schlüssel:    a (zufällig, 1 ≤ a ≤ n-1)
  Öffentlicher Schlüssel: (α, α^a)
    → α^a ist wie der öffentliche DH-Anteil des Empfängers

#### Verschlüsselung (probabilistisch)
  Sender will Nachricht m an Empfänger schicken:

  Wähle zufälliges k (1 ≤ k ≤ n-1)     ← jedes Mal ein neues!
  γ = α^k                               ← "einmaliger DH-Anteil" des Senders
  δ = m · (α^a)^k                       ← Nachricht maskiert mit dem
                                            gemeinsamen DH-Geheimnis
  Ciphertext: (γ, δ)

  Wichtig: Durch das zufällige k ergibt dieselbe Nachricht jedes Mal
  einen anderen Ciphertext → probabilistisch, nicht deterministisch
  wie rohes RSA.

#### Entschlüsselung
  Empfänger kennt privaten Schlüssel a:

  Berechne γ^a = (α^k)^a = α^(ka)      ← gemeinsames DH-Geheimnis
  Berechne γ^(-a)                        ← Inverses davon
  m = δ · γ^(-a)                         ← Maskierung aufheben

#### Korrektheit:
  δ · γ^(-a) = m · (α^a)^k · (α^k)^(-a)
             = m · α^(ak) · α^(-ak)
             = m

#### Sicherheit:
  - Basiert auf der DDH-Annahme (Decisional Diffie-Hellman):
    Es ist nicht unterscheidbar, ob ein Tupel (α, α^a, α^k, α^(ak))
    oder (α, α^a, α^k, zufällig) vorliegt.
  - ElGamal ist IND-CPA-sicher unter DDH.
  - Aber NICHT IND-CCA-sicher: Ein Angreifer kann aus einem
    gültigen Ciphertext (γ, δ) einen neuen gültigen Ciphertext
    (γ, δ·m') erzeugen, der m·m' verschlüsselt (Malleability).

#### Nachteil:
  Ciphertext (γ, δ) ist doppelt so lang wie die Nachricht m,
  weil zwei Gruppenelemente übertragen werden müssen.

---

## Übersicht: Symmetrische vs. Asymmetrische Kryptographie

|Eigenschaft|Symmetrisch (z. B. AES, ChaCha20)|Asymmetrisch (z. B. RSA, ElGamal)|
|---|---|---|
|Schlüssel|Ein gemeinsamer geheimer Schlüssel|Schlüsselpaar (öffentlich/privat)|
|Geschwindigkeit|Schnell|Langsam (10–1000× langsamer)|
|Schlüsselaustausch|Problem (sicherer Kanal nötig)|Kein sicherer Kanal nötig|
|Anwendung|Bulk-Datenverschlüsselung|Schlüsselaustausch, Signaturen|
|Praxis|Beide kombiniert in **Hybrid-Kryptographie**||

In der Praxis: Asymmetrische Kryptographie tauscht einen Session-Key aus, der dann für symmetrische Verschlüsselung verwendet wird (z. B. TLS Handshake).