Come funziona

sicurezza.

Solo il tuo gruppo può leggere.

Stato: in corso di realizzazione, 11.11.2026

Solo i membri di un gruppo possono leggerne i messaggi e i punti d’incontro. Né il gestore dell’app, né Supabase, né chi dovesse rubare la banca dati.

Qui trovi come funziona, cosa vede comunque il server e dove sono i limiti. Tutto, non solo i lati positivi.

In corso di realizzazione. Questa pagina descrive la crittografia così come viene sviluppata in questo momento. Appena sarà nell’app, qui comparirà la versione. I messaggi di prova non cifrati della fase di sviluppo verranno eliminati al momento del passaggio alla cifratura.

01Funzionamento

Come funziona.

Ogni account ha una propria coppia di chiavi. La parte privata resta sul tuo telefono.

Ogni gruppo ha una chiave di gruppo. Viene imbustata separatamente per ogni membro, con la chiave pubblica di quel membro. Solo il telefono a cui la busta è destinata può aprirla.

Con questa chiave il tuo telefono cifra ogni messaggio prima che lasci il dispositivo, e lo firma. Il server conserva e distribuisce solo ciò che non può leggere.

  1. AccountCoppia di chiavi: X25519 per ricevere, Ed25519 per firmare.
  2. GruppoChiave di gruppo (256 bit), imbustata per ogni membro con HPKE.
  3. MessaggioCifrato con AES-256-GCM, firmato con Ed25519.
  4. ServerConserva chiavi pubbliche, buste e messaggi cifrati.
Nel dettaglio: la chiave del tuo account

Con ogni chiave dell’account il tuo telefono pubblica un’autofirma. Gli altri telefoni accettano una chiave solo se questa firma è valida, e ricordano l’ultima chiave che hanno visto per te. Se cambia, compare un avviso in ogni gruppo in comune.

// le etichette tra virgolette separano gli usi
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)
Due telefoni e il server: solo i telefoni hanno la chiave di gruppo, sul server passano solo dati cifrati.Telefono di AnnaChiave di gruppoAdunata 0615al capannoneleggibile solo quiTelefono di BenChiave di gruppoAdunata 0615al capannoneleggibile solo qui7f3a 9c2e 41d07f3a 9c2e 41d0cifratoServernessuna chiave di gruppochiavi pubblichebuste, cifratemessaggi, cifrati e firmati

Anche sul telefono.

  • Le chiavi private restano sul dispositivo.

    iPhone: nel portachiavi, solo per questo dispositivo. Android: protette da una chiave nel Keystore di Android. Non nei backup di iCloud o Google.

  • Anche la cache è cifrata.

    La cronologia della chat sul telefono è cifrata con una chiave che non lascia mai il dispositivo, ed è esclusa dal backup.

  • Solo standard.

    Nessuna crittografia fatta in casa. Solo procedure pubblicate; entrambe le app devono riprodurre gli stessi vettori di test.

02Epoche

I nuovi membri leggono a partire dal loro ingresso.

Una chiave di gruppo non vale per sempre. Quando il gruppo cambia, inizia una nuova epoca con una nuova chiave: quando qualcuno entra, esce o viene rimosso, e anche quando un membro ha una nuova chiave, per esempio su un nuovo telefono senza codice di ripristino.

Chi esce non può quindi più leggere nulla di nuovo. Chi arriva vede solo ciò che viene scritto dopo il suo ingresso. I messaggi precedenti non li riceve, nemmeno da altri membri.

La nuova epoca viene avviata automaticamente dall’app del primo membro che nota il cambiamento. Fino ad allora il server non accetta più messaggi cifrati con la vecchia chiave. Chi è appena uscito non può quindi continuare a leggere con una chiave che possiede ancora.

Nel dettaglio: quando un telefono accetta un’epoca

L’app che avvia un’epoca imbusta la nuova chiave per ogni membro attivo che ha pubblicato una chiave e firma l’elenco dei destinatari. Un telefono accetta l’epoca solo se la busta si apre, se la chiave corrisponde all’impronta pubblicata, se l’elenco dei destinatari è corretto e contiene sia chi ha avviato l’epoca sia il telefono stesso, e se la firma è autentica. Così il server non può introdurre di nascosto una propria chiave di gruppo.

