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.
import std.crypto.pqc.hybrid;
→ std.crypto.pqc · std.crypto.pqc.mlkem · std.crypto.pqc.pqc (High-Level API)
| 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) | |||
| 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 |
| 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. |
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;
}
| 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