sicherheit.
Nur deine Gruppe liest mit.
Stand: in Umsetzung, 11.11.2026
Nur die Mitglieder einer Gruppe können ihre Nachrichten und Treffpunkte lesen. Nicht der Betreiber der App, nicht Supabase, nicht jemand, der die Datenbank stiehlt.
Hier steht, wie das funktioniert, was der Server trotzdem sieht und wo die Grenzen liegen. Alles, nicht nur das Gute.
In Umsetzung. Diese Seite beschreibt die Verschlüsselung, wie sie gerade gebaut wird. Sobald sie in der App ist, steht hier die Version. Unverschlüsselte Testnachrichten aus der Entwicklung werden beim Umstieg gelöscht.
01Ablauf
So funktioniert es.
Jedes Konto hat ein eigenes Schlüsselpaar. Der private Teil bleibt auf deinem Telefon.
Jede Gruppe hat einen Gruppenschlüssel. Er wird für jedes Mitglied einzeln verpackt, mit dessen öffentlichem Schlüssel. Öffnen kann den Umschlag nur das Telefon, für das er bestimmt ist.
Damit verschlüsselt dein Telefon jede Nachricht, bevor sie es verlässt, und signiert sie. Der Server speichert und verteilt nur, was er nicht lesen kann.
- KontoSchlüsselpaar: X25519 zum Empfangen, Ed25519 zum Signieren.
- GruppeGruppenschlüssel (256 Bit), für jedes Mitglied verpackt mit HPKE.
- NachrichtVerschlüsselt mit AES-256-GCM, signiert mit Ed25519.
- ServerSpeichert öffentliche Schlüssel, Umschläge und verschlüsselte Nachrichten.
Genauer: dein Kontoschlüssel
Mit jedem Kontoschlüssel veröffentlicht dein Telefon eine Selbstsignatur. Andere Telefone nehmen einen Schlüssel nur an, wenn sie stimmt, und merken sich, welchen Schlüssel sie zuletzt für dich gesehen haben. Ändert er sich, erscheint ein Hinweis in jeder gemeinsamen Gruppe.
// Bezeichner in Anführungszeichen trennen die Zwecke voneinander
self_signature = Ed25519.sign(sig_seed,
"militio/account-key/v1" || profile_id || key_version || enc_pub || sig_pub)
fingerprint = SHA-256("militio/fingerprint/v1" || profile_id || enc_pub || sig_pub)Auch auf dem Telefon.
Private Schlüssel bleiben auf dem Gerät.
iPhone: im Schlüsselbund, nur für dieses Gerät. Android: geschützt durch einen Schlüssel im Android Keystore. Nicht in iCloud- oder Google-Backups.
Auch der Zwischenspeicher ist verschlüsselt.
Der Chatverlauf auf dem Telefon ist mit einem Schlüssel verschlüsselt, der das Gerät nie verlässt, und vom Backup ausgenommen.
Nur Standards.
Keine selbst erfundene Kryptografie. Nur veröffentlichte Verfahren; beide Apps müssen dieselben Testvektoren nachrechnen.
02Epochen
Neue Mitglieder lesen ab ihrem Beitritt.
Ein Gruppenschlüssel gilt nicht für immer. Ändert sich die Gruppe, beginnt eine neue Epoche mit einem neuen Schlüssel: wenn jemand beitritt, austritt oder entfernt wird, und wenn ein Mitglied einen neuen Schlüssel hat, zum Beispiel auf einem neuen Telefon ohne Wiederherstellungscode.
Wer austritt, kann darum nichts Neues mehr lesen. Wer neu dazukommt, sieht nur, was nach dem Beitritt geschrieben wird. Ältere Nachrichten bekommt er nicht, auch nicht von anderen Mitgliedern.
Die neue Epoche startet automatisch die App des ersten Mitglieds, das die Änderung bemerkt. Bis dahin nimmt der Server keine Nachrichten im alten Schlüssel mehr an. Wer gerade ausgetreten ist, kann also nicht mit einem Schlüssel weiterlesen, den er noch hat.
Genauer: wann ein Telefon eine Epoche annimmt
Die App, die eine Epoche startet, verpackt den neuen Schlüssel für jedes aktive Mitglied mit veröffentlichtem Schlüssel und signiert die Liste der Empfänger. Ein Telefon nimmt die Epoche nur an, wenn sich der Umschlag öffnen lässt, der Schlüssel zur veröffentlichten Prüfsumme passt, die Empfängerliste stimmt und sowohl die startende Person als auch es selbst darauf stehen, und die Signatur echt ist. So kann der Server keinen eigenen Gruppenschlüssel unterschieben.
// pro Epoche, auf dem Telefon der startenden Person
epoch_key = 32 random bytes
recipients_hash = SHA-256("militio/recipients/v1" || (profile_id || key_version)…)
key_commitment = SHA-256("militio/epoch-commitment/v1" || group || epoch || epoch_key)
epoch_signature = Ed25519.sign(creator.sig_seed, "militio/epoch/v1" || group || epoch
|| creator || creator_key_version || key_commitment || recipients_hash)
envelope = HPKE.seal(recipient.enc_pub,
info = "militio/epoch-key/v1" || group || epoch
|| recipient || recipient_key_version,
aad = empty, plaintext = epoch_key)03Nachrichten
Jede Nachricht hat ihren eigenen Schlüssel.
Aus dem Gruppenschlüssel leitet dein Telefon für jede Nachricht einen eigenen Schlüssel ab. Damit verschlüsselt es den Inhalt: den Text, und bei einem Treffpunkt Ort, Koordinaten, Zeit und Bemerkung. Auch ob es ein Text oder ein Treffpunkt ist, steht nur im verschlüsselten Teil.
Vorher wird der Inhalt auf ein Vielfaches von 256 Byte aufgefüllt. So verrät die Länge nur ungefähr, wie lang eine Nachricht ist.
Zum Schluss signiert dein Telefon die Nachricht. Alle in der Gruppe haben denselben Gruppenschlüssel; wer etwas geschrieben hat, beweist nur die Signatur. Sie verhindert auch, dass der Server eine Nachricht jemand anderem zuschreibt.
Kann ein Telefon eine Nachricht nicht prüfen oder nicht entschlüsseln, zeigt es sie nicht an, auch nicht teilweise, sondern «Nachricht kann nicht angezeigt werden».
Genauer: was mit einer Nachricht geschieht
Bearbeiten geht wie bisher 15 Minuten lang; dabei wird alles im aktuellen Gruppenschlüssel neu berechnet. Beim Löschen leert der Server den verschlüsselten Inhalt samt Signatur.
// pro Nachricht, auf dem Telefon des Absenders
padded = content || 0x80 || 0x00 … // bis zum nächsten Vielfachen von 256 Byte
ctx = group || epoch || message_id || sender
mk = HKDF(epoch_key, info = "militio/message-key/v1" || ctx)
fk = HKDF(epoch_key, info = "militio/franking-key/v1" || ctx)
ciphertext = AES-256-GCM(mk, nonce = 12 random bytes,
aad = "militio/message/v1" || ctx, padded)
commitment = HMAC-SHA256(fk, "militio/commitment/v1" || ctx || content)
signature = Ed25519.sign(sender.sig_seed, "militio/message-signature/v1" || ctx
|| sender_key_version || nonce || SHA-256(ciphertext) || commitment)04Code
Neues Telefon, gleicher Verlauf.
Ohne Vorkehrung wäre mit dem Telefon auch der private Schlüssel weg, und mit ihm der Verlauf. Darum bietet die App beim Einrichten einen Wiederherstellungscode an: 24 Zeichen, von der App erzeugt und einmal angezeigt. Schreib ihn auf oder leg ihn in einen Passwortmanager. Du kannst ihn überspringen; dann gibt es keine Wiederherstellung.
Aus dem Code berechnet dein Telefon mit Argon2id einen Sicherungsschlüssel und verschlüsselt damit deine privaten Schlüssel. Auf dem Server liegt nur das Ergebnis. Der Code selbst verlässt dein Telefon nie.
Auf einem neuen Telefon: anmelden, Code eingeben, und der Verlauf ist wieder da. Ohne Code bekommst du neue Schlüssel, und ältere Nachrichten bleiben für dich unlesbar.
Genauer: die Sicherung
Beim Eingeben ignoriert die App Leerzeichen und Bindestriche und nimmt Kleinbuchstaben an. Jedes andere Zeichen macht die Eingabe ungültig, statt still verschluckt zu werden. Nach dem Entschlüsseln prüft die App, ob die Schlüssel zu den veröffentlichten passen.
// nur auf deinem Telefon; auf dem Server liegen salt, nonce und backup
code = 15 random bytes → 24 × "ABCDEFGHJKLMNPQRSTUVWXYZ23456789"
backup_key = Argon2id(code, salt = 16 random bytes,
t = 4, m = 262144 KiB, p = 1, length = 32)
backup = AES-256-GCM(backup_key, nonce = 12 random bytes,
aad = "militio/backup/v1" || profile_id || key_version,
enc_priv || sig_seed)Wie weit wir gehen.
Wer die verschlüsselte Sicherung vom Server stiehlt, kann Codes ausprobieren, ohne dass unsere Sperren greifen. Argon2id macht jeden Versuch teuer: Es braucht viel Arbeitsspeicher und Rechenzeit, und gegen Speicherbedarf helfen auch Grafikkarten und Spezialchips wenig.
- Es läuft zweimal im Leben eines Geräts: beim Erstellen der Sicherung und beim Wiederherstellen. Ein paar Sekunden mit Fortschrittsanzeige sind in Ordnung.
- Speicher ist, was Angreifern mit Grafikkarten wehtut. Mehr Durchgänge vervielfachen die Kosten nur.
- Die Werte werden beim Erstellen festgelegt, wiederhergestellt wird vielleicht auf einem günstigeren Telefon (Android 8, 2–3 GB Arbeitsspeicher). Das langsamste unterstützte Telefon setzt die Grenze.
- 1 GiB riskiert, dass das System die App auf solchen Telefonen beendet; 512 MiB ist knapp. 256 MiB ist das Höchste, das überall läuft.
| Speicher | t = 2 | t = 3 | t = 4 | t = 6 |
|---|---|---|---|---|
| 64 MiB | 0,05 s | 0,08 s | 0,10 s | 0,15 s |
| 128 MiB | 0,10 s | 0,16 s | 0,21 s | 0,32 s |
| 256 MiB | 0,21 s | 0,32 s | 0,44 s | 0,66 s |
| 512 MiB | 0,44 s | 0,67 s | 0,89 s | 1,33 s |
Gewählt
Argon2id · 256 MiB · t = 4 · p = 1 · Salz 16 Byte · Schlüssel 32 Byte
Auf dem Mac 0,44 s. Auf Telefonen noch nicht gemessen, geschätzt: etwa 0,6–1 s auf einem neueren iPhone, 1–2 s auf einem mittleren Android-Telefon, 3–5 s auf einem alten, günstigen.
Gemessen wird auf dem langsamsten Telefon, das wir unterstützen; t steigt, bis es etwa 3 Sekunden braucht. Nie unter 256 MiB und t = 4. Die Werte stehen bei jeder Sicherung dabei, sie können also später steigen, ohne ältere Sicherungen zu brechen.
Zum Vergleich: viermal so viel Speicher wie die Variante von RFC 9106 für Geräte mit wenig Speicher (64 MiB, t = 3) und mehr als 13-mal das Minimum von OWASP (19 MiB, t = 2).
Ehrlich gesagt:
Bei einem zufälligen Code mit 120 Bit ist Raten auch mit einem schnellen Verfahren aussichtslos; eine Million Grafikkarten bräuchten weit länger, als das Universum alt ist. Argon2id sorgt dafür, dass das so bleibt, und kostet eine kurze Wartezeit. Selbst gewählte Passwörter lassen wir bewusst nicht zu: Ein schwaches Passwort bliebe auch mit Argon2id schwach.
Wo wir bewusst kein langsames Verfahren brauchen
- Alle anderen Ableitungen beginnen mit zufälligen 256-Bit-Schlüsseln. Dort sind HKDF und SHA-256 richtig; Verlangsamen bringt nichts und kostet Akku.
- Es gibt keine Passwörter. Angemeldet wird mit Apple, mit Google oder mit einem Code per E-Mail: 8 Ziffern, 10 Minuten gültig, nur einmal verwendbar. In der Mail stehen nur deine Adresse und der Code. Er öffnet das Konto, nicht die Schlüssel: Wer ihn abfängt, liest deine bisherigen Nachrichten nicht. Meldet er sich damit an, bekommt sein Gerät einen neuen Schlüssel, und in jeder deiner Gruppen erscheint ein Hinweis.
- Einladungscodes und Benutzerschlüssel schützt die Sperre des Servers (höchstens 20 Fehlversuche pro Stunde). Sie in der Datenbank zu hashen, würde nichts nützen: Wer die Datenbank lesen kann, hat die Gruppen ohnehin.
05Server
Was der Server sieht. Und was nicht.
Verschlüsselung versteckt den Inhalt, nicht alles drumherum. Diese Liste ist vollständig.
Sieht
- dass du ein Konto hast; Name, Grad und Funktion in deinem Profil; deine E-Mail-Adresse, wenn du dich per E-Mail oder mit Google anmeldest
- in welchen Gruppen du bist und als was (Mitglied, Admin, Besitzer)
- Name, Art, Symbol und Ort einer Gruppe (nötig für die Vorschau beim Beitreten und fürs Wetter)
- Notizen und Aufgaben (noch nicht verschlüsselt)
- wer wann in welcher Gruppe eine Nachricht geschickt hat; Bearbeiten und Löschen mit Zeitpunkt
- ungefähr, wie lang eine Nachricht ist (in Stufen von 256 Byte)
- deine öffentlichen Schlüssel und deine verschlüsselte Sicherung
- IP-Adressen in den Protokollen von Supabase
- gemeldete Nachrichten, weil die meldende Person sie mitschickt
Sieht nicht
- den Text von Nachrichten
- Treffpunkte: Ort, Koordinaten, Zeit, Bemerkung
- ob eine Nachricht ein Text oder ein Treffpunkt ist
- Gruppenschlüssel
- deine privaten Schlüssel
- deinen Wiederherstellungscode
Melden, ohne dass der Server mitliest.
Wer eine Nachricht meldet, schickt ihren Inhalt bewusst an den Betreiber. Nur dann sieht er ihn.
Damit niemand einem anderen einen Text unterschieben kann, den dieser nie geschrieben hat, legt das Telefon des Absenders beim Senden eine Prüfsumme ab (HMAC-SHA256). Beim Melden rechnet der Server sie mit dem mitgeschickten Inhalt nach und nimmt die Meldung nur an, wenn sie übereinstimmt. Das Verfahren heisst Message Franking; Facebook Messenger meldet so in seinen verschlüsselten Chats.
Der Schlüssel dafür gilt nur für diese eine Nachricht. Er verrät weder den Nachrichten- noch den Gruppenschlüssel, und der Server behält ihn nicht.
// prüft der Server beim Melden
HMAC-SHA256(fk, "militio/commitment/v1" || ctx || content) == commitment06Grenzen
Was die Verschlüsselung nicht kann.
Der Server verwaltet die Mitgliederliste.
Er verteilt auch die öffentlichen Schlüssel. Ein kompromittierter Server könnte ein falsches Mitglied hinzufügen oder einen Schlüssel austauschen. Dagegen hilft: Jeder Beitritt und jeder neue Schlüssel erscheint im Chat. Geplant ist zudem, dass Mitglieder einander persönlich per QR-Code prüfen können. Ohne diese Prüfung vertraust du dem Server in diesem einen Punkt. WhatsApp und Signal haben dieselbe Grenze.
Kein Vorwärtsschutz innerhalb einer Epoche.
Wer dein entsperrtes Telefon oder deinen Kontoschlüssel hat, kann jede Epoche lesen, in der du warst. Ein neuer Schlüssel nach einem verlorenen Telefon schützt nur, was danach kommt. Signal und MLS gehen hier weiter.
Metadaten bleiben sichtbar.
Wer wann in welcher Gruppe schreibt, sieht der Server. Die ganze Liste steht oben.
Notizen und Aufgaben sind noch nicht verschlüsselt.
Sie leben lange, und neue Mitglieder müssen sie lesen können. Das passt nicht zu Epochen, die sich bei jedem Beitritt ändern; sie brauchen eine eigene Lösung.
07Technik
Algorithmen und Parameter.
Keine eigene Kryptografie, nur veröffentlichte Standards. Beide Apps müssen dieselben Testvektoren erfüllen, damit sie Byte für Byte dasselbe ergeben.
| Zweck | Verfahren | Standard |
|---|---|---|
| Gruppenschlüssel verteilen | HPKE, Base-Modus: DHKEM(X25519, HKDF-SHA256), HKDF-SHA256, AES-256-GCM | RFC 9180 |
| Schlüsselvereinbarung | X25519 | RFC 7748 |
| Signieren | Ed25519 | RFC 8032 |
| Nachrichten verschlüsseln | AES-256-GCM, zufällige 96-Bit-Nonce | NIST SP 800-38D |
| Schlüssel ableiten | HKDF-SHA256 | RFC 5869 |
| Prüfsummen, Fingerabdrücke | SHA-256, HMAC-SHA256 | FIPS 180-4, RFC 2104 |
| Sicherungsschlüssel | Argon2id (Version 0x13), 256 MiB, t = 4, p = 1 | RFC 9106 |
| Übertragung binärer Werte | Base64 mit Auffüllung | RFC 4648 |
| Zufall | Zufallsgenerator des Betriebssystems | – |
Bezeichner, die die Zwecke trennen
militio/account-key/v1 | Selbstsignatur eines Kontoschlüssels |
militio/fingerprint/v1 | Fingerabdruck eines Kontoschlüssels |
militio/recipients/v1 | Liste der Empfänger einer Epoche |
militio/epoch-commitment/v1 | Prüfsumme eines Gruppenschlüssels |
militio/epoch/v1 | Signatur einer Epoche |
militio/epoch-key/v1 | Umschlag eines Gruppenschlüssels (HPKE info) |
militio/message-key/v1 | Schlüssel einer Nachricht |
militio/franking-key/v1 | Schlüssel für die Prüfsumme beim Melden |
militio/message/v1 | Zusatzdaten der Verschlüsselung |
militio/commitment/v1 | Prüfsumme einer Nachricht |
militio/message-signature/v1 | Signatur einer Nachricht |
militio/backup/v1 | Zusatzdaten der Sicherung |
Die vollständige Spezifikation und die Testvektoren folgen mit der Veröffentlichung.
Sicherheitslücke gefunden?
Schreib mir, bevor du sie veröffentlichst. Ich antworte und sage, wann sie behoben ist.