Attaque temporelle

Un article de Wikipédia, l'encyclopédie libre.
Aller à : navigation, rechercher

En cryptanalyse, une attaque temporelle consiste à estimer et analyser le temps mis pour effectuer certaines opérations cryptographiques dans le but de découvrir des informations secrètes. Certaines opérations peuvent prendre plus de temps que d'autres et l'étude de ces informations temporelles peut être précieuse pour le cryptanalyste. La mise en œuvre de ce genre d'attaque est intimement liée au matériel ou au logiciel attaqué.

Limitations[modifier | modifier le code]

Des attaques temporelles peuvent aussi se faire à distance, via un réseau. L'observation des délais dans un système est en général soumise à des perturbations aléatoires. Ceci est d'autant plus vrai que l'observation se fait via un réseau. La plupart des attaques temporelles demandent que l'adversaire connaisse les détails de l'implémentation. Cependant, ces attaques peuvent aussi servir à identifier les algorithmes employés et faire de l'ingénierie inverse.

Attaques sur la cryptographie asymétrique[modifier | modifier le code]

Les algorithmes d'exponentation modulaire sont coûteux, le temps d'exécution dépend linéairement du nombre de bits à '1' dans la clé. Si connaître le nombre de '1' n'est pas une information toujours suffisante pour trouver la clé, le recoupement statistique entre plusieurs chiffrements avec cette clé peut offrir de nouvelles possibilités au cryptanalyste.

Attaques sur un réseau[modifier | modifier le code]

En 2003, Boneh et Brumley ont démontré une attaque pratique contre des serveurs SSL. Leur cryptanalyse est basée sur des vulnérabilités découvertes dans les implémentations du théorème des restes chinois. L'attaque fut toutefois menée à travers un réseau de taille limitée mais elle montrait que ce type d'attaque était sérieuse et praticable en l'espace de quelques heures. Les implémentations furent améliorées pour limiter les corrélations entre la clé et le temps de chiffrement.

Attaque sur les chiffrements par bloc[modifier | modifier le code]

Les chiffrements par bloc sont en général moins sensibles aux attaques temporelles, la corrélation entre la clé et les opérations étant plus limitées, mais celles-ci existent quand même. La plupart reposent sur les temps mis pour accéder aux différentes tables (par exemple les S-Boxes).

En 2005, Daniel J. Bernstein a démontré qu'une attaque contre une implémentation vulnérable d'AES était possible à partir du cache des processeurs modernes des PC (AMD ou Intel)[1]. Bernstein reproche au NIST d'avoir négligé ces problèmes lors du concours AES, il ajoute que le NIST s'est trompé en partant du principe que le temps d'accès aux tables était constant.

Exemple d'attaque[modifier | modifier le code]

En 1996, Paul Kocher exhibe une faille dans une implémentation du calcul de l'exponentiation modulaire[2]. L'algorithme consiste à calculer mod , avec public, et obtenu par espionnage (ou une quelconque autre manière). Le but de l'attaquant est de trouver la valeur de (la clé secrète).

Pour que cette attaque se déroule correctement, la 'victime' doit calculer mod pour plusieurs valeurs de , où , et le temps de calcul (à un grain suffisamment fin) sont connus de l'attaquant.

Voici l'algorithme, avec le nombre de bits de longueur de .

Soit
Pour allant de à faire
Si le -ème bit de vaut 1
Alors mod
Sinon
mod
FinPour
Renvoyer ()

On remarque que selon la valeur du bit, on calcule soit mod soit rien (en fait, on effectue l'affectation , mais en termes de temps de calcul c'est négligeable). Donc si on peut observer suffisamment finement le temps d'exécution de l'algorithme, on peut déduire la valeur du bit en fonction du temps de calcul, et ainsi recouvrer totalement le secret en procédant par itération sur les bits de l'exposant.

Défense[modifier | modifier le code]

Cette attaque peut être contrée en modifiant l’implémentation pour que tous les calculs soient effectués d’office, quels que soient les bits de la clé :

Soit
Pour allant de à faire
Soit mod
Si le -ème bit de vaut 1
Alors
Sinon
mod
FinPour
Renvoyer ()

Cette fois-ci, le temps de calcul ne dépend aucunement de la valeur de la clé (seule la source de l’affectation à change), l’attaque temporelle devient donc impossible sur ce fragment de code. Cela rend certes plus long le temps de calcul total, mais, donc le contexte qui nous intéresse, l’impératif de sécurité est incommensurablement plus important que celui de vitesse.

Notes et références[modifier | modifier le code]

Annexes[modifier | modifier le code]

Bibliographie[modifier | modifier le code]

Liens externes[modifier | modifier le code]