// per epoca, sul telefono di chi la avvia
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)
Epoche: Anna legge tutte e tre, Ben solo le epoche 1 e 2, Luca solo dall’epoca 2.AAnnaBBenLLucatempoEpoca 1leggelegge—Epoca 2leggeleggeleggeEpoca 3legge—legge+ Luca entra · nuova epoca− Ben esce · nuova epocapuò leggerenessun accesso

03Messaggi

Ogni messaggio ha la sua chiave.

Dalla chiave di gruppo il tuo telefono deriva una chiave propria per ogni messaggio. Con essa cifra il contenuto: il testo e, per un punto d’incontro, luogo, coordinate, ora e osservazione. Persino il tipo, cioè se si tratta di un testo o di un punto d’incontro, figura solo nella parte cifrata.

Prima della cifratura, il contenuto viene riempito fino a un multiplo di 256 byte. Così la lunghezza rivela solo approssimativamente quanto è lungo un messaggio.

Infine il tuo telefono firma il messaggio. Tutti nel gruppo hanno la stessa chiave di gruppo; solo la firma dimostra chi ha scritto qualcosa. La firma impedisce anche al server di attribuire un messaggio a qualcun altro.

Se un telefono non riesce a verificare o a decifrare un messaggio, non lo mostra, nemmeno in parte, ma indica «Impossibile visualizzare il messaggio».

Nel dettaglio: cosa succede a un messaggio

La modifica resta possibile per 15 minuti, come finora; tutto viene ricalcolato con la chiave di gruppo attuale. All’eliminazione, il server cancella il contenuto cifrato e la firma.

// per messaggio, sul telefono del mittente
padded     = content || 0x80 || 0x00 …        // fino al prossimo multiplo di 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)
Cinque passi dal contenuto al messaggio cifrato e firmato, e cosa ne vede il server.1Contenuto{"kind":"text","body":"Adunata…"}2Riempire a 256 byteContenuto0x80 00 00 …3Chiave propriaHKDF dalla chiave di gruppo e dagli ID4CifrareAES-256-GCM → 9d4e 07b1 c3a8 …5FirmareEd25519 · autentica il mittenteSul servervisibilegruppo · mittente · ora · dimensionenascostotesto · punto d’incontro · tipo

04Codice

Nuovo telefono, stessa cronologia.

Senza precauzioni, con il telefono sparirebbe anche la chiave privata, e con essa la cronologia. Per questo l’app propone un codice di ripristino durante la configurazione: 24 caratteri, generati dall’app e mostrati una sola volta. Annotalo o salvalo in un gestore di password. Puoi saltare questo passo; in tal caso il ripristino non è possibile.

Dal codice il tuo telefono calcola con Argon2id una chiave di backup e cifra con essa le tue chiavi private. Sul server c’è solo il risultato. Il codice stesso non lascia mai il tuo telefono.

Su un nuovo telefono: accedi, inserisci il codice, e la cronologia è di nuovo lì. Senza codice ricevi nuove chiavi, e i messaggi precedenti restano illeggibili per te.

Nel dettaglio: il backup

All’inserimento l’app ignora spazi e trattini e accetta le minuscole. Qualsiasi altro carattere rende l’inserimento non valido, invece di essere ignorato in silenzio. Dopo la decifratura l’app verifica che le chiavi corrispondano a quelle pubblicate.

// solo sul tuo telefono; sul server si trovano salt, nonce e 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)
Codice di ripristino: Argon2id ne ricava la chiave di backup; sul server resta solo il backup cifrato.SUL TUO TELEFONOil codice non lo lascia maiCodice di ripristino · 120 bitK7QM-3XRA-PW9E-HN2T-4JDC-ZB8VArgon2idlento, di proposito256 MiBt = 4p = 1sale 16 byteChiave di backup · 32 byteAES-256-GCMcifra le tue chiavi privateBackup cifratosul server · inutile senza il codice

Fin dove arriviamo.

