Sommaire
Briques de base
TLS est la référence absolue pour tous les algos, mais c’est à vous de faire votre choix. Libsodium est une implémentation des derniers algos recommandés et fait le choix pour vous. Ces deux bibliothèques sont énormes et sont optimisées pour PC. Un professeur de cryptographie a écrit une série de tweets qui contient une petite lib qui reprend les algorithmes de libsodium en version auditable (https://tweetnacl.cr.yp.to/). Mais elle est lente.
Une autre personne écrit ce que je cherche : Monocypher. C’est un fichier .c avec les algo principaux de libsodium et qui compile en pur C sans dépendance ! C’est parfait pour mon besoin.
Cette bibliothèque fournit uniquement les briques de base, on est très loin d’un protocole Signal. Quand on parle de cryptographie, on pense à AES pour le chiffrement symétrique, à RSA pour le chiffrement à clef publique et la signature, aux hashs SHA1 ou SHA512 pour un hash de qualité cryptographique. Les propriétés nécessaires sont fascinantes mais cela ne dit pas comment bien les utiliser ensuite.
Le chiffrement symétrique
Il s’agit de chiffrer un bloc avec une clé de taille fixe. Le représentant le plus connu est AES, avec des clés de 128 ou 256 bits. On a un bloc, on a une clé, et on obtient un bloc plus ou moins aléatoire. AES utilise des modes (GCM, XTS, …) pour renforcer le mélange et garantir la sécurité selon différents contextes.
Ici, l’algorithme recommandé est ChaCha20. Pas besoin de mode externe : tout est prévu dans l’algorithme de base.
Au déchiffrement, la brique ne se pose pas de question : si la donnée a été altérée, le résultat le sera aussi.Il faut donc ajouter un protocole d’authentification, qui utilise la même clé et un hash pour vérifier l’intégrité. Les algorithmes classiques sont MAC, HMAC, mais il est facile de faire une erreur dans leur utilisation.
Monocypher utilise Poly1305 pour authentifier le message (AEAD – Authenticated Encryption with Associated Data). Son API combine XChaCha20 et Poly1305, ce qui évite de se poser des questions : en cas de modification du message chiffré, la fonction de déchiffrement renvoie une erreur explicite.
Cette fonction nécessite un NONCE ("Number used once"), qui doit être différent à chaque appel.
Le hash
Un hash prend un bloc de données, fait une grosse salade et rend un chiffre de taille fixe avec de bonnes propriétés crypto. Le but est d’avoir une empreinte de taille fixe pour un bloc de données, et qu’il soit impossible de forger un hash identique en modifiant un peu les données d’origine. En gros.
Le hash recommandé est BLAKE2b : “as secure as SHA-3 and as fast as MD5”. Il fait 256 ou 512 bits.
“Password hashing” ou la création de clef à partir de mot de passe
Lorsqu’un mot de passe est saisi, il n’est jamais utilisé tel quel : il est d’abord transformé en une valeur de taille fixe via une fonction de hachage. Pour contrer les attaques par force brute, on a commencé par appliquer des centaines d’itérations de SHA1, avant d’adopter des fonctions de hachage volontairement lentes, comme bcrypt ou scrypt. Le but étant justement d’éviter qu’elles soient rapides, contrairement aux fonctions de hachage classiques.
Aujourd’hui, Argon2 est recommandé.
Chiffrement à clef publique
L’image est souvent celle d’un cadenas ouvert : n’importe qui peut fermer le cadenas, mais seul le possesseur de la clef peut l’ouvrir. RSA a été le premier algorithme inventé avec cette propriété. Aujourd’hui, la mode est aux courbes elliptiques avec X25519.
La fonction principale est basée sur l’échange Diffie-Hellman (DH). C’est le truc magique de la crypto asymétrique.
DH(Clef publique de A, Clé privée de B) = DH(Clef publique de B, Clé privée de A) = N
Sans une clef privée, il est cryptographiquement impossible de retrouver N.
Comment créer une clef privée ? C’est simplement 32 octets très aléatoires. Toute la sécurité dépend de cela. On se rappelle de la faille Debian utilisant un générateur prévisible en 2008.
Générateur d’aléatoire
Pour faire de la cryptographie sérieusement, il faut un vrai générateur aléatoire de qualité cryptographique. Monocypher, par exemple, n’en fournit pas, car cela dépend trop du matériel utilisé. C’est donc à vous d'en fournir un correct.
Ne surtout pas utiliser random() ou rand() : ces fonctions ne sont pas prévues pour la sécurité. Elles offrent souvent à peine 32 bits d’entropie, ce qui signifie qu’elles peuvent générer des valeurs qui tournent en boucle après seulement 4 milliards de cas, ce qui est trivial à explorer pour un attaquant moderne.
Un bon générateur s’appuie sur des sources d’entropie, autrement dit, des phénomènes imprévisibles : le bruit du système, les délais entre événements, la température, etc. Ensuite, ces sources sont mélangées (souvent via un gros hash) pour produire des nombres avec des propriétés statistiques solides.
Par exemple, Linux collecte plein de métriques internes (activité réseau, mouvements de la souris, etc.) pour alimenter son générateur aléatoire /dev/urandom.
Côté matériel, certaines plateformes proposent un vrai générateur physique : il peut mesurer le bruit électrique à travers une diode via un convertisseur analogique-numérique (ADC), ou encore exploiter les légères variations de vitesse d’oscillateurs internes (anneaux d’inverseurs), qui sont ensuite mélangées avec des circuits comme des LFSR combinés via XOR.
Utilisez le générateur cryptographique fourni par votre plateforme (par exemple getrandom(), arc4random(), ou un TRNG matériel si vous êtes en embarqué).
Il ne faut pas se créer son propre générateur sans savoir exactement ce que l’on fait. Le pire étant de réutiliser des données (des clefs par exemple) pour générer d’autres nombres. On crée ainsi une énorme dépendance entre eux, qui n’ont plus rien d’aléatoire.
Les dernières failles des imprimantes Brother proviennent du fait que les mots de passe d’administration sont dérivés de leur numéro de série (!).
Signature
On a un bloc de données, on signe avec une clef privée, on vérifie la signature avec la clef publique.
Monocypher propose EdDSA.
Serial Guard, le protocole de communication
Il ne faut pas créer sa propre cryptographie, c’est trop facile de se tromper. C’est pourtant exactement ce que j’ai fait. La suite peut donc contenir des erreurs. L’idée est de créer un protocole léger de communication. Si des experts passent par là et voient une horreur, qu’ils n’hésitent pas à crier.
On a maintenant les blocs de base. Et il faut maintenant les agencer comme il faut. On veut que A communique avec B (Alice et Bob), sans que E puisse comprendre les messages, insérer des messages, modifier des messages, rejouer des messages, récupérer les messages dans le futur s’il a tout enregistré et récupérer les clefs privées.
Dans le monde de l’embarqué « simple », on communique avec des read et des write sur lien série. L’idéal est d’avoir à peu près la même API.
Il faut réduire au minimum l’échange d’informations préalable pour être le plus léger possible.
Je laisse de coté le "framing", c'est à dire la mise en paquet pour être envoyé sur un lien physique. Un lien série envoie des octets, serialguard fonctionne par paquets d'octet. Il faut reconstituer un paquet avant de l'envoyer dans la bibliothèque.
La base est d’avoir une clef privée chacun, à longue durée de vie. Cela permet de s’authentifier selon le principe : si c’est toujours la même clef depuis l’installation, c’est toujours le même pair : TOFU.
Si on a besoin de faire mieux, il faudrait qu’une « clef de confiance » signe cette clef. Mais on entre dans les méandres complexes d’une public key infrastructure, des certificats ou des web of trust type GPG.
Pour pouvoir tout de même changer une clef privée à long terme, tout en ayant de la sécurité pour éviter les man-in-the-middle, il faut garder un secret partagé dans tous les pairs. Cela peut être très compliqué sur un réseau de serveurs, mais ici, chaque boîtier est programmé au même endroit.
Il s’agit simplement d’un nombre de 32 octets aléatoire partagé par tous. C’est nommé pompeusement pre-shared key (PSK).
Il faudra éviter de la laisser traîner dans le code source.
Une clef de session est une clef temporaire, renouvelable. L’idée est d’utiliser la cryptographie asymétrique pour se mettre d’accord sur une clef symétrique.
Si on utilise le nombre généré par Diffie-Hellman (DH) directement, il est unique par pair de clefs privées : ce n’est pas top. On pourrait échanger des nombres aléatoires pour se mettre d’accord sur une clef symétrique, mais je veux limiter les échanges au minimum.
Pour cela, je vais utiliser une clef de session asymétrique, qui est l’invention du protocole Signal. Une fois la clef symétrique générée, la clef privée éphémère est jetée. Il sera impossible ensuite de déchiffrer la session, même dans le futur.
On commence donc par un échange de 2 clefs publiques : l’une à durée de vie longue et l’autre éphémère.
On croise les 8 clefs (2 publiques et 2 privées de chaque côté) dans 3 échanges DH, on trie les nombres pour avoir le même ordre des 2 côtés, et le résultat est donné à la fonction de hachage avec la PSK.
On a ainsi notre clef de session symétrique.
Le rejeu
Tant que la session est active, l’envoi d’un message précédent reste valide. Pour éviter cela, un NONCE est utilisé dans le chiffrement symétrique. C’est un nombre fourni quelconque mais qui ne doit jamais être identique d’un paquet à l’autre. Il peut être transmis avec le paquet, mais cela prend de la place.
J’ai choisi d’utiliser un simple compteur, cela évite de devoir se rappeler les NONCE passés pour éviter le rejeu.
Les liaisons n’étant pas fiables, un paquet peut être corrompu : il faut pouvoir décoder le paquet suivant. J’ai simplement choisi de tester les 10 nombres successifs en cas d’erreurs, avant d’échouer.
Durée de session
Une session doit être limitée en temps ou en quantité d’informations transmises. Il faut trouver un événement symétrique des 2 côtés pour redéclencher un handshake. J’ai laissé ce point à l’application. Cela pourrait être inclus dans le protocole réseau de plus haut niveau.
Envoi d’un seul message
Ce schéma ne couvre pas le cas d’envoi d’un seul message.
Dans l’Internet des objets, on pousse un message dans MQTT et on ne s’attend pas à une réponse. Cela serait bien plus pratique de pouvoir le faire. Il faut pouvoir faire l’envoi sans handshake préalable. Mais il faut tout de même envoyer les clefs publiques, ce qui prend de la place.
Le système a besoin de la clef publique du serveur et du PSK, et tout le reste est fourni en plus du chiffré (NONCE, clef publique, et clef publique éphémère) dans le message envoyé.
La différence est qu’il n’y a que 2 DH, et pas de clef éphémère du côté serveur.
Travail en cours
C’est encore un travail en cours. Il manque des tests sur le terrain et l’évaluation des performances sur plusieurs plateformes.
Connexion
