Das Protokoll, aufgeschrieben
Schlüssellängen, KDF-Eingaben, Wire-Format und die Grenzen jeder Konstruktion, aus den Design-Dokumenten, gegen die die App gebaut wird. Was jeder Teil für dich tut, steht auf der Sicherheitsseite.
Jeder Abschnitt nennt die Konstruktion, die die Android-App ausführt, in der Notation der Spezifikation, der sie folgt, und listet danach, wogegen sie nicht schützt. Unter der Notation der meisten Abschnitte steht die Funktion, die sie implementiert. Sie wird bei jedem Build dieser Website an den angegebenen Zeilennummern aus der Quelldatei geschnitten, ohne die Kommentare. Wird eine Funktion umbenannt oder entfernt, schlägt der Build fehl, jeder Ausschnitt entspricht also dem Code, aus dem diese Website gebaut wurde. Die App auf deinem Telefon kann aus einem neueren oder älteren Build stammen.
Die Labels in den KDF-Aufrufen sind die Domain-Separation-Strings der App und stehen hier wörtlich, damit eine unabhängige Implementierung dieselben Schlüssel ableiten kann.
Identität
Drei Schlüsselpaare und eine ID, die dir niemand zuteilen kann
Eine Identität entsteht beim ersten Start auf dem Telefon: ein X25519-Schlüssel für den Schlüsselaustausch, ein Ed25519-Schlüssel, der jeden veröffentlichten Prekey signiert, und ein ML-KEM-1024-Schlüssel für den Sealed-Sender-Umschlag. Die User-ID ist eine UUID, abgeleitet aus den beiden Public Keys. Die Registrierung wird abgelehnt, wenn die ID nicht zu den Schlüsseln passt oder der Registrierende keinen Nachweis signieren kann, der den Relay nennt. Ein Relay kann also keine ID für Schlüssel ausgeben, die er nicht besitzt.
Neben der Identität veröffentlicht die App Prekeys für alle, die eine Unterhaltung beginnen wollen, während sie offline ist: einen signierten X25519-Prekey, einen Vorrat an einmaligen X25519-Prekeys, einen signierten ML-KEM-1024-Prekey und einen Vorrat an signierten einmaligen ML-KEM-1024-Prekeys. Der Relay speichert Public Keys. Jeder private Schlüssel liegt im Tresor.
identity_key X25519 Schlüsselaustausch
signing_key Ed25519 signiert jeden Prekey dieser Identität
sealed_kem_key ML-KEM-1024 langlebig, Ziel des Sealed-Sender-Umschlags
user_id UUIDv8( SHA-256(identity_pk ‖ signing_pk)[0..16] )
identity_pk = 01 02 … 20, signing_pk = 21 22 … 40 → 20a7ec84-684f-8fe1-a4cb-3727d049734a
prekeys SPK X25519 (signiert) · OPK X25519 · PQSPK ML-KEM-1024 (signiert) · PQOPK ML-KEM-1024 (signiert)pub fn derive_user_id(identity_public_key: &[u8], identity_signing_key: &[u8]) -> Uuid {
let mut h = Sha256::new();
h.update(identity_public_key);
h.update(identity_signing_key);
let digest = h.finalize();
let mut bytes = [0u8; 16];
bytes.copy_from_slice(&digest[..16]);
bytes[6] = (bytes[6] & 0x0F) | 0x80;
bytes[8] = (bytes[8] & 0x3F) | 0x80;
Uuid::from_bytes(bytes)
}Grenzen
- Die Signaturen sind Ed25519 und halten gegen einen klassischen Fälscher. Ein Angreifer mit Quantencomputer, online zum Zeitpunkt des Handshakes, könnte sie fälschen; derselbe Angreifer bricht auch den X25519-Identitätsschlüssel, beide liegen also auf einer Stufe. Der Wechsel des Signaturschlüssels auf ML-DSA ist geplant.
- Der Erstkontakt ist Trust-on-first-use: Die App vertraut der ID, die sie bekommen hat. Jeder Schlüssel, der für diese ID abgerufen wird, muss zu ihr hashen, sonst lehnt die App die Sitzung ab. Die Sicherheitsnummern decken den gesamten Schlüsselaustausch ab, für den Abgleich über einen anderen Kanal.
Implementiert in X25519.kt · Ed25519.kt · MLKEM.kt · KeyManager.kt
Handshake
PQXDH mit ML-KEM-1024
Der Initiator holt das Prekey-Bundle des Gegenübers, prüft jede Signatur unter dessen Signaturschlüssel und lehnt das Bundle ab, wenn eine Signatur nicht stimmt oder kein ML-KEM-Prekey enthalten ist. Der Handshake nimmt das Post-Quanten-Material als nicht-optionales Argument, eine Sitzung ohne es kompiliert nicht. Ein Relay, der den ML-KEM-Prekey aus einem Bundle entfernt, bekommt eine Ablehnung.
Vier X25519-Berechnungen (drei, wenn der Vorrat an einmaligen Prekeys leer ist) und eine ML-KEM-1024-Encapsulation gehen in einen HKDF-SHA-512-Aufruf. Der Initiator kapselt an einen einmaligen ML-KEM-Prekey, wenn das Bundle einen hat, sonst an den signierten Last-Resort-Prekey. Die 32 Byte Ausgabe sind der erste Root Key des Ratchets.
Die erste Nachricht trägt den Ephemeral Key, die IDs der benutzten Prekeys, den KEM-Ciphertext und eine erste Ratchet-Nachricht. Der Empfänger baut die Sitzung im Speicher auf, und erst wenn diese Nachricht entschlüsselt, installiert er die Sitzung, verbraucht die einmaligen Prekeys und archiviert die vorherige Sitzung, in einer Tresor-Transaktion. Ein Handshake, dessen Nachricht sich nicht öffnen lässt, weil ein einmaliger Prekey durch eine Wiederholung verbraucht wurde, bei einer Wiederherstellung verloren ging oder das Ganze gefälscht war, lässt die aktuelle Sitzung, das Archiv und jeden Prekey, wie sie waren. Einen Handshake, den der Empfänger schon beantwortet hat, entschlüsselt er auf der Sitzung, die er dafür gebaut hat, und dieselbe Nachricht ein zweites Mal ist ein Duplikat.
DH1 = X25519(IK_A, SPK_B)
DH2 = X25519(EK_A, IK_B)
DH3 = X25519(EK_A, SPK_B)
DH4 = X25519(EK_A, OPK_B) wenn ein einmaliger Prekey verfügbar war
(CT, SS) = ML-KEM-1024.Encaps(PQPK_B) einmaliger PQ-Prekey bevorzugt, sonst der signierte
SK = HKDF-SHA-512( salt = 0⁶⁴,
ikm = 0xFF³² ‖ DH1 ‖ DH2 ‖ DH3 [‖ DH4] ‖ SS,
info = "Aphotic_CURVE25519_SHA-512_ML-KEM-1024",
L = 32 )fun initiateSession(
ourIdentityPrivate: PrivateKey,
ourIdentityPublic: ByteArray,
theirIdentityPublic: PublicKey,
theirSignedPrekey: PublicKey,
theirOneTimePrekey: PublicKey?,
theirPqPrekey: ByteArray,
): X3DHResult {
val ephemeral = X25519.generateKeyPair()
val dh1 = X25519.dh(ourIdentityPrivate, theirSignedPrekey)
val dh2 = X25519.dh(ephemeral.private, theirIdentityPublic)
val dh3 = X25519.dh(ephemeral.private, theirSignedPrekey)
val dhConcat: ByteArray
if (theirOneTimePrekey != null) {
val dh4 = X25519.dh(ephemeral.private, theirOneTimePrekey)
dhConcat = dh1 + dh2 + dh3 + dh4
CryptoUtils.zeroize(dh4)
} else {
dhConcat = dh1 + dh2 + dh3
}
val (kemCiphertext, ss) = MLKEM1024.encapsulate(theirPqPrekey)
val ikm = KDF_F + dhConcat + ss
CryptoUtils.zeroize(ss)
val sharedSecret = CryptoUtils.hkdfSha512(HKDF_SALT, ikm, HKDF_INFO_PQ, 32)
CryptoUtils.zeroize(dh1)
CryptoUtils.zeroize(dh2)
CryptoUtils.zeroize(dh3)
CryptoUtils.zeroize(ikm)
CryptoUtils.zeroize(dhConcat)
return X3DHResult(
sharedSecret = sharedSecret,
ephemeralKeyPair = ephemeral,
kemCiphertext = kemCiphertext,
)
}Grenzen
- SK bekommt nur ein Angreifer, der X25519 und ML-KEM-1024 beide bricht. Ein später gebauter Quantencomputer gewinnt SK nicht aus heute aufgezeichnetem Verkehr.
- PQXDH schützt den Aufbau. Was danach mit den Schlüsseln passiert, ist Sache des Ratchets, unten.
Implementiert in X3DHManager.kt · SessionManager.kt
Ratchet
Triple Ratchet: ein KEM-Schritt auf jedem DH-Schritt
Jede Sitzung läuft über das Double Ratchet: eine symmetrische Kette, die jeder Nachricht einen eigenen Schlüssel gibt und ihn nach Gebrauch vernichtet, und ein DH-Ratchet, das den Root Key ersetzt, sobald die Unterhaltung die Richtung wechselt. Ein drittes Ratchet läuft im Gleichschritt mit dem zweiten. Bei jedem DH-Schritt erzeugt der Sender ein frisches ML-KEM-768-Schlüsselpaar, kapselt an das aktuelle des Gegenübers, und das KEM-Geheimnis geht neben der DH-Ausgabe in die Root-KDF.
Jede Nachricht trägt den aktuellen ML-KEM Public Key des Senders und, auf jeder Kette nach einem Schritt, den Ciphertext für das Gegenüber. Jede einzelne Nachricht einer Kette kann deshalb den Schritt des Gegenübers auslösen; nichts wird über Nachrichten verteilt oder wieder zusammengesetzt. Eine Nachricht darf der zuletzt empfangenen um bis zu 2.000 Positionen voraus sein. Die übersprungenen Schlüssel bleiben 7 Tage erhalten, höchstens 500 pro Sitzung, damit verspätete Nachrichten noch entschlüsseln. Bei 2²⁴ Nachrichten endet die Kette und die Sitzung wird neu aufgebaut.
Der Zustand wird erst in den Tresor geschrieben, wenn eine Entschlüsselung verifiziert ist. Eine fehlgeschlagene Entschlüsselung lässt die Sitzung, wie sie war. Ein Duplikat wird vor jedem DH-Schritt erkannt, auf der aktuellen Empfangskette und auf den letzten fünf stillgelegten, und ändert nichts; die letzten fünf Sitzungen mit einem Kontakt bleiben archiviert, damit ein Nachzügler aus einer davon noch entschlüsselt. Eine auseinandergelaufene Sitzung, eine Lücke jenseits des Fensters auf der aktuellen Kette oder drei unentschlüsselbare Nachrichten in Folge, wird höchstens einmal pro Kontakt und 24 Stunden aus einem frischen Bundle neu aufgebaut, und nur für einen Kontakt, nie für einen Fremden. Die alte Sitzung wandert ins Archiv.
Kettenschritt MK = HMAC-SHA-256(CK, 0x01) CK' = HMAC-SHA-256(CK, 0x02)
Nachricht AES-256-GCM(MK, plaintext, AD)
AD IK_sender ‖ IK_receiver ‖ 0x03 ‖ dhPub ‖ counter ‖ prev ‖ flags ‖ kemGen ‖ kemPub [‖ ctTargetGen ‖ kemCt]
Root-Schritt (RK', CK) = HKDF-SHA-256( salt = RK,
ikm = DH(32) ‖ SS(32),
info = "Aphotic_TripleRatchet",
L = 64 )
DH: X25519 zwischen dem neuen Ratchet Key und dem des Gegenübers
SS: ML-KEM-768, Encaps an den aktuellen Key des Gegenübers beim Senden, Decaps beim Empfang
Wire 0x03 ‖ flags ‖ kemGen(u32) ‖ kemPub(1184 B) [‖ ctTargetGen(u32) ‖ kemCt(1088 B)] ‖ AEAD-Ausgabe
+1190 B auf jeder Nachricht, +2282 B auf einer Kette nach einem Schrittfun kdfRk3(rootKey: ByteArray, dh: ByteArray, ss: ByteArray?): Pair<ByteArray, ByteArray> {
val ikm = if (ss != null) dh + ss else dh
val output = CryptoUtils.hkdf(rootKey, ikm, TRIPLE_RATCHET_INFO, 64)
val newRootKey = output.copyOfRange(0, 32)
val chainKey = output.copyOfRange(32, 64)
if (ss != null) CryptoUtils.zeroize(ikm)
CryptoUtils.zeroize(output)
return Pair(newRootKey, chainKey)
}Grenzen
- Ohne Kompromittierung lernt ein passiver Angreifer mit vollständigem Transkript und Quantencomputer nichts: Jeder Root-Übergang nach dem Aufbau mischt ein KEM-Geheimnis ein, das er nicht gewinnen kann, und der Aufbau ist PQXDH.
- Nach einem einmaligen Auslesen des Telefonzustands heilt die Senderichtung des Opfers bei seinem nächsten DH-Schritt und die Empfangsrichtung einen Round Trip später, gegen einen passiven Quanten-Angreifer.
- Ein Angreifer mit einer vollständigen Kopie des Zustands, der aktiv im Pfad sitzt, schlägt jedes Ratchet dieser Familie, auch dieses.
- Das Ratchet-Format wird beim Aufbau der Sitzung aus einer nativen Fähigkeit festgelegt und nie vom Wire gelesen. Ein Gegenüber, das die App mit KEM-Ratchet gepinnt hat, bekommt in keiner Richtung eine Sitzung ohne es.
Implementiert in DoubleRatchet.kt · TripleRatchet.kt · RatchetSession.kt
Direktnachrichten
Sealed Sender, post-quantum
Eine Direktnachricht geht ohne Authorization-Header an den Relay des Empfängers. Die Anfrage nennt den Empfänger und trägt einen undurchsichtigen Blob; die ID des Senders steckt in der Verschlüsselung. Der Seal Key kommt aus einem Ephemeral-X25519-Schlüssel und einer ML-KEM-1024-Encapsulation an den langlebigen Sealed-KEM-Schlüssel des Empfängers; der Ephemeral Key, der Identitätsschlüssel und der KEM-Schlüssel des Empfängers sind in die HKDF-Info gebunden.
In der Verschlüsselung legt der Sender seine User-ID als 16 Rohbytes ab, dazu die beiden öffentlichen Schlüssel, deren Hash sie ist, und einen Tag, dessen Schlüssel aus einer X25519-Vereinbarung zwischen seinem Identitätsschlüssel und dem des Empfängers stammt. Der Empfänger macht nur weiter, wenn die ID der Hash dieser Schlüssel ist und der Tag stimmt. So kann niemand eine Nachricht aussehen lassen, als käme sie von jemand anderem, und eine Nachricht, die eine der beiden Prüfungen nicht besteht, wird verworfen, bevor ein Kontakt, eine Abfrage oder eine Sitzung berührt wird. Der Empfänger kann denselben Tag berechnen; er ist also ein MAC und keine Signatur, und der Sender bleibt abstreitbar. Der Tag liegt innerhalb der Post-Quanten-Verschlüsselung und kann deshalb später nicht als Orakel dafür dienen, wer was gesendet hat.
Die Null-Nonce ist sicher, weil beide Eingaben des Seal Keys pro Nachricht frisch sind. Der KEM-Schlüssel des Empfängers ist unter dessen Ed25519-Signaturschlüssel signiert und reist im Prekey-Bundle mit, ein Relay kann also keinen eigenen unterschieben. Ein Umschlag ohne ML-KEM-Teil oder ohne Sender-Prüfung wird beim Entschlüsseln abgelehnt, und ein fehlender KEM-Schlüssel lässt das Senden scheitern; jeder Fallback würde einem Relay erlauben, einen Schutz durch Löschen eines Felds zu entfernen. Ohne den ML-KEM-Teil würde ein Angreifer, der heute Direktnachrichten aufzeichnet und später X25519 bricht, den Sender jeder einzelnen zurückgewinnen.
Das Senden weist eine Lizenz mit einem zufälligen Handle nach, das jede Stunde wechselt, über einen eigenen Tor-Circuit (siehe Lizenz-Tokens unten). Der Relay füllt jeden gespeicherten Umschlag auf eine feste Bucket-Größe auf.
(eph_sk, eph_pk) = X25519.KeyGen()
dh = X25519(eph_sk, IK_recipient)
(ct, ss) = ML-KEM-1024.Encaps(SealedKEM_recipient)
wake = 64 Zufallsbytes, oder bei offer / hangup eines Anrufs: 64 B
nonce ‖ AES-256-GCM( HKDF-SHA-256(salt = 0³², ikm = ring_key, info = "Aphotic_Wake_v1", L = 32),
kind ‖ call_id ‖ sent_at ‖ 0¹¹,
aad = "Aphotic_Wake_v1" ‖ 0x04 ‖ eph_pk )
header = 0x04 ‖ wake ‖ eph_pk ‖ ct 1 + 64 + 32 + 1568 B
seal_key = HKDF-SHA-256( salt = 0³², ikm = dh ‖ ss,
info = "Aphotic_SealedSender_v4" ‖ eph_pk ‖ IK_recipient ‖ SealedKEM_recipient,
L = 32 )
uid = UUIDv8( SHA-256(IK_sender ‖ SK_sender) ) 16 B
tag = HKDF-SHA-256( salt = 0³², ikm = X25519(IK_sender, IK_recipient),
info = "Aphotic_SealedSender_v4_auth" ‖ eph_pk ‖ SHA-256(ct) ‖ uid
‖ IK_sender ‖ SK_sender ‖ IK_recipient ‖ SHA-256(Ratchet-Nachricht),
L = 32 )
body = uid ‖ IK_sender ‖ SK_sender ‖ tag ‖ Ratchet-Nachricht
blob = header ‖ AES-256-GCM(seal_key, nonce = 0¹², aad = header, body)fun seal(
recipientIdentityKey: ByteArray,
recipientSealedKemKey: ByteArray,
sender: Sender,
innerCiphertext: String,
wake: WakeSpec? = null,
): ByteArray {
require(recipientIdentityKey.size == IDENTITY_KEY_LEN) {
"recipient identity key must be $IDENTITY_KEY_LEN bytes, got ${recipientIdentityKey.size}"
}
require(recipientSealedKemKey.size == MLKEM1024.PUBLIC_KEY_LEN) {
"recipient sealed-sender KEM key must be ${MLKEM1024.PUBLIC_KEY_LEN} bytes, " +
"got ${recipientSealedKemKey.size}"
}
require(sender.identityPublic.size == IDENTITY_KEY_LEN) {
"sender identity key must be $IDENTITY_KEY_LEN bytes, got ${sender.identityPublic.size}"
}
require(sender.signingPublic.size == SIGNING_KEY_LEN) {
"sender signing key must be $SIGNING_KEY_LEN bytes, got ${sender.signingPublic.size}"
}
val recipientPub = X25519.publicKeyFromBytes(recipientIdentityKey)
val ephemeral = X25519.generateKeyPair()
val ephPubBytes = X25519.publicKeyToBytes(ephemeral.public)
val dh = X25519.dh(ephemeral.private, recipientPub)
val (kemCt, kemSecret) = MLKEM1024.encapsulate(recipientSealedKemKey)
val wakeBytes = wake?.let { WakeHeader.seal(it.key, it.kind, it.callId, it.sentAtMs, ephPubBytes) }
?: WakeHeader.random()
val header = byteArrayOf(VERSION_V4) + wakeBytes + ephPubBytes + kemCt
val key = deriveSealKey(dh, kemSecret, ephPubBytes, recipientIdentityKey, recipientSealedKemKey)
CryptoUtils.zeroize(dh)
CryptoUtils.zeroize(kemSecret)
val uid = UserId.derive(sender.identityPublic, sender.signingPublic)
val innerBytes = innerCiphertext.toByteArray(Charsets.UTF_8)
val staticDh = X25519.dh(sender.identityPrivate, recipientPub)
val tag = authTag(
staticDh, ephPubBytes, kemCt, uid, sender.identityPublic, sender.signingPublic,
recipientIdentityKey, innerBytes,
)
CryptoUtils.zeroize(staticDh)
val body = uid + sender.identityPublic + sender.signingPublic + tag + innerBytes
val aead = CryptoUtils.aesGcmEncryptWithNonce(key, ZERO_NONCE, body, header)
CryptoUtils.zeroize(key)
CryptoUtils.zeroize(body)
CryptoUtils.zeroize(uid)
CryptoUtils.zeroize(tag)
CryptoUtils.zeroize(innerBytes)
return header + aead
}fun open(
envelope: ByteArray,
ourIdentityPrivate: PrivateKey,
ourIdentityPublic: ByteArray,
ourSealedKemPrivate: ByteArray,
ourSealedKemPublic: ByteArray,
): Opened {
require(envelope.size > HEADER_LEN) { "sealed envelope too short: ${envelope.size} bytes" }
require(envelope[0] == VERSION_V4) {
"unsupported sealed envelope version 0x${(envelope[0].toInt and 0xFF).toString(16)}"
}
val ephPubBytes = envelope.copyOfRange(EPH_OFFSET, EPH_OFFSET + EPH_PUB_LEN)
val kemCt = envelope.copyOfRange(EPH_OFFSET + EPH_PUB_LEN, HEADER_LEN)
val header = envelope.copyOfRange(0, HEADER_LEN)
val aead = envelope.copyOfRange(HEADER_LEN, envelope.size)
val dh = X25519.dh(ourIdentityPrivate, X25519.publicKeyFromBytes(ephPubBytes))
val kemSecret = MLKEM1024.decapsulate(ourSealedKemPrivate, kemCt)
val key = deriveSealKey(dh, kemSecret, ephPubBytes, ourIdentityPublic, ourSealedKemPublic)
CryptoUtils.zeroize(dh)
CryptoUtils.zeroize(kemSecret)
val body = CryptoUtils.aesGcmDecryptWithNonce(key, ZERO_NONCE, aead, header)
CryptoUtils.zeroize(key)
try {
if (body.size < SENDER_BLOCK_LEN) {
throw SealedUnauthenticatedException("sealed body too short for the sender block")
}
var off = 0
val uid = body.copyOfRange(off, off + UID_LEN).also { off += UID_LEN }
val senderIk = body.copyOfRange(off, off + IDENTITY_KEY_LEN).also { off += IDENTITY_KEY_LEN }
val senderSk = body.copyOfRange(off, off + SIGNING_KEY_LEN).also { off += SIGNING_KEY_LEN }
val tag = body.copyOfRange(off, off + TAG_LEN).also { off += TAG_LEN }
val inner = body.copyOfRange(off, body.size)
try {
if (!MessageDigest.isEqual(UserId.derive(senderIk, senderSk), uid)) {
throw SealedUnauthenticatedException("sealed sender uid does not derive from its keys")
}
val senderIkPub = try {
X25519.publicKeyFromBytes(senderIk)
} catch (e: IllegalArgumentException) {
throw SealedUnauthenticatedException("sealed sender identity key is not a valid X25519 key", e)
}
val staticDh = try {
X25519.dh(ourIdentityPrivate, senderIkPub)
} catch (e: GeneralSecurityException) {
throw SealedUnauthenticatedException("sealed sender identity key is degenerate", e)
}
val expected = authTag(
staticDh, ephPubBytes, kemCt, uid, senderIk, senderSk, ourIdentityPublic, inner,
)
CryptoUtils.zeroize(staticDh)
val tagOk = MessageDigest.isEqual(expected, tag)
CryptoUtils.zeroize(expected)
if (!tagOk) throw SealedUnauthenticatedException("sealed sender authentication tag mismatch")
return Opened(
senderId = UserId.toCanonicalString(uid),
senderUid = uid,
senderIdentityKey = senderIk,
senderSigningKey = senderSk,
innerCiphertext = String(inner, Charsets.UTF_8),
)
} finally {
CryptoUtils.zeroize(tag)
CryptoUtils.zeroize(inner)
}
} finally {
CryptoUtils.zeroize(body)
}
}private fun authTag(
staticDh: ByteArray,
ephPub: ByteArray,
kemCt: ByteArray,
uid: ByteArray,
senderIdentityKey: ByteArray,
senderSigningKey: ByteArray,
recipientIdentityKey: ByteArray,
inner: ByteArray,
): ByteArray {
val info = AUTH_INFO + ephPub + CryptoUtils.sha256(kemCt) + uid + senderIdentityKey +
senderSigningKey + recipientIdentityKey + CryptoUtils.sha256(inner)
return CryptoUtils.hkdf(HKDF_SALT, staticDh, info, TAG_LEN)
}Grenzen
- Diese Schicht hat keine Forward Secrecy: Sie verschlüsselt an langlebige Empfängerschlüssel. Die liefert die Ratchet-Nachricht darin.
- Wie jede Authentisierung auf Basis einer Schlüsselvereinbarung übersteht die Sender-Prüfung den Identitätsschlüssel des Empfängers selbst nicht: Wer ihn besitzt, kann Nachrichten an diesen Empfänger so aussehen lassen, als kämen sie von beliebigen Absendern. Wer ihn besitzt, hat den Vault des Telefons ohnehin.
- Der Empfänger steht im Klartext, weil der Relay zustellen muss. Ein Relay sieht, wer wann was empfängt, und weil er den Moment wählt, in dem er die wartende Anfrage des Empfängers weckt, kann es ein Senden mit einem Empfangen paaren, während es passiert. Sealed Sender verbirgt die Identität des Senders vor dem Relay. Es hindert ein Relay nicht daran, die beiden Enden einer Unterhaltung über das Timing zu korrelieren, und wenn in derselben Stunde nur wenige Geräte Handles rotieren, ist die Menge, in der sich ein Sender versteckt, klein.
Implementiert in SealedSender.kt
Auf dem Telefon
Ein zufälliger Schlüssel unter zwei Hüllen
Nachrichten, Kontakte, Sitzungen und die langlebigen privaten Schlüssel sind eine SQLCipher-Datenbank. Ihr Schlüssel ist ein zufälliger 256-Bit-Wert, der nie aus der PIN abgeleitet wird. Er liegt unter zwei AES-256-GCM-Schichten: einer inneren, deren Schlüssel per Argon2id aus der PIN kommt, und einer äußeren mit einem nicht exportierbaren AES-Schlüssel im Android Keystore, in der StrongBox, wo das Telefon eine hat.
Fotos, Videos und Sprachnotizen sind eigene Dateien, jede in AES-256-GCM-Segmenten unter einem Schlüssel, der aus einem Medien-Hauptschlüssel in der Datenbank abgeleitet wird. Eine Datei, die gekürzt, verlängert, umsortiert oder in einem Bit verändert wurde, wird abgelehnt. Das Löschen der Datenbank vernichtet deshalb jede Mediendatei kryptographisch, bevor eine einzige von der Platte geht, und in dieser Reihenfolge arbeiten der Wipe, ein View-once, ein Ablauf und das Löschen einer Nachricht. Empfangene Medien werden nie entschlüsselt abgelegt; der einzige Ausgang ist der Galerie-Export, den du selbst einschaltest.
Der Tresor sperrt sich nach einem Timer, der auf der Betriebszeit-Uhr des Telefons läuft, sodass auch ein schlafendes Telefon pünktlich sperrt, und immer, wenn die App in den Hintergrund geht. Eine Sperre schließt die Datenbank, wirft jede entschlüsselte Nachricht aus dem Speicher und startet die JavaScript-Laufzeit der App neu, damit auch deren Heap verschwindet; solange der Tresor gesperrt ist, läuft die Zustellung im Hintergrund in nativem Code, und die Benachrichtigung nennt niemanden.
Eine falsche PIN lässt einen GCM-Tag fehlschlagen; in den Metadaten gibt es keinen separaten Prüfwert zum Angreifen. Fünf Fehlversuche löschen die Datenbank, ihre Metadaten und jede Mediendatei. Die Panik-PIN ist ein zweiter umhüllter Blob mit einem Sentinel. Die beiden PINs leiten verschiedene Schlüssel ab, es öffnet also höchstens ein Blob, und ein gültiges Entschlüsseln des Sentinels löst denselben Wipe ohne Rückfrage aus, danach zeigt die App ihren Einrichtungsbildschirm.
Mit der optionalen Master-Passphrase wird der Schlüssel unter Argon2id der Passphrase mit 128 MiB neu umhüllt, und ein zeitlich begrenzter Keystore-Schlüssel öffnet ein PIN-Fenster (8 Stunden bis 7 Tage, 48 Stunden als Standard), in dem die sechsstellige PIN allein entsperrt. Das Fenster erzwingen die Gültigkeitsdauer des Keystore selbst, ein Ablauf in der App und ein monotoner Uhrzeit-Wächter gegen Zurückdrehen. Ein Neustart des Telefons fragt die Passphrase wieder ab.
Ein Backup ist eine Datei, neu verschlüsselt unter Argon2id mit 128 MiB über ein Geheimnis: standardmäßig einen 260-Bit-Wiederherstellungsschlüssel, den die App für jeden Export neu erzeugt, einmal als 52 Zeichen anzeigt und nie speichert, oder eine Passphrase mit mindestens 12 Zeichen. Der Wechsel auf ein neues Telefon ist eine direkte Übertragung von Gerät zu Gerät. Vom Android-Backup meldet sich die App ab.
K_pin = Argon2id( PIN, salt; m = 64 MiB, t = 4, p = 1 )
K_hw = AES-256 im Android Keystore, nicht exportierbar, StrongBox bevorzugt
wrapped_dek = AES-256-GCM( K_hw, AES-256-GCM( K_pin, DEK ) )
Entsperren äußere Schicht mit K_hw entfernen (nur auf diesem Telefon), dann die innere mit K_pin
der GCM-Tag ist die PIN-Prüfung
Panik AES-256-GCM( K_hw, AES-256-GCM( K_panic, SENTINEL ) ) ein gültiges Entschlüsseln löscht
Passphrase K_master = Argon2id( Passphrase ≥ 12 Zeichen, salt; m = 128 MiB, t = 4 )
Backup Argon2id( Wiederherstellungsschlüssel (260 Bit, pro Export neu) oder Passphrase ≥ 12 Zeichen, salt; m = 128 MiB, t = 4 ), AES-256-GCM
Medien K_file = HMAC-SHA-256( K_media, r ), K_media im Tresor, r zufällig pro Datei
AES-256-GCM über 64-KiB-Segmente, Header als AAD, letztes Segment markiertprivate fun wrap(payload: ByteArray, kPin: ByteArray): String {
val inner = CryptoUtils.aesGcmEncrypt(kPin, payload)
val outer = hw.wrapEncrypt(inner)
return CryptoUtils.toBase64(outer)
}Grenzen
- Eine kopierte Tresordatei ist ohne K_hw wertlos, und das macht eine sechsstellige PIN vertretbar. Code, der auf einem gerooteten Telefon als die App läuft, kann den Keystore bitten, die äußere Schicht zu entfernen, und dann die PIN offline raten. Für diese Bedrohung gibt es die Master-Passphrase.
- Ist der Keystore-Schlüssel weg (Werksreset, gelöschte App-Daten), lässt sich der Tresor nicht öffnen. Eine Backup-Datei ist der einzige Weg zurück, und ohne ihren Wiederherstellungsschlüssel oder ihre Passphrase bleibt sie verschlossen.
- Argon2id nutzt für die tägliche PIN 64 MiB, weil schwachen Telefonen darüber der Speicher ausgeht. Die Hardware-Hülle ist dort die erste Barriere, die KDF-Kosten die zweite.
Implementiert in PinManager.kt · VaultDatabase.kt · VaultKeyStore.kt · VaultBackup.kt · Argon2id.kt · MediaCipher.kt · EncryptedMediaStore.kt · AppLockManager.kt
Lizenz
Blind signierte Lizenz-Tokens
Der Shop kennt die Lizenz und die Zahlung. Der Chat-Relay kennt die Identität. Niemand darf die beiden verbinden, auch ihr Betreiber nicht. Eine Lizenz weist sich mit RSA-Blindsignaturen aus: Die App erzeugt zufällige 32-Byte-Token-IDs, blendet sie und schickt die geblendeten Werte an den Lizenzdienst, der sie mit einem Schlüssel signiert, der eine Stunde lang existiert, und pro Lizenz zählt, wie viele er signiert hat. Eine ungeblendete ID sieht er nie.
Die App entblendet die Signaturen und gibt später ein Token beim Relay aus, der es unter dem Public Key dieser Stunde prüft, einen Hash der ID gegen Wiederverwendung vermerkt und die Identität bis zum Ende der Stunde als lizenziert markiert. Der Relay erfährt, dass der Inhaber in dieser Stunde lizenziert ist, und nichts darüber, welche Lizenz.
Die Stundenschlüssel werden 72 Stunden im Voraus veröffentlicht, unter einer Zusage, die mit dem Relay-Directory-Schlüssel signiert ist. Die App pinnt jeden Schlüssel beim ersten Sehen, lehnt jede spätere Änderung eines gepinnten Schlüssels ab und mintet nur unter einem Schlüssel, den sie zweimal im Abstand von mindestens 15 Minuten gesehen hat. Ein auf ein einzelnes Gerät zugeschnittener Schlüssel kann dessen Tokens also nicht markieren. Ein Mint deckt ein Fenster von bis zu 48 Stunden ab, und zwischen jeder Lizenzanfrage, die die Lizenz nennt, und jedem Einlösen beim Relay liegt eine zufällige Pause von 45 bis 180 Sekunden, mit einer Ausnahme, die unten bei den Grenzen steht.
Das Sealed-Sender-Handle wird mit einem zweiten Token auf einer Route ohne jede Authentifizierung lizenziert, ein Handle und eine Identität stehen also nie in einer Anfrage. Der Client betreibt drei Tor-SOCKS-Ports (Lizenzdienst, Identitätssitzung, Sealed Sends), damit die drei nie einen Circuit teilen, und einen vierten für Gast-Identitäten auf anderen Relays. Wechselt das Handle, werden die gepoolten Verbindungen seines Circuits verworfen, damit eine Verbindung nicht zwei Pseudonyme verkettet.
Suite RSA-2048, RSASSA-PSS, SHA-256, Salt 32 (RFC 9474)
Epoche floor(unix_time / 3600); ein Signaturschlüsselpaar pro Epoche, gelöscht nach Ablauf
Ausgabe lizenzierte Anfrage: geblendete IDs → Blindsignaturen; ≤ 10 × Seats + 2 pro Lizenz und Epoche
Schlüssel 72 Epochen im Voraus veröffentlicht, unter einer mit dem Relay-Directory-Schlüssel signierten Zusage
Mint bis zu 48 Epochen auf einmal, nur unter Schlüsseln, die zweimal im Abstand ≥ 15 min gesehen wurden
Einlösen ohne Credentials: (epoch, token_id, signature); 45–180 s nach jeder Anfrage, die die Lizenz nannte, außer bei der ersten Registrierung
prüfen → INSERT (epoch, SHA-256(token_id)) INTO spent_tokens, abgelehnt falls vorhanden → lizenziert bis zum Ende der Epoche
zwei Tokens eins für die Identitätssitzung, eins für das Sealed-Sender-Handlepub async fn verify_and_spend(
state: &AppState,
epoch: i64,
token_id: &[u8],
signature: &[u8],
) -> Result<i64, AppError> {
let cur = current_epoch();
if epoch < cur - 1 || epoch > cur + 1 {
return Err(AppError::LicenseInvalid(
"redeem_required: token epoch out of range".into(),
));
}
if token_id.len() != 32 {
return Err(AppError::BadRequest("token_id must be 32 bytes".into()));
}
let key = get_key(state, epoch).await?;
let sig = Signature(signature.to_vec());
sig.verify(&key.pk, None, token_id, &opts())
.map_err(|_| AppError::LicenseInvalid("redeem_required: invalid token".into()))?;
if !record_spend(state, epoch, token_id).await? {
return Err(AppError::LicenseInvalid(
"redeem_required: token already redeemed".into(),
));
}
Ok(epoch_end(epoch))
}Grenzen
- Eine über ihre Seats hinaus geteilte Lizenz braucht ihr Stundenkontingent mitten in der Stunde auf. Das ist die ganze Durchsetzung; eine gepatchte App gewinnt nichts, weil das Urteil des Relays nur ein unverbrauchtes, korrekt signiertes Token setzen kann.
- Die zwei Einlösungen eines Geräts passieren in derselben Stunde, um 20 Sekunden versetzt. Die Menge, in der sich ein Gerät versteckt, ist die Zahl der Geräte, die in diesem Fenster einlösen. Bei wenigen Nutzern ist die Timing-Korrelation der beiden praktikabel.
- Eine frische Installation kann erst senden, wenn sie den aktuellen Schlüssel zweimal gesehen hat, und das dauert nach dem ersten Start 15 bis 30 Minuten.
- Die erste Registrierung nach der Aktivierung einer Lizenz mintet ein Token und löst es sofort ein, ohne Pause. Wer beide Dienste betreibt, kann diesen einen Moment über das Timing zuordnen.
Implementiert in blindToken.ts · token_verify.rs · token_keys.rs
Communities
MLS mit hybridem KEM
Communities mit bis zu 5.000 Mitgliedern laufen über RFC 9420 MLS mit TreeKEM, aus einer Clean-Room-Implementierung, die an den Testvektoren des RFC hängt. Communities nutzen eine Ciphersuite aus dem privaten Bereich, 0xF043: Der KEM ist X25519 kombiniert mit ML-KEM-768 über einen Combiner, der beide Ciphertexte bindet, das Hybrid hält also, wenn eine der beiden Komponenten hält; AEAD ist AES-256-GCM, Hash SHA-256, Signatur Ed25519.
Jedes Leaf Credential trägt die User-ID des Mitglieds, die beiden öffentlichen Schlüssel, deren Hash sie ist, und eine Ed25519-Signatur über den Leaf Key, die Ciphersuite und den Schlüssel des Gründers. Es wird überall geprüft, wo ein Leaf besetzt wird; ein Platz gehört also einer Identität, und die Rangdurchsetzung hängt am authentifizierten Sender, den die MLS-Entschlüsselung liefert. Der Schlüssel des Gründers ist der Vertrauensanker und reist im Einladungslink mit. Eine Einladungskarte nimmt die eine Person auf, an die sie ging. Wer geht, wird vom nächsten Admin-Gerät entfernt, auf seine eigene signierte Austrittsbitte hin, nie auf das Wort des Relays.
Ein Welcome trägt den Baum als SHA-256-Referenz, der Baum selbst wird einmal neben dem Commit geschickt, ein Welcome bleibt also bei jeder Mitgliederzahl gleich groß. Commits landen zusätzlich in einem dauerhaften Log, sodass ein Mitglied, das länger als die 7 Tage des Streams offline war, sie der Reihe nach unter seinem bestehenden Leaf nachspielt. Jedes Mitglied darf einen Self-Update-Commit ausgeben; so füllt sich der Baum, und jeder Commit bleibt logarithmisch in der Mitgliederzahl.
Suite 0xF043 KEM = X25519 + ML-KEM-768 (über beide Ciphertexte kombiniert) · AES-256-GCM · SHA-256 · Ed25519 Leaf Credential = uid ‖ IK ‖ SK ‖ Ed25519( Leaf Key ‖ Suite ‖ Gründerschlüssel ), geprüft überall, wo das Leaf besetzt wird Welcome GroupInfo + GroupSecrets; Baum als SHA-256-Referenz, einmal mit dem Commit geschickt Historie Commits in einem dauerhaften Log; Inhalte auf einem 7-Tage-Stream
private fun combine(ssM: ByteArray, ssX: ByteArray, ctX: ByteArray, pkX: ByteArray): ByteArray {
val d = SHA3Digest(256)
for (part in arrayOf(ssM, ssX, ctX, pkX, LABEL)) d.update(part, 0, part.size)
val out = ByteArray(SHARED)
d.doFinal(out, 0)
return out
}Grenzen
- Der Relay sieht die Mitgliederliste und die Epochennummer jeder Community.
- Alltagsgruppen bis 20 bleiben paarweise: Jede Nachricht wird mit dem Ratchet oben für jedes Mitglied einzeln verschlüsselt und als versiegelte Teilsendungen unter einem eigenen Handle für Gruppenverkehr verschickt, auf dem Relay existiert also kein Gruppenschlüssel. Wer in der Gruppe ist, entscheiden ihre Admins: Die Mitgliederliste ist der Schnappschuss eines Admins innerhalb der Verschlüsselung, die Gruppen-ID leitet sich aus dem Schlüssel des Gründers ab, und ein Einladungslink trägt ein Beitrittsgeheimnis, das nur der Admin bestätigen kann, der ihn erzeugt hat. Über die Gruppe selbst speichert der Relay nichts. Für jeden Einladungslink hält er einen Rendezvous-Eintrag: Hashes des Link-Tokens und eines Verwaltungsgeheimnisses, einen verschlüsselten Blob fester Größe, den nur das Geheimnis des Links öffnet, und eine auf die volle Stunde aufgerundete Ablaufzeit. Von einem Link, den der Betreiber sperrt, bleibt nur der Token-Hash, mindestens ein Jahr lang, damit er nicht erneut veröffentlicht werden kann.
- Jede Gruppensendung enthält eine Teilsendung an die eigene Warteschlange des Senders, und alle Teilsendungen einer Sendung sind auf dieselbe Länge aufgefüllt. Der Relay sieht also die ganze Mitgliederliste als Empfänger und nie die Liste ohne den Sender. Die Zahl der Teilsendungen sieht er, und ein Bucket verrät die Größe einer Nachricht bis auf den Faktor zwei.
Implementiert in CipherSuite.kt · HybridKem.kt · MlsGroup.kt · Welcome.kt · KeySchedule.kt
Auf dem Relay
Was gespeichert wird, und wie lange
Der Relay ist ein Tor Hidden Service ohne Clearnet-Endpunkt. Er speichert Public Keys, die daraus abgeleitete User-ID, Community-Mitgliederlisten, einen Rendezvous-Eintrag pro Einladungslink einer Gruppe und Ciphertext in der Warteschlange für höchstens 7 Tage. Das Abrufen der Schlüssel eines anderen Nutzers trägt kein Sitzungs-Token, der Relay beantwortet es also, ohne zu erfahren, wer gefragt hat. Ein gespeicherter Anhang liegt neben dem Hash eines Download-Tokens und sonst nichts; das Token reist in der verschlüsselten Nachricht mit, und der Download legt es ohne Sitzung vor. Jeder gespeicherte Umschlag wird auf einen Bucket von 256, 512, 1024, 2048, 4096 oder 8192 Bytes aufgefüllt, darüber in 4-KiB-Schritten, mit 256 KB als Obergrenze. Die Tabellen haben keine Spalten für Anmelde- oder Zuletzt-gesehen-Zeiten. Tippanzeigen und Online-Status existieren auf dem Wire nicht. Lesebestätigungen sind optional, standardmäßig aus und auf Einzelchats beschränkt. Sind sie an, legt der Client ein Feld read_up_to in den versiegelten Umschlag: den sent_at-Stempel des Gegenübers für die neueste gelesene Nachricht, der alle Nachrichten bis dorthin abdeckt. Das Feld reist mit der nächsten Nachricht an diesen Kontakt; geht nichts raus, trägt es nach zufälligen 15 bis 30 Sekunden ein einzelner versiegelter Umschlag ohne Inhalt.
Antworten tragen keinen Server- und keinen Versions-Header. Der Verkehr erreicht den Relay vom lokalen Tor-Prozess, keine Anfrage trägt also eine Client-IP, die sich loggen ließe.
pub fn padded_size(actual: usize) -> usize {
for &bucket in BUCKETS {
if actual <= bucket {
return bucket;
}
}
let last = *BUCKETS.last().unwrap();
last + ((actual - last + LARGE_BOUNDARY - 1) / LARGE_BOUNDARY) * LARGE_BOUNDARY
}Grenzen
- Timing überlässt die App Tor. Wer beide ersten Hops gleichzeitig beobachtet, kann sie korrelieren, und Tor nennt diese Grenze offen; eine Verzögerung in der App würde beide Enden gleich verschieben.
- Eine einzeln gesendete Lesebestätigung ist eine weitere versiegelte Sendung, die der Relay neben den letzten Abruf des Lesers legen kann. Die zufällige Verzögerung verwischt das, eine Bestätigung, die an einer Nachricht mitreist, beseitigt es, und sind Lesebestätigungen aus, schickt der Client keine.
Implementiert in padding.rs · sealed.rs · longpoll.rs
Anrufe
Sprachanrufe über unseren eigenen Relay
Tor transportiert kein UDP, deshalb verlässt der Ton eines Anrufs Tor und läuft über das normale Internet durch einen TURN-Relay, den wir betreiben. Vor jedem Anruf, ob abgehend oder angenommen, lässt die App bestätigen, dass der Anruf Tor verlässt, und klingeln kann nur ein Kontakt, den du angenommen hast. Aufgebaut wird der Anruf im Chat: Angebot und Antwort sind versiegelte Direktnachrichten unter dem Triple Ratchet. Jede trägt den 32-Byte-Anteil einer Seite am Anrufgeheimnis und deren DTLS-Fingerprint, der Relay kann sich also nicht in den Handshake setzen.
Jedes Telefon holt TURN-Zugangsdaten über Tor beim Chat-Relay, mit einer Anfrage ohne Sitzungs-Token, die eine Lizenz über das Sealed-Sender-Handle nachweist. Der Benutzername ist ein Ablaufzeitpunkt und eine zufällige Nonce, nie eine User-ID, und die Zugangsdaten gelten 10 Minuten. libwebrtc läuft mit Relay-only-ICE gegen unsere TURN-Server und ohne STUN-Server, und jeder Kandidat, der kein Relay-Kandidat ist, wird aus beiden Sitzungsbeschreibungen entfernt. Kein Telefon sieht also je die Adresse des anderen.
Der Ton ist Opus mit konstanter Bitrate und ohne Discontinuous Transmission, in zwei Schichten: DTLS-SRTP mit den AES-GCM-Suites und eine Frame-Schicht, deren Schlüssel aus den beiden Anteilen kommen. Der Frame-Cryptor von libwebrtc leitet 128-Bit-Schlüssel ab, die Frame-Schicht ist also AES-128-GCM, unterhalb des AES-256 im Rest der App.
ICE iceTransportPolicy = relay, nur unsere TURN-Server, kein STUN; Nicht-Relay-Kandidaten aus beiden SDPs entfernt
TURN POST /v1/calls/turn-credentials über Tor: keine Sitzung, X-Sealed-Handle
username = Ablauf ‖ ":" ‖ hex(16 Zufallsbytes), password = Base64( HMAC-SHA1(secret, username) ), TTL 600 s
Aufbau Angebot { k_c, SDP }, Antwort { k_r, SDP }: versiegelte Direktnachrichten unter dem Triple Ratchet
k_c, k_r = je 32 Zufallsbytes; der DTLS-Fingerprint steht im SDP
Geheimnis S = HKDF-SHA-256( salt = "aphotic-call-v1", ikm = k_c ‖ k_r, info = call_id, L = 32 )
Frame-Keys K_i = HKDF-SHA-256( salt = "aphotic-call-key", ikm = S, info = call_id ‖ "|" ‖ i, L = 32 ) i = 0..15, alle 5 min der nächste
Frames libwebrtc FrameCryptor, AES-GCM, Schlüssel pro Frame mit 128 Bit abgeleitet
Transport DTLS-SRTP, AES-GCM-Suites
Ton Opus, cbr = 1, usedtx = 0, 32 kbit/sGrenzen
- Der Anruf-Relay sieht beide IP-Adressen, dass die beiden miteinander sprechen, wann der Anruf beginnt und endet und wie viele Bytes fließen. Er sieht das, solange der Anruf läuft. Wir führen darüber kein Log, und das beruht auf unserem Wort.
- Chat-Relay und Anruf-Relay laufen beim selben Betreiber. Wer beide betreibt, könnte ein Anrufangebot, das einem Empfänger zugestellt wird, mit den Relay-Allokationen abgleichen, die es Sekunden später auslöst, und so die IP-Adresse des Empfängers erfahren. Keiner der beiden speichert etwas, womit das nachträglich ginge.
- Die Schlüsselvereinbarung von DTLS-SRTP ist klassisch. Die Anteile der Frame-Schicht reisen im Triple Ratchet, das ML-KEM einmischt, aufgezeichneter Ton bleibt also mit AES-128-GCM gegen einen späteren Quantenangreifer geschützt. Das ist die niedrigste Post-Quanten-Sicherheitskategorie der NIST.
- Dein Internetanbieter sieht UDP- oder TLS-Verkehr zu einer bekannten Aphotic-Adresse und kann daran erkennen, dass du telefonierst.
- Ein Anruf, der länger als 80 Minuten dauert, bleibt beim letzten Frame-Schlüssel.
Implementiert in CallManager.kt · SdpMunge.kt · CallFrameFormat.kt · callFrameKeys.ts · callSession.ts · calls.rs
Wogegen die Konstruktionen getestet sind
Zu jeder Konstruktion gehören ausführbare Tests, und die, die einer öffentlichen Spezifikation folgen, sind an deren Vektoren gebunden.
- PQXDH: HKDF-SHA-512-Vektoren aus der Konstruktion der Spezifikation selbst, plus Seed-zu-Public-Key-Pins für ML-KEM
- Double und Triple Ratchet: Round Trip, Zustellung außer der Reihe, Heilung nach Kompromittierung und Überleben eines Neustarts, auf der JVM und auf einem Telefon
- Sealed Sender: Round Trip, ein Umschlag ohne KEM-Teil abgelehnt, Manipulationserkennung auf jedem Header-Feld
- X25519: Ablehnung eines gesetzten High Bit, von u ≥ p und jedes Small-Order-Punkts, mit einem handgebauten Schlüssel pro Fall
- Argon2id: Known-Answer-Tests gegen die Referenzausgabe
- MLS: die offiziellen RFC-9420-Vektoren für Baum-Arithmetik, Crypto Basics, Key Schedule, Secret Tree, Tree Validation und Welcome, plus Round Trips mit mehreren Mitgliedern
- Blind-Tokens: der TypeScript-Client Byte für Byte gegen die auditierte Rust-Crate der Dienste geprüft
Eine Lücke gefunden?
Jede Nachricht über die Kontaktseite erreicht den Betreiber als eine E-Mail. Ein Fund, der standhält, bekommt eine Antwort und eine Zeile auf der Transparenzseite.