Comment ça marche

sécurité.

Seul ton groupe peut lire.

État : en cours de réalisation, 11.11.2026

Seuls les membres d’un groupe peuvent lire ses messages et ses points de rendez-vous. Ni l’exploitant de l’app, ni Supabase, ni quelqu’un qui volerait la base de données.

Cette page explique comment cela fonctionne, ce que le serveur voit malgré tout et où sont les limites. Tout, pas seulement les bons côtés.

En cours de réalisation. Cette page décrit le chiffrement tel qu’il est en train d’être construit. Dès qu’il sera dans l’app, la version figurera ici. Les messages de test non chiffrés de la phase de développement seront supprimés lors du passage au chiffrement.

01Fonctionnement

Comment ça marche.

Chaque compte a sa propre paire de clés. La partie privée reste sur ton téléphone.

Chaque groupe a une clé de groupe. Elle est mise sous enveloppe séparément pour chaque membre, avec la clé publique de ce membre. Seul le téléphone auquel l’enveloppe est destinée peut l’ouvrir.

Avec cette clé, ton téléphone chiffre chaque message avant qu’il ne quitte l’appareil, et le signe. Le serveur ne stocke et ne distribue que ce qu’il ne peut pas lire.

  1. ComptePaire de clés : X25519 pour recevoir, Ed25519 pour signer.
  2. GroupeClé de groupe (256 bits), mise sous enveloppe pour chaque membre avec HPKE.
  3. MessageChiffré avec AES-256-GCM, signé avec Ed25519.
  4. ServeurStocke les clés publiques, les enveloppes et les messages chiffrés.
En détail : ta clé de compte

Avec chaque clé de compte, ton téléphone publie une autosignature. Les autres téléphones n’acceptent une clé que si cette signature est valide, et retiennent la dernière clé qu’ils ont vue pour toi. Si elle change, un avis apparaît dans chaque groupe commun.

// les libellés entre guillemets séparent les usages
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)
Deux téléphones et le serveur : seuls les téléphones ont la clé de groupe ; le serveur ne voit passer que des données chiffrées.Téléphone d’AnnaClé de groupeRendez-vous0615 à la hallelisible seulement iciTéléphone de BenClé de groupeRendez-vous0615 à la hallelisible seulement ici7f3a 9c2e 41d07f3a 9c2e 41d0chiffréServeurpas de clé de groupeclés publiquesenveloppes, chiffréesmessages, chiffrés et signés

Sur le téléphone aussi.

  • Les clés privées restent sur l’appareil.

    iPhone : dans le trousseau, uniquement pour cet appareil. Android : protégées par une clé du Keystore Android. Pas dans les sauvegardes iCloud ou Google.

  • Le cache est chiffré, lui aussi.

    L’historique du chat sur le téléphone est chiffré avec une clé qui ne quitte jamais l’appareil, et exclu de la sauvegarde.

  • Uniquement des standards.

    Aucune cryptographie maison. Uniquement des procédés publiés ; les deux apps doivent reproduire les mêmes vecteurs de test.

02Époques

Les nouveaux membres lisent à partir de leur arrivée.

Une clé de groupe n’est pas valable indéfiniment. Quand le groupe change, une nouvelle époque commence avec une nouvelle clé : quand quelqu’un rejoint le groupe, le quitte ou en est retiré, et aussi quand un membre a une nouvelle clé, par exemple sur un nouveau téléphone sans code de récupération.

Qui quitte le groupe ne peut donc plus rien lire de nouveau. Qui arrive ne voit que ce qui est écrit après son arrivée. Les anciens messages, il ne les reçoit pas, pas même de la part d’autres membres.

La nouvelle époque est lancée automatiquement par l’app du premier membre qui remarque le changement. D’ici là, le serveur n’accepte plus de messages chiffrés avec l’ancienne clé. Qui vient de partir ne peut donc pas continuer à lire avec une clé qu’il possède encore.

En détail : quand un téléphone accepte une époque

L’app qui lance une époque met la nouvelle clé sous enveloppe pour chaque membre actif ayant publié une clé et signe la liste des destinataires. Un téléphone n’accepte l’époque que si l’enveloppe s’ouvre, si la clé correspond à l’empreinte publiée, si la liste des destinataires est exacte et contient à la fois la personne qui a lancé l’époque et le téléphone lui-même, et si la signature est authentique. Ainsi, le serveur ne peut pas glisser en douce sa propre clé de groupe.