Chi ruba il backup cifrato dal server può provare dei codici senza che i nostri blocchi intervengano. Argon2id rende costoso ogni tentativo: richiede molta memoria e tempo di calcolo, e contro il fabbisogno di memoria servono a poco anche schede grafiche e chip specializzati.

  1. Viene eseguito due volte nella vita di un dispositivo: alla creazione del backup e al ripristino. Qualche secondo con un indicatore di avanzamento va bene.
  2. È la memoria a far male agli attaccanti con schede grafiche. Più passaggi moltiplicano solo i costi.
  3. I parametri vengono fissati alla creazione, ma il ripristino potrebbe avvenire su un telefono più economico (Android 8, 2–3 GB di RAM). È il telefono più lento supportato a fissare il limite.
  4. Con 1 GiB il sistema rischia di chiudere l’app su questi telefoni; 512 MiB è al limite. 256 MiB è il massimo che funziona ovunque.
Misurato su un Mac (Apple M5), Argon2id con p = 1.
Memoriat = 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

Scelto

Argon2id · 256 MiB · t = 4 · p = 1 · sale 16 byte · chiave 32 byte

0,44 s sul Mac. Sui telefoni non ancora misurato, stima: circa 0,6–1 s su un iPhone recente, 1–2 s su un Android di fascia media, 3–5 s su un modello vecchio ed economico.

La misura si fa sul telefono più lento che supportiamo; t aumenta finché gli servono circa 3 secondi. Mai sotto 256 MiB e t = 4. I parametri sono salvati con ogni backup: possono quindi aumentare in futuro senza rompere i backup più vecchi.

Per confronto: quattro volte la memoria della variante della RFC 9106 per dispositivi con poca memoria (64 MiB, t = 3) e oltre 13 volte il minimo dell’OWASP (19 MiB, t = 2).

A essere onesti:

Con un codice casuale di 120 bit indovinare è senza speranza anche con una procedura veloce; un milione di schede grafiche impiegherebbe molto più dell’età dell’universo. Argon2id fa sì che resti così, al prezzo di una breve attesa. Di proposito non permettiamo password scelte dall’utente: una password debole resterebbe debole anche con Argon2id.

Dove di proposito non serve una procedura lenta

  • Tutte le altre derivazioni partono da chiavi casuali di 256 bit. Lì HKDF e SHA-256 sono gli strumenti giusti; rallentare non porta nulla e consuma batteria.
  • Non ci sono password. L’accesso avviene con Apple, con Google o con un codice ricevuto per e-mail: 8 cifre, valido 10 minuti, utilizzabile una sola volta. L’e-mail contiene solo il tuo indirizzo e il codice. Il codice apre l’account, non le chiavi: chi lo intercetta non legge i tuoi messaggi precedenti. Se accede con il codice, il suo dispositivo riceve una nuova chiave e in ognuno dei tuoi gruppi compare un avviso.
  • I codici d’invito e le chiavi utente sono protetti dal blocco del server (al massimo 20 tentativi errati all’ora). Farne l’hash nella banca dati non servirebbe: chi può leggere la banca dati ha comunque i gruppi.

05Server

Cosa vede il server. E cosa no.

La crittografia nasconde il contenuto, non tutto ciò che lo circonda. Questo elenco è completo.

Vede

  • che hai un account; nome, grado e funzione nel tuo profilo; il tuo indirizzo e-mail, se accedi per e-mail o con Google
  • in quali gruppi sei e con quale ruolo (membro, admin, proprietario)
  • nome, tipo, simbolo e luogo di un gruppo (necessari per l’anteprima all’ingresso e per il meteo)
  • note e compiti (non ancora cifrati)
  • chi ha inviato un messaggio in quale gruppo e quando; modifiche ed eliminazioni con data e ora
  • la lunghezza approssimativa di un messaggio (a scaglioni di 256 byte)
  • le tue chiavi pubbliche e il tuo backup cifrato
  • gli indirizzi IP nei log di Supabase
  • i messaggi segnalati, perché chi segnala li invia

Segnalare senza che il server legga i messaggi.

Chi segnala un messaggio ne invia di proposito il contenuto al gestore. Solo allora il gestore lo vede.

