====== std.crypto.pqc.hybrid ======

Hybrid-KEM kombiniert **X25519** (klassisch) und **ML-KEM-768** (post-quantum) zu einem einzigen KEM. Beide Shared Secrets werden via SHAKE-256 zu einem gemeinsamen 32-Byte-Schlüssel kombiniert.

**Prinzip:** Schützt auch dann, wenn ein der beiden Verfahren kompromittiert wird — der Angreifer muss sowohl X25519 als auch ML-KEM brechen. Dieses Schema wird von Signal, Google (Chrome) und Apple (iMessage PQ3) eingesetzt.

<code lyx>
import std.crypto.pqc.hybrid;
</code>

→ [[lyx_-_programmiersprache:units:crypto:pqc|std.crypto.pqc]] · [[lyx_-_programmiersprache:units:crypto:pqc:mlkem|std.crypto.pqc.mlkem]] · [[lyx_-_programmiersprache:units:crypto:pqc:pqc|std.crypto.pqc.pqc (High-Level API)]]

----

===== Schlüsselgrößen =====

^ Größe ^ Wert ^ Zusammensetzung ^
| Public Key | 1216 B | X25519-PK (32) + ML-KEM-768-PK (1184) |
| Secret Key | 2432 B | X25519-SK (32) + ML-KEM-768-SK (2400) |
| Ciphertext | 1120 B | X25519-CT (32, ephemerer PK) + ML-KEM-768-CT (1088) |
| Shared Secret | 32 B | SHAKE-256(ss_x25519 || ss_mlkem || ct_x25519 || ct_mlkem) |

----

===== Konstanten =====

^ Konstante ^ Wert ^ Bedeutung ^
| ''HYBRID_PK'' | 1216 | Public-Key-Größe in Bytes |
| ''HYBRID_SK'' | 2432 | Secret-Key-Größe in Bytes |
| ''HYBRID_CT'' | 1120 | Ciphertext-Größe in Bytes |
| ''HYBRID_SS'' | 32 | Shared-Secret-Länge in Bytes |

----

===== Funktionen =====

^ Funktion ^ Beschreibung ^
| ''HybridKEMKeyGen(seed, pk, sk)'' | Erzeugt Schlüsselpaar. seed: 64 Bytes = seed_x25519[0..31] + seed_mlkem[32..95]. pk: HYBRID_PK Bytes; sk: HYBRID_SK Bytes. |
| ''HybridKEMEncapsulate(pk, rand, ct, ss)'' | Erzeugt Ciphertext und 32-Byte Shared Secret. rand: 64 Bytes = rand_x25519[0..31] + rand_mlkem[32..63]. |
| ''HybridKEMDecapsulate(sk, ct, ss)'' | Rekonstruiert Shared Secret aus SK und CT. |

----

===== Verwendungsbeispiel =====

<code lyx>
import std.crypto.pqc.hybrid;
import std.crypto.rand;
import std.alloc;

fn main(): int64 {
  // Schlüsselpaar erzeugen
  var seed: int64 := alloc(64);
  RandBytesExact(seed, 64);
  var pk: int64 := alloc(HYBRID_PK);
  var sk: int64 := alloc(HYBRID_SK);
  HybridKEMKeyGen(seed, pk, sk);

  // Sender: kapselt Shared Secret ein
  var rand: int64 := alloc(64);
  RandBytesExact(rand, 64);
  var ct: int64 := alloc(HYBRID_CT);
  var ss_enc: int64 := alloc(HYBRID_SS);
  HybridKEMEncapsulate(pk, rand, ct, ss_enc);

  // Empfänger: rekonstruiert Shared Secret
  var ss_dec: int64 := alloc(HYBRID_SS);
  HybridKEMDecapsulate(sk, ct, ss_dec);
  // ss_enc == ss_dec

  free(seed, 64); free(rand, 64);
  free(pk, HYBRID_PK); free(sk, HYBRID_SK);
  free(ct, HYBRID_CT); free(ss_enc, HYBRID_SS); free(ss_dec, HYBRID_SS);
  return 0;
}
</code>

----

===== Sicherheitseigenschaften =====

^ Eigenschaft ^ Ergebnis ^
| Klassische Sicherheit | X25519 (Curve25519, ~128-Bit) |
| Quantensicherheit | ML-KEM-768 (FIPS 203, ~120-Bit Quantum) |
| Kombinations-Sicherheit | Angreifer muss beide Verfahren brechen |
| KDF | SHAKE-256(ss_x || ss_k || ct_x || ct_k) — bindet CT in den Key ein (Forward Secrecy) |
| Verbreitung | Signal Protocol PQXDHv2, Google Chrome CECPQ2, Apple PQ3 (analoges Schema) |

Letzte Aktualisierung: 2026-06-08