# Cours A1

## Cours/TP 12/10

Injection de fautes, exploiter les failles.
Mecanismes cryptographiques, algo mathematiquement robustes. Quand on veut les implémenter, ils peuvent êtres soumis à différentes attaques.

Attaque par injection de code. (Injecter des données, qui peuvent correspondre à du code donné, exploitation de bug dans le code logiciel)
Attaque par canaux auxiliaires. (temps d'execution, consommation elec, connexion)

Raison d'optimisation (multiplication), multiplier par 0 -> pas de calcul, temps de calcul très long donc si secret = 0, temps de calcul court.
Attaque physique. (Ouvrir le circuit, sonder (microprobing) entre la mémoire et le processeur, FIB ?)

Certaines attaques nécessitent le composant physique, d'autres à distances (marron et bleu p4)
Tirs lasers pour modifier la mémoire, injecter des fautes.


p9. nécessite une précision en cycle processeur très grande. Il faut cibler une ou quelques cycles.
p10. Algo plus connus/utilisé.

Evaluation : QCM sur toutes les parties. (qu'est-ce qu'une attaque etc... Contres mesures et classification) Dans quel cas on utilise certaines contre mesure et dans cette attaque là quelle contre mesure utiliser ?

p12. CRC pour protéger les CSP (critical security parameters) pour éviter de changer les p,q qui sont premiers.

p14. On faute l'exposant d_i de proche en proche pour obtenir les m_i
p15. Contre mesure = rajouter un produit avec un nombre aléatoire (Stratégie Résilience)

Vérification de valeur -> Stratégie détection

p19. On déplace l'instant d'exécution de l'instruction sensible -> Observation de la consommation électrique
On peut rajouter des capteurs (lumière pour l'ouverture de la puce, f_clk pour le downclocking pour observer les signaux)

### TD

Q1 Donner l'équation de R_16 en fonction de R_15 et L_15
R_16 = L_15 ^ f(R_15,K_16) #f(.,.) p40
f(R_15,K_16) = P(S_1-8(E(R_15) ^ K_16))

Q2 Entrée R_15 fautée : R_15'
R_16' = L_15' ^ P(S_1-8(E(R_15') ^ K_16))

Q3 Delta(R_16) = R_16 ^ R_16'
= Delta(L_15) ^ P(a) ^ P(b)
= Delta(L_15) ^ P(S_1-8(E(R_15) ^ K_16) ^ S_1-8(E(R_15') ^ K_16))

Q4
Connues : R_16, R_15 = L_16 et R_15' = L_16'
Inconnues : Delta(L_15) et K_16

On veut Delta(L_15) = 0 donc ne pas toucher L_15 lors de la faute.

Q5
P⁻¹(Delta(R_16)) = S_1-8(E(R_15) ^ K_16) ^ S_1-8(E(R_15') ^ K_16)

On teste les clés K_16 pour avoir égalité des deux côtés, si elle c'est vérifié, la clé est une candidate.

Défi 4 :

Q1 
P⁻¹_1(Delta(R_16)) = S_1(E(R_15) ^ K_16,1) ^ S_1(E(R_15') ^ K_16,1)


## 19/10 Side-Channel Analysis

p9: ce qu'on attaque, c'est pas l'algo, c'est l'implémentation de celui-ci.

p10: 10000 essais en force brute, 40 avec canal auxiliaire en regardant le temps d'exécution et sa variation pour chaque digit.

p15: le pic de courant indique le nombre de portes logiques qui ont changé d'état

p58: Si on a pas de connaissances à priori sur le système, on regarde une fenetre temporelle élevée pour déterminer la trace. On réduit la fenêtre quand on cible l'attaque.

## Reverse Engineering 02/11

x = f o g o h. On donne toute la fonction x mais on ne retrouve pas le secret g.

Regarder les mesures de protection contre les attaques DES. Balance-logic pour le calcul inversé.

Split des variables : on sépare en plusieurs une variable de plusieurs octets en plusieurs variable de 1 octet.
Inversement pour plusieurs petites variables.

Remplacer une une instruction par un équivalent moins évident (exemple addition A + B + C -> fonction de xor & et |)

Garbage code : rajouter du code de bruit pour perdre l'attaquant.

Code mort : condition toujours vraie pour executer le reste du code.

Code flattening : remplacer des if par des switch.

Code tiles loops : Remplacer des boucles 1D par des boucles à plusieurs dimensions.