lord-feistel/power_analysisPreuve de concept démontrant une attaque par canal auxiliaire d'analyse de puissance contre une implémentation RSA vulnérable sur Arduino (Atmega328P), avec une configuration matérielle détaillée et une méthodologie de mesure.
Récemment, j'ai observé des personnes implémentant elles-mêmes la cryptographie pour Arduino, comme dans ce sujet sur stackoverflow :
https://stackoverflow.com/questions/39189065/rsa-encryption-decryption-functions-for-arduino
Plusieurs d'entre eux peuvent être trouvés sur Internet, certains se trouvent d'ailleurs dans des bibliothèques bien connues.
J'ai décidé de réaliser cette petite POC (Preuve de concept) pour montrer pourquoi il est important non seulement de ne pas inventer son propre algorithme cryptographique, mais aussi d'utiliser une implémentation robuste de tels algorithmes.
Cette POC effectue une attaque par canal auxiliaire (attaque par analyse de puissance) contre une mauvaise implémentation d'une routine auxiliaire utilisée dans l'implémentation RSA (exponentiation rapide).
Une attaque par canal auxiliaire est une méthode visant à compromettre un système cryptographique en exploitant des fuites d'informations indirectes plutôt qu'en attaquant directement l'algorithme ou le protocole cryptographique lui-même.
Ce type de fuite peut provenir de diverses sources telles que les informations temporelles, la consommation électrique, les émissions électromagnétiques, ou même le son.
De telles attaques peuvent être très efficaces pour compromettre des systèmes cryptographiques comme RSA sans obliger l'attaquant à résoudre les problèmes mathématiques sous-jacents qui assurent la sécurité du système cryptographique (Kocher, Jaffe, & Jun, 1999).
Cet article réalisera une attaque par analyse de puissance sur une vulnérabilité bien connue dans une implémentation de l'algorithme RSA dans un firmware pour Arduino (Atmega328P).
Remarque : Je l'ai fait rapidement, veuillez m'excuser pour les fautes d'orthographe / de grammaire que vous trouverez éventuellement.
Les attaques par analyse de puissance consistent à mesurer la consommation électrique d'un appareil lors d'opérations cryptographiques.
L'analyse différentielle de puissance (DPA) implique une analyse statistique des schémas de consommation électrique sur plusieurs opérations cryptographiques pour extraire des secrets, ce qui la rend plus sophistiquée que l'analyse simple de puissance (SPA), qui corrèle directement les fluctuations de puissance avec des opérations cryptographiques spécifiques pour déduire des secrets.
L'analyse différentielle de puissance (DPA) et l'analyse simple de puissance (SPA) peuvent être utilisées pour extraire des clés privées en analysant les schémas de consommation électrique lors des calculs RSA.
Ces attaques peuvent révéler la clé privée en identifiant des schémas distincts d'utilisation de la puissance associés à différents bits de la clé (Kocher, Jaffe, & Jun, 1999).
RSA (Rivest-Shamir-Adleman) est un algorithme de chiffrement à clé publique largement utilisé, nommé d'après ses inventeurs : Ron Rivest, Adi Shamir et Leonard Adleman, qui l'ont introduit en 1977 (Paar & Pelzl, 2010).
Il reste l'une des méthodes les plus sécurisées pour transmettre des données de manière sécurisée sur Internet.
L'un des fondements de la sécurité de RSA réside dans la difficulté de factoriser de grands nombres composés en leurs facteurs premiers (Menezes, van Oorschot, & Vanstone, 1996).
Ce problème, connu sous le nom de problème de factorisation, consiste à trouver les nombres premiers qui se multiplient pour former un grand nombre donné.
Le chiffrement RSA repose sur l'hypothèse que ce problème de factorisation est suffisamment difficile sur le plan computationnel pour qu'il soit irréaliste de briser le chiffrement en factorisant le module en ses facteurs premiers (Menezes, van Oorschot, & Vanstone, 1996).
La Figure 1 illustre le processus de chiffrement et de déchiffrement RSA à l'aide d'un exemple simple.
Figure 1 - Exemple RSA.
Veuillez noter que dans ce cas, 3 et 33 sont publics. Le nombre 7 dans l'exemple est la clé privée.
La fonction Phi (N), fonction indicatrice d'Euler, calcule tous les nombres premiers entre eux dans l'intervalle de 1 à 33.
La valeur 33 est obtenue par la multiplication de P et Q ; dans ce cas, 11 multiplié par 3.
Le résultat de la fonction Phi est obtenu en multipliant (P - 1) par (Q - 1) ; dans ce cas, 10 multiplié par 2.
L'opération e<sup>-1</sup> mod 20 désigne l'opération d'inverse modulaire (Menezes, van Oorschot, & Vanstone, 1996).
Remarque : Si vous souhaitez approfondir RSA, ce qui n'est pas nécessaire pour comprendre cet article. Il y a une introduction rapide à ces opérations de base de théorie des nombres dans ce dépôt, dans le fichier number_theory.md. L'explication peut améliorer votre compréhension des opérations RSA.
L'expérience a utilisé un oscilloscope DS1102 (présenté dans la Figure 2) fabriqué par Rigol.
Le manuel de l'oscilloscope peut être trouvé dans les références (RIGOL Technologies, Inc., 2017).
Une alimentation générique a également été utilisée (présentée dans la Figure 3).
Figure 2 - Oscilloscope utilisé dans l'expérience.
Figure 3 - Alimentation utilisée dans l'expérience.
La loi d'Ohm est un principe fondamental dans le domaine du génie électrique et de la physique.
Elle stipule que le courant traversant un conducteur entre deux points est directement proportionnel à la tension entre ces deux points et inversement proportionnel à la résistance entre eux (Boylestad, 2015).
La Figure 4 montre un circuit et la loi d'Ohm.
Figure 4 - Illustration de la loi d'Ohm.
La loi d'Ohm implique que si vous augmentez la tension aux bornes d'un conducteur, le courant augmentera également, à condition que la résistance reste constante (Johnson & Hilburn, 2013). La Figure 5 présente un exemple d'application de la loi d'Ohm dont l'objectif est de trouver le courant dans le circuit.
Figure 5 - Exemple de la loi d'Ohm.
La loi des tensions de Kirchhoff (LTK) est un principe fondamental en génie électrique et en physique (Boylestad, 2015).
Elle stipule que la somme de toutes les différences de potentiel électrique (tensions) autour de tout réseau ou boucle fermée est nulle (Boylestad, 2015).
La Figure 6 illustre la loi des tensions de Kirchhoff.
Figure 6 - Illustration de la loi de Kirchhoff.
Un exemple d'application de la loi de Kirchhoff est présenté dans la Figure 7 afin de trouver le courant traversant les résistances R1 et R2.
Figure 7 - Exemple de la loi de Kirchhoff.
Le diviseur de tension est une conséquence de la loi des tensions de Kirchhoff (LTK) et énonce une façon de calculer la Vout, qui est la tension entre la résistance R1 et R2.
La formule du diviseur de tension est présentée dans la Figure 8.
Un exemple d'application du diviseur de tension est présenté dans la Figure 9.
Figure 8 - Illustration du diviseur de tension.
Figure 9 - Exemple de diviseur de tension.
Une résistance shunt est une résistance de faible valeur placée en série avec l'alimentation du circuit pour mesurer le courant traversant le circuit.
L'utilisation d'une résistance shunt pour mesurer le courant est l'une des techniques utilisées dans les multimètres modernes (Boylestad, 2015).
En mesurant la chute de tension aux bornes de la résistance shunt et en connaissant sa résistance, on obtient suffisamment d'informations pour calculer le courant à l'aide de la loi d'Ohm.
Pour mesurer la consommation électrique d'un appareil Arduino, il est nécessaire de placer une résistance shunt en série avec le VCC (positif).
La façon dont elle sera connectée est présentée dans la Figure 10.
Remarque 1 : Veuillez noter que dans la POC, au lieu d'utiliser la carte Arduino Uno comme cible, le microcontrôleur (atmega328p) est transféré sur une plaque d'essai séparée comme présenté dans la Figure 11. Cela permet de manipuler plus facilement le brochage du microcontrôleur sans nécessiter de soudure.
Remarque 2 : Si vous ne savez pas comment faire, mon précédent article montrant le fonctionnement du glitch explique comment procéder et peut être trouvé à l'adresse https://github.com/lord-feistel/hardware_hacking_lab)
Figure 10 - Résistance shunt avec Arduino.
Figure 11 - Circuit de la résistance shunt sur la plaque d'essai.
Pour démontrer la mesure de la consommation électrique à l'aide d'une résistance shunt, une LED (Sedra & Smith, 2014) sera connectée à la GPIO du microcontrôleur (Figure 12) et l'oscilloscope sera utilisé pour observer comment cela affecte la consommation électrique aux bornes de la résistance shunt dans les situations où la LED est allumée ou éteinte.
Remarque : Pour extraire la clé ou observer l'effet de charge sur la consommation électrique, il n'est pas nécessaire d'utiliser la loi d'Ohm pour obtenir le courant, seule la chute de tension suffit (Johnson & Hilburn, 2013).
Figure 12 - Mesure de puissance.
Pour mieux l'observer, veuillez consulter la Vidéo 1 qui montre la chute de tension lorsque la LED est allumée.
Vidéo 1 - Chute de tension due à la consommation de la LED.
Le code suivant a été utilisé pour faire clignoter la LED. Il peut également être trouvé dans ce dépôt.```C const int PIN_CHARGE = 9 ; void setup() { pinMode(PIN_CHARGE, OUTPUT);
}
void loop() {
digitalWrite(PIN_CHARGE, HIGH);
delay(10);
digitalWrite(PIN_CHARGE, LOW);
delay(10);
}
Il est important de noter que cette chute de tension se produit également lors d'un calcul complexe (Kocher, Jaffe, & Jun, 1999).
Le code suivant provoque la chute de tension présentée dans la **Figure 13**```C
void setup() {
}
void loop() {
volatile unsigned long i = 0;
i = ((i + 1) * (i - 1) + (i * i) - (i / 2) * (i % 3) + (i * i * i * i)) * ((i + 2) * (i - 2) + (i * i) - (i / 3) * (i % 5) + (i * i * i * i));
delayMicroseconds(100);
}
Si la chute de tension reflète le calcul, elle peut donc être utilisée pour déterminer les données en cours de traitement.
Figure 13 - Consommation d'énergie lors du calcul lourd.
La manière conventionnelle d'effectuer l'opération de puissance est de multiplier la base n fois.
Supposons que 23 donne 2*2*2 puisque 2 est la base et 3 est n.
Cela fonctionne très bien, mais pas assez efficacement pour rendre RSA réalisable.
Pour parvenir à une telle implémentation, on utilise l'algorithme d'exponentiation rapide.
L'exponentiation rapide, également connue sous le nom d'exponentiation par carrés, est une méthode efficace pour élever un nombre à une puissance.
Le pseudo-code suivant pour l'exponentiation rapide peut être trouvé.```C
function fast_exponentiation(a, b): result = 1 base = a exponent = b
while exponent > 0:
if (exponent % 2 == 1): // If exponent is odd
result = result * base
base = base * base // Square the base
exponent = exponent // 2 // Divide exponent by 2
return result
.
Les étapes de l'exponentiation rapide de 2<sup>4</sup> se trouvent dans le **Tableau 1**
| Itération | Valeur de base | Exposant en binaire | Opération | Résultat |
|-----------|----------------|---------------------|-----------|-------------------------|
| Initial | 2 | 100 | Départ | 1 |
| 1 | 4 | 010 | Carré | 1 |
| 2 | 16 | 001 | Carré | 1 |
| 3 | 256 | 000 | Multiplication | 16 |
| Final | - | - | Fin | 16 |
**Tableau 1** - Itérations de l'exponentiation rapide de 2<sup>4</sup>.
Le processus est expliqué comme suit :```
- **Initialization:**
Start with base = 2 , exponent = 4 ( binary 100) , result = 1.
- **Iteration 1:** exponent = 4 (binary 100, even)
Square base to get 4 .
result remains 1.
- **Iteration 2:** exponent = 2 (binary 010, even)
Square base to get 16 .
result remains 1.
- **Iteration 3:** exponent = 1 (binary: 001, odd)
Multiply result by a = 16 to get 16.
result becomes 16.
- **Final:** n = 0 (binary: 000)
The loop ends with result = 16.
Notez que pour les petits nombres, rien ne change ou cela empire, mais pour les grands nombres, cela permet d'obtenir un gain significatif en efficacité.
Cela réduit le nombre d'opérations multiplicatives par rapport à l'approche naïve, ce qui est particulièrement utile pour les grands exposants.
Tableau 2 montre une comparaison des itérations pour un tel nombre utilisant l'exponentiation naïve et l'exponentiation rapide.
L'exponentiation rapide est cruciale dans RSA pour les processus de chiffrement et de déchiffrement, car ces processus impliquent d'élever de grands nombres à de grandes puissances modulo un autre grand nombre (Paar & Pelzl, 2010).
Comme présenté dans la section Exemple RSA, la clé est l'exposant et il s'agira généralement d'un très grand nombre.
Tableau 2 - Comparaison de l'efficacité entre l'exponentiation conventionnelle et l'exponentiation rapide.
Une exponentiation rapide a été implémentée dans l'Arduino et téléversée dans l'Atmega328P. Comme il s'agit d'une PoC, nous l'avons implémentée de la manière la plus simple à visualiser.
Par exemple, on utilise généralement une opération de décalage sur une variable entière, mais nous avons implémenté l'exposant sous forme de tableau pour être mieux compris.
Notez que l'exposant représentant la clé est le tableau {0, 1, 0, 1, 0, 1, 0, 1} qui créera un motif dans la mesure acquise par l'oscilloscope comme preuve de son fonctionnement.```C
#include <Arduino.h>
volatile long long dumb_vulnerableExponentiation(volatile long long base, const volatile int* exponentArray, volatile int arrayLength, volatile long long modulo) { volatile long long result = 1; base %= modulo;
for (volatile int i = 0; i < arrayLength; ++i) {
result = (result * result) % modulo;
if (exponentArray[i] == 1) {
result = (result * base) % modulo;
}
}
return result;
}
void setup() { }
void loop() { volatile long long base = 3; volatile long long modulo = 1000000007; const volatile int exponentArray[] = {0, 1, 0, 1, 0, 1, 0, 1}; volatile int arrayLength = sizeof(exponentArray) / sizeof(exponentArray[0]); delay(2); volatile long long result = dumb_vulnerableExponentiation(base, exponentArray, arrayLength, modulo); }
### Résultats
Comme présenté au début, pour les opérations de chiffrement et de déchiffrement, la clé est l'exposant ; par conséquent, découvrir l'exposant expose la clé RSA.
En utilisant le matériel mentionné précédemment, il est possible de visualiser le spectre de la consommation électrique sur l'oscilloscope, comme présenté dans la **Figure 14** et la **Figure 15**.
Les périodes pendant lesquelles la tension chute pendant une longue période signifient que le bit `1` de la clé est en cours de traitement, sinon il s'agit du bit `0`.
Veuillez noter que lorsque l'exposant est pair, il y a une multiplication supplémentaire, ce qui prolonge la chute d'énergie, exposant ainsi des informations sur la clé.
**Vidéo 2** montre la capture de la clé. Pour comprendre comment régler la période et l'amplitude, veuillez vous référer au manuel de l'oscilloscope.
**Figure 14** - Capture de la clé
**Figure 15** - Mise en évidence des 0 et 1 de la clé à l'aide de l'oscilloscope
[](https://youtu.be/MBZ1abtTN_k)
**Vidéo 2** - Capture de la clé avec un oscilloscope.
Une telle attaque peut être utilisée dans un scénario où le microcontrôleur utilise une bibliothèque bien connue, mais où le firmware est verrouillé, empêchant l'attaquant d'obtenir directement la clé depuis la mémoire.
Ce type d'attaque peut également être utilisé contre du matériel.
### Conclusion
Implémenter son propre système de chiffrement RSA (Rivest-Shamir-Adleman) est fortement déconseillé pour plusieurs raisons critiques, en particulier la vulnérabilité à des attaques sophistiquées comme les attaques par analyse de puissance.
Le chiffrement RSA, bien que mathématiquement robuste lorsqu'il est correctement implémenté, nécessite une attention méticuleuse aux détails dans son implémentation pour garantir la sécurité.
Même des défauts ou omissions mineurs dans l'implémentation peuvent involontairement divulguer des informations sur la clé privée, compromettant ainsi toute la sécurité du système.
De plus, les bibliothèques cryptographiques établies et les cadres de travail subissent un examen rigoureux et des tests par la communauté de la sécurité, garantissant leur résistance aux attaques et vulnérabilités connues. L'utilisation de ces bibliothèques éprouvées permet non seulement d'économiser du temps et des efforts, mais réduit également considérablement le risque d'introduire involontairement des vulnérabilités dans le système.
### Références
1. Understanding Cryptography - Paar, C., & Pelzl, J. (2010). **Understanding Cryptography**. Springer.
2. Handbook of Applied Cryptography - Menezes, A. J., van Oorschot, P. C., & Vanstone, S. A. (1996). **Handbook of Applied Cryptography**. CRC Press.
3. Differential Power Analysis - Kocher, P., Jaffe, J., & Jun, B. (1999). **Differential Power Analysis**. Proceedings of CRYPTO '99, Lecture Notes in Computer Science, vol 1666. Springer, Berlin, Heidelberg. DOI: 10.1007/3-540-48405-1_25.
4. DS1102 Oscilloscope Datasheet - RIGOL Technologies, Inc. (2017). **DS1000E, DS1000D Series Digital Oscilloscope Datasheet**. Consulté sur [Fiche technique RIGOL](https://beyondmeasure.rigoltech.com/acton/attachment/1579/f-03b8/1/-/-/-/-/DS1000E_DS1000D_DataSheet_EN.pdf)
5. Introductory Circuit Analysis - Boylestad, R. L. (2015). **Introductory Circuit Analysis** (13e éd.). Pearson.
6. Fundamentals of Electrical Circuits - Johnson, D., & Hilburn, J. L. (2013). **Fundamentals of Electrical Circuits**. McGraw-Hill Education.
7. Microelectronic Circuits - Sedra, A. S., & Smith, K. C. (2014). **Microelectronic Circuits** (7e éd.). Oxford University Press.
| Exponent (b) | Binary (b) | Conventional Exponentiation Operations | Fast Exponentiation Operations |
|---|
| 1 | 1 | 1 | 1 |
| 2 | 10 | 1 | 1 |
| 4 | 100 | 3 | 2 |
| 8 | 1000 | 7 | 3 |
| 16 | 10000 | 15 | 4 |
| 32 | 100000 | 31 | 5 |
| 64 | 1000000 | 63 | 6 |
| 128 | 10000000 | 127 | 7 |
| 256 | 100000000 | 255 | 8 |
| 512 | 1000000000 | 511 | 9 |
| 1024 | 10000000000 | 1023 | 10 |