So funktioniert es

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.

  1. KontoSchlüsselpaar: X25519 zum Empfangen, Ed25519 zum Signieren.
  2. GruppeGruppenschlüssel (256 Bit), für jedes Mitglied verpackt mit HPKE.
  3. NachrichtVerschlüsselt mit AES-256-GCM, signiert mit Ed25519.
  4. 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)
Zwei Telefone und der Server: Nur die Telefone haben den Gruppenschlüssel, über den Server geht nur Verschlüsseltes.Telefon von AnnaGruppenschlüsselAntreten 0615vor der Hallelesbar nur hierTelefon von BenGruppenschlüsselAntreten 0615vor der Hallelesbar nur hier7f3a 9c2e 41d07f3a 9c2e 41d0verschlüsseltServerkein Gruppenschlüsselöffentliche SchlüsselUmschläge, verschlüsseltNachrichten, verschlüsselt und signiert

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)
Epochen: Anna liest alle drei, Ben nur Epoche 1 und 2, Luca erst ab Epoche 2.AAnnaBBenLLucaZeitEpoche 1liestliest—Epoche 2liestliestliestEpoche 3liest—liest+ Luca tritt bei · neue Epoche− Ben tritt aus · neue Epocheliest mitkein Zugang

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)
Fünf Schritte vom Inhalt zur signierten, verschlüsselten Nachricht, und was der Server davon sieht.1Inhalt{"kind":"text","body":"Antreten…"}2Auffüllen auf 256 ByteInhalt0x80 00 00 …3Eigener SchlüsselHKDF aus Gruppenschlüssel und IDs4VerschlüsselnAES-256-GCM → 9d4e 07b1 c3a8 …5SignierenEd25519 · beweist den AbsenderAuf dem ServersichtbarGruppe · Absender · Zeit · GrösseverborgenText · Treffpunkt · Art

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)
Wiederherstellungscode: Argon2id macht daraus den Sicherungsschlüssel; auf dem Server liegt nur die verschlüsselte Sicherung.AUF DEINEM TELEFONder Code verlässt es nieWiederherstellungscode · 120 BitK7QM-3XRA-PW9E-HN2T-4JDC-ZB8VArgon2idlangsam, mit Absicht256 MiBt = 4p = 1Salz 16 ByteSicherungsschlüssel · 32 ByteAES-256-GCMverschlüsselt deine privaten SchlüsselVerschlüsselte Sicherungauf dem Server · ohne Code nutzlos

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.

  1. Es läuft zweimal im Leben eines Geräts: beim Erstellen der Sicherung und beim Wiederherstellen. Ein paar Sekunden mit Fortschrittsanzeige sind in Ordnung.
  2. Speicher ist, was Angreifern mit Grafikkarten wehtut. Mehr Durchgänge vervielfachen die Kosten nur.
  3. 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.
  4. 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.
Gemessen auf einem Mac (Apple M5), Argon2id mit p = 1.
Speichert = 2t = 3t = 4t = 6
64 MiB0,05 s0,08 s0,10 s0,15 s
128 MiB0,10 s0,16 s0,21 s0,32 s
256 MiB0,21 s0,32 s0,44 s0,66 s
512 MiB0,44 s0,67 s0,89 s1,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

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) == commitment
Melden: Beim Senden speichert der Server eine Prüfsumme; beim Melden rechnet er sie mit Inhalt und Schlüssel nach.BEIM SENDENAnnasendet+ PrüfsummeServerspeichert die PrüfsummeBEIM MELDENBenmeldetInhalt + fkServerrechnet HMAC nachPrüfsummestimmt: angenommen✕sonst: abgelehnt

06Grenzen

Was die Verschlüsselung nicht kann.

  1. 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.

  2. 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.

  3. Metadaten bleiben sichtbar.

    Wer wann in welcher Gruppe schreibt, sieht der Server. Die ganze Liste steht oben.

  4. 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.

ZweckVerfahrenStandard
Gruppenschlüssel verteilenHPKE, Base-Modus: DHKEM(X25519, HKDF-SHA256), HKDF-SHA256, AES-256-GCMRFC 9180
SchlüsselvereinbarungX25519RFC 7748
SignierenEd25519RFC 8032
Nachrichten verschlüsselnAES-256-GCM, zufällige 96-Bit-NonceNIST SP 800-38D
Schlüssel ableitenHKDF-SHA256RFC 5869
Prüfsummen, FingerabdrückeSHA-256, HMAC-SHA256FIPS 180-4, RFC 2104
SicherungsschlüsselArgon2id (Version 0x13), 256 MiB, t = 4, p = 1RFC 9106
Übertragung binärer WerteBase64 mit AuffüllungRFC 4648
ZufallZufallsgenerator des Betriebssystems–
Bezeichner, die die Zwecke trennen
militio/account-key/v1Selbstsignatur eines Kontoschlüssels
militio/fingerprint/v1Fingerabdruck eines Kontoschlüssels
militio/recipients/v1Liste der Empfänger einer Epoche
militio/epoch-commitment/v1Prüfsumme eines Gruppenschlüssels
militio/epoch/v1Signatur einer Epoche
militio/epoch-key/v1Umschlag eines Gruppenschlüssels (HPKE info)
militio/message-key/v1Schlüssel einer Nachricht
militio/franking-key/v1Schlüssel für die Prüfsumme beim Melden
militio/message/v1Zusatzdaten der Verschlüsselung
militio/commitment/v1Prüfsumme einer Nachricht
militio/message-signature/v1Signatur einer Nachricht
militio/backup/v1Zusatzdaten 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.

info@militio.ch