// par époque, sur le téléphone de la personne qui la lance
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)
Époques : Anna lit les trois, Ben seulement les époques 1 et 2, Luca seulement à partir de l’époque 2.AAnnaBBenLLucatempsÉpoque 1litlit—Époque 2litlitlitÉpoque 3lit—lit+ Luca arrive · nouvelle époque− Ben part · nouvelle époquepeut lirepas d’accès

03Messages

Chaque message a sa propre clé.

À partir de la clé de groupe, ton téléphone dérive une clé propre à chaque message. Avec celle-ci, il chiffre le contenu : le texte et, pour un point de rendez-vous, le lieu, les coordonnées, l’heure et la remarque. Même le fait qu’il s’agisse d’un texte ou d’un point de rendez-vous ne figure que dans la partie chiffrée.

Avant le chiffrement, le contenu est complété jusqu’à un multiple de 256 octets. La longueur ne révèle ainsi qu’approximativement la taille d’un message.

Enfin, ton téléphone signe le message. Tous les membres ont la même clé de groupe ; seule la signature prouve qui a écrit. Elle empêche aussi le serveur d’attribuer un message à quelqu’un d’autre.

Si un téléphone ne peut pas vérifier ou déchiffrer un message, il ne l’affiche pas, pas même en partie, mais indique « Impossible d’afficher le message ».

En détail : ce qui arrive à un message

La modification reste possible pendant 15 minutes, comme avant ; tout est alors recalculé avec la clé de groupe actuelle. Lors d’une suppression, le serveur efface le contenu chiffré et la signature.

// par message, sur le téléphone de l’expéditeur
padded     = content || 0x80 || 0x00 …        // jusqu’au prochain multiple de 256 octets
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)
Cinq étapes du contenu au message chiffré et signé, et ce que le serveur en voit.1Contenu{"kind":"text","body":"Rendez-vous…"}2Compléter à 256 octetsContenu0x80 00 00 …3Clé propreHKDF à partir de la clé de groupe et des ID4ChiffrerAES-256-GCM → 9d4e 07b1 c3a8 …5SignerEd25519 · authentifie l’expéditeurSur le serveurvisiblegroupe · expéditeur · heure · taillecachétexte · rendez-vous · type

04Code

Nouveau téléphone, même historique.

Sans précaution, la clé privée disparaîtrait avec le téléphone, et l’historique avec elle. C’est pourquoi l’app propose un code de récupération lors de la configuration : 24 caractères, générés par l’app et affichés une seule fois. Note-le ou range-le dans un gestionnaire de mots de passe. Tu peux sauter cette étape ; aucune récupération n’est alors possible.

À partir du code, ton téléphone calcule une clé de sauvegarde avec Argon2id et chiffre tes clés privées avec elle. Sur le serveur, il n’y a que le résultat. Le code lui-même ne quitte jamais ton téléphone.

Sur un nouveau téléphone : se connecter, saisir le code, et l’historique est de retour. Sans code, tu reçois de nouvelles clés, et les anciens messages restent illisibles pour toi.

En détail : la sauvegarde

À la saisie, l’app ignore les espaces et les tirets et accepte les minuscules. Tout autre caractère rend la saisie invalide au lieu d’être ignoré en silence. Après le déchiffrement, l’app vérifie que les clés correspondent aux clés publiées.

// uniquement sur ton téléphone ; sur le serveur se trouvent salt, nonce et 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)
Code de récupération : Argon2id en tire la clé de sauvegarde ; le serveur ne garde que la sauvegarde chiffrée.SUR TON TÉLÉPHONEle code ne le quitte jamaisCode de récupération · 120 bitsK7QM-3XRA-PW9E-HN2T-4JDC-ZB8VArgon2idvolontairement lent256 MiBt = 4p = 1sel 16 octetsClé de sauvegarde · 32 octetsAES-256-GCMchiffre tes clés privéesSauvegarde chiffréesur le serveur · inutile sans le code

Jusqu’où nous allons.

