Avant de transmettre le son ou la vidéo, Baby Monitor Timmy doit permettre aux deux appareils de se trouver et de vérifier leur interlocuteur. J’explique ici comment Timmy associe deux téléphones, quels mécanismes cryptographiques interviennent et comment la comparaison du code de sécurité peut révéler une intervention dans l’échange de clés.
Le problème : avec qui mon appareil communique-t-il ?
Lors de la première connexion entre deux appareils, une question se pose : l’appareil A communique-t-il bien avec l’appareil B, ou quelqu’un s’interpose-t-il ? En cryptographie, on parle d’attaque de l’homme du milieu (MITM).
Timmy associe un échange de clés Elliptic Curve Diffie–Hellman (ECDH) via Firebase à une comparaison du code de sécurité affiché sur les deux appareils.
Ce schéma présente les grandes étapes de l’appairage :
Étape 1 : chaque appareil crée une paire de clés
Au début de chaque nouvel appairage, chaque appareil génère une paire de clés ECDH éphémère sur la courbe P-256 (secp256r1) :
- Une clé privée, qui reste sur l’appareil
- Une clé publique, échangée via Firebase
Timmy utilise Random.secure() pour initialiser le générateur aléatoire servant à créer les clés. Chaque paire ECDH est propre à cet appairage.
Étape 2 : échanger les clés publiques via Firebase
Timmy utilise un code de quatre caractères comme point de rendez-vous entre les appareils. La détection automatique le trouve sur le réseau local grâce à DNS-SD/mDNS. Il est aussi possible de le saisir à la main. Ce code détermine le document Firestore utilisé pour l’échange de clés. Les clés cryptographiques sont créées séparément.
Une fois le code connu des deux appareils, chacun écrit sa clé publique ECDH dans un document Firestore commun. Il y lit ensuite la clé publique de l’autre appareil.
Lors de l’échange de clés, chaque appareil transmet sa clé publique. La clé privée reste sur l’appareil. Selon les hypothèses de sécurité d’ECDH, connaître les seules clés publiques ne permet pas de calculer le secret partagé avec des moyens de calcul raisonnables.
Étape 3 : calculer un secret partagé
Après avoir récupéré la clé publique de l’autre appareil depuis Firebase, les deux appareils calculent indépendamment le même secret partagé, dans le déroulement normal de l’échange :
sharedSecret = ECDH(myPrivateKey, theirPublicKey)
→ 32 octets (identiques sur les deux appareils) Les propriétés mathématiques des courbes elliptiques font aboutir les deux calculs au même résultat, alors que chaque appareil ne connaît que sa propre clé privée et la clé publique de l’autre.
Étape 4 : comparer le code de sécurité (SAS)
Chaque appareil dérive une courte chaîne d’authentification (SAS, Short Authentication String) à partir du secret partagé et des deux clés publiques. Timmy l’affiche sous la forme d’un code de sécurité à deux chiffres.
[pubkey1, pubkey2] = sort(publicKeysAsStrings)
prefix = UTF-8("sas:" + pubkey1 + ":" + pubkey2 + ":")
hash = SHA-256(prefix + sharedSecret)
number = (hash[0] × 256 + hash[1]) mod 100 → de 00 à 99 Dans un échange normal, les deux appareils affichent le même nombre, par exemple 42. Compare les valeurs sur les deux écrans. Confirme séparément sur chaque appareil si elles correspondent et si tu souhaites bien associer ces appareils.
Comment le code de sécurité peut révéler une attaque
Si un attaquant peut remplacer les clés publiques utilisées dans l’échange, il peut tenter d’établir un secret différent avec chaque appareil :
- Intercepter et remplacer les véritables clés publiques dans Firebase
- Utiliser ses propres paires de clés pour effectuer un échange séparé avec chaque appareil
Dans cet exemple, l’attaquant établit le secret S_A avec l’appareil A et un autre secret, S_B, avec l’appareil B. Les appareils affichent ici 73 et 18. La comparaison des écrans peut donc faire apparaître une différence.
Deux échanges différents peuvent aussi produire le même nombre à deux chiffres. L’affichage constitue donc une vérification supplémentaire. Annule l’appairage si les valeurs diffèrent ou si la demande est inattendue.
Étape 5 : terminer l’appairage
Chaque appareil termine sa partie de l’appairage après la confirmation sur cet appareil :
- Dériver du secret partagé une clé d’appairage de 64 caractères hexadécimaux :
SHA-256("pair:" + sharedSecret) → pairingKey - Dériver la clé du document Firestore à partir de la clé d’appairage :
SHA-256("doc:" + pairingKey) → documentKey - Utiliser un autre hachage pour dériver la clé AES-256-GCM de la signalisation chiffrée :
SHA-256("enc:" + pairingKey) → encryptionKey - Enregistrer localement les données d’appairage dérivées. Si les deux appareils confirment l’échange normal, ils dérivent la même clé d’appairage.
Pour les sessions suivantes, AES-256-GCM protège les données SDP et le texte des candidats ICE dans Firestore. Dans le fonctionnement décrit ici, la clé d’appairage reste sur l’appareil. Un identifiant de document distinct en est dérivé pour le routage. WebRTC protège le trafic multimédia indépendamment.
De l’appairage à la transmission
La détection locale, Firestore et WebRTC remplissent des rôles différents. Le schéma suivant distingue les chemins empruntés par les données, de la recherche du code d’appairage à la transmission du son et de la vidéo, en passant par l’échange de clés.
Les chemins de communication en détail :
- WebRTC : DTLS-SRTP protège le son et la vidéo. Le DataChannel utilise DTLS. Le trafic peut circuler directement entre les appareils.
- Firebase Firestore : pendant l’appairage, Firestore transmet les clés publiques ECDH. Pour les sessions suivantes, il transporte les données SDP et le texte des candidats ICE protégés par AES-256-GCM. Des champs techniques peuvent être stockés séparément.
- STUN : permet aux appareils de déterminer leurs correspondances d’adresses et de ports visibles depuis l’extérieur. ICE vérifie les chemins possibles pour la connexion.
- Relais TURN : transmet le trafic WebRTC protégé lorsqu’un relais est nécessaire. Les appareils obtiennent des identifiants temporaires via une fonction Cloud Functions for Firebase.
- DNS-SD/mDNS : la détection locale aide les appareils à trouver le code d’appairage sur le même réseau. L’échange des clés publiques passe par Firestore.
Les composants et leurs rôles
On peut aussi examiner cette architecture sous l’angle de ses composants. Les deux téléphones utilisent Firebase pour l’authentification anonyme, les échanges via Firestore et l’obtention d’identifiants TURN temporaires. STUN aide à déterminer les correspondances d’adresses ; si nécessaire, un relais TURN transmet le trafic WebRTC protégé. Le schéma de composants ci-dessous montre comment ces éléments s’articulent.
Si la détection échoue : saisir le code manuellement
Si la détection automatique ne trouve pas l’autre appareil, tu peux saisir le code de quatre caractères manuellement. Les appareils effectuent ensuite le même échange ECDH via Firestore et affichent le code de sécurité à comparer. Seule la manière dont le code parvient au second appareil change.
Les mécanismes de sécurité en bref
| Mécanisme | Rôle |
|---|---|
| Échange de clés ECDH (P-256) | Dériver un secret partagé à partir de la clé privée locale et de la clé publique reçue |
| Paires de clés éphémères | Créer une nouvelle paire ECDH pour chaque nouvel appairage |
| Code de sécurité (SAS) | Comparer les écrans comme vérification supplémentaire |
| Hachage SHA-256 comme identifiant de document | Adresser un document à l’aide d’un identifiant dérivé |
| Chiffrement AES-256-GCM | Protéger les données SDP et le texte des candidats ICE |
| Confirmation sur chaque appareil | Enregistrer les données d’appairage sur chaque appareil après confirmation |
| DTLS-SRTP (WebRTC) | Protéger le son et la vidéo pendant leur transmission |
Le code permet aux appareils de se retrouver. ECDH fournit le secret partagé utilisé pour dériver les clés, et la comparaison du code de sécurité aide à vérifier l’interlocuteur. AES-256-GCM protège ensuite certaines données de signalisation. WebRTC protège les médias séparément.