Perché nessuno possa attribuire a qualcun altro un testo che non ha mai scritto, il telefono del mittente deposita un’impronta al momento dell’invio (HMAC-SHA256). Alla segnalazione, il server la ricalcola con il contenuto inviato e accetta la segnalazione solo se corrisponde. La procedura si chiama message franking; è il metodo con cui Facebook Messenger gestisce le segnalazioni nelle sue chat cifrate.

La chiave necessaria vale solo per questo messaggio. Non rivela né la chiave del messaggio né la chiave di gruppo, e il server non la conserva.

// verificato dal server alla segnalazione
HMAC-SHA256(fk, "militio/commitment/v1" || ctx || content) == commitment
Segnalare: all’invio il server conserva un’impronta; alla segnalazione la ricalcola con contenuto e chiave.ALL’INVIOAnnainvia+ improntaServerconserva l’improntaALLA SEGNALAZIONEBensegnalacontenuto + fkServerricalcola l’HMACimprontacorrisponde: accettata✕altrimenti: respinta

06Limiti

Cosa la crittografia non può fare.

  1. Il server gestisce l’elenco dei membri.

    Distribuisce anche le chiavi pubbliche. Un server compromesso potrebbe aggiungere un membro falso o sostituire una chiave. Contromisura: ogni ingresso e ogni nuova chiave compaiono nella chat. È inoltre previsto che i membri possano verificarsi a vicenda di persona con un codice QR. Senza questa verifica ti fidi del server su quest’unico punto. WhatsApp e Signal hanno lo stesso limite.

  2. Niente forward secrecy all’interno di un’epoca.

    Chi ha il tuo telefono sbloccato o la chiave del tuo account può leggere ogni epoca di cui hai fatto parte. Una nuova chiave dopo la perdita di un telefono protegge solo ciò che viene dopo. Signal e MLS vanno oltre su questo punto.

  3. I metadati restano visibili.

    Chi scrive quando e in quale gruppo, il server lo vede. L’elenco completo è più in alto.

  4. Note e compiti non sono ancora cifrati.

    Restano a lungo e i nuovi membri devono poterli leggere. Questo non si adatta a epoche che cambiano a ogni ingresso; per note e compiti serve una soluzione a parte.

07Tecnica

Algoritmi e parametri.

Nessuna crittografia fatta in casa, solo standard pubblicati. Entrambe le app devono soddisfare gli stessi vettori di test, affinché producano esattamente gli stessi byte.

ScopoProceduraStandard
Distribuire le chiavi di gruppoHPKE, modalità base: DHKEM(X25519, HKDF-SHA256), HKDF-SHA256, AES-256-GCMRFC 9180
Accordo di chiaviX25519RFC 7748
FirmareEd25519RFC 8032
Cifrare i messaggiAES-256-GCM, nonce casuale di 96 bitNIST SP 800-38D
Derivare chiaviHKDF-SHA256RFC 5869
ImpronteSHA-256, HMAC-SHA256FIPS 180-4, RFC 2104
Chiave di backupArgon2id (versione 0x13), 256 MiB, t = 4, p = 1RFC 9106
Trasmissione dei valori binariBase64 con riempimentoRFC 4648
Numeri casualiGeneratore casuale del sistema operativo–
Etichette che separano gli usi
militio/account-key/v1Autofirma di una chiave dell’account
militio/fingerprint/v1Impronta di una chiave dell’account
militio/recipients/v1Elenco dei destinatari di un’epoca
militio/epoch-commitment/v1Impronta di una chiave di gruppo
militio/epoch/v1Firma di un’epoca
militio/epoch-key/v1Busta di una chiave di gruppo (info HPKE)
militio/message-key/v1Chiave di un messaggio
militio/franking-key/v1Chiave dell’impronta per la segnalazione
militio/message/v1Dati associati della cifratura
militio/commitment/v1Impronta di un messaggio
militio/message-signature/v1Firma di un messaggio
militio/backup/v1Dati associati del backup

La specifica completa e i vettori di test seguiranno con la pubblicazione.

Hai trovato una vulnerabilità?

Scrivimi prima di pubblicarla. Ti rispondo e ti dico quando sarà corretta.

info@militio.ch