Attaques temporelles dans le code applicatif

L'opérateur standard d'égalité des chaînes dans la plupart des langages de programmation s'arrête dès qu'une différence est trouvée. L'opérateur == de Python sur les objets bytes, strcmp de C et String.equals de Java retournent tous immédiatement dès qu'ils trouvent le premier octet différent. Pour une comparaison normale de chaînes, il s'agit d'une optimisation, mais pour comparer des valeurs secrètes comme des balises MAC ou des mots de passe, cela crée un canal auxiliaire temporel mesurable qui divulgue des informations.

Un attaquant mesure le temps nécessaire pour comparer une balise HMAC soumise à la valeur correcte. Soumettre une balise HMAC dont le premier octet est correct prend légèrement plus de temps que soumettre une balise dont le premier octet est incorrect (une comparaison d’octet supplémentaire). En soumettant de nombreuses valeurs avec chacun des premiers octets possibles et en mesurant les temps de réponse, l’attaquant identifie le premier octet correct. Le processus se répète octet par octet jusqu’à récupérer la balise complète.

Les attaques temporelles modernes sur les réseaux peuvent distinguer des différences de temps de quelques dizaines à quelques centaines de nanosecondes sur Internet. Une comparaison HMAC de 32 octets, où chaque octet correct ajoute environ 10 à 100 ns au temps de traitement, fournit un signal mesurable après suffisamment de mesures répétées pour faire la moyenne des fluctuations du réseau. Dans un réseau local, même des différences d’une seule nanoseconde peuvent être exploitées avec un échantillonnage statistique suffisant.

Dans Python, comparer des balises MAC avec == n’est pas sûr : si mac == submitted_mac, la valeur True ou False dépend de la position de la première différence. Un attaquant qui soumet des milliers de balises conçues à cet effet et mesure les temps de réponse peut retrouver la balise attendue octet par octet. Cette vulnérabilité est apparue dans des applications web en production qui implémentaient incorrectement la comparaison de jetons de session ou de clés d’API sans fonctions à temps constant.

La fonction Python hmac.compare_digest(a, b) compare deux valeurs d’octets ou de chaînes en temps constant : elle prend le même temps, quelle que soit la position de la première différence. Elle est implémentée en C afin de garantir un comportement à temps constant, même avec la surcharge liée à l’interprétation du code-octet Python. Utilisez toujours hmac.compare_digest pour comparer des balises MAC, des jetons de session, des clés d’API ou toute valeur dont la divulgation d’informations temporelles serait dangereuse.

OpenSSL fournit CRYPTO_memcmp(a, b, length) pour effectuer une comparaison de mémoire à temps constant. Contrairement à memcmp, cette fonction traite toujours tous les octets indiqués par length, même en cas de différence précoce. La valeur renvoyée est zéro si les valeurs sont égales et différente de zéro dans le cas contraire. Il est important de toujours comparer la longueur attendue complète : comparer des valeurs de longueurs différentes en utilisant la plus courte peut tout de même divulguer des informations sur la longueur. Utilisez CRYPTO_memcmp dans toute comparaison critique pour la sécurité en code C/C++ utilisant OpenSSL.

Les attaques temporelles vont au-delà de la comparaison de chaînes. L’attaque de Bleichenbacher menée en 2006 contre le déchiffrement RSA PKCS#1 v1.5 a démontré l’existence d’un oracle temporel pratique contre des implémentations SSL/TLS. Le temps d’exécution de l’opération avec la clé privée RSA variait selon que la valeur déchiffrée possédait ou non un remplissage PKCS#1 valide. En soumettant des milliers de textes chiffrés forgés, les attaquants pouvaient retrouver des clés privées RSA. Cela a motivé RSA-OAEP et les implémentations RSA à temps constant.

Les implémentations d’AES utilisant des tables de consultation, courantes pour leurs performances, accèdent à des entrées différentes selon la clé et le texte en clair. Les accès réussis au cache et les défauts de cache créent des différences de temps mesurables, qui révèlent quelles entrées de table ont été consultées. Ce canal auxiliaire peut révéler les clés AES. La défense consiste à utiliser des implémentations d’AES qui ne reposent pas sur des tables de consultation, comme les instructions matérielles AES-NI ou les implémentations logicielles par tranches de bits.

Écrire du code à temps constant exige d’éviter : les branchements conditionnels fondés sur des données secrètes (utilisez une sélection sans branchement avec masquage), les schémas d’accès mémoire qui dépendent de données secrètes (évitez les tables de consultation indexées par des secrets) et toute opération dont la latence dépend de valeurs secrètes (par exemple, la division sur certains processeurs). Les compilateurs peuvent optimiser et supprimer les constructions à temps constant ; des accès mémoire en assembleur ou volatile peuvent donc être nécessaires dans les sections critiques.

La meilleure défense contre les attaques temporelles visant la comparaison de balises MAC consiste à utiliser des modes AEAD (GCM, ChaCha20-Poly1305) et à déléguer la vérification des balises MAC à la bibliothèque cryptographique. Les implémentations des bibliothèques effectuent en interne une vérification à temps constant. Si vous utilisez correctement AEAD (le déchiffrement échoue à la moindre modification et vous ne déchiffrez jamais avant d’avoir vérifié la balise), vous n’avez jamais besoin de comparer des balises MAC dans le code de l’application, ce qui élimine entièrement la vulnérabilité temporelle.

La détection des vulnérabilités temporelles exige une analyse statistique des distributions des temps de réponse. Des outils comme tlsfuzzer, des scripts de détection d’attaques temporelles et l’infrastructure dudect aident à détecter les différences de temps dans les implémentations cryptographiques. Une analyse t des échantillons de temps de réponse pour des entrées censées produire le même temps d’exécution peut révéler des différences statistiquement significatives. De faux négatifs sont possibles ; une revue du code à temps constant est également essentielle en complément de la vérification.

Quelle fonction Python faut-il utiliser pour comparer en toute sécurité une balise HMAC afin de prévenir les attaques temporelles ?

Récapitulatif d’une attaque temporelle : une comparaison de chaînes avec sortie anticipée divulgue des valeurs secrètes octet par octet par les différences de temps de réponse, qui sont mesurables sur un réseau avec suffisamment d’échantillons ; utilisez hmac.compare_digest en Python et CRYPTO_memcmp dans OpenSSL pour une comparaison à temps constant ; les attaques temporelles visant le remplissage RSA compromettent les clés privées (utilisez un RSA à temps constant et OAEP) ; les attaques temporelles des tables de consultation AES divulguent des bits de clé (utilisez AES-NI ou des implémentations par tranches de bits) ; enfin, la vérification par une bibliothèque AEAD élimine le besoin de comparer les balises MAC au niveau de l’application.