Qui vole la sauvegarde chiffrée sur le serveur peut essayer des codes sans que nos blocages s’appliquent. Argon2id rend chaque essai coûteux : il exige beaucoup de mémoire et de temps de calcul, et face à ce besoin en mémoire, même les cartes graphiques et les puces spécialisées n’aident guère.

  1. Il tourne deux fois dans la vie d’un appareil : à la création de la sauvegarde et lors de la récupération. Quelques secondes avec un indicateur de progression, c’est acceptable.
  2. C’est la mémoire qui fait mal aux attaquants équipés de cartes graphiques. Davantage d’itérations ne font que multiplier le coût.
  3. Les paramètres sont fixés à la création, mais la récupération se fera peut-être sur un téléphone meilleur marché (Android 8, 2–3 Go de mémoire vive). C’est le téléphone le plus lent pris en charge qui fixe la limite.
  4. Avec 1 GiB, le système risque de fermer l’app sur ces téléphones ; 512 MiB, c’est juste. 256 MiB, c’est le maximum qui fonctionne partout.
Mesuré sur un Mac (Apple M5), Argon2id avec p = 1.
Mémoiret = 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

Choisi

Argon2id · 256 MiB · t = 4 · p = 1 · sel 16 octets · clé 32 octets

0,44 s sur le Mac. Pas encore mesuré sur des téléphones, estimation : environ 0,6–1 s sur un iPhone récent, 1–2 s sur un Android de milieu de gamme, 3–5 s sur un ancien modèle bon marché.

La mesure se fait sur le téléphone le plus lent que nous prenons en charge ; t augmente jusqu’à ce qu’il lui faille environ 3 secondes. Jamais moins de 256 MiB et t = 4. Les paramètres sont enregistrés avec chaque sauvegarde : ils peuvent donc augmenter plus tard sans casser les anciennes sauvegardes.

À titre de comparaison : quatre fois la mémoire de la variante de la RFC 9106 pour les appareils disposant de peu de mémoire (64 MiB, t = 3) et plus de 13 fois le minimum de l’OWASP (19 MiB, t = 2).

Pour être honnête :

Avec un code aléatoire de 120 bits, deviner est sans espoir, même avec un procédé rapide ; il faudrait à un million de cartes graphiques bien plus de temps que l’âge de l’univers. Argon2id garantit que cela reste vrai, au prix d’une courte attente. Nous n’autorisons volontairement pas les mots de passe choisis par l’utilisateur : un mot de passe faible resterait faible, même avec Argon2id.

Là où nous n’avons volontairement pas besoin d’un procédé lent

  • Toutes les autres dérivations partent de clés aléatoires de 256 bits. HKDF et SHA-256 y sont appropriés ; ralentir n’apporte rien et coûte de la batterie.
  • Il n’y a pas de mots de passe. La connexion se fait avec Apple, avec Google ou avec un code reçu par e-mail : 8 chiffres, valable 10 minutes, utilisable une seule fois. L’e-mail ne contient que ton adresse et le code. Celui-ci ouvre le compte, pas les clés : qui l’intercepte ne lit pas tes messages précédents. S’il s’en sert pour se connecter, son appareil reçoit une nouvelle clé, et un avis apparaît dans chacun de tes groupes.
  • Les codes d’invitation et les clés d’utilisateur sont protégés par le blocage du serveur (au plus 20 essais erronés par heure). Les hacher dans la base de données n’aiderait pas : qui peut lire la base de données a de toute façon les groupes.

05Serveur

Ce que voit le serveur. Et ce qu’il ne voit pas.

Le chiffrement cache le contenu, pas tout ce qui l’entoure. Cette liste est complète.

Voit

  • que tu as un compte ; nom, grade et fonction dans ton profil ; ton adresse e-mail si tu te connectes par e-mail ou avec Google
  • dans quels groupes tu es et à quel titre (membre, admin, propriétaire)
  • nom, type, symbole et lieu d’un groupe (nécessaires pour l’aperçu à l’adhésion et pour la météo)
  • les notes et les tâches (pas encore chiffrées)
  • qui a envoyé un message dans quel groupe et quand ; modifications et suppressions avec leur date et heure
  • la longueur approximative d’un message (par paliers de 256 octets)
  • tes clés publiques et ta sauvegarde chiffrée
  • les adresses IP dans les journaux de Supabase
  • les messages signalés, parce que la personne qui signale les envoie

Signaler sans que le serveur lise les messages.

Qui signale un message envoie délibérément son contenu à l’exploitant. Ce n’est qu’à ce moment-là que l’exploitant le voit.

