Etude de WEP et Rivest Cipher 4

Le Wired Equivalent Privacy (abrégé WEP) est un protocole pour sécuriser les réseaux sans fil de type Wi-Fi.

Ce protocole de “protection” des réseaux WIFI est bien sur obsolète depuis maintenant 2001, mais nous trouvons encore beaucoup de réseaux de particuliers qui implémentent ce protocole  (ainsi que certaines entreprises peu soucieuses ou inconscientes des failles de ce protocole). Ce protocole à été remplacé par WPA, WPA2..etc. (pour infos, WPA peux également être déchiffré, et implémente aussi l’algorithme RC4, contrairement à WPA2 qui utilise AES pour “Advanced Encryption Standard”).

Le WEP fait partie de la norme IEEE 802.11. Le WEP utilise l’algorithme de chiffrement par flot RC4 pour assurer la confidentialité et la somme de contrôle CRC-32 (contrôle de redondance cyclique ) pour assurer l’intégrité des paquets et c’est sur ce protocole RC4 que nous allons nous pencher dans cet article.

RC4 est un protocole de génération de bits pseudo aléatoires utilisé nottement dans les protocoles WEP, mais aussi SSH. Il fonctionne de la façon suivante : la clef RC4 permet d’initialiser un tableau de 256 octets en répétant la clef autant de fois que nécessaire pour remplir le tableau. Par la suite, des opérations très simples sont effectuées : les octets sont déplacés dans le tableau, des additions sont effectuées, etc. Le but est de mélanger autant que possible le tableau.

Au final on obtient une suite de bits pseudo-aléatoires qui peuvent être utilisés pour chiffrer les données via un XOR.

L’algorithme RC4, pour ”Rivest Cipher 4”, permet, à partir d’une clé secrète, d’obtenir une suite de bits qui servent à encoder un message en faisant simplement un XOR bit à bit avec les données du message. Plus précisément, étant donnée K (la clé) un tableau d’octets de longueur len ≤ 256, l’algorithme commence par générer une permutation S aussi aléatoire que possible à l’aide de l’algorithme suivant :

Algorithm 1 RC4 key setup – KSA Algorithm (Key Scheduling):

1: for i ← 0 to 255 do
2: S[i] ← i
3: end for
4: j ← 0
5: for i ← 0 to 255 do
6: j ← S[i] + K[i mod len(K)] mod 256
7: swap(S, i, j)
8: end for
9: j ← 0
10: i ← 0

La permutation S et les variables i, j sont appelées “état interne de l’algorithme RC4”.

Ensuite, à chaque fois qu’on a besoin d’un octet pour en faire le xor avec les données qu’on
veut crypter, on appelle la fonction suivante :

Algorithm 2 RC4 key stream generation – PRGA Algorithm (pseudo-random generation):

1: i ← i + 1 mod 256
2: j ← j + S[i] mod 256
3: swap(S, i, j)
4: k ← S[i] + S[j] mod 256
5: return Xi = S[k]

Structure du générateur avec la dernière opération de génération. Loctet en sortie pour le flux de chiffrement est choisi dans le tableau, à lindex S(i) + S(j). On retrouve en sortie cette valeur S(S(i) + S(j)) qui sera xor-ée avec loctet correspondant du texte clair.

Implémentation de RC4 en C

unsigned char S[256];
unsigned int i, j;

/* KSA */
void rc4_init(unsigned char *key, unsigned int key_length) {
for (i = 0; i < 256; i++)
S[i] = i;

for (i = j = 0; i < 256; i++) {
unsigned char temp;

j = (j + key[i % key_length] + S[i]) & 255;
temp = S[i];
S[i] = S[j];
S[j] = temp;
}

i = j = 0;
}

/* PRGA */
unsigned char rc4_output() {
unsigned char temp;

i = (i + 1) & 255;
j = (j + S[i]) & 255;

temp = S[j];
S[j] = S[i];
S[i] = temp;

return S[(temp + S[j]) & 255];
}

#include
#include
#include

int main() {
unsigned char test_vectors[3][2][32] =
{
{"Key", "Plaintext"},
{"Wiki", "pedia"},
{"Secret", "Attack at dawn"}
};

int x;
for (x = 0; x < 3; x++) {
int y;
rc4_init(test_vectors[x][0], strlen((char*)test_vectors[x][0]));

for (y = 0; y < strlen((char*)test_vectors[x][1]); y++)
printf("%02X", test_vectors[x][1][y] ^ rc4_output());
printf("\n");
}
return 0;
}

Technique d’attaque de RC4

Voici une des plusieurs failles de RC4:

Une stupidité: l’authentification

Le point d’accès envoi un texte en clair T que le client qui veut s’authentifier doit renvoyé codé.
Si l’on sniffe le réseau, on peux donc voir passer:
* Un texte en clair T
* Le vecteur d’initialisation (VI)
* Le texte codé T ⊕ C=F

Il en déduit immédiatement le code RC4 correspondant à VI: C=F ⊕ T =T ⊕ T⊕ C

ON PEUX S’AUTHENTIFIER SANS PROBLÈME

De plus si T’ est un nouveau texte, posons M=T⊕T’, T’ codé par C sera

F’=T’⊕C=T⊕M⊕C=M⊕T⊕C=M⊕F connu

On peut envoyer un texte codé de même longueur sans problème

L’utilisation de cela avec le protocole réseau permet de «générer», ou «injecter» du trafic sur un réseau WIFI sans problème.

Annexes très intéressants:

Breaking 104 bit WEP in less than 60 seconds

Attacks on the RC4 stream cipher

Benoit

Network engineer at CNS Communications. CCIE #47705, focused on R&S, Data Center, SD-WAN & Automation.

More Posts - Website

Follow Me: