# Zusammenfassung: Kryptographie **Vorlesung IT-Sicherheit – Gerrit Kalkbrenner, HWR Berlin, 2026** _Erweitert mit aktuellen Informationen und Diagrammen_ --- ## 1. Einführung Kryptographie ist eine moderne, mathematisch geprägte Wissenschaft mit einer Geschichte von über 3.000 Jahren. Bekannte historische Beispiele sind das Babington-Komplott (1586), das Zimmermann-Telegramm (Erster Weltkrieg) und die Enigma-Entschlüsselung im Zweiten Weltkrieg. Heute ist Kryptographie allgegenwärtig – in Mobilfunk, EC-Karten, SSL/TLS, Bitcoin, Wegfahrsperren und vielen weiteren Bereichen. > **Wichtig:** Kryptographie ≠ Sicherheit. Sie ist ein unverzichtbarer Baustein, aber kein vollständiger Ersatz für ein ganzheitliches Sicherheitskonzept. _(Quelle: Bart Preneel, „Cryptographic Algorithms and Protocols for Network Security", 2008)_ --- ## 2. Grundlagen der Verschlüsselung ### Begriffe |Begriff|Bedeutung| |---|---| |**Klartext** (Plaintext)|Die Originaldaten| |**Schlüsseltext / Chiffrat** (Ciphertext)|Die transformierten, unlesbaren Daten| |**Verschlüsselung**|Die mathematische Transformation| |**Entschlüsselung**|Die Umkehrung der Transformation| |**Kryptoanalyse**|Analyse eines Kryptosystems zur Bewertung seiner Stärke| |**Steganographie**|Verbergen der _Existenz_ einer Information (z. B. digitale Wasserzeichen)| ### Kryptographisches System (6-Tupel) Ein Kryptosystem wird formal als **(M, C, K_E, K_D, E, D)** beschrieben: ``` Klartext m ──► [ Verschlüsselung E(m, ke) ] ──► Chiffrat c ▲ Schlüssel ke Chiffrat c ──► [ Entschlüsselung D(c, kd) ] ──► Klartext m ▲ Schlüssel kd Bedingung: D( E(m, ke), kd ) = m ``` **Kerckhoffs-Prinzip:** Der Algorithmus darf öffentlich bekannt sein – die Sicherheit beruht allein auf der Geheimhaltung des Schlüssels. Ein Verschlüsselungsverfahren sollte mindestens **5 Jahre öffentlich diskutiert** werden, bevor es eingesetzt wird. ### Kryptoanalyse-Strategien |Angriffsart|Was der Angreifer kennt|Stärke| |---|---|---| |**Ciphertext-only**|Nur den Schlüsseltext|Schwächster Angriff| |**Known-plaintext**|Klartext-/Schlüsseltext-Paare|Mittel| |**Chosen-plaintext**|Kann beliebige Klartexte verschlüsseln|Stärkster Angriff| |**Brute Force**|Alle Schlüssel werden durchprobiert|Immer möglich| |**Statistische Analyse**|Buchstaben-/Worthäufigkeiten im Chiffretext|Gegen schwache Verfahren| |**Trial & Error**|Eingeschränkte Schlüsselräume (z. B. nur Wörter)|Gegen schlechte Schlüssel| > **Rainbow Tables** ermöglichen vorberechnete Brute-Force-Angriffe – Qualität der Schlüsselgenerierung ist entscheidend! ### Sicherheitskategorien und Schlüssellängen - **Absolute Sicherheit:** Theoretisch unmöglich zu brechen (nur mit One-Time-Pad, OTP) - **Praktische/Rechnerische Sicherheit:** Theoretisch brechbar, aber der Aufwand ist prohibitiv hoch **Brute-Force-Aufwand bei 10⁹ Versuchen/Sekunde:** ``` Schlüssellänge │ Mögliche Schlüssel │ Aufwand (Jahre) ───────────────┼────────────────────┼────────────────────── 8 Bit │ 256 │ < 0,000001 40 Bit │ ~1,1 × 10¹² │ 0,00002 56 Bit │ ~7,2 × 10¹⁶ │ ~1,14 ← DES (veraltet!) 64 Bit │ ~1,8 × 10¹⁹ │ ~292 128 Bit │ ~3,4 × 10³⁸ │ > 5 × 10²¹ ← AES-128 256 Bit │ ~1,2 × 10⁷⁷ │ > 10⁵⁹ ← AES-256 ``` > Aufgrund steigender Rechenleistung (und Quantencomputer) ist alle **10–15 Jahre** ein Algorithmenwechsel notwendig: DES 56 Bit (1977) → AES 128 Bit (2001) → AES 256 Bit (empfohlen für die nächsten ~20 Jahre) > > _Quelle: BSI TR-02102-1, Version 2026-01 – [bsi.bund.de](https://www.bsi.bund.de/SharedDocs/Downloads/EN/BSI/Publications/TechGuidelines/TG02102/BSI-TR-02102-1.pdf)_ --- ## 3. Elementarverschlüsselungen ### Einmal-Schlüssel (One-Time-Pad, OTP) ``` Klartext: K R Y P T O L O G I E ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ Schlüssel: (zufällig, gleiche Länge, nur einmal verwenden!) ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ XOR (mod 2) Chiffrat: ? ? ? ? ? ? ? ? ? ? ? ``` - Das einzig **absolut sichere** Verfahren (mathematisch beweisbar – Shannon 1949) - Schlüssel muss mindestens so lang wie die Nachricht sein - Schlüssel darf **niemals wiederverwendet** werden - Wurde für den „Heißen Draht" Washington–Moskau genutzt - Im kommerziellen Einsatz unpraktisch (Schlüsselverteilungsproblem) ### Monoalphabetische Substitution ``` Klartext: A B C D E F G H I J K L M N O P Q R S T U V W X Y Z ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ Chiffre: G W X V L O A K U B C N D R M F H Y P Q T Z E I J S Beispiel: KRYPTOLOGIE → CYJFQMNMAUL ``` Jedes Zeichen wird durch ein **festes** anderes ersetzt. Leicht durch **Häufigkeitsanalyse** zu brechen: ``` Häufigkeit in Deutsch (Auszug): E: 17,4% ████████████████████ N: 9,8% ███████████ I: 7,6% ████████ S: 7,3% ████████ R: 7,0% ███████ A: 6,5% ███████ ... ``` ### Polyalphabetische Substitution (Vigenère) ``` Klartext: K R Y P T O L O G I E Schlüssel: 5 3 2 5 3 2 5 3 2 5 3 (wird wiederholt) ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ Chiffrat: O T Z T V P P Q H M G ``` Verwendet mehrere Alphabete (gesteuert durch einen Schlüssel). Verdeckt Häufigkeitsverteilungen besser als monoalphabetische Substitution, aber bei langen Texten durch Kasiski-Test und statistische Analyse brechbar. ### Transpositionsverfahren ``` Zick-Zack (Tiefe 5), Klartext: L-A-B-O-R-F-Ü-R-V-E-R-T-E-I-L-T-E-S-Y-S-T-E-M-E L R L E A Ü - I T T M B F V E E S E O - E T - Y R R S → Schlüsseltext: LRLE AÜ-IT TM BFVEESEД0-ET-Y-NRRSU ``` Die Zeichen werden **permutiert** (vertauscht), nicht ersetzt. Historisches Beispiel: Spartanische Skytale (~500 v. Chr.) --- ## 4. Symmetrische Verschlüsselung (Private-Key) Sender und Empfänger verwenden **denselben geheimen Schlüssel**. ``` Geheimer Schlüssel K │ │ ▼ ▼ Alice ──[m]──► [ E_K ] ──[c]──► [ D_K ] ──[m]──► Bob Verschlüsseln Entschlüsseln ``` **Schlüsselverwaltungsproblem:** Bei _n_ Teilnehmern werden **n(n−1)/2** Schlüssel benötigt: - 12 Partner → 66 Schlüssel - 100 Partner → 4.950 Schlüssel - 1.000 Partner → 499.500 Schlüssel ### Überblick: Symmetrische Algorithmen |Verfahren|Schlüssellänge|Blockgröße|Status| |---|---|---|---| |DES|56 Bit|64 Bit|❌ Veraltet (1998 in 22h gebrochen)| |Triple-DES (2 Keys)|112 Bit|64 Bit|⚠️ Auslaufend| |Triple-DES (3 Keys)|168 Bit|64 Bit|⚠️ Auslaufend| |IDEA|128 Bit|64 Bit|✅ Als stark betrachtet| |RC4|variabel|Strom|❌ Veraltet (gebrochen)| |Blowfish|variabel|64 Bit|⚠️ Nicht mehr empfohlen| |**AES-128**|**128 Bit**|**128 Bit**|✅ **Aktueller Standard**| |**AES-256**|**256 Bit**|**128 Bit**|✅ **Empfohlen für Langzeitschutz**| ### AES (Advanced Encryption Standard) – Aufbau einer Runde Entwickelt von Joan Daemen und Vincent Rijmen als „Rijndael", 2001 als FIPS 197 standardisiert. **Patentfrei**. **Rundenanzahl nach Schlüssel- und Blocklänge:** ``` Schlüssellänge │ 128 Bit │ 192 Bit │ 256 Bit ───────────────┼─────────┼─────────┼───────── 128 Bit │ 10 │ 12 │ 14 192 Bit │ 12 │ 12 │ 14 256 Bit │ 14 │ 14 │ 14 ``` **Jede Runde in 4 Schritten (der interne Zustand ist eine 4×4-Byte-Matrix):** ``` ┌──────────────────────────────────────────────────────────┐ │ Runde i │ │ │ │ [4×4 Byte-Matrix] │ │ │ │ │ ▼ │ │ 1. SubBytes – Jedes Byte durch S-Box ersetzen │ │ (nichtlinear, basiert auf Galoisfeld GF(2⁸)) │ │ │ │ │ ▼ │ │ 2. ShiftRows – Zeilen zyklisch verschieben │ │ Zeile 0: keine Verschiebung │ │ Zeile 1: 1 Byte nach links │ │ Zeile 2: 2 Bytes nach links │ │ Zeile 3: 3 Bytes nach links │ │ │ │ │ ▼ │ │ 3. MixColumns – Spalten mit fester MDS-Matrix │ │ multiplizieren (Diffusion, Galoisfeld GF(2⁸)) │ │ [entfällt in der letzten Runde!] │ │ │ │ │ ▼ │ │ 4. AddRoundKey – XOR mit Rundenschlüssel │ │ (aus Key-Schedule erzeugt) │ └──────────────────────────────────────────────────────────┘ ``` > **Warum ist AES sicher?** SubBytes + MixColumns liefern **Konfusion und Diffusion** (Shannon): Ein einzelnes geändertes Eingabebit beeinflusst nach 2 Runden statistisch alle 128 Ausgabebits (Lawineneffekt). _Quelle: NIST FIPS 197 – [csrc.nist.gov](https://csrc.nist.gov/pubs/fips/197/final)_ ### AES-Betriebsmodi im Vergleich ``` ECB (Electronic Codebook) – NICHT empfohlen! ┌─────┐ ┌─────┐ ┌─────┐ │ P₁ │ │ P₂ │ │ P₃ │ ← gleiche Blöcke └──┬──┘ └──┬──┘ └──┬──┘ │E(K) │E(K) │E(K) ← gleicher Schlüssel └──┴──┘ └──┴──┘ └──┴──┘ │ C₁ │ │ C₂ │ │ C₃ │ ← gleiche Chiffrate! Muster sichtbar └─────┘ └─────┘ └─────┘ CBC (Cipher Block Chaining) – Verkettung IV──►XOR◄────────────────────────────── │P₁ ┌──►XOR◄────────────── ▼ │ │P₂ ┌──►XOR E(K)────►C₁┘ ▼ │ │P₃ E(K)────►C₂──┘ ▼ E(K)────►C₃ GCM (Galois/Counter Mode) – Authenticated Encryption Counter: CTR₀ CTR₁ CTR₂ CTR₃ ← Zähler, eindeutig pro Nachricht │E(K) │E(K) │E(K) │E(K) ▼ ▼ ▼ ▼ Auth XOR XOR XOR XOR tag P₁►C₁ P₂►C₂ P₃►C₃ └────GHASH────────► Auth-Tag (Integrität + Vertraulichkeit in einem Schritt) ``` **Modus-Empfehlungen laut BSI TR-02102-1 (2026-01):** |Modus|Vertraulichkeit|Integrität|BSI-Status|Einsatz| |---|---|---|---|---| |ECB|⚠️ Schwach|❌|❌ Nicht empfohlen|–| |CBC|✅|❌ nur mit MAC|⚠️ Mit HMAC|Ältere Systeme| |CFB|✅|❌ nur mit MAC|⚠️ Mit HMAC|Zeichenorientiert| |OFB|✅|❌ nur mit MAC|⚠️ Mit HMAC|Fehleranfällige Kanäle| |CTR|✅|❌ nur mit MAC|⚠️ Mit HMAC|Massendaten, ZIP| |**GCM**|✅|✅ **(AEAD)**|✅ **Bevorzugt**|TLS, IPSec, SSH| _Quelle: BSI TR-02102-1 – [bsi.bund.de](https://www.bsi.bund.de/SharedDocs/Downloads/EN/BSI/Publications/TechGuidelines/TG02102/BSI-TR-02102-1.pdf)_ --- ## 5. Asymmetrische Verschlüsselung (Public-Key) ### Grundidee: Das Briefkasten-Prinzip ``` Öffentlicher Schlüssel (frei verfügbar) │ ▼ Alice ──[m]──► [ E_pub(B) ] ──[c]──► Bob ──► [ D_priv(B) ] ──[m]► ▲ Nur Bob kennt seinen privaten Schlüssel! Schlüsselproblem: n Partner → nur n Schlüsselpaare (statt n(n-1)/2) ``` Der private Schlüssel ist aus dem öffentlichen **nicht in vertretbarer Zeit ableitbar** – basiert auf mathematisch schwer lösbaren Problemen (**One-Way-Trapdoor-Funktionen**). ### Digitale Signatur ``` Signieren (Sender Alice): Verifizieren (Empfänger Bob): Dokument ──► Hash ──► h Dokument ──► Hash ──► h' │ │ priv(A) ▼ pub(A) ▼ E(h) = Signatur ──────────► D(Sig) = h'' Gültig wenn: h' == h'' ``` - Entspricht einem digitalen Äquivalent zur handschriftlichen Unterschrift - Setzt eine **Public-Key-Infrastruktur (PKI)** mit Zertifizierungsstellen (CA/Trustcenter) voraus ### RSA (Rivest, Shamir, Adleman, 1978) **Schlüsselgenerierung:** ``` 1. Wähle zwei große Primzahlen p und q 2. Berechne: n = p × q (Modulus) 3. Berechne: φ(n) = (p-1)(q-1) 4. Wähle e mit: ggT(e, φ(n)) = 1 (öffentlicher Exponent, oft 65537) 5. Berechne d mit: e × d ≡ 1 (mod φ(n)) (privater Exponent) Öffentlicher Schlüssel: (e, n) Privater Schlüssel: (d, n) ``` **Ver- und Entschlüsselung:** ``` Verschlüsseln: c = mᵉ mod n Entschlüsseln: m = cᵈ mod n Beispiel (vereinfacht, p=61, q=53, n=3233, e=17, d=2753): m = 123 → c = 123¹⁷ mod 3233 = 855 c = 855 → m = 855²⁷⁵³ mod 3233 = 123 ✓ ``` **Sicherheit basiert auf:** Schwierigkeit der Primfaktorzerlegung großer Zahlen. **Aktuelle Schlüssellängen-Empfehlungen (2024–2026):** ``` Schlüssellänge │ Symmetr. Äquivalenz │ BSI │ NIST ───────────────┼─────────────────────┼──────────────┼────────────── 1024 Bit │ ~80 Bit │ ❌ Verboten │ ❌ Seit 2013 2048 Bit │ ~112 Bit │ ⚠️ bis 2026 │ ⚠️ bis 2030 3000 Bit │ ~128 Bit │ ✅ Minimum │ ✅ ab 2030 4096 Bit │ ~140 Bit │ ✅ Empfohlen │ ✅ Empfohlen ``` _Quelle: BSI TR-02102-1 (2026-01) – [bsi.bund.de](https://www.bsi.bund.de/SharedDocs/Downloads/EN/BSI/Publications/TechGuidelines/TG02102/BSI-TR-02102-1.pdf)_ ### Diffie-Hellman Schlüsselaustausch (1976) Ermöglicht zwei Parteien, über einen **unsicheren Kanal** ein gemeinsames Geheimnis zu vereinbaren – ohne es vorher ausgetauscht zu haben. ``` Öffentlich bekannt: Primzahl p, Generator g Alice Bob ───── ─── Wählt geheimes a Wählt geheimes b A = gᵃ mod p ────────────────────► ◄─────────────────── B = gᵇ mod p K = Bᵃ mod p = gᵃᵇ mod p K = Aᵇ mod p = gᵃᵇ mod p └────── Gemeinsames Geheimnis K ──────┘ Lauscher sieht: g, p, A, B → kann K NICHT effizient berechnen (Diskretes-Logarithmusproblem) ``` **ECDH (Elliptic Curve Diffie-Hellman):** Gleiches Prinzip auf elliptischen Kurven – gleiche Sicherheit bei **viel kleineren Schlüsseln** (256-Bit ECDH ≈ 3072-Bit klassisches DH). In TLS 1.3 ist **ECDHE** (ephemeral) der Standard für den Schlüsselaustausch – neue Schlüssel pro Sitzung garantieren **Perfect Forward Secrecy**. ### Hybridverschlüsselung in der Praxis (TLS 1.3) In der Praxis werden symmetrische und asymmetrische Verfahren kombiniert: ``` TLS 1.3 Handshake (vereinfacht): Client Server ────── ────── 1. ClientHello ──────────────────► (ECDHE Public Key, unterstützte Cipher Suites) 2. ◄─────────────── ServerHello (ECDHE Public Key, gewählte Cipher Suite, Zertifikat + Signatur) 3. Beide berechnen: gemeinsames Geheimnis via ECDHE → Sitzungsschlüssel für AES-GCM (symmetrisch) 4. Alle weiteren Daten: AES-256-GCM (schnell, AEAD) Asymmetrisch (langsam) → nur für Schlüsselaustausch + Authentifizierung Symmetrisch (schnell) → für alle Nutzdaten ``` _Quelle: Cloudflare Blog zu RFC 8446 – [blog.cloudflare.com](https://blog.cloudflare.com/rfc-8446-aka-tls-1-3/)_ --- ## 6. One-Way-Hashfunktionen ### Grundprinzip ``` Beliebig langer Input M Fester kurzer Output h ──────────────────────► H(M) ──────────────────────► "Hamlet" (200.000 Zeichen) a89de23fede8... (256 Bit) "Hamiet" (1 Buchstabe anders) 38fe38aa9c2d... (256 Bit, komplett anders!) └── Lawineneffekt ``` **Drei Sicherheitseigenschaften:** 1. **Einwegfunktion:** `h = H(M)` leicht berechnen; aus `h` das `M` finden – praktisch unmöglich 2. **Zweites Urbild:** Zu gegebenem `M` kein anderes `M'` finden mit `H(M) = H(M')` 3. **Kollisionsresistenz:** Kein beliebiges Paar `(M, M')` mit `H(M) = H(M')` finden ### Das Geburtstagsparadox ``` Wie viele Menschen braucht man, damit 2 am gleichen Tag Geburtstag haben (p > 50%)? → Nur 23 Menschen! (bei 365 Tagen) Übertragen auf Hashfunktionen: Bei n-Bit-Hashwert genügen ~2^(n/2) Versuche für eine Kollision. Beispiel: 60-Bit-Hash → nur 2³⁰ ≈ 10⁹ Versuche! → Hashwerte müssen länger als symmetrische Schlüssel sein (Faustregel: mindestens 2× die gewünschte Sicherheit in Bit) ``` ### Wichtige Hashfunktionen |Algorithmus|Hashwert|Konstruktion|Status| |---|---|---|---| |MD5|128 Bit|Merkle-Damgård|❌ Gebrochen (Kollisionen in Sekunden)| |SHA-1|160 Bit|Merkle-Damgård|❌ Gebrochen (SHAttered 2017, ~63 USD/GPU)| |**SHA-256**|**256 Bit**|Merkle-Damgård|✅ **Standard**| |**SHA-512**|**512 Bit**|Merkle-Damgård|✅ **Standard**| |**SHA3-256**|**256 Bit**|Keccak/Sponge|✅ **Empfohlen (FIPS 202)**| |RIPEMD-160|160 Bit|Merkle-Damgård|⚠️ Nur noch in Bitcoin| > **Warum SHA-1 gebrochen ist:** Google und CWI Amsterdam erzeugten 2017 zwei verschiedene PDF-Dateien mit **identischem SHA-1-Hash** (SHAttered-Angriff). SHA-1 ist für alle Sicherheitsanwendungen verboten. _Quelle: [shattered.io](https://shattered.io)_ > **SHA-256 vs. SHA3-256:** SHA-256 basiert auf der Merkle-Damgård-Konstruktion (anfällig für Length-Extension-Angriffe ohne HMAC); SHA-3/Keccak nutzt die **Sponge-Konstruktion** und ist immun dagegen. Beide sind aktuell sicher und vom BSI empfohlen. _Quelle: NIST FIPS 202 – [csrc.nist.gov](https://csrc.nist.gov/pubs/fips/202/final)_ ### Message Authentication Code (MAC) ``` Normale Hashfunktion: MAC (Keyed Hash): H(M) → jeder kann prüfen HMAC(K, M) → nur Schlüsselinhaber kann prüfen HMAC-Konstruktion (RFC 2104): HMAC(K, M) = H( (K ⊕ opad) ‖ H( (K ⊕ ipad) ‖ M ) ) ipad = 0x36363636... (Schlüssellänge) opad = 0x5C5C5C5C... (Schlüssellänge) ``` - **CBC-MAC:** Letzter Block einer CBC-Verschlüsselung als Prüfsumme – Standard im Bankwesen - **HMAC:** Internet-Standard RFC 2104, z. B. in IPSec, TLS (für ältere Modi), SSH --- ## 7. Aktueller Stand & Ausblick: Post-Quanten-Kryptographie > **Neu ab 2024 – nicht Teil der Vorlesung, aber prüfungsrelevant für die Praxis!** ### Die Quantenbedrohung ``` Klassische Computer: Brute Force RSA-2048 → ~300 Billionen Jahre Quantencomputer (Shors Algorithmus): RSA-2048 brechen → Stunden bis Tage (benötigt ~1 Mio. logische Qubits – noch nicht erreicht) Auswirkung: RSA, ECDSA, ECDH, DH → VOLLSTÄNDIG GEBROCHEN durch Shor AES-128 → ~64 Bit Sicherheit (Grover-Algorithmus) AES-256 → ~128 Bit Sicherheit ✅ weiterhin sicher SHA-256 → ~128 Bit Sicherheit ✅ weiterhin sicher ``` ### NIST Post-Quanten-Standards (August 2024) Im **August 2024** veröffentlichte NIST die ersten drei finalisierten Post-Quanten-Standards: |Standard|Algorithmus|Typ|Mathematisches Problem| |---|---|---|---| |**FIPS 203**|ML-KEM (Kyber)|Schlüsselkapselung|Module-LWE (Gitter)| |**FIPS 204**|ML-DSA (Dilithium)|Digitale Signatur|Module-LWE (Gitter)| |**FIPS 205**|SLH-DSA (SPHINCS+)|Digitale Signatur|Hashfunktionen| _Quelle: NIST – [nist.gov](https://www.nist.gov/news-events/news/2024/08/nist-releases-first-3-finalized-post-quantum-encryption-standards)_ ### BSI-Strategie: Hybrid ist Pflicht Das BSI verfolgt einen konservativeren Ansatz als NIST: **PQC-Verfahren müssen mit klassischen Verfahren kombiniert werden** (Hybridmodus), bis ausreichend Vertrauen aufgebaut ist. ``` Hybride Verschlüsselung (BSI-Empfehlung): Schlüsselkapselung: ECDH (P-256) + ML-KEM-768 └────────────────────► kombiniertes Geheimnis → AES-256-GCM Signatur: ECDSA (P-256) + ML-DSA-65 (beide Signaturen werden erstellt und verifiziert) ``` **Migrationsfristen laut BSI TR-02102-1 (2026-01):** ``` Heute (2026) 2030 2032 2035 │ │ │ │ ▼ ▼ ▼ ▼ ───────────────────────────────────────────────────────────── Klassische Verfahren ████████ (RSA, ECDH) allein ████████████████████████ Hybride Verfahren ████████████████████ (PQC + klassisch) ████████████████████████████████████ Reine PQC-Verfahren ████████████████████████ Kritische Infrastruktur muss bis 2030 migriert sein! ``` _Quelle: BSI TR-02102-1 Version 2026-01 – [bsi.bund.de](https://www.bsi.bund.de/SharedDocs/Downloads/EN/BSI/Publications/TechGuidelines/TG02102/BSI-TR-02102-1.pdf)_ > **„Harvest Now, Decrypt Later" (HNDL):** Staatliche Akteure speichern heute bereits verschlüsselte Kommunikation, um sie nach Verfügbarkeit eines Quantencomputers zu entschlüsseln. Daten mit **langfristiger Vertraulichkeitsanforderung müssen JETZT** mit PQC geschützt werden! --- ## 8. Zusammenfassung ``` Kryptographie-Überblick: ELEMENTAR SYMMETRISCH ASYMMETRISCH HASH ─────────── ─────────── ──────────── ──── OTP (absolut AES-256-GCM ✅ RSA ≥ 3000 Bit ✅ SHA-256 ✅ sicher, aber (BSI-Empfehlung) ECDH (P-256/ SHA3-256 ✅ unpraktisch) X25519) ✅ DES ❌ MD5 ❌ Substitution RC4 ❌ RSA-1024 ❌ SHA-1 ❌ (historisch) Triple-DES ⚠️ Transposition ► Hybridverschlüsselung (historisch) in TLS 1.3, IPSec, ... ZUKUNFT: Post-Quanten-Kryptographie ML-KEM + ECDH (hybrid) ✅ (BSI ab 2026 empfohlen) ``` **Kernprinzipien der Vorlesung:** - Die Sicherheit hängt **niemals** von der Geheimhaltung des Algorithmus ab, sondern **ausschließlich** von der Geheimhaltung des privaten Schlüssels - Kosten des Brechens müssen **höher** sein als der Wert der geschützten Information - Zeitaufwand zum Knacken muss **länger** sein als das Interesse an der Information - Empfehlungen nationaler Behörden beachten (BSI, NIST) – und alle **10–15 Jahre** Algorithmen überprüfen --- ## Weiterführende Ressourcen |Ressource|Link| |---|---| |BSI Technische Richtlinien (TR-02102)|[bsi.bund.de](https://www.bsi.bund.de/DE/Themen/Unternehmen-und-Organisationen/Standards-und-Zertifizierung/Technische-Richtlinien/TR-nach-Thema-sortiert/tr02102/tr02102_node.html)| |NIST Kryptographie-Standards|[csrc.nist.gov](https://csrc.nist.gov/projects/cryptographic-standards-and-guidelines)| |NIST Post-Quanten-Standards|[nist.gov/pqc](https://www.nist.gov/news-events/news/2024/08/nist-releases-first-3-finalized-post-quantum-encryption-standards)| |CrypTool (interaktives Lerntool)|[cryptool.de](https://www.cryptool.de)| |Bundesnetzagentur|[bundesnetzagentur.de](https://www.bundesnetzagentur.de)| |SHAttered (SHA-1 gebrochen)|[shattered.io](https://shattered.io)| |TLS 1.3 erklärt (Cloudflare)|[blog.cloudflare.com](https://blog.cloudflare.com/rfc-8446-aka-tls-1-3/)|