Sécurité des réseaux WIFI
PTUT

Année universitaire 2019 - 2020

DUT Informatique - Année 1 - Semestre 2
IUT d’Aix en Provence

Florian Ancelin - Lucas Duval - Clément Mathieu–Drif
Jean-Christophe Nguyen - Nils Ponsard - Hugo Tritz

Tuteur
Samuele Anni

02/06/2020

Auteurs des parties

Éléments du WEP, Authentiﬁcation, Chiﬀrement avec WEP, Spéciﬁcité du protocole, Fin de vie : Lucas Duval et Jean-Christophe Nguyen

RC4, KSA, PRGA, Fin de l’exemple, Déchiﬀrement : Florian Ancelin et Clément Mathieu–Drif

WPA2 (Historique, Modes de chiﬀrement, AES) : Clément Mathieu–Drif

Détection des intrusions : Lucas Duval, Jean-Christophe Nguyen et Nils Ponsard

Failles de sécurité du WEP : Lucas Duval, Jean-Christophe Nguyen

Description du 4-way handshake : Florian Ancelin

Failles de sécurité du WPA2 (KRACK, KR00K, autres attaques) : Clément Mathieu–Drif

Liens utiles

Site internet du projet : https://hugo_harkness.gitlab.io/JPP-de-PTUT Dépôt GitLab : https://gitlab.com/Hugo_Harkness/JPP-de-PTUT (diagramme de Gantt disponible sur ce dépôt)

Table des matières

1 Introduction
Protocoles
2 WEP
2.1 Éléments du WEP
2.2 Authentiﬁcation
2.2.1 Open System auth
2.2.2 Shared Key auth
2.3 Spéciﬁcités du protocole
2.3.1 Diﬀérents types de WEP
2.4 Fin de vie
2.5 RC4
2.6 KSA
2.7 PRGA
2.8 Fin de l’exemple
2.9 Déchiﬀrement
2.9.1 Une fonction involutive est bijective
2.9.2 Application au RC4
2.9.3 Conséquence
3 WPA2
3.1 Historique
3.2 Chiﬀrement et modes de chiﬀrement
3.2.1 TKIP
3.2.2 CCMP
3.2.3 CTR - Counter mode
3.2.4 CBC - Cipher Block Chaining
3.2.5 CBC-MAC - Message Authentication Code
3.3 AES
3.3.1 Opérations
3.3.2 SubBytes
3.3.3 ShiftRows
3.3.4 MixColumns
3.3.5 Préparation de la clé - Key Schedule
3.3.6 Add RoundKey
3.3.7 Algorithme de haut niveau
Détection des intrusions
4 Pourquoi détecter les intrusions ?
4.1 Quels sont les risques d’une intrusion ?
5 Les méthodes de détection
5.1 Détection par adresse MAC
5.2 Détection d’usurpation d’adresse MAC
5.3 Détection de "Brutforce"
5.4 Détection d’injections WEP
5.5 Détection des injection VLAN
5.6 Détection d’usurpation de point d’accès
Failles de sécurité
6 WEP
6.1 Introduction aux failles du protocole
6.2 Diﬀérentes attaques sur le protocole
7 Authentiﬁcation : 4-way handshake
7.1 Les diﬀérentes clés et outils utilisés
7.2 Utilisation du 4-Way Handshake
8 WPA2
8.1 Faille KRACK
8.1.1 Résumé de la situation
8.1.2 Outils de détection
8.1.3 Attaque de l’homme du milieu (man in the middle : MITM)
8.1.4 Associativité du XOR (eXclusive OR)
8.1.5 Fonctionnement de l’attaque
8.1.6 Cas particuler : wpa_supplicant 2.4 et 2.5
8.1.7 Impact
8.1.8 Informations complémentaires
8.1.9 Correctifs
8.2 Faille Kr00k
8.2.1 Fonctionnement
8.2.2 Appareils concernés
8.2.3 Correctifs
8.3 Autres attaques
Conclusion

1 Introduction

Les technologies sans ﬁl (WIFI, Bluetooth, NFC, etc) sont utilisés tous les jours et par tous mais ne sont maitrisées que par une minorité de leurs utilisateurs.
Étant nous même utilisateurs, nous avons décidé dans le cadre du projet tutoré du second semestre de DUT informatique de nous interesser À l’une d’entre elles et plus particulièrement à la manière dont elle sécurise les données transmisses. Le travail eﬀectué durant ce projet aura donc pour but de comprendre comment fonctionne la sécurisation des connexions WIFI.

Les sujets principaux traités dans le cadre de ce projet sont :

Étude de protocoles WEP et WPA2
Description des failles de ces deux protocoles
Présentation des méthodes de détection des intrusions

Première partie
Protocoles

2 WEP

WEP (Wired Equivalent Privacy) est un protocole réseau qui protège les données circulant sur un réseau WIFI. Le WEP est employé dans un WLAN (Wireless Local Area Network) pour rendre inintelligible à un tiers non autorisé les données encapsulées dans des trames.

Le WEP a pour objectif de garantir la conﬁdentialité, l’authentiﬁcation et l’intégrité des données et il est inclus dans la norme IEE 802.11 (1997). Le but recherché est d’atteindre le niveau de sécurité d’une communication ﬁlaire.

Le WEP utilise une clé RC4 (Rivest Cipher 4 : algorithme de chiﬀrement symétrique décrit plus loin dans ce dossier) composée d’une partie de 40 bits et d’un vecteur d’initialisation de 24 bits. Un contrôle de redondance cyclique (CRC-32) est également utilisé pour assurer l’intégrité des données. Quand le WEP est activé sur un réseau local sans ﬁl, chaque trame est chiﬀrée dans un ﬂux codé RC4, généré par une clé 64 bits. Ce protocole a été remplacé par le WPA (Wi-Fi Protected Access) en 2003 (Wiﬁ Alliance) puis déprécié en 2004.

2.1 Éléments du WEP

WEP utilise une clé secrète qui est partagée entre les clients ; elle sert au chiﬀrement, au déchiﬀrement et à l’authentiﬁcation. Cette clé contient une séquence "secrète" de 40 bits ou 104 bits. Elle peut être composée de caractères ASCII (5 pour 40bits) ou des caractères hexadécimaux (10 pour 40 bits). Les caractères ASCII doivent être aﬃchables, ce qui réduit les possibilités par rapport à l’hexadécimal.
Les clés de chiﬀrement supportées et principalement utilisées sont composées de 64 bits avec 40 bits pour la clé et 24 bits pour le vecteur d’initialisation ou de 128 bits dont 104 bits pour la clé et 24 bits pour le vecteur d’initialisation. La clé peut être considérée comme une suite de caractères qui changent selon les bits. Pour WEP-64, c’est 5 caractères ASCII pour 40 bits ou 10 caractères hexadécimaux pour 40 bits. Pour WEP-128, ce sont 13 caractères ASCII pour 104 bits ou 26 caractères hexadécimaux pour 104 bits.
Le vecteur d’initialisation (IV) est une séquence de bits qui change régulièrement. Combiné à la clé statique, il introduit une notion aléatoire au chiﬀrement. Ainsi, deux messages identiques ne donneront pas le même contenu chiﬀré, puisque l’IV est dynamique. Le vecteur d’initialisation peut avoir 2²⁴=16 777 216 combinaisons diﬀérentes ce qui permettra d’obtenir des clés de chiﬀrement "uniques" rendant le déchiﬀrement plus diﬃcile. Plus la clé est longue, plus la sécurité est optimisée (une clé de 128 bits mettra plus de temps à être trouvée qu’une clé de 64 bits).
Le WEP utilise un mécanisme nommé Integrity Check Value (ICV), destiné à contrôler l’intégrité des trames. Pour cela, un code équivalent au CRC32 est calculé. Il résulte du message en clair $M$ et non du contenu chiﬀré. Le CRC32 correspond en fait au reste de la division en binaire du message par un diviseur ﬁxé à l’avance (polynôme de degré 32).

https://flylib.com/books/en/2.519.1/wep_cryptographic_operations.html

2.2 Authentiﬁcation

2.2.1 Open System auth

Cette méthode peut-être considérée comme une authentiﬁcation nulle car pas d’authentiﬁcation. La clé doit être utilisée lors de l’appairage.

2.2.2 Shared Key auth

4 étapes :

Le client envoie une requête d’authentiﬁcation
Le point d’accès répond avec un challenge (non chiﬀré)
Le client chiﬀre le challenge et le renvoie
Le point d’accès déchiﬀre le challenge chiﬀré et regarde si le texte est le même

Si le réseau est perturbé l’authentiﬁcation échouera.

Il y a une faille plutôt évidente : si on intercepte le challenge non chiﬀré puis la réponse chiﬀrée, un simple XOR (OU exclusif) permet à un attaquant de recueillir suﬃsamment d’informations pour s’authentiﬁer à son tour.

2.3 Spéciﬁcités du protocole

2.3.1 Diﬀérents types de WEP

Il y a deux types de WEP :

Le WEP statique : il ne doit être pas être utilisé n’importe quand et n’importe comment, c’est une solution qui n’est pas la meilleure mais qui reste adaptée dans certains cas.
Le WEP statique est capable de contrer des attaques peu intenses et occasionnelles mais pas de grosses attaques. Cependant des appareils tels que des lecteurs de code-barres portables supportent exclusivement le WEP statique, c’est donc la seule option viable pour sécuriser la couche de liaison.
Le WEP dynamique : les meilleures solutions sont basées sur le WEP dynamique. Chaque station utilise 2 clés au lieu d’une :
-La 1^ère clé est une clé de mappage partagée entre la station et le point d’accès, elle protège les trames unicast.

-La 2^ème clé est une clé par défaut, partagée entre toutes les stations, elle protège les trames multicast et broadcast.

Il suﬃt de quelques minutes pour reconstituer tous les morceaux de la clé WEP qui circulent de temps à autres sur votre réseau. La raison pour laquelle ils circulent est intimement liée à l’algorithme utilisé car celui-ci doit être initialisé à chaque échange pour ne pas utiliser deux fois la même clé.

Nous verrons dans ce dossier la raison pour laquelle une clé de chiﬀrement ne doit pas être réutilisée lorsque l’on fait appel à un algorithme de chiﬀrement qualiﬁé de "One time pad".

2.4 Fin de vie

Le protocole WEP est donc composé de plusieurs éléments, se décline sous plusieurs formes et a été beaucoup utilisé entre 1999 et 2004 car il était l’un des protocoles les plus sécurisés. Mais aujourd’hui, s’il n’est (quasiment) plus utilisé c’est parce qu’il a été remplacé par le WPA puis le WPA2, des protocoles plus performants et moins vulnérables.

2.5 RC4

