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 CCIE #47705, focused on R&S, Data Center and SDN.

More Posts - Website

Follow Me:
TwitterLinkedIn

3 Comments

  1. Sid 22 août 2009

    Tu écris: « Voici une des plusieurs failles de RC4″…

    En fait, ce sont des failles induites par une mauvaise utilisation de RC4. Pour le cas de l’authentification, c’est un problème de mauvais key scheduling, donc de possible réutilisation de clés.

  2. Benoit 23 août 2009

    Bonjour Sid,
    Il est vrai que ces faiblesses sont plutôt induites par l’utilisation que fait WEP de l’algorithme RC4…
    Au plaisir de te revoir faire un détour par mon blog.
    N’hésite pas à me reprendre s’il le faut !

  3. Sid 24 août 2009

    Par contre, RC4 présente des faiblesses qui peuvent être utilisées pour exploiter plus efficacement la mauvaise utilisation qui en est faite par WEP. Cf. le problème des clés faibles qui conduit à la FMS, le papier de Klein que tu cites ou encore la plus récente PTW.

    Au plaisir de te relire. Tchuss :)

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Vous pouvez utiliser ces balises et attributs HTML : <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>