ML-KEM (CRYSTALS-Kyber, NIST FIPS 203) ist ein Key Encapsulation Mechanism (KEM). Er ersetzt ECDH und RSA-OAEP. Die Sicherheit basiert auf dem Module Learning With Errors (MLWE)-Problem, das als quantensicher gilt.
Klassifikation: Asymmetrischer KEM — erzeugt einen gemeinsamen Schlüssel (Shared Secret), der dann als symmetrischer Schlüssel verwendet wird.
import std.crypto.pqc.mlkem;
→ std.crypto.pqc · std.crypto.pqc.pqc (High-Level API) · std.crypto
ML-KEM bietet drei Stufen, die über den Parameter k gesteuert werden:
| Stufe | k | Klassische Sicherheit | Quantensicherheit | Empfehlung |
|---|---|---|---|---|
| ML-KEM-512 | 2 | AES-128-äquivalent | ~100-Bit | Eingeschränkte Ressourcen |
| ML-KEM-768 | 3 | AES-192-äquivalent | ~120-Bit | Standardwahl |
| ML-KEM-1024 | 4 | AES-256-äquivalent | ~160-Bit | Höchste Sicherheit |
Empfehlung: ML-KEM-768 (k=3) ist der NIST-Standard für die meisten Anwendungen (analog zu ECDH-P256 heute).
| Konstante | Wert | Bedeutung |
|---|---|---|
MLKEM512_PK | 800 | Public-Key-Größe ML-KEM-512 in Bytes |
MLKEM512_SK | 1632 | Secret-Key-Größe ML-KEM-512 in Bytes |
MLKEM512_CT | 768 | Ciphertext-Größe ML-KEM-512 in Bytes |
MLKEM768_PK | 1184 | Public-Key-Größe ML-KEM-768 in Bytes |
MLKEM768_SK | 2400 | Secret-Key-Größe ML-KEM-768 in Bytes |
MLKEM768_CT | 1088 | Ciphertext-Größe ML-KEM-768 in Bytes |
MLKEM1024_PK | 1568 | Public-Key-Größe ML-KEM-1024 in Bytes |
MLKEM1024_SK | 3168 | Secret-Key-Größe ML-KEM-1024 in Bytes |
MLKEM1024_CT | 1568 | Ciphertext-Größe ML-KEM-1024 in Bytes |
SK-Layout: dk_pke (384·k) || ek (384·k+32) || H(ek) (32) || z (32)
| Funktion | Beschreibung |
|---|---|
MLKEMKeyGen(seed, k, pk, sk): int64 | Erzeugt Schlüsselpaar aus 64-Byte-Seed. seed[0..31]=d, seed[32..63]=z. Gibt 0 zurück. |
MLKEMEncapsulate(pk, k, randomness, ct, sharedKey): int64 | Erzeugt ct und 32-Byte sharedKey aus Public Key und 32-Byte-Zufall. Gibt 0 zurück. |
MLKEMDecapsulate(sk, k, ct, sharedKey): int64 | Rekonstruiert sharedKey aus Secret Key und Ciphertext. Implizite Ablehnung: falscher CT → pseudozufälliger Key (kein Fehler-Code). Gibt 0 zurück. |
Alle Puffer sind caller-alloziert. Größen aus den Konstanten oben.
Wichtig — Implizite Ablehnung: MLKEMDecapsulate gibt bei manipuliertem Ciphertext einen deterministischen Pseudo-Key zurück (kein -1). Der Unterschied zu einem echten Key ist von außen nicht erkennbar (constant-time). Das ist beabsichtigt (FIPS 203 §6.4).
import std.crypto.pqc.mlkem;
import std.crypto.rand;
import std.alloc;
fn main(): int64 {
// Schlüsselpaar erzeugen (ML-KEM-768, k=3)
var seed: int64 := alloc(64);
RandBytesExact(seed, 64);
var pk: int64 := alloc(MLKEM768_PK);
var sk: int64 := alloc(MLKEM768_SK);
MLKEMKeyGen(seed, 3, pk, sk);
// Sender: kapselt Shared Secret ein
var rand: int64 := alloc(32);
RandBytesExact(rand, 32);
var ct: int64 := alloc(MLKEM768_CT);
var ss_enc: int64 := alloc(32);
MLKEMEncapsulate(pk, 3, rand, ct, ss_enc);
// Empfänger: rekonstruiert Shared Secret
var ss_dec: int64 := alloc(32);
MLKEMDecapsulate(sk, 3, ct, ss_dec);
// ss_enc == ss_dec (wenn ct unmanipuliert)
free(seed, 64); free(rand, 32);
free(pk, MLKEM768_PK); free(sk, MLKEM768_SK);
free(ct, MLKEM768_CT); free(ss_enc, 32); free(ss_dec, 32);
return 0;
}
Hinweis: Für den einfachsten Einstieg → std.crypto.pqc.pqc verwenden (High-Level API, kein manuelles k/Seedhandling).
| Eigenschaft | Ergebnis |
|---|---|
| NIST-Standard | FIPS 203 (2024) — offiziell standardisiert |
| Quantensicherheit | IND-CCA2 im QROM; Grover-Bound je nach Stufe |
| Klassische Sicherheit | MLWE-Härte (strukturell sicherer als RSA/ECDH gegen Quantenrechner) |
| Constant-Time | Implizite Ablehnung CT-sicher via CTMemEqual/CTSelect |
| Interoperabilität | FIPS 203 kompatibel (Wire-Format identisch mit liboqs, BoringSSL) |
Letzte Aktualisierung: 2026-06-08