Pour que personne ne puisse attribuer à quelqu’un un texte qu’il n’a jamais écrit, le téléphone de l’expéditeur dépose une empreinte lors de l’envoi (HMAC-SHA256). Lors d’un signalement, le serveur la recalcule avec le contenu transmis et n’accepte le signalement que si elle correspond. Ce procédé s’appelle message franking ; c’est ainsi que Facebook Messenger traite les signalements dans ses chats chiffrés.

La clé nécessaire n’est valable que pour ce seul message. Elle ne révèle ni la clé du message ni la clé de groupe, et le serveur ne la conserve pas.

// vérifié par le serveur lors d’un signalement
HMAC-SHA256(fk, "militio/commitment/v1" || ctx || content) == commitment
Signaler : à l’envoi, le serveur garde une empreinte ; lors d’un signalement, il la recalcule avec le contenu et la clé.À L’ENVOIAnnaenvoie+ empreinteServeurgarde l’empreinteAU SIGNALEMENTBensignalecontenu + fkServeurrecalcule le HMACempreintecorrespond : accepté✕sinon : refusé

06Limites

Ce que le chiffrement ne peut pas faire.

  1. Le serveur gère la liste des membres.

    Il distribue aussi les clés publiques. Un serveur compromis pourrait ajouter un faux membre ou remplacer une clé. Ce qui limite ce risque : chaque adhésion et chaque nouvelle clé apparaissent dans le chat. Il est en outre prévu que les membres puissent se vérifier mutuellement en personne par code QR. Sans cette vérification, tu fais confiance au serveur sur ce seul point. WhatsApp et Signal ont la même limite.

  2. Pas de confidentialité persistante (forward secrecy) au sein d’une époque.

    Qui possède ton téléphone déverrouillé ou ta clé de compte peut lire chaque époque dont tu as fait partie. Une nouvelle clé après la perte d’un téléphone ne protège que ce qui vient ensuite. Signal et MLS vont plus loin sur ce point.

  3. Les métadonnées restent visibles.

    Qui écrit quand et dans quel groupe, le serveur le voit. La liste complète figure plus haut.

  4. Les notes et les tâches ne sont pas encore chiffrées.

    Elles sont conservées longtemps et les nouveaux membres doivent pouvoir les lire. Cela ne convient pas à des époques qui changent à chaque adhésion ; notes et tâches ont besoin d’une solution à part.

07Technique

Algorithmes et paramètres.

Aucune cryptographie maison, uniquement des standards publiés. Les deux apps doivent satisfaire aux mêmes vecteurs de test, afin de produire exactement les mêmes octets.

UsageProcédéStandard
Distribuer les clés de groupeHPKE, mode de base : DHKEM(X25519, HKDF-SHA256), HKDF-SHA256, AES-256-GCMRFC 9180
Accord de clésX25519RFC 7748
SignerEd25519RFC 8032
Chiffrer les messagesAES-256-GCM, nonce aléatoire de 96 bitsNIST SP 800-38D
Dériver des clésHKDF-SHA256RFC 5869
EmpreintesSHA-256, HMAC-SHA256FIPS 180-4, RFC 2104
Clé de sauvegardeArgon2id (version 0x13), 256 MiB, t = 4, p = 1RFC 9106
Transmission des valeurs binairesBase64 avec remplissageRFC 4648
AléaGénérateur aléatoire du système d’exploitation–
Libellés qui séparent les usages
militio/account-key/v1Autosignature d’une clé de compte
militio/fingerprint/v1Empreinte d’une clé de compte
militio/recipients/v1Liste des destinataires d’une époque
militio/epoch-commitment/v1Empreinte d’une clé de groupe
militio/epoch/v1Signature d’une époque
militio/epoch-key/v1Enveloppe d’une clé de groupe (info HPKE)
militio/message-key/v1Clé d’un message
militio/franking-key/v1Clé de l’empreinte pour le signalement
militio/message/v1Données associées du chiffrement
militio/commitment/v1Empreinte d’un message
militio/message-signature/v1Signature d’un message
militio/backup/v1Données associées de la sauvegarde

La spécification complète et les vecteurs de test suivront avec la publication.

Tu as trouvé une faille de sécurité ?

Écris-moi avant de la publier. Je te réponds et je te dis quand elle sera corrigée.

info@militio.ch