RC4 (Rivest Cipher 4) est un algorithme de chiﬀrement par ﬂot crée en 1987 par Ronald Rivest. Ce document décrit son fonctionnement au travers d’un exemple.

RC4 utilise deux fonction, KSA (Key Scheduling Algorithm) et PRGA (Pseudo Random Generation Algorithm) pour générer un ﬂot de bits pseudo aléatoire qui sera utilisé pour le chiﬀrement. De manière générale, la taille du tableau à initialiser est de $8 n = 2 = 256$ . Les éléments de ce tableau sont des mots de $n$ bits Dans notre cas, le tableau contiendra donc 256 éléments de 1 octet

"For real applications, n=8 is used as it is a good trade-oﬀ between security and memory requirements, and it is also natural and easy to implement" Evaluation of RC4 Stream Cipher - Ed Dawson, Helen Gustafson, Matt Henricksen, Bill Millan

Remarque 1 : les implémentations fournies dans ce document (en C++) utilisent n = 256.

Remarque 2 : les tableaux représentés dans ce document le sont avec l’élément d’indice $i = 0$ à gauche et celui d’indice $i = tailleDuT ableau − 1$ à droite.

Avant l’exécution de ces deux fonctions, le tableau est initialisé ainsi :

array<uint8_t, 256> tab;
for(unsigned i(0); i < tab.size(); ++i)
tab[i] = uint8_t(i);

soit la permutation identité de $Sym (n)$ , $idn = (0,1,...,n − 1)$

$ji ∈ ℤ∕nℤ$
$ˆji ∈ ℤ∕nℤ$

$σi ∈ Sym (n)$
$σˆi ∈ Sym (n)$

les $Ki ∈ ℤ∕nℤ$ sont les caractères de la clé K de taille $l ∈ [1,n]$
$idn = (0,1,...,n − 1)$

2.6 KSA

Après initialisation, le vecteur est parcouru une première fois par l’indice $i$ aﬁn d’appliquer une série de permutations. Les permutations eﬀectuées par KSA sont calculées en fonction de la clé $K$ .

Les permutations sont déﬁnies par ces relations :

