---
# System prepended metadata

title: Sécurité matériel - TP

---

# Sécurité matériel - TP

## Desciption de l'infra
Durant l'ensemble de ces TP, nous travaillerons avec la même infrastructure.

Tout d'abord, nous utiliserons un **Arduino**. Celui-ci nous permettra d'exécuter du code que nous analyserons par la suite.

Une fois le code executer sur notre Arduino, nous allons nous servir d'une sonde nous permettant de capter le bruit créés par le processeur de l'Arduino. Cette sonde sera, tout d'abord, relié à un **Preamplifier PA 303** permettant d'amplifier les ondes. Ensuite, celui-ci est branché au port B de notre oscilloscope de la marque **Picoscope 3206D** qui lui même est branché sur notre PC. Ceci permettra d'afficher le retour sur notre PC via le logiciel **Picoscope** associé. Ensuite, la **PIN 8** et **GNR** sont reliée au port **A** de notre oscilloscope pour afficher les périodes du signal.

![](https://i.imgur.com/kk9NhS1.png)

## Exercice 1
Pour ce premier exercice, nous avons exécuté le code suivant sur notre Arduino.

```c=
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <avr/io.h>
#include <util/delay.h>

#define LED            5
#define TRIGGER     0    
#define TX          1

#define nop __asm__ __volatile__ ("nop\n\t")
#define nop10 nop; nop; nop; nop; nop; nop; nop; nop; nop; nop;

#define N 8

unsigned int secret[N] = {0, 1, 1, 0, 1, 0, 0, 1};

void setup() {
    DDRB =0xFF;
    PORTB = 0x00;
}

int main(void)
{
   unsigned char i; 
   setup();
   while (1)
   {
      PORTB = PORTB ^ (1<< TRIGGER); 
      for (i=0 ; i<N ; i++)
      {
         PORTB = PORTB ^ (1<< TX); 
         PORTB = PORTB ^ (1<< TX); 
         nop10;
         if (secret[i] == 1)
         {
            nop10;
         }
      }
      PORTB = PORTB ^ (1<< TRIGGER); 
      nop10;
    }
    return(0);
}
```

Le code le plus important à analyser se trouve entre le **TRIGGER** c'est à dire entre la ligne `PORTB = PORTB ^ (1<< TRIGGER);` et `PORTB = PORTB ^ (1<< TRIGGER);`

Ici, le programme prend un secret. Celui-ci est `0 1 1 0 1 0 0 1`. Il prend chaque élément et exécute la tâche suivante:

- Pour chaque bit **`0`** de notre secret, **un seul** `nop10` est envoyé.
- Pour chaque bit **`1`** de notre secret, **deux** `nop10` sont envoyés.

Notre but sera de découvrir le secret via notre sonde en analysant le signal perçu.

<br>

Pour commencer, nous pouvons déduire du programme une information très importante. Le signal correspondant à un `1` sera forcément **plus long** que pour les `0`. En effet, un bit à `1` enverra deux `nop10`.

Si l'on utilise notre sonde pour capter les signaux émit par notre Arduino, nous obtenons ceci pour une période:

![](https://i.imgur.com/wMyYUdh.png)

Si nous regardons d'un peu plus près, nous pouvons nous apercevoir que la distance entre chaque pics n'est pas la même. Nous pouvons ressortir deux distances différentes. *(Ces distances correspondent à un temps plus ou moins long)*.

Le temps d'émission du bit à `0` est d'environ **1,884us**:
![](https://i.imgur.com/hsQt5gv.png)

Le temps d'émission du bit à `1` est, quant à lui, d'environ **2,442us** 
![](https://i.imgur.com/iHJW28q.png)

Nous observons donc bien que les temps sont différents. Grâce à ceci et en ayant le code en tête, nous pouvons faire la correspondance entre un bit à `0` ou à `1`. En effet, un bit à `0` prendra moins de temps à être émis puisqu'un bit à `1` émet un `nop10` supplémentaire.

![](https://i.imgur.com/j0fBhq9.png)

De ce fait, nous pouvons maintenant écrire un code qui récupèrera le secret automatiquement.

Pour ce faire, nous avons tout d'abord récupéré les **traces** de ce signal, c'est à dire les informations de chaque point.

En voici un court extrait:
```
Temps	Canal A	Canal B
(us)	(V)	(mV)

-10.00257113	5.14456200	15.42507000
-10.00057113	5.14456200	3.42642700
-9.99857113	5.14456200	6.85593000
-9.99657113	5.14456200	5.99778500
-9.99457113	5.14456200	4.28457200
-9.99257113	5.14456200	0.00000000
-9.99057113	5.14456200	-3.42642700
-9.98857113	5.14456200	-2.56828200
-9.98657113	5.14456200	-5.13964000
     ...             ...            ...
```

Le signal est maintenant sauvegardé. Nous pouvons l'analyser facilement et efficacement.

La librairie **Numpy** associé à **Panda** nous sera utile pour proceder à l'analyse de ce dataset.

Le code suivant nous permet de séparer le **canal A** du **canal B**:

```python=
import numpy as np
import pandas as pd
%matplotlib inline
import matplotlib.pyplot as plt

d1 = pd.read_csv("./trace.txt", delimiter='\t')

fig= plt.figure(figsize=(20,7))
plt.plot(d1['Temps'], d1['Canal A'])
plt.xlabel('time') 
plt.ylabel('V') 

fig= plt.figure(figsize=(20,7))
plt.plot(d1['Temps'], d1['Canal B'])
plt.xlabel('time') 
plt.ylabel('mV') 
```
![](https://i.imgur.com/HJVyGeU.png)

![](https://i.imgur.com/vYodaXv.png)

Nous pouvons retrouver les même déductions que précédemment.

![](https://i.imgur.com/ApbIHL5.png)

Voici le code utilisé pour extraire le secret (Des commentaires sont disponibles pour comprendre plus facilement le code):

```python=
import pandas as pd

#Prend en input le chemin du fichier contenant les traces
dataAllFrames = pd.read_csv('trace.txt', delimiter='\t')

#45 est la valeur jugée visuellement comme assez haute pour distinguer un "pic" important
dataFramesFilter = dataAllFrames[dataAllFrames["Canal B"] > 45] 

#Transforme l'objet panda dataFrame en List pour faciliter la manipualtion
listFilter = dataFramesFilter.to_dict('records') 

#List qui va contenir les pics significatifs dont l'écart est séparé par un laps de temps supérieur à 0.5 xEchelle secondes
listFilterUnique=[]

i = 0
while (i < len(listFilter)-1): 
    if ( abs( listFilter[i]["Temps"] - listFilter[i+1]["Temps"] ) > 0.5  ):
        listFilterUnique.append(listFilter[i])
        i=i+1
        if (i >= len(listFilter)-1) :
            listFilterUnique.append(listFilter[i])
        continue
    i=i+1

#Liste qui va contenir l'écart en xEchelle secondes entre 2 pics 
listGapSecond = []

for i in range (len(listFilterUnique)-1) :
    listGapSecond.append(abs( listFilterUnique[i]["Temps"] - listFilterUnique[i+1]["Temps"] ))

#Moyenne des écarts précédemment calculés
average = sum(listGapSecond)/len(listGapSecond)

#Va contenir le code secret 
secretCodeCalc = []

#Si laps de temps sup à la moyenne alors ca equivaut à 0 sinon 1
for i in range (len(listGapSecond)) : 
    if (listGapSecond[i] >= average ) :
        secretCodeCalc.append(0)
    else : 
        secretCodeCalc.append(1)
       
print(secretCodeCalc)
```

En l'exécutant, nous retrouvons bien notre secret `[0, 1, 1, 0, 1, 0, 0, 1]`.



## Exercice 2
Pour ce second exercice, examinons le code exécuté sur notre Arduino.

```c=
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <avr/io.h>

#define TRIGGER     0   

#define nop __asm__ __volatile__ ("nop\n\t")
#define nop10 nop; nop; nop; nop; nop; nop; nop; nop; nop; nop;
#define nop5 nop; nop; nop; nop; nop;


#define mul1 __asm__ __volatile__ ("mul r20, r21\n\t")
#define mul2 __asm__ __volatile__ ("mul r17, r18\n\t")
#define mul5 mul1; mul2; mul1; mul2; mul1;


void setup() {
    DDRB =0xFF;
    PORTB = 0x00;
}

int main(void)
{
    setup();
    while (1)
    {
        PORTB = PORTB ^ (1<< TRIGGER); 

        mul5; nop5; mul5; nop5; mul5; nop5; mul5;

        PORTB = PORTB ^ (1<< TRIGGER);
        nop10;
    }
    return(0);
}
```

Comme précédemment, le code réellement utile est celui entre le TRIGGER.

Ici, nous avons une alternance entre l'envoie d'un `mul5` puis d'un `nop5` ainsi que l'ajout d'un `nop10` pour finir la série. *(Finalement, nous avons au total, pour une période, 4 `mul5`, 3 `nop5` et 1 `nop10`)*

Nous retrouvons, grâce à notre sonde, le signal suivant:

![](https://i.imgur.com/99iG4cH.png)

Si nous l'analysons, nous pouvons retrouver un pattern bien précis pour chaque opération.

Pour la **muliplication**, nous avons la succession **d'un grand pic** puis **trois petits pics**.
Pour le **nop**, nous avons **un grand pic** et **un petit pic**.

![](https://i.imgur.com/apcdC06.png)

Voici le même signal, mais cette fois-ci analysé:

![](https://i.imgur.com/fJzVbTU.png)

Nous visualisons bien les deux opérations, `nop5` et `mul5` qui ont été réalisés par notre Arduino.

Si nous n'avions pas le code exécuté par notre Arduino, nous n'aurions pas pu savoir quelle pattern correspondaient à tel opération. En revanche, il existe une méthode pour retrouver cette correspondance.

Tout d'abord, nous savons que la fréquence de notre Arduino est de **16Mhz**. De ce fait, le temps d'un cycle est de: $${1 \over 16*10^6} = 62,5ns$$

Ensuite, nous savons qu'un `nop` dure **un seul cycle** alors qu'un `mul` dure **deux cycles.**

| ![](https://i.imgur.com/lxwnIWR.png) | 
|:--:| 
| *Durée d'un `nop` -> 62,5ns* |

| ![](https://i.imgur.com/KqSIap9.png) | 
|:--:| 
| *Durée d'un `mul` -> 130ns* |

Ainsi, grâce à cette technique, nous avons pu différencier un `nop` d'un `mul`.

## Exercice 3

Commençons par analyser le code exécuté sur notre Arduino.

```c=
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <avr/io.h>

#define TRIGGER     0   

#define nop __asm__ __volatile__ ("nop\n\t")
#define nop10 nop; nop; nop; nop; nop; nop; nop; nop; nop; nop;

#define mul3 __asm__ __volatile__ ("mul r20, r21\n\t")
#define mul4 __asm__ __volatile__ ("mul r0, r20 \n\t")

#define zeror0 __asm__ __volatile__ ("eor r0, r0 \n\t")

#define mul13 mul3; mul3; mul3; mul3; mul3; mul3; mul3; mul3; mul3; mul3;
#define mul14 mul4; mul4; mul4; mul4; mul4; mul4; mul4; mul4; mul4; mul4;

void setup() {
    DDRB =0xFF;
    PORTB = 0x00;
}



int main(void)
{
    setup();
    while (1)
    {
       zeror0;
       PORTB = PORTB ^ (1<< TRIGGER); 

       nop10;nop10;
       mul13;mul13;mul13;
       mul14;mul14;mul14;

       PORTB = PORTB ^ (1<< TRIGGER);
       nop10;
    }
    return(0);
}
```

Nous avons, ici deux opérations différentes qui sont exécutés. Nous avons un`mul13` *(composé de 10 opérations `mul3`)*, considéré comme une opération complexe, et un `mul14` *(composé de 10 opérations `mul4`)*, considéré comme une opération simple.. Ces deux opérations sont similaires et il est impossible de les différencier avec la méthode de l'exercice 2. 

Nous pouvons afficher **une seule courbe**.

![](https://i.imgur.com/eQLu7VW.png)

Sans surpise, nous ne voyons aucune différence. *(Les deux grands pics représentent le trigger)*.

Pour pouvoir différencier les deux opérations, nous allons simplement capturer une nombre *n* de courbe puis réaliser une **moyenne** entre chaque point. De ce fait, une pattern ressortira du résultat.

Si nous montons jusqu'à **300 courbes** superposées, nous pouvons visualiser un pattern pour chaque opération.

![](https://i.imgur.com/WSFcnFt.png)

- **nop10** : Plus resserré, moins d'instruction en moins de temps
- **mul13** : Structure irrégulière , chaotique (Nous avons plus de changement de valeur)
- **mul14** : Structure régulière, moins d’activité

**Pourquoi avons-nous cette irrégularité ?** 

Regardons comment sont définis les opérations `mul13` et `mul14`.

```c=
#define mul3 __asm__ __volatile__ ("mul r20, r21\n\t")
#define mul4 __asm__ __volatile__ ("mul r0, r20 \n\t")
```

Nous pouvons voir que l'opération `mul3` *(composant `mul13`)* est définie par des valeurs aléatoires. Nous avons, ici, une multiplication **complexe**. A l'inverse, `mul4` est définie en utilisant le registre `r0`. Ce registre ne ressortira uniquement des bits à `0`. De ce fait, manipuler des bits aléatoires a plus d'impact niveau consommation que manipuler des bits à `0`, d'où cet effet chaotique.

**Grâce à cette technique, nous avons pu différencier deux opérations qui sont, à première vue, très similaires.**

## Exercice 4

Nous allons tenter, via cet exercice, de mettre en évidence une corrélation entre la **consommation électrique** et le **poids de Hamming**.

Pour ce faire, nous allons lancer **9 mesures**. Chacune aura un poids de Hamming différents. Ajouté à cela, nous utiliseront la méthode de l'exercice 3 pour obtenir un résultat exploitable sur chaque mesure. C'est à dire que nous allons faire une moyenne de près de **5000 échantillons** pour obtenir un résultat exploitable.

Nous pouvons donc afficher ces 9 courbes avec le programme suivant:

```python=
min = 0
max = -1
# create a new plot with default tools, using figure
p = figure(plot_width=1500, plot_height=800, title="My Line Plot")

p.line(timings[min:max], xb0[min:max], line_color="Chartreuse", line_width=0.5)
p.line(timings[min:max], xb1[min:max], line_color="Gold", line_width=0.5)
p.line(timings[min:max], xb2[min:max], line_color="Fuchsia", line_width=0.5)
p.line(timings[min:max], xb3[min:max], line_color="Cyan", line_width=0.5)
p.line(timings[min:max], xb4[min:max], line_color="red", line_width=0.5)
p.line(timings[min:max], xb5[min:max], line_color="DarkViolet", line_width=0.5)
p.line(timings[min:max], xb6[min:max], line_color="Blue", line_width=0.5)
p.line(timings[min:max], xb7[min:max], line_color="Silver", line_width=0.5)
p.line(timings[min:max], xb8[min:max], line_color="Black", line_width=0.5)
show(p)
```
![](https://i.imgur.com/K887Oqd.png)

Dès à présent, nous cherchons un point dans le temps où nos 9 courbes sont **corrélé au poids de Hamming**. Nous cherchons donc une proportionnalité entre les différentes **distances de Hamming** *(et non pas au poids de Hamming)*. 

Pour rendre la tâche plus facile, nous allons réaliser un script python pour analyser ces 9 courbes et trouver les points dans le temps où nous avons cette proportionnalité.

Voici le script:

```python=
lst = []
for i in range(len(xb0)):
    if xb0[i] < xb1[i] and xb1[i] < xb2[i] and xb2[i] < xb3[i] and xb3[i] < xb4[i] and xb4[i] < xb5[i] and xb5[i] < xb6[i] and xb6[i] < xb7[i] and  xb7[i] < xb8[i]:
        lst.append(i)

for i in range(len(xb0)):
    if xb0[i] > xb1[i] and xb1[i] > xb2[i] and xb2[i] > xb3[i] and xb3[i] > xb4[i] and xb4[i] > xb5[i] and xb5[i] > xb6[i] and xb6[i] > xb7[i] and xb7[i] > xb8[i]:
        lst.append(i)
        
print(lst)
```
```python=
[4062, 4282, 4344, 4376, 4377, 4439, 4462, 4813, 4970, 4383, 4539]
```

Ainsi, nous trouvons **11 points** où cette proportionnalité est présente. Voici à quoi ressemble les courbes à ce point:

| ![](https://i.imgur.com/FdUtkEC.png) | 
|:--:| 
| *Au point 4970* |


| ![](https://i.imgur.com/pB54m5W.png) | 
|:--:| 
| *Au point 4539* |


Ainsi, à ces points là, nous avons une **fuite de donnée**. Nous pouvons donc nous servir de ces fuites de donnée en appliquant un simple XOR avec la sbox de l’entrée pour **remonter à la clé.** 

Finallement, nous avons pu, ici, utiliser le **rayonnement électromagnétique, la consommation électrique et le poids / distance de Hamming pour retrouver la clé utilisée**.