docs: add obsidian hwr docs

Kryptografie/zusammenfassungen/kr2 - zusammenfassung.md

@@ -0,0 +1,366 @@
+# 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).