{ ji = 0 si i = 0 ji−1 + σi−1(i− 1)+ Ki−1 modl si 1 ≤ i ≤ n

{ σ = idn si i = 0 i (i− 1,ji)∘ σi−1 si 1 ≤ i ≤ n

l’implémentation du KSA est la suivante :

uint8_t j(0);
for(unsigned i(0); i < tab.size(); ++i)
{
j = (j + tab[i] + cle[i % cle.size()]) % 256;
swap(tab[i], tab[j]);
}

où

j = (j + tab[i] + cle[i % cle.size()]) % n

correspond à

ji = ji−1 +σi−1(i− 1)+ Ki−1 modl

Puisque $σ0 = idn$ et que cela correspond à la première initialisation du tableau, la boucle peut commencer à $σ1$ . La permutation eﬀectuée par le programme lorsque $i = 0$ correspond donc à $σ1$ . Le programme eﬀectue alors $n− 1$ permutations. La $eme i$ permutation de l’algorithme correspond alors à la $eme i+ 1$ permutation calculée avec la relation précédente. L’indice

de l’implémentation varie donc entre $0$ et $n − 1$ .

Voici un exemple avec

n = 5

K =


4	2	1

chaine =


0	1	2

$j0 = 0$
$σ0 = id5$

$j1 = j0 + σ0(0)+ K0 = 0+ 0 + 4 = 4$
$σ1 = (0,4)∘ id5 = (0,4)$

$j2 = j1 + σ1(1)+ K1 = 4+ 1 + 2 = 7 ≡ 2 mod5$
$σ2 = (1,2)∘ (0,4)$

$j3 = j2 + σ2(2)+ K2 = 2+ 1 + 1 = 4$
$σ3 = (2,4)∘ ((1,2)∘ (0,4))$

$j4 = j3 + σ3(3)+ K0 = 4+ 3 + 4 = 11 ≡ 1 mod5$
$σ4 = (3,1)∘ ((2,4)∘ ((1,2)∘(0,4)))$

$j5 = j4 + σ4(4)+ K1 = 1+ 1 + 2 = 4$
$σ5 = (4,4)∘ ((3,1)∘ ((2,4)∘((1,2)∘(0,4))))$

ce qui correspond donc à :


0	1	2	3	4


4	1	2	3	0


4	2	1	3	0


4	2	0	3	1


4	3	0	2	1


4	3	0	2	1

les valeurs de j calculées par l’algorithme pour ce même exemple sont :
i = 0, j = 4
i = 1, j = 2
i = 2, j = 4
i = 3, j = 1
i = 4, j = 4

et les permutations qui en découlent sont de la forme :

swap(tab[i], tab[j])

soit (0, 4), (1, 2), (2, 4), (3, 1) et (4, 4) (dans l’ordre d’application) ce qui correspond à ce qui a été calculé précédemment.

2.7 PRGA

PRGA (Pseudo-Random Generation Algorithm) est un générateur pseudo aléatoire qui eﬀectue des permutations sur un tableau

tab

pour en initialiser un second

tab2

(appelé "keystream"). A chaque itération, PRGA échange deux éléments du tableau

tab

(qui est le résultat du KSA). Le nombre d’itérations dépend de la taille du message à chiﬀrer Le tableau mélangé

tab2

est utilisé pour chiﬀrer le message à l’aide de l’opération XOR (OU exclusif) entre le vecteur mélangé et le message à chiﬀrer. Chaque élément du tableau est déplacé au moins une fois toutes les $n = 256$ itérations.

implémentation en C++ :

uint8_t a(0), b(0);
vector<uint8_t> tab2;
for(unsigned i(0); i < chaine.size(); ++i)
{
a = (a + 1) % 256;
b = (b + tab[a]) % 256;
swap(tab[a], tab[b]);
tab2.push_back((tab[(tab[a] + tab[b]) % 256]));
}

Les permutations appliquées sur

tab

sont déﬁnies par les relation :

{ ˆji = 0 si i = 0 ji−1 + ˆσi−1(i) si i ≥ 1

{ ˆσi = σn si i = 0 (i,ji)∘ ˆσi−1 si i ≥ 1

$i ∈ [0,l− 1]$

les $zi ∈ ℤ∕nℤ$ sont les éléments du second tableau :

zi = ˆσi+1(ˆσi+1(i)+ ˆσi+1(ji+1))

La taille ﬁnale du tableau

tab2

est

chaine.size()

$= l$

Suite de l’exemple avec

n = 5

K =


4	2	1

chaine =


0	1	2

$j0 = 0$
$ˆσ0 = σ5$

$j1 = j0 + σ0(1) = 0 + 3 = 3$
$ˆσ1 = (1,3)∘ σ5$

$j2 = j1 + σ1(2) = 3 + 0 = 3$
$ˆσ2 = (2,3)∘ ((1,3)∘ σ5)$

$j3 = j2 + σ2(3) = 3 + 0 = 3$
$ˆσ3 = (3,3)∘ ((2,3)∘ ((1,3)∘σ5))$

$j4 = j3 + σ3(4) = 3 + 1 = 4$
$ˆσ3 = (4,4)∘ ((3,3)∘ ((2,3)∘((1,3)∘σ5)))$

les diﬀérents états de

tab

sont :


4	3	0	2	1


4	2	0	3	1


4	2	3	0	1


4	2	3	0	1


4	2	3	0	1

2.8 Fin de l’exemple

Calculons les valeurs des éléments de

tab2

( $zi$ )

$z0 = ˆσ1(ˆσ1(1)+ ˆσ1(j1)) = ˆσ1(ˆσ1(1) + ˆσ1(3)) = ˆσ1(2+ 3) = ˆσ1(0) = 4$

$z1 = ˆσ2(ˆσ2(2)+ ˆσ2(j2)) = ˆσ2(ˆσ2(2) + ˆσ2(3)) = ˆσ2(3+ 0) = ˆσ2(3) = 0$

$z2 = ˆσ3(ˆσ3(3)+ ˆσ3(j3)) = ˆσ3(ˆσ3(3) + ˆσ3(3)) = ˆσ3(0+ 0) = ˆσ3(0) = 4$

Après

chaine.size()

itérations, les éléments de

tab2

sont :


4	0	4

la ﬁn du processus de chiﬀrement consiste en un XOR bit à bit (déﬁni plus loin) entre

tab2

chaine

for(unsigned i(0); i < chaine.size(); ++i)
tab2[i] = tab2[i] ^ chaine[i];

Les implémentations du PRGA et de l’étape ﬁnale (XOR) peuvent être regroupées ainsi :

Le XOR (ou exclusif) est noté $⊕$ (et

en C++) et est déﬁni ainsi :


a	b	a XOR b

0	0	0

0	1	1

1	0	1

1	1	0

tab2 ^ chaine

tab2


4	0	4

chaine


0	1	2

message chiﬀré :


4 XOR 0	0 XOR 1	4 XOR 2

message chiﬀré :


4	1	6

2.9 Déchiﬀrement

Le déchiﬀrement est très simple dans la mesure où il utilise la même fonction que celle que nous venons de décrire. La raison pour laquelle le chiﬀrement et le déchiﬀrement utilisent le même algorithme découle du fait que la fonction correspondante est involutive.

2.9.1 Une fonction involutive est bijective

Soit $f : E ↦→ E$ une fonction involutive.
Soient $x$ et $y$ deux éléments de E

f(x) = f(y) ⇒ f(f(x )) = f(f (y)) ⇒ x = y

$f$ est injective

f(x) = y ⇒ f (f(x)) = f(y) ⇒ x = f (y)

$f$ est surjective et donc $f$ est bijective

2.9.2 Application au RC4

Soit $f : E ↦→ E$ avec $fG (M ) = M ⊕ G$ et E l’ensemble des messages (chiﬀrés ou non chiﬀrés).
M est le message a chiﬀrer, G est le tableau pseudo aléatoire dépendant de la clé de chiﬀrement (sortie du PRGA) et C est le message chiﬀré donc $C = fG (M ) = M ⊕ G$ .
La fonction $f$ est utilisée dans le chiﬀrement RC4 de la manière suivante :

fG (M ) = M ⊕ G = C

Montrons que $fG (C ) = M$

$fG(C ) = C ⊕ G = (M ⊕ G) ⊕ G$
$= ¬ (¬M.G + M.¬G ).G + (¬M.G + M.¬G ).¬G$
$= (¬(¬M.G ).¬(M.¬G )).G + (¬M.G. ¬G )+ (M.¬G.¬G )$
$= (¬(¬M.G ).¬(M.¬G )).G + (M. ¬G )$
$= ((M + ¬G ).(¬M + G)).G + (M.¬G )$
$= ((M.¬M )+ (M.G )+ (¬G.¬M )+ (¬G.G)).G + (M.¬G )$
$= ((M.G )+ (¬G.¬M )).G + (M.¬G )$
$= (M.G.G )+ (¬G.¬M.G ) +(M. ¬G)$
$= (M.G )+ (M.¬G )$
$= M. (G + ¬G )$
$= M.1 = M$

Nous avons donc :

fG (M ) = M ⊕ G = C

fG(C) = C ⊕ G = M

donc la fonction est involutive.

fG ∘ fG = IdE

Dans RC4, la fonction de chiﬀrement est la même que celle de déchiﬀrement.

2.9.3 Conséquence

Nous avons vu précédemment qu’une application involutive est bijective. De ce fait, dans le cas de RC4, deux messages diﬀérents ne peuvent pas donner lieu au même message chiﬀré pour un keystream donné. Cette propriété découle de l’injectivité.

3 WPA2

3.1 Historique

Suite à la découverte des vulnérabilités du WEP une nouvelle version du système de sécurisation des réseaux WIFI était nécessaire. La norme IEEE 802.11i est alors rédigée. Une première version, le WPA a été publiée en 2003 alors que la nouvelle norme était encore en rédaction. Finalement en 2004 la norme IEEE 802.11i est terminée et donne naissance au WPA2 encore largement utilisé aujourd’hui.

Il existe deux versions de WPA2 :

WPA2 personnel qui se base sur un secret partagé
WPA2 entreprise qui utilise un serveur d’authentiﬁcation (comme eduroam).

En 2018 la wiﬁ Alliance a annoncé WPA3 corrigeant des problèmes de sécurité de WPA2 (voir à ce sujet la partie consacrée à la faille KRACK). WPA3 a cependant déjà été compromis par Mathy Vanhoef (à l’origine de la faille KRACK du WPA2) et Eyal Ronen, qui ont présenté en avril 2019 l’attaque DragonBlood se basant sur le Dragonﬂy Handshake utilisé par ce protocole. Des correctifs ont depuis été publiés.

3.2 Chiﬀrement et modes de chiﬀrement

3.2.1 TKIP

Temporal Key Integrity Protocol, utilise le chiﬀrement RC4. Ce type de connexion est considérée comme non sécurisée et est uniquement utilisé pour assurer la compatibilité avec de vieux équipements. TKIP n’est pas traité en détail dans ce document.

3.2.2 CCMP

Counter Mode with Cipher Block Chaining Message Authentication Code Protocol (CCMP), basé sur le standard AES (Advanced Encryption Standard), permet une protection supérieure et une vériﬁcation d’intégrité plus eﬃcace que TKIP. L’utilisation de cette méthode de chiﬀrement est nécessaire pour dépasser un débit de 54 Mbit/s (spéciﬁcation 802.11n).
CCMP utilise une clé de 128 bits et un numéro de paquet $P N$ de 48 bits qui n’est jamais réutilisé et évite les attaques de type rejeu. Ce protocole encapsule les données dans un MPDU (MAC Protocol Data Unit).
CCMP utilise le mode CTR pour le chiﬀrement des données avec AES et CBC-MAC pour contrôler l’intégrité des messages. Commençons par décrire ces deux modes. ¹

3.2.3 CTR - Counter mode

Ce mode ne crée pas de lien entre les blocs de données contrairement au mode CBC décrit dans la partie suivante. Cette particularité peut permettre d’eﬀectuer le chiﬀrement en parallèle car le traitement d’un bloc ne dépend pas de celui des blocs précédents.

Notons $Mi$ le $ieme$ bloc non chiﬀré, $Ci$ le $ieme$ bloc chiﬀré. La fonction de chiﬀrement est notée $AESk$ avec $k$ la clé de chiﬀrement.

source : Wikipédia

Ci = AESk (N once||Counteri)⊕ Mi

Où || est l’opérateur de concaténation. Et $⊕$ représente l’opérateur XOR.

source : Wikipédia

Mi = Ci ⊕ AESk (Nonce||Ci)

Dans ce mode, comme pour le chiﬀrement RC4 par exemple, la fonction de chiﬀrement est la même que celle de déchiﬀrement (voir la partie sur RC4).

Ci = AESk (N once||Counteri)⊕ Mi

ce qui nous donne donc :

AESk (N once||Counteri)⊕ Ci

= AESk (Nonce||Counteri)⊕ AESk (Nonce||Counteri)⊕ Mi = Mi

CCMP utilise une valeur appelée CTR Preload, elle correspond à la concaténation $(N once||Counteri)$ présente sur les descriptions. Cette valeur est composée d’un octet de drapeaux (ﬂags), d’un octet provenant du champs QoS, de l’adresse de l’émetteur sur 6 octets, d’un $P N$ (6 octets) et d’un compteur $P L$ sur deux octets initialisé à 1 et qui sera incrémenté pour chaque nouveau chiﬀrement. Soit un total de 128 bits. Ce qui donne ﬁnalement :

Mi = Ci ⊕ AESk (CT R Preload)

Ci = AESk (CT R P reload)⊕ Mi

l’indice $i$ n’apparaît pas ici mais le compteur $PL$ est bien présent dans le $CT R P reload$ . Ce compteur est incrémenté à chaque nouveau chiﬀrement. Notons également que lors du chiﬀrement du MAC (déﬁni dans la partie suivante), le compteur $PL$ du $CT R Preload$ est égal à $0$ .

3.2.4 CBC - Cipher Block Chaining

Chaque bloc à chiﬀrer subit un XOR avec le bloc chiﬀré précédent. Pour le premier bloc, un vecteur d’initialisation $IV$ est utilisé.

Illustration : à gauche, les données non chiﬀrées, au centre, le chiﬀrement utilise le mode ECB et à droite, un autre mode tel que CBC (source : Wikipédia)

Avec le mode ECB (Electronic codebook), deux blocs identiques donnent le même bloc chiﬀré (ce qui permet de trouver les blocs clairs réutilisés), ce qui n’est pas le cas avec le mode CBC puisque le bloc chiﬀré dépend des blocs précédents. De plus, l’interdépendance des blocs permet d’assurer qu’un bloc de la chaîne ne peut pas être modiﬁé sans conséquences sur les suivants.

source : Wikipédia

Notons $Mi$ le $eme i$ bloc non chiﬀré, $Ci$ le $eme i$ bloc chiﬀré avec $i ≥ 1$ et $C0 = IV$ . La fonction de chiﬀrement est notée $AESk$ et le déchiﬀrement $− 1 AES k$ avec $k$ la clé de chiﬀrement.

Ci = AESk (Mi ⊕ Ci−1)

Ci = AESk (Mi ⊕ Ci−1)

− 1 AES k (Ci) = Mi ⊕ Ci−1

AES −1(Ci)⊕ Ci−1 = Mi ⊕ Ci−1 ⊕Ci− 1 k

AES −k 1(Ci)⊕ Ci−1 = Mi

3.2.5 CBC-MAC - Message Authentication Code

Ce calcul a pour but de construire un code d’authentiﬁcation (MAC) en se basant sur le mode CBC aﬁn de contrôler l’intégrité du message ainsi que l’authentiﬁcation car le processus nécessite de connaitre la clé de chiﬀrement.

Dans ce cas le vecteur d’initialisation est le résultat du chiﬀrement par AES d’un $N once$ très similaire au $CTR Preload$ . Ce $N once$ est construit par concaténation avec un octet de drapeaux, un octet provenant du champ QoS, l’adresse de l’émetteur sur 6 octets, un $P N$ sur 6 octets et deux octets contenant la longueur totale du message à chiﬀrer.

Les 64 premiers bits (bits de poids fort) du dernier bloc chiﬀré de 128 bits sont conservés pour former le MAC.

Ce MAC permet de vériﬁer l’intégrité de l’intégralité du message (en-tête comprise) mais dans la trame ﬁnale, l’en-tête n’est pas chiﬀrée.

Lors de la réception, le destinataire déchiﬀre le message (mode CTR) puis calcule le MAC (mode CBC) qu’il compare au MAC reçu, si les deux résultats correspondent, les données n’ont pas été modiﬁées et peuvent donc être conservées.

Voici un schéma résumant le fonctionnement de CCMP ² .

3.3 AES

Advanced Encryption Standard (AES) est une spéciﬁcation de chiﬀrement symétrique par blocs déﬁnie par la National Institute of Standards and Technology. La taille des blocs est de 128 bit et la taille de clé peut être de 128,192 ou 256 bits.

https://www.researchgate.net/figure/AES-key-lengths-and-number-of-rounds_tbl2_326557872

Ce document traite de la version AES-128

AES utilise une matrice carrée d’ordre 4 pour représenter les données à chiﬀrer (128 bits soit 16 octets, ce qui correspond au nombre d’éléments de la matrice). Notons que dans une implémentation, il est également possible de représenter les données comme un tableau unidimensionnel à 16 éléments.

indices 0 à 3 : première colonne
indices 4 à 7 : deuxième colonne
indices 8 à 11 : troisième colonne
indices 12 à 15 : quatrième colonne

Quelle que soit la représentation utilisée, les octets sont considérés comme des éléments de $𝔽256$ .

Dans la suite de ce document nous utiliserons la représentation matricielle et la matrice sera notée $S$ .

3.3.1 Opérations

Le corps ﬁni $𝔽256$ est muni de deux opérations : l’addition et la multiplication.

$0$ est l’élément neutre pour l’addition et est l’élément absorbant pour la multiplication. $1$ est l’élément neutre pour la multiplication.

La multiplication est distributive par rapport à l’addition.

L’addition dans $𝔽256$ est simple à comprendre et à implémenter car elle est équivalente à un XOR (OU exclusif). Ainsi $0x19 +0x0d$ est équivalent à $000110012 ⊕ 000011012 = 000101002$ donc $0x19+ 0x0d = 0x14$ .
La multiplication, quant à elle, est moins directe. Ici, il est nécessaire de représenter les éléments de $𝔽256$ comme étant des polynômes dans $8 4 3 𝔽2[x]∕x + x + x +x + 1$ (le polynôme $8 4 3 x + x + x + x+ 1$ est irréductible). La multiplication se fait en deux étapes :

multiplication des polynômes
recherche du reste de la division par $8 4 3 x + x + x + x+ 1$

Le résultat est le reste de la seconde étape. La recherche du reste étant similaire à celle utilisée dans le calcul de CRC (Contrôle de redondance cyclique), voici un cours expliquant son fonctionnement :
https://ensiwiki.ensimag.fr/images/f/f3/Tp∖_crc16.pdf Un programme en C++ permettant de réaliser ce calcul de reste est disponible dans le répertoire CPP du dépôt GitLab (lien au début de ce dossier).

Calculons $0x23 ∗0x1d$ . dans un premier temps voici les polynômes correspondants :

$0x19 = 001000112$ donc $5 x +x + 1$

$0x0d = 000111012$ donc $4 3 2 x +x + x + 1$

5 4 3 2 (x + x +1) ∗(x + x + x + 1)

9 8 7 5 5 4 3 4 3 2 = x + x + x + x + x +x + x + x +x + x + x + 1

dans $𝔽2$ , 1 + 1 = 0 ce qui nous donne :

x9 + x8 +x7 + x2 + x +1

cherchons le reste de la division par $x8 + x4 + x3 + x + 1$

1 1 1 0 0 0 0 1 1 1 1 0 0 0 1 1 0 1 1 − − − − − − − − − 0 1 1 0 1 1 0 0 0 1 1 0 0 0 1 1 0 1 1 − − − − − − − − − 0 1 0 1 0 1 0 1 0

le polynôme trouvé est $x7 + x5 + x3 + x$ soit $10101010 = 0xaa 2$
Notons que la représentation utilisant les polynômes peut être utilisée pour l’addition également, c’est ce qui a été fait pour calculer ceci :

x9 + x8 + x7 + x5 + x5 +x4 + x3 + x +x4 + x3 + x2 + 1

= x9 + x8 +x7 + x2 + x +1

Les opérations décrites dans cette partie sont utilisées tout au long de ce document.

3.3.2 SubBytes

La première étape de l’algorithme consiste à calculer l’inverse multiplicatif de chaque élément de la matrice de départ dans $𝔽256$ et à appliquer la transformation aﬃne suivante dans $(𝔽2)8$ (chaque élément de cet ensemble représente un octet dont les bits sont : $b7,b6,b5,b4,b3,b2,b1,b0$ avec $b0$ le bit de poids faible et $b7$ le bit de poids fort) :

⌊ ⌋ ⌊ ⌋ ⌊ ⌋ ⌊ ⌋ |s0| | 1 0 0 0 1 1 1 1| |b0| |1| ||s1|| || 1 1 0 0 0 1 1 1|| ||b1|| ||1|| ||s2|| || 1 1 1 0 0 0 1 1|| ||b2|| ||0|| ||s3||= || 1 1 1 1 0 0 0 1||∗ ||b3||+ ||0|| ||s4|| || 1 1 1 1 1 0 0 0|| ||b4|| ||0|| |⌈s5|⌉ |⌈ 0 1 1 1 1 1 0 0|⌉ |⌈b5|⌉ |⌈1|⌉ s6 0 0 1 1 1 1 1 0 b6 1 s7 0 0 0 1 1 1 1 1 b7 0

Notons que la matrice utilisée est circulante.

s = b + b + b + b + b + 1 0 0 4 5 6 7

s1 = b0 + b1 + b5 + b6 + b7 + 1

s2 = b0 + b1 + b2 + b6 + b7 + 0

s3 = b0 + b1 + b2 + b3 + b7 + 0

s4 = b0 + b1 + b2 + b3 + b4 + 0

s5 = b1 + b2 + b3 + b4 + b5 + 1

s6 = b2 + b3 + b4 + b5 + b6 + 1

s = b + b + b + b + b + 0 7 3 4 5 6 7

ce qui correspond à :

si = bi ⊕ b(i+4)mod8 ⊕ b(i+5)mod8 ⊕ b(i+6)mod8 ⊕ b(i+7)mod8 ⊕ ci

avec $c = 0x63 = 011000112$ . Il est ici question d’associer à la valeur $b$ de chaque octet une nouvelle valeur $s = S(b)$ .

D’après le théorème de Lagrange sur les groupes, l’ordre d’un élément d’un groupe est un diviseur du cardinal de ce groupe. donc pour un élément $a$ d’ordre $t$ , dans un groupe de cardinal $n$ , on a $n = k ∗t,k ∈ ℕ$ . donc $n tk k a = (a) = 1 = 1$ . Alors $n−1 a$ est l’inverse de $a$ car $n−1 n a ∗ a = a = 1$ . Dans le cas d’AES nous cherchons des inverses dans $∗ 𝔽256 − {0} = (𝔽256)$ (groupe par rapport à la multiplication car tous les éléments ont un inverse). $∗ (𝔽256)$ est de cardinal 255. Donc pour tout $∗ A ∈ (𝔽256)$ , nous avons $254 −1 A = A$

Puisque 0 n’a pas d’inverse, nous considérons que sa valeur reste inchangée lors de cette étape et nous avons donc $S(0) = 0x63$ .

Exemple : dans cet exemple, un élément de la matrice S est $b = 90 = 0x5a = 010110102$ . $b ∈ 𝔽256$ Nous cherchons l’inverse multiplicatif de $b$ noté $−1 b$ . Comme nous l’avons vu, $255 b = 1$ et $−1 b∗ b = 1$ donc $−1 254 b = b$

Calculer des produits d’éléments de $𝔽256$ peut être fait avec une fonction de ce type ³ qui utilise la technique de multiplication dite Russe :

uint8_t gmul(uint8_t a, uint8_t b)
{
uint8_t p = 0;
while (a && b)
{
if (b & 1)
p ^= a;

if (a & 0x80)
a = (a << 1) ^ 0x11b; // x^8 + x^4 + x^3 + x + 1
else
a <<= 1;
b >>= 1;
}
return p;
}

Élevons $b$ à la puissance 254 :

uint8_t resultat = gmul(90, 90); // 2
resultat = gmul(resultat, 90); // 3
uint8_t p3 = resultat;
resultat = gmul(resultat,resultat); // 6
resultat = gmul(resultat, resultat); // 12
uint8_t p15 = gmul(resultat, p3); // 15
resultat = gmul(resultat, resultat); // 24
resultat = gmul(resultat, resultat); // 48
resultat = gmul(resultat, p15); // 63
resultat = gmul(resultat, resultat); // 126
resultat = gmul(resultat, 90); // 127
resultat = gmul(resultat, resultat); // 254

Après exécution, nous trouvons $b254 = b−1 = 34 = 001000102$ .

ce qui nous donne :

s0 = 0 + 0+ 1+ 0 +0 + 1 = 0

s1 = 0 + 1+ 1+ 0 +0 + 1 = 1

s = 0 + 1+ 0+ 0 +0 + 0 = 1 2

s3 = 0 + 1+ 0+ 0 +0 + 0 = 1

s4 = 0 + 1+ 0+ 0 +0 + 0 = 1

s5 = 1 + 0+ 0+ 0 +1 + 1 = 1

s6 = 0 + 0+ 0+ 1 +0 + 1 = 0

s = 0 + 0+ 1+ 0 +0 + 0 = 1 7

soit $S(b) = 101111102 = 0xbe$ . ce qui correspond bien à la valeur trouvée dans la S-box :

source : Wikipédia

En pratique, il est possible de conserver la S-box dans le code source d’un programme pour éviter les calculs, c’est ce qui a été fait dans le noyau Linux ⁴ par exemple :

static volatile const u8 __cacheline_aligned aes_sbox[] = {
0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5,
0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0,
0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc
...
};

Toutes les valeurs de la S-box sont diﬀérentes et il n’existe aucun $b ∈ 𝔽256$ telle que $S(b) = b$ . L’application décrite ici est donc une bijection sans point ﬁxe. Notons également qu’il n’existe pas non plus d’élément $b ∈ 𝔽256$ tel que $S (b)⊕ b = 0xf f$ (soit $S(b)+ b = 0xff)$ .

3.3.3 ShiftRows

Cette étape modiﬁe les lignes de la matrice obtenue après l’étape SubBytes. Pour cela, des décalages circulaires vers la gauche sont appliqués sur les lignes selon les données suivantes :

ligne 0 : reste inchangée
ligne 1 : 1 rang
ligne 2 : 2 rangs
ligne 3 : 3 rangs (équivalent à un décalage d’un rang vers la droite)

À gauche, la matrice après l’étape SubBytes et à droite le résultat de l’étape ShiftRows.

3.3.4 MixColumns

Une fois les rotations appliquées sur les lignes, nous représentons une colonne de la matrice avec un élément de $(𝔽256)4$ .

⌊ ⌋ |a0 a4 a8 a12| |a1 a5 a9 a13| ⌈a2 a6 a10 a14⌉ a3 a7 a11 a15

donne $(a0,a1,a2,a3)$ , $(a4,a5,a6,a7)$ , $(a8,a9,a10,a11)$ et $(a12,a13,a14,a15)$ .
La transformation suivante est appliquée pour toutes les colonnes :

⌊b0⌋ ⌊2 3 1 1⌋ ⌊a0⌋ ||b1|| ||1 2 3 1|| ||a1|| ⌈b2⌉ = ⌈1 1 2 3⌉∗ ⌈a2⌉La matrice utilisée est circulante. b3 3 1 1 2 a3

Exemple : Considérons une matrice dont une des colonnes serait représentée par $4 C ∈ (𝔽256)$

⌊ 01⌋ | 20| C = |⌈ 6c|⌉ 2f

Les valeurs notées ici sont en hexadécimal.
Ceci nous donne donc :

⌊b0⌋ ⌊ 2 3 1 1⌋ ⌊ 01⌋ ⌊ 2∗01 + 3∗20 + 1∗6c + 1∗2f⌋ |b1| | 1 2 3 1| | 20| | 1∗01 + 2∗20 + 3∗6c + 1∗2f| |⌈b2|⌉ = |⌈ 1 1 2 3|⌉ ∗|⌈ 6c|⌉ = |⌈ 1∗01 + 1∗20 + 2∗6c + 3∗2f|⌉ b3 3 1 1 2 2f 3∗01 + 1∗20 + 1∗6c + 2∗2f

⌊ 2 + 3∗20 + 6c+ 2f ⌋ |1+ 2 ∗20+ 3 ∗6c+ 2f| = |⌈1+ 20 + 2∗6c +3 ∗2f|⌉ 3 + 20+ 6c+ 2∗ 2f

calculons $3 ∗20$ , $2∗ 20$ , $3∗6c$ , $2 ∗6c$ , $3∗ 2f$ et $2∗2f$ .

$0x20 = 001000002$ = $x5$ .

$0x6c = 011011002$ = $x6 + x5 + x3 +x2$ .

$0x2f = 001011112$ = $x5 + x3 +x2 + x+ 1$ .

$0x03 = 000000112$ = $x+ 1$ .

$0x02 = 000000102$ = $x$ .

ce qui nous donne :

3∗ 20 = (x +1) ∗x5 = x6 + x5 = 011000002 = 0x60

2∗20 = x∗ x5 = x6 = 010000002 = 0x40

6 5 3 2 7 6 4 3 6 5 3 2 3∗ 6c = (x+ 1)∗ (x + x + x + x ) = x + x + x + x + x + x + x + x

7 5 4 2 = x + x + x + x

= 10110100 = 0xb4 2

2∗ 6c = x ∗(x6 + x5 + x3 + x2) = x7 + x6 + x4 + x3 = 110110002 = 0xd8

3∗2f = (x+1 )∗(x5+x3 +x2 +x+1 ) = x6 +x4+x3 +x2 +x+x5 +x3 +x2 +x+1

= x6 + x5 + x4 + 1

= 011100012 = 0x71

2∗2f = x∗ (x5+ x3+ x2+ x+ 1) = x6 + x4+ x3+ x2+ x = 010111102 = 0x5e

⌊ ⌋ | 2 + 3∗20 + 6c+ 2f | |⌈1+ 2 ∗20+ 3 ∗6c+ 2f|⌉ 1+ 20 + 2∗6c+ 3 ∗2f 3 + 20+ 6c+ 2∗ 2f

⌊2+ 60+ 6c +2f⌋ ||1+ 40+ b4+ 2f|| = ⌈1+ 20+ d8 + 71⌉ 3+ 20 +6c + 5e

⌊ ⌋ 21 = || da|| ⌈ 88⌉ 11

3.3.5 Préparation de la clé - Key Schedule

L’objectif de cette étape est d’obtenir 11 clés (la clé initiale plus une clé par tour, soit un total de 176 octets) à partir de la clé initiale (16 octets). Comme pour les données à chiﬀrer, la clé peut être représentée comme une matrice carrée d’ordre 4 et le résultat par une matrice à 4 lignes et 44 colonnes dont les 4 premières colonnes sont celles de la clé initiale.
Nous allons voir comment calculer les colonnes suivantes.

Il est nécessaire de déﬁnir les $RCon$ (Round constants) qui sont des éléments de $(𝔽256)4$ . Chaque $RCon$ correspond à un tour, il est donc nécessaire d’en calculer 10.
$RC (i) = xi−1$ pour $1 ≤ i ≤ 10$ .
Représentons ceci sous la forme d’une matrice à 4 lignes et 10 colonnes.

⌊ ⌋ ⌊ 0 1 9⌋ |RC (1) RC (2) ... RC (10)| |x x ... x | |⌈ 0 0 ... 0 |⌉ = |⌈0 0 ... 0|⌉ 0 0 ... 0 0 0 ... 0 0 0 ... 0 0 0 ... 0

Il est nécessaire de trouver le reste de la division de $x9$ par $x8 + x4 + x3 + x + 1$ . Il en est de même pour $x8$ (les autres polynômes ont déjà un degré inférieur à 8).
Pour $x8$ on a $100000000 2$

1 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 1 1 − − − − − − − − − 0 0 0 0 1 1 0 1 1

le reste est $x4 + x3 + x+ 1 = 000110112 = 0x1b$
Pour $x9$ on a $10000000002$

1 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 1 1 − − − − − − − − − 0 0 0 0 1 1 0 1 1 0

le reste est $5 4 2 x + x + x + x = 001101102 = 0x36$

Voici la matrice ﬁnale obtenue :

⌊ ⌋ | 1 2 4 8 10 20 40 80 1b 36| R = |⌈ 0 0 0 0 0 0 0 0 0 0 |⌉ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

La $ieme$ colonne est utilisée comme RCon pour le $ieme$ tour.

Calcul pour calculer la $eme i$ ( $5 ≤ i ≤ 44$ ) colonne de la matrice ﬁnale :

si $i ≡ 1 mod 4$
pour B, la $eme (i− 1)$ colonne de la matrice représentée ainsi : $⌊ ⌋ | b0| B = |⌈ b1|⌉ b2 b3$
A, la $(i− 4)eme$ colonne :
$⌊a0⌋ ||a1|| A = ⌈a2⌉ a3$

La $ieme$ colonne C se calcule ainsi :
$⌊ ⌋ ⌊ ⌋ ⌊ ⌋ ⌊ ⌋ c0 S(b1) a0 RC (i− 4) || c1|| = || S(b2)|| + ||a1||+ || 0 || ⌈ c2⌉ ⌈ S(b3)⌉ ⌈a2⌉ ⌈ 0 ⌉ c3 S(b0) a3 0$

remarquons l’ordre des éléments dans :
$⌊ ⌋ |S(b1)| |⌈S(b2)|⌉ S(b3) S(b0)$

ceci sera expliqué plus précisément dans l’exemple suivant.
sinon
pour B, la $(i− 1)eme$ colonne et A la $(i− 4)eme$ de la matrice (A et B déﬁnis comme précédemment).
La $ieme$ colonne C se calcule ainsi : $⌊ ⌋ ⌊ ⌋ ⌊ ⌋ |c0| | b0| |a0| |⌈c1|⌉ = |⌈ b1|⌉ + |⌈a1|⌉ c2 b2 a2 c3 b3 a3$

Exemple Choisissons la clé initiale suivante :

0 1 2 3 4 5 6 7 8 9 a b c d e f

représentée ainsi :

⌊ ⌋ 0 4 8 c || 1 5 9 d || ⌈ 2 6 a e⌉ 3 7 b f

colonne 5 :
Nous considérons ici la $4eme$ colonne.

⌊ ⌋ c ||d|| ⌈e⌉ f

Nous appliquons une rotation de 1 octet vers la gauche (la forme matricielle n’est qu’une représentation), ce qui nous donne :

⌊d⌋ |e| |⌈f|⌉ c

Eﬀectuons maintenant la même substitution que celle opérée lors de l’étape SubBytes. Pour cela, cherchons les éléments correspondants dans la S-box.

⌊ ⌋ ⌊ ⌋ |S(d)| |d7| |⌈S (e)|⌉ = |⌈ab|⌉ S(f) 76 S (c) fe

Ici, nous sommes au premier tour donc la valeur RCon recherchée correspond à la première colonne de la matrice $R$ .

⌊d7⌋ ⌊0⌋ ⌊1⌋ ⌊d6⌋ ||ab|| ||1|| ||0|| ||aa|| ⌈76⌉ + ⌈2⌉ + ⌈0⌉ = ⌈74⌉ fe 3 0 fd

colonne 6 :

⌊ ⌋ ⌊ ⌋ ⌊ ⌋ d6 4 d2 ||aa|| + ||5|| = ||af|| ⌈74⌉ ⌈6⌉ ⌈72⌉ fd 7 fa

colonne 7 :

⌊ ⌋ ⌊ ⌋ ⌊ ⌋ |d2| |8| |da| |⌈af|⌉ + |⌈9|⌉ = |⌈a6|⌉ 72 a 78 fa b f1

colonne 8 :

⌊da⌋ ⌊c⌋ ⌊d6⌋ ||a6|| ||d|| ||ab|| ⌈78⌉ + ⌈e⌉ = ⌈76⌉ f1 f fe

colonne 9 :

⌊ ⌋ ⌊ ⌋ |d6| |ab| |⌈ab|⌉ rotation :|⌈76|⌉ 76 fe fe d6

⌊ S(ab)⌋ ⌊ 62⌋ || S(76)|| || 38|| ⌈ S(fe)⌉ = ⌈ bb⌉ S(d6) f6

⌊ ⌋ ⌊ ⌋ ⌊ ⌋ ⌊ ⌋ 62 d6 2 b6 || 38||+ || aa||+ || 0||= || 92|| ⌈ bb⌉ ⌈ 74⌉ ⌈ 0⌉ ⌈ cf ⌉ f6 fd 0 b

colonne 10 :

⌊ ⌋ ⌊ ⌋ ⌊ ⌋ | b6 | |d2 | | 64| |⌈ 92|⌉+ |⌈af |⌉ = |⌈ 3d|⌉ cf 72 bd b f a f1

colonne 11 :

⌊ 64⌋ ⌊ da⌋ ⌊be⌋ || 3d|| || a6|| ||9b|| ⌈ bd⌉+ ⌈ 78⌉ = ⌈c5⌉ f1 f1 0

colonne 12 :

⌊ ⌋ ⌊ ⌋ ⌊ ⌋ | be| |d6| | 68| |⌈ 9b|⌉+ |⌈ab|⌉ = |⌈ 30|⌉ c5 76 b3 0 f e f e

...

...

...

Le résultat ﬁnal est :

⌊ ⌋ 0 4 8 c d6 d2 da d6 b6 64 be 68 ... ||1 5 9 d aa af a6 ab 92 3d 9b 30 ...|| ⌈2 6 a e 74 72 78 76 cf bd c5 b3 ...⌉ 3 7 b f fd fa f1 fe b f1 0 f e ...

3.3.6 Add RoundKey

Cette étape consiste simplement à additionner La matrice $S$ et une matrice représentant une clé (clé initiale ou clé de tour).

⌊ ⌋ ⌊ ⌋ | a0 a4 a8 a12| |k0 k4 k8 k12| | a1 a5 a9 a13| + |k1 k5 k9 k13| ⌈ a2 a6 a10 a14⌉ ⌈k2 k6 k10 k14⌉ a3 a7 a11 a15 k3 k7 k11 k15

Le résultat est ensuite aﬀecté à la matrice $S$ .

3.3.7 Algorithme de haut niveau

Tous les composants d’AES étant maintenant décrits, voici son fonctionnement général :

AddRoundKey; //avec la clé initiale et la matrice S
pour i variant_de 1 a 9 faire
SubBytes;
ShiftRows;
MixColumns;
AddRoundKey; //avec la clé du i-ème tour et la matrice S
ffaire

//le tour final est différent (10ème tour)
SubBytes;
ShiftRows;
//pas de MixColumns dans le dernier tour
AddRoundKey;

Le déchiﬀrement est eﬀectué en faisant toutes ces étapes dans le sens inverse.

Deuxième partie
Détection des intrusions

4 Pourquoi détecter les intrusions ?

Les réseaux WIFI privés sont construits pour être sécurisés et empêcher des connexions non voulues au réseau ; malgré cette "sécurité" il existe des failles qui permettent d’y accéder sans autorisation.

4.1 Quels sont les risques d’une intrusion ?

Avoir accès au réseau facilite la pénétration des systèmes connectés. L’attaquant peut aussi observer les données échangées entre les périphériques, et il lui est d’autre part possible d’utiliser le réseau dans le but d’usurper l’identité de la victime.

Pour éviter ces risques il faut détecter les intrusions malveillantes dans le réseau.

5 Les méthodes de détection

5.1 Détection par adresse MAC

L’adresse MAC est un identiﬁant particulier à la carte réseau qui permet d’identiﬁer chaque périphérique (cette carte peut être sans ﬁl ou ﬁlaire).

On peut détecter une intrusion en obtenant régulièrement les adresses MAC (on peut pour cela utiliser l’outil nmap) des périphériques connectés au réseau et comparer la liste d’adresse obtenue à une liste d’adresses autorisées. Si une adresse n’est pas dans la liste des adresses autorisées alors un nouveau périphérique s’est connecté.

Cette méthode a quelques problèmes :

Il faut autoriser chaque nouveau périphérique que l’on veut ajouter au réseau.
Il est possible de changer manuellement l’adresse MAC d’un périphérique (spooﬁng) et donc d’usurper l’identité d’un périphérique autorisé.

5.2 Détection d’usurpation d’adresse MAC

Les numéros de séquence servent à indiquer quel fragment (en cas de fragmentation) est envoyé dans le paquet. Si ce numéro de séquence change plusieurs fois rapidement (moins d’une seconde), il peut y avoir une usurpation d’adresse MAC, et cette technique peut donner des "faux positifs" à cause du grand nombre de paquets envoyés.

Les paramètres optionnels sont des données dépendantes de la carte réseau utilisée ainsi que du driver, du ﬁrmware et de la conﬁguration. Elles sont diﬃciles à modiﬁer ; si ces paramètres optionnels changent rapidement (dans la seconde), il y a sûrement usurpation d’adresse MAC.

La qualité du signal reçu dépend de la distance entre le périphérique et le routeur ; ce paramètre n’est pas constant même si les deux équipements restent immobiles (du fait des interférences). Cependant si cette valeur change beaucoup plus que d’habitude et très rapidement (par exemple passer de -80dBm à -20dBm dans la même seconde) on peut suspecter une usurpation d’adresse MAC. Avec cette méthode il est possible d’obtenir des résultats "faux positifs".

Les systèmes d’exploitation ont des façons diﬀérentes de générer les trames réseau, ils laissent une «empreinte» qui peut être détectable. Si cette empreinte change rapidement plusieurs fois (moins d’une seconde) alors il y a sûrement usurpation d’adresse MAC.

En combinant ces facteurs il est possible de déterminer si une usurpation d’adresse MAC a lieu et de réduire le nombre de "faux positifs".

5.3 Détection de "Brutforce"

la technique de "Brutforce" consiste à essayer un grand nombre de combinaisons de mots de passe pour essayer de trouver "le bon". Ces combinaisons sont souvent formées à partir de mots du dictionnaire.

détection : La détection est plutôt simple : il suﬃt de compter le nombre d’essais avec un mot de passe erroné et alerter quand il y a un grand nombre d’essais dans un temps donné.

5.4 Détection d’injections WEP

Les injections WEP prennent souvent la forme de paquets envoyés avec le même vecteur d’initialisation dans un temps réduit. Détecter un grand nombre de paquets avec le même vecteur d’initialisation dans une période de temps courte (une seconde par exemple) est souvent indicateur d’une attaque par injection.

5.5 Détection des injection VLAN

Certains points d’accès peuvent être attaqués par des paquets VLAN de la norme 802.1Q. Pour détecter ce type d’intrusions il suﬃt de détecter la présence d’en-tête 802.1Q dans les paquets wiﬁ.

5.6 Détection d’usurpation de point d’accès

Certaines attaques consistent à créer un point d’accès avec les mêmes caractéristiques que le point d’accès attaqué pour pouvoir contrôler les données transmises. La détection d’une attaque de ce type se fait au niveau du point d’accès qui doit lancer une alerte s'il détecte un autre point d'accès avec les mêmes caractéristiques que lui.

Troisième partie
Failles de sécurité

6 WEP

6.1 Introduction aux failles du protocole

Le WEP est malheureusement un protocole très vulnérable en raison de ses caractéristiques cryptographiques de qualité insuﬃsante. Déjà en 1995, des chercheurs ont pu démontrer des failles dans l’algorithme du RC4 (Wagner, Roos,...) utilisé dans le protocole WEP. Mais ce dernier restait encore un protocole plutôt ﬁable et c’est à partir du début des années 2000 que de plus en plus de faiblesses sont révélées, avec des articles et des publications sur le sujet. Puis en 2004-2005, des attaques montrent la quasi obsolescence du protocole.

Les failles suivantes ont été trouvées dans le protocole WEP :

En terme de conﬁdentialité, la partie secrète de la clé est la même pour tout le monde et la partie envoyée en clair (IV) a 24 bits (la clé est réutilisée après 224 trames). Les STA (Spanning Tree Algorithm) utilisent le même IV quand elles commencent à transmettre. Il existe des méthodes qui permettent de découvrir la clé WEP à partir d’un certain nombre de trames interceptées. Le paradoxe des anniversaires fait que dès que l'on a capturé environ 5000 paquets, on a plus d’une chance sur deux d’avoir utilisé la même clé.
Concernant les doublons, aucune protection n’est mise en place.
Le contrôle d’intégrité n’est pas cryptographiquement sûr ; l’utilisation du CRC est satisfaisante pour des erreurs aléatoires mais pas pour les erreurs délibérées et il est possible de modiﬁer des messages sans être détecté (changer des données et ICV).
Enﬁn, aucune authentiﬁcation bidirectionnelle n’est prévue et seule la station (STA) est authentiﬁée. Le challenge d’authentiﬁcation à clé partagée est envoyé en clair ce qui provoque une exposition dangereuse à des attaques connues.

6.2 Diﬀérentes attaques sur le protocole

Les attaques ont donc commencé dès 2001 (ces attaques avaient pour but d’exploiter les failles laissées par le protocole WEP). Une multitude d’attaque et de méthode existent aujourd’hui, par exemple :

L’attaque des "mots de passe" par dictionnaire
L’attaque "man in the middle"
Packet injection
Attaque FMS
Fake authentication
L’attaque chopchop de KoreK
Bit ﬂipping sur la somme de contrôle CRC-32
Plaintext attack
Attaque par fragmentation
Attaque par IV connu
Utilisation de vecteurs d’initialisation IV « faibles »
Collision des vecteurs d’initialisation IV
Réutilisation du vecteur d’initialisation IV

Dans ce document, nous allons nous intéresser plus particulièrement à 2 de ces attaques : Packet injection et FMS.

L’attaque par injection de paquets a pour but d’accélérer la production d’IV nécessaire à l’obtention de la clé. Cette attaque est très eﬃcace lorsqu’une station connectée génère des requêtes ARP. L’attaquant essaie de trouver un paquet ARP chiﬀré aﬁn de l’utiliser pour l’injection. L’injection de paquets peut être considérée comme une véritable attaque contre le WEP, car ce protocole n’a pas été conçu pour résister à ce type de menace. Un paquet envoyé dans un réseau protégé par le WEP et qui a été intercepté par un attaquant peut ensuite être injecté à nouveau dans le réseau, à condition que la clé n’ait pas été modiﬁée et que la station d’envoi d’origine soit toujours dans le réseau.

Autre type d’attaque, l’attaque FMS (pour les initiales des noms des chercheurs FLURHER, MANTIN et SHAMIR). En 2001, les chercheurs Scott FLURHER, Itsik MANTIN et Adi SHAMIR ont publié une attaque de récupération de clé qui consiste à exploiter le fait que le protocole WEP possède des IVs faibles. C’est à dire que l’attaquant va récupérer des paquets chiﬀrés en écoutant passivement le traﬁc et mémoriser les 3 premiers octets publics. Il connaît alors les l premiers octets d’une clé RC4 utilisée pour générer un keystream X. Il peut ainsi commencer à eﬀectuer les premières étapes du RC4-KSA (Key scheduling algorithm) pour connaître S_l et j_l. Ensuite, j_l+1 = j_l + K[l] + S_l[l] et une permutation est faite entre S_l[j_l+1] et S_l[l]. Mais si l’attaquant pouvait connaître S_l+1[l] il pourrait alors obtenir K[l] en faisant S_l⁻¹[S_l+1[l]] − j_l − S_l[l].
Les 3 chercheurs ont alors une méthode pour l’obtenir : supposons que les conditions suivantes se maintiennent après les l premières étapes du RC4-KSA (les conditions 3 et 4 ont été introduites plus tard, par Korek pour améliorer l’eﬃcacité de l’attaque) :

1. S_l[1] < l
2. S_l[1] + S_l[S_l[1]] = l
3. S_l⁻¹[X[0]]≠1
4. S_l⁻¹[X[0]]≠S_l[1]

Ensuite, une valeur k à laquelle on aﬀecte S_l[j_l+1] pour après la permuter avec S_l+1[l]. Si j change aléatoirement pendant le reste de l’algorithme, les valeurs S[1], S[S[1]] et S[l] ne seront pas modiﬁées avec une probabilité d’environ ( 1
e )³ ≃ 5∕100 pour le reste de l’algorithme. Quand le premier octet de sortie est produit par le RC4-PRGA (Pseudo-random generation algorithm), j prendra la valeur S_n[1] puis S_n[1] et S_n[j] seront échangés. Après cela, S_l[1] + S_l[S_l[1]] = l tient toujours et le premier octet de sortie du RC4-PRGA X[0] sera alors S[l]. Ensuite, si ces 4 conditions sont toujours vériﬁées, la fonction suivante :

F_fms(K[0],...,K[l − 1],X[0]) = S₁⁻¹[X[0]] − j_l − S_l[l]

prendra alors la valeur de K[l] avec une probabilité de ( 1
e )³ ≃ 5∕100. Ainsi, grâce à ces conditions et cette fonction, on peut donc lancer une attaque de récupération complète de la clé sur le WEP. L’attaquant, lorsqu’il a capturé suﬃsamment de paquets, sélectionne où se trouve les conditions résolues et calcule F_fms pour ces paquets. Chacun des résultats pourra être considéré comme un vote pour la valeur de Rk[0] et l’attaquant devra choisir laquelle correspond bien à la vraie valeur de Rk[0]. Si la décision est bonne, alors il connaît les premiers l octets de chaque paquet et il fait de même pour Rk[1] et ainsi de suite. Une fois tous les octets de Rk obtenus, l’attaquant vériﬁe alors la clé qu’il a pu former aﬁn de savoir si elle est correcte ; dans l’aﬃrmative l’attaque a réussi.

En moyenne il fallait au moins 4 000 000 de paquets chiﬀrés pour retrouver la clé avec une probabilité supérieure à 1/2.

Autre type d’attaque, Korek en 2004 (qui introduit en même temps l’attaque chopchop). Korek est un hacker qui a publié une série de 16 attaques sur le WEP pour retrouver la clé de chiﬀrement. Pour cela la structure de l’attaque est la même que pour l’attaque FMS mais celle de Korek permet de réduire le nombre moyen de paquets nécessaire à 700 000 pour une probabilité qui est autour de 1/2.
Toutefois c’est en 2005 qu’une équipe du FBI démontre la possibilité de rentrer dans un réseau protégé par le protocole WEP en moins de 5 minutes avec des outils pratiquement à la portée de tous. En eﬀet, ces agents du FBI auraient utilisé, entre autre, Kismet, un logiciel de détection de réseaux et Airodump, qui fonctionne avec Aircrack, pour capturer les paquets. Durant cette démonstration, ils ont notamment utilisé une attaque par rejeu.

Cette démonstration prouvait alors déﬁnitivement l’insuﬃsance de ce protocole pour assurer la sécurité d’un réseau (le WPA existait déjà à ce moment-là).
Aujourd’hui il est même possible d’entrer dans un réseau protégé par le protocole WEP en moins d’une minute grâce à de bons outils et c’est la raison pour laquelle il n’est presque plus utilisé sur les réseaux WIFI.

7 Authentiﬁcation : 4-way handshake

Le 4-Way Handshake est utilisé par WPA2. Il permet l’authentiﬁcation d’un appareil voulant se connecter à un réseau WIFI. Ce processus en 4 temps a pour but de générer diﬀérentes clés de chiﬀrement qui seront ensuite utilisée par le client pour communiquer sur le réseau.

Ce processus étant à la base de la faille KRACK que nous présenterons dans la prochaine partie, il est nécessaire de s’attarder quelques instants sur son fonctionnement.

7.1 Les diﬀérentes clés et outils utilisés

A = Point d’accès
S = Station
ANonce = Authenticator Number (used) once : est un nombre généré aléatoirement par le point d’accès
SNonce = Supplicant Number (used) once : est un nombre généré aléatoirement par le client
MAC(AA) = adresse MAC du point d’accès
MAC(SA) = adresse MAC de la station
PMK = Pairwise Master Key : La PMK est une clé connue du point d’accés et de la station, elle correspond à la PSK (Pre-Shared Key qui représente un secret partagé entre la station et le point d’accès) dans le cas du WPA2 personnel.
PTK = Pairwise Transcient Key : est une clé utilisée pour chiﬀrer les trames de la station à destination du point d’accès.
PRF (PMK + Anonce + SNonce + Mac (AA)+ Mac (SA)) : PRF est une fonction pseudo-aléatoire avec en entrées diﬀérentes données citées plus tôt, cette combinaison aura pour but de calculer la PTK.
GTK = Group Transient/Temporal Key : est une clé commune à toutes les stations associées au point d’accès. Elle est utilisée pour le chiﬀrement des trames multicast et broadcast.
MIC = Message Integrity Code (contrôle d’intégrité des données).

EAPoL-Key ⁵ = Paquet qui permet l’échange de clé de chiﬀrement, de forme :


MAC header	Ethernet Type	Version	Packet Type

12 octets	2 octets	1 octets	1 octets


Packet Body Length	Packet Body	Frame Check Sequence

2 octets	Taille variable	4 octets

Pour le 4-Way Handshake, le champ "Type de paquet" prend la valeur 0000 0011 qui désigne le type EAPoL-key.

7.2 Utilisation du 4-Way Handshake

Le 4-way-handshake débute après l’EAP Success reçu par la station. Comme son nom l’indique le 4-way-handshake comporte 4 messages qui sont envoyés entre la station et le point d’accès, le premier message est envoyé par le point d’accès vers la station. Et comme dit précédemment, chaque message transmis est encapsulé avec EApoL-key.

Premier message :

Le premier message (du point d’accès vers la station) contient le ANonce et est encapsulé avec EAPoL-Key comme montré ci-dessus (l’encaspulation ne sera plus précisée par la suite mais sera eﬀectuée à chaque étape). À cette étape, la station possède toutes les informations pour calculer la PTK.
Deuxième message :
Le deuxième message (de la station vers le point d’accès) contient le SNonce et un MIC (chiﬀré par la station). Avec ces informations, le point d’accès est lui aussi capable de calculer la PTK, il peut alors vériﬁer le MIC.
Troisième message :
Le troisième message (du point d’accès vers la station), contient la GTK. C’est à la réception de ce message que le point d’accès installe la PTK. Ce point sera traité plus précisément lors du chapitre sur la faille KRACK.
Quatrième message :

Le quatrième et dernier message, de la station vers le point d’accès, informe ce dernier que la GTK et la PTK ont été installées, à cette même étape le point d’accès installe lui aussi la PTK.

Après l’exécution du 4-way-handshake, le traﬁc est ouvert pour la station ; toutes les trames en unicast seront chiﬀrées avec la PTK et les trames en multicast et broadcast le seront avec la GTK.

8 WPA2

8.1 Faille KRACK

8.1.1 Résumé de la situation

Le protocoles WPA2 (chiﬀrement CCMP qui s’appuie sur AES) est, depuis l’abandon oﬃciel du WEP par la Wi-Fi Alliance en 2004, le protocole le plus largement utilisé pour la sécurisation des réseau WIFI. Cependant, un type d’attaque nommé KRACK ⁶ (Key Reinstallation Attacks) découvert par Mathy Vanhoef et Frank Piessens en 2017 permet, grâce à une conﬁguration "homme du milieu" (man in the middle), de déchiﬀrer des données transmises sur un réseau protégé par le protocole WPA2. Contrairement à d’autres attaques, l’existence de la vulnérabilité ne dépend pas des diﬀérentes implémentations du protocole mais se situe dans le protocole lui-même. C’est ici la phase de connexion d’un appareil au point d’accès qui est concernée, cette phase est appelée 4-way handshake (décrit dans la partie précédente). Cette étape permet de déﬁnir avec quelle clé (PTK : Pairwise Transient Key - diﬀérente pour chaque session) les messages envoyés sur le réseau seront chiﬀrés. Les protocoles WPA2 personnel et entreprise sont concernés par cette vulnérabilité car ils utilisent tous deux un 4-way handshake. Il existe diﬀérentes formes d’attaques KRACK, et nous prenons ici le parti de décrire la plus connue d’entre-elles qui opère sur le troisième message du 4-way handshake.

8.1.2 Outils de détection

Mathy Vanhoef a mis à disposition un ensemble de scripts permettant de détecter si un client ou un point d’accès est concerné par les attaques de type KRACK :
https://github.com/vanhoefm/krackattacks-scripts

8.1.3 Attaque de l’homme du milieu (man in the middle : MITM)

Une telle attaque consiste, pour un attaquant, à rediriger le traﬁc du réseau aﬁn qu’il passe par sa machine (pour cela, il existe diﬀérentes méthodes : ARP Poisoning, au DNS Spooﬁng, ou encore la création d’un point d’accès WIFI...). Cette conﬁguration lui permet de lire les données échangées et dans certains cas de les modiﬁer. Il peut également injecter des données sur le réseau. ⁷

https://www.thesslstore.com/blog/man-in-the-middle-attack-2/

8.1.4 Associativité du XOR (eXclusive OR)

algèbre de boole :
XOR est noté : $⊕$

(a⊕ b)⊕ c

= ((a.¬b + ¬a.b).¬c)+ (¬(a.¬b + ¬a.b).c)

= (a.¬b.¬c + ¬a.b.¬c)+ (¬(a.¬b).¬(¬a.b).c)

= (a.¬b.¬c+ ¬a.b.¬c)+ ((¬a +b).(a + ¬b).c)

= (a.¬b.¬c+ ¬a.b.¬c) + (¬a.a.c) + (¬a.¬b.c)+ (b.a.c)+ (b.¬b.c)

= (a.¬b.¬c+ ¬a.b.¬c)+ (¬a.¬b.c)+ (b.a.c)

= a.((¬b.¬c)+ (b.c))+ ¬a.(b.¬c+ ¬b.c)

= a.¬(¬(¬b.¬c).¬(b.c))+ ¬a.(b.¬c+ ¬b.c)

= a.¬((b+ c).(¬b+ ¬c))+ ¬a.(b.¬c + ¬b.c)

= a.¬(b.¬b + b.¬c+ c.¬b+ c.¬c )+ ¬a.(b.¬c + ¬b.c)

= a.¬(b.¬c+ c.¬b)+ ¬a.(b.¬c+ ¬b.c)

= a ⊕ (b ⊕c)

Donc $(a⊕ b)⊕ c = a ⊕ (b ⊕ c)$

8.1.5 Fonctionnement de l’attaque

La mise en place de cette attaque débute par la création, par l’attaquant, d’un clone du point d’accès WIFI sur un canal diﬀérent (il y a par exemple 11 canaux sur la bande des 2.4GHz). Les données transmises seront ensuite relayées sur le canal réel du point d’accès. Dans cette situation, l’attaquant peut intercepter les données transmises mais est incapable de les déchiﬀrer. Voici un extrait de Operating Channel Validation : Preventing Multi-ChannelMan-in-the-Middle Attacks Against Protected Wi-Fi Networks⁸ par Mathy Vanhoef, Nehru Bhandaru et Thomas Derham :

"3.3 Channel Switch Announcements (CSAs)We discovered a novel method to force clients into connecting to the rogue AP. In particular, an adversary can forge Channel SwitchAnnouncements (CSAs) to force a client to switch to the rogue AP’schannel. Normally these announcements are sent when the AP is switching to a diﬀerent channel. For instance, when an AP operates on certain 5 GHz channels and detects (weather) radar pulses, it must switch to a diﬀerent channel to comply with regulations.Channel switch announcements can be broadcasted using three diﬀerent frames. The ﬁrst is by including a CSA element inside a beacon. The second method is by including a CSA element inside a probe response. And the third technique is to send action frames with a CSA element to associated clients. The ﬁrst two methods use unprotected management frames, and the third method is protected when MFP is enabled. As a result, even when MFP is used, an adversary can forge CSA elements inside beaconsand probe responses to force clients to switch channels."

La seconde étape consiste à transmettre les trois premiers messages du 4-way handshake puis à bloquer le quatrième. Du point de vue du client, la procédure de connexion est terminée mais le point d’accès n’a pas reçu le dernier message. Dans cette situation, le point d’accès procède à la ré-émission du troisième message qui est traité à nouveau, or, le client ayant déjà installé la clé de chiﬀrement (PTK), le quatrième message (envoyé pour la seconde fois) est désormais chiﬀré. L’attaquant doit ici bloquer ce message chiﬀré qui serait rejeté par le point d’accès et retransmettre la première version du quatrième message (non chiﬀré) au point d’accès aﬁn qu’il installe la clé de chiﬀrement à son tour (l’utilisation de ce message 4 non chiﬀré implique que le numéro de paquet n’est pas le plus récent : toutefois de nombreuses implémentations l’acceptent tout de même car il n’a jamais été utilisé dans une trame de réponse de la part du client mais seulement en émission depuis le point d’accès). À cette étape, la clé est réinstallée par le client, ce qui entraîne la réinitialisation du compteur de trames (Nonce) et donc, l’émission de trames avec un Nonce déjà utilisé. Cela permet de déchiﬀrer les trames envoyées dans la mesure où le keystream est utilisé pour la seconde fois. L’opération XOR bit à bit entre le message 4 chiﬀré et celui non chiﬀré donne :

note : Nous utilisons ici les mêmes notations que dans le document décrivant le fonctionnement du chiﬀrement RC4

C = G ⊕ M

C ⊕ M = (G ⊕ M )⊕ M

donc par associativité : $(G ⊕ M )⊕ M = G ⊕ (M ⊕ M ) = G$

Représentation simpliﬁée du chiﬀrement avec WPA2-CCMP

Nous connaissons alors le keystream utilisé pour les trames chiﬀrées correspondant à ce Nonce, et elles deviennent donc facilement déchiﬀrables.

L’utilisation d’un chiﬀrement sur la couche transport (SSL) permet d’éviter que les données soient déchiﬀrables grâce à une attaque de type KRACK. Il est cependant possible de contourner cette sécurité grâce à sslstrip ⁹ comme présenté par Mathy Vanhoef. ¹⁰ Il est donc préférable d’utiliser du matériel à jour (non exposé à ce type d’attaques).

8.1.6 Cas particuler : wpa_supplicant 2.4 et 2.5

wpa_supplicant est un client WIFI utilisé par linux et android. Après l’installation de la clé de chiﬀrement par le noyau linux, wpa_supplicant ne conserve pas de copie de cette clé et l’eﬀace avec des 0 dans la mémoire (conseillé par la norme ieee 802.11).

os_memset(sm->ptk.tk,0, WPA_TK_MAX_LEN);

Lors de la réinstallation, c’est la clé appelée "all-zero key" qui est installée, et à partir de cet instant, toutes les trames transmises en unicast sont chiﬀrées avec cette nouvelle clé. Ainsi, les données sont facilement déchiﬀrables. C’est l’exécution à deux reprises de la fonction

wpa_supplicant_install_ptk()

qui est à l’origine de la vulnérabilité.

Voici une partie du commit ¹¹ qui empêche l’installation d’une clé "all-zero" dans la version 2.6 de wpa_supplicant :

+ if (!sm->tk_to_set) {
+ wpa_dbg(sm->ctx->msg_ctx, MSG_DEBUG,
+ "WPA: Do not re-install same PTK to the driver");
+ return 0;
+ }

puis

+ sm->tk_to_set = 0;

qui empêche une réinstallation de la clé si la fonction est exécutée plus d’une fois. wpa_supplicant 2.6 est cependant vulnérable à un autre type d’attaque de la famille KRACK qui agit sur le premier message du 4-way handshake.

8.1.7 Impact

Dans la pratique, cette attaque permet de déchiﬀrer les données transmises après l’exécution du 4-way handshake, or, ces données ne sont pas "intéressantes" pour un attaquant. Il est cependant possible de forcer la "désautentiﬁcation" du client, le système d’exploitation procède alors à un nouveau 4-way handshake aﬁn de se reconnecter au point d’accès. Les données transmises après cette reconnexion pourront être déchiﬀrées (car les connexions TCP ne sont pas fermées pendant ce processus).

Dans le cas de l’installation d’une "all-zero key" il est possible de calculer le keystream utilisé et donc de déchiﬀrer les données transmises pour chaque valeur de nonce. Notons tout de même ceci : "The real AP will then ignore data frames from the victim (because it fails to decrypt them)." (ceci nous a été précisé lors d’une conversation avec Mathy Vanhoef)

8.1.8 Informations complémentaires

Il est possible de contrôler le nombre de valeurs de nonce qui seront réutilisées en choisissant l’instant de réémission du troisième message du 4-way handshake. "You can delay the key reinstallation to, in principle, decrypt arbitrary many frames. E.g. you let the victim send N frames, and only then trigger to key reinstallation, after which you can decrypt N frames."(ceci nous a également été précisé par Maty Vanhoef).

De plus, si nous ne disposons pas de la version non chiﬀrée d’une trame mais seulement de deux trames chiﬀrée avec une réutilisation du Nonce, il est possible d’utiliser des méthodes telles que le crib dragging ¹² pour déchiﬀrer les données.

Voici ce qui nous a été précisé par Mathy Vanhoef "Here we assume that if there are two message with a reused nonce, we know the plaintext of one of them, e.g. based on the length of the frame we can predict what type of packet it is, and this packet may have a very predictable content. For example, traﬃc analysis can be used to detect (based on encrypted frames) which plaintext HTTP website a victim is visiting, allowing is to predict the content of a lot of frames. This predicted plaintext can then be used to decrypt the other frames with the reused nonce."

8.1.9 Correctifs

La majorité des appareils qui étaient encore maintenus lors de cette découverte ont reçu une mise à jour de sécurité empêchant l’exploitation de KRACK. Il faut cependant veiller à ce que les points d’accès (également vulnérables) aient été mis à jour dans la mesure où ce processus n’est généralement pas automatique.

8.2 Faille Kr00k

Une vulnérabilité permettant de déchiﬀrer les données transmises sur les réseaux utilisant le protocole WPA2 a été découverte par la société ESET en 2019 et rendue publique le 26 février 2020 (RSA Conference). Les chercheurs d’ESET ont découvert cette vulnérabilité alors qu’ils cherchaient à déterminer si l’Amazon echo 2 était concerné par une attaque de type KRACK. Nommée Kr00k, ¹³ elle concerne la phase de désassociation d’une station et d’un point d’accès qui peut être amorcée de plusieurs manières.

8.2.1 Fonctionnement

Après une désassociation, la clé de chiﬀrement utilisée est eﬀacée dans la mémoire de la puce WIFI et est remplacée par des 0. Il est cependant possible que des données se trouvent encore dans le tampon d’émission (d’une capacité de 32Kb). Ces trames sont chiﬀrées avec la clé en mémoire ("all-zero key") et envoyées sur le réseau. Les données sont alors facilement déchiﬀrables si elles ne sont pas chiﬀrées à un niveau supérieur (SSL par exemple sur la couche transport).

Les désassociations se produisent naturellement lorsque la station passe d’un point d’accès à un autre, par exemple. Il est cependant possible de forcer cette désassociation par des trames spéciales : "802.11 management frames" qui ne sont pas chiﬀrées et peuvent donc être envoyées par un attaquant.

Source : RSA Conference 2020, ESET

Le contenu des trames récupérées est alors aléatoire car il dépend de l’instant auquel se produit la désassociation. La répétition du processus permet d’obtenir un grand nombre de trames et donc potentiellement des données intéressantes pour un attaquant.

8.2.2 Appareils concernés

Les puces WIFI touchées sont celles des fabricants Broadcom et Cypress, ce qui concerne plus d’un milliard d’appareils (clients et points d’accès). Voici une liste non-exhaustive des modèles concernés :

Amazon Echo 2nd gen
Amazon Kindle 8th gen
Apple iPad mini 2
Apple iPhone 6, 6S, 8, XR
Apple MacBook Air Retina 13-inch 2018
Google Nexus 5
Google Nexus 6
Google Nexus 6P
Raspberry Pi 3
Samsung Galaxy S4 GT-I9505
Samsung Galaxy S8
Xiaomi Redmi 3S
Asus RT-N12
Huawei B612S-25d
Huawei EchoLife HG8245H
Huawei E5577Cs-321

Si l’attaque est menée sur un point d’accès, ce sont les trames envoyées par ce dernier qui seront déchiﬀrables même si le client connecté n’est pas vulnérable.

8.2.3 Correctifs

Des correctifs logiciels ont été développés et déployés en 2019 et 2020 par les fabricants des puces WIFI concernées pendant la période de 120 jours octroyée par ESET avant que Kr00k ne soit rendue public.

8.3 Autres attaques

Il existe d’autres attaques visant les réseaux utilisant le protocole WPA2 ¹⁴ . Certains logiciels implémentent des attaques par force brute qui ont pour but de trouver le mot de passe sécurisant le réseau en forçant un client à se déconnecter et à procéder à un nouveau 4-way handshake. Ce type d’attaque est très rapide sur les réseaux protégés par un mot de passe faible susceptible de se trouver dans une liste de mots de passe appelée "dictionnaire". Le protocole WPA3 ayant pour objectif d’empêcher les attaques connues sur le WPA2 a été introduit par la WIFI Alliance en 2018 et commence à être utilisé :

WPA3-Personal brings better protections to individual users by providing more robust password-based authentication, even when users choose passwords that fall short of typical complexity recommendations. This capability is enabled through Simultaneous Authentication of Equals (SAE), which replaces Pre-shared Key (PSK) in WPA2-Personal. The technology is resistant to oﬄine dictionary attacks where an adversary attempts to determine a network password by trying possible passwords without further network interaction.¹⁵

Il est à noter que Mathy Vanhoef et Eyal Ronen ont découvert une attaque ¹⁶ visant le "Dragonﬂy handshake" utilisé par le WPA3 permettant de trouver le mot de passe d’un réseau utilisant ce protocole. Des correctifs ont cependant déjà été apportés et l’utilisation de WPA3 en remplacement de WPA2 est conseillée (si possible) du fait de la complexité des attaques par lesquelles ce protocole est concerné.

Conclusion et références

Conclusion

Comme nous l’avons vu, le chemin qui mène du WEP au WPA2 a été rapidement parcouru, du fait des évidentes failles de sécurité qui sont apparues au fur et à mesure de l’utilisation du WEP, notamment en raison de la présence de l’algorithme de chiﬀrement RC4 aujourd’hui considéré comme non ﬁable.
Le WPA a vite montré ses limites et il a fallu l’améliorer, pour arriver au WPA2.
Toutefois depuis 2017 déjà, on s’est rendu compte que le WPA2 (IEEE 802.11i) lui-même n’est pas exempt de faiblesses. Les travaux de Mathy Vanhoef et Frank Piessens, deux chercheurs belges, ont dévoilés ses failles, en particulier pour la partie jusque-là considérée comme sûre : la phase d’authentiﬁcation nommée 4 way handshake.
L’IEEE a donc établi un nouveau cahier des charges, aﬁn de mettre au point le WPA3. Toutefois, les enjeux de la sécurité réseau obligent à des mises à niveau permanentes et il y a fort à parier que le WPA3 devra rapidement être mis à jour. D’autant que Mathy Vanhoef et Eyal Ronen ont signalé qu’ils avaient découvert une faille de sécurité (corrigée depuis) dans le Dragonﬂy Handshake utilisé par ce protocole.