Prima di trasmettere audio e video, Baby Monitor Timmy deve consentire ai due dispositivi di trovarsi e di verificare con chi stanno comunicando. Qui spiego come Timmy abbina due telefoni, quali meccanismi crittografici usa e come il confronto del numero di sicurezza può far emergere una manomissione dello scambio delle chiavi.
Il problema: con chi sta comunicando il mio dispositivo?
Quando due dispositivi si collegano per la prima volta, la domanda è questa: il dispositivo A sta davvero comunicando con il dispositivo B, oppure qualcuno si è inserito fra i due? In crittografia si parla di attacco man-in-the-middle (MITM).
Timmy combina uno scambio di chiavi Elliptic Curve Diffie–Hellman (ECDH) tramite Firebase con il confronto del numero di sicurezza sui due dispositivi.
Questo diagramma riassume le fasi dell’abbinamento:
Passaggio 1: ogni dispositivo genera una coppia di chiavi
All’inizio di ogni nuovo abbinamento, ciascun dispositivo genera una coppia di chiavi ECDH effimera sulla curva P-256 (secp256r1):
- Una chiave privata, che rimane sul dispositivo
- Una chiave pubblica, scambiata tramite Firebase
Timmy usa Random.secure() per inizializzare il generatore casuale impiegato nella creazione delle chiavi. La coppia ECDH appartiene a quello specifico abbinamento.
Passaggio 2: scambiare le chiavi pubbliche tramite Firebase
Timmy usa un codice di quattro caratteri come punto d’incontro fra i dispositivi. La ricerca automatica lo individua sulla rete locale tramite DNS-SD/mDNS; in alternativa puoi inserirlo a mano. Il codice determina il documento Firestore usato per lo scambio delle chiavi. Le chiavi crittografiche vengono generate separatamente.
Quando entrambi conoscono il codice, ogni dispositivo scrive la propria chiave pubblica ECDH in un documento Firestore condiviso. Da quel documento legge poi la chiave pubblica dell’altro dispositivo.
Durante lo scambio viene trasmessa la chiave pubblica. Quella privata rimane sul dispositivo. Secondo le ipotesi di sicurezza di ECDH, conoscere soltanto le chiavi pubbliche non consente di ricavare il segreto condiviso con risorse di calcolo ragionevoli.
Passaggio 3: calcolare un segreto condiviso
Dopo aver letto da Firebase la chiave pubblica dell’altro, nel normale svolgimento dello scambio i due dispositivi calcolano in modo indipendente lo stesso segreto condiviso:
sharedSecret = ECDH(myPrivateKey, theirPublicKey)
→ 32 byte (identici sui due dispositivi) Le proprietà matematiche delle curve ellittiche fanno sì che i due calcoli diano lo stesso risultato, anche se ciascun dispositivo conosce soltanto la propria chiave privata e la chiave pubblica dell’altro.
Passaggio 4: confrontare il numero di sicurezza (SAS)
Dal segreto condiviso e dalle due chiavi pubbliche, ogni dispositivo deriva una breve stringa di autenticazione (SAS, Short Authentication String). Timmy la mostra come numero di sicurezza a due cifre.
[pubkey1, pubkey2] = sort(publicKeysAsStrings)
prefix = UTF-8("sas:" + pubkey1 + ":" + pubkey2 + ":")
hash = SHA-256(prefix + sharedSecret)
number = (hash[0] × 256 + hash[1]) mod 100 → da 00 a 99 In uno scambio normale, i due dispositivi mostrano lo stesso numero, per esempio 42. Confronta i numeri sugli schermi e conferma separatamente su ciascun dispositivo se coincidono e se volevi effettivamente abbinarli.
Come il numero di sicurezza può rivelare una manomissione
Se un attaccante riesce a sostituire le chiavi pubbliche usate nello scambio, può tentare di concordare un segreto diverso con ciascun dispositivo:
- Intercettare e sostituire le chiavi pubbliche autentiche in Firebase
- Usare le proprie coppie di chiavi per effettuare uno scambio separato con ciascun dispositivo
In questo esempio, l’attaccante concorda il segreto S_A con il dispositivo A e un altro segreto, S_B, con il dispositivo B. I dispositivi mostrano rispettivamente 73 e 18. Confrontando gli schermi si può notare la differenza.
Due scambi diversi possono anche produrre lo stesso numero a due cifre. Il numero costituisce quindi una verifica aggiuntiva. Annulla l’abbinamento se i numeri sono diversi o se la richiesta è inattesa.
Passaggio 5: completare l’abbinamento
Ciascun dispositivo completa la propria parte dopo la conferma su quel dispositivo:
- Derivare dal segreto condiviso una chiave di abbinamento di 64 caratteri esadecimali:
SHA-256("pair:" + sharedSecret) → pairingKey - Derivare dalla chiave di abbinamento la chiave del documento Firestore:
SHA-256("doc:" + pairingKey) → documentKey - Usare un altro hash per derivare la chiave AES-256-GCM della segnalazione cifrata:
SHA-256("enc:" + pairingKey) → encryptionKey - Salvare localmente i dati di abbinamento derivati. Se entrambi confermano lo scambio normale, i due dispositivi derivano la stessa chiave di abbinamento.
Nelle sessioni successive, AES-256-GCM protegge i dati SDP e il testo dei candidati ICE in Firestore. Nel flusso descritto, la chiave di abbinamento rimane sul dispositivo. Da essa viene derivato un identificatore separato del documento, usato per l’instradamento. WebRTC protegge il traffico multimediale in modo indipendente.
Dall’abbinamento alla trasmissione
La ricerca locale, Firestore e WebRTC hanno compiti diversi. Il diagramma seguente distingue i percorsi dei dati: dalla ricerca del codice e dallo scambio delle chiavi fino alla trasmissione di audio e video.
I percorsi di comunicazione nel dettaglio:
- WebRTC: DTLS-SRTP protegge audio e video. Il DataChannel usa DTLS. Il traffico può passare direttamente fra i dispositivi.
- Firebase Firestore: durante l’abbinamento trasmette le chiavi pubbliche ECDH. Nelle sessioni successive trasporta i dati SDP e il testo dei candidati ICE protetti da AES-256-GCM. I campi tecnici possono essere memorizzati separatamente.
- STUN: aiuta i dispositivi a individuare le mappature di indirizzi e porte visibili dall’esterno. ICE verifica i percorsi possibili per la connessione.
- Relay TURN: inoltra il traffico WebRTC protetto quando è necessario un relay. I dispositivi ottengono credenziali temporanee tramite una Firebase Cloud Function.
- DNS-SD/mDNS: la ricerca locale aiuta i dispositivi a trovare il codice di abbinamento sulla stessa rete. Lo scambio delle chiavi pubbliche avviene tramite Firestore.
Quali componenti lavorano insieme
La stessa architettura si può leggere anche attraverso i suoi componenti. Entrambi i telefoni usano Firebase per l’autenticazione anonima, gli scambi tramite Firestore e la richiesta di credenziali TURN temporanee. STUN aiuta a individuare le mappature degli indirizzi; quando serve, un relay TURN inoltra il traffico WebRTC protetto. Il diagramma dei componenti mostra come questi elementi si collegano.
Se la ricerca non riesce: inserire il codice a mano
Se la ricerca automatica non trova l’altro dispositivo, puoi inserire manualmente il codice di quattro caratteri. I dispositivi eseguono poi lo stesso scambio ECDH tramite Firestore e mostrano il numero di sicurezza da confrontare. Cambia soltanto il modo in cui il codice arriva al secondo dispositivo.
I meccanismi di sicurezza in sintesi
| Meccanismo | Compito |
|---|---|
| Scambio di chiavi ECDH (P-256) | Derivare un segreto condiviso dalla chiave privata locale e dalla chiave pubblica ricevuta |
| Coppie di chiavi effimere | Generare una nuova coppia ECDH per ogni nuovo abbinamento |
| Numero di sicurezza (SAS) | Confrontare gli schermi come verifica aggiuntiva |
| Hash SHA-256 come identificatore del documento | Indirizzare un documento tramite un identificatore derivato |
| Cifratura AES-256-GCM | Proteggere i dati SDP e il testo dei candidati ICE |
| Conferma su ciascun dispositivo | Salvare i dati di abbinamento su ciascun dispositivo dopo la conferma |
| DTLS-SRTP (WebRTC) | Proteggere audio e video durante la trasmissione |
Il codice permette ai dispositivi di trovarsi. ECDH fornisce il segreto condiviso da cui derivare le chiavi; il confronto del numero di sicurezza aiuta a verificare l’interlocutore. AES-256-GCM protegge poi alcuni dati di segnalazione, mentre WebRTC protegge separatamente i contenuti multimediali.