Consignes

Le TP est à rendre, par email, avant le 24 décembre à 23h59...

Pour ce TP, la seule chose à m'envoyer sera un fichier prenom-nom.c contenant votre programme. Ce fichier sera utilisable directement avec les autres fichiers fournis pour le TP.

Le non-respect de cette consigne risque de me mettre de mauvaise humeur...

Attention, le seul fait que votre programme fonctionne ne suffit pas pour avoir une bonne note. Les points suivants seront pris en compte :

1. l'architecture de votre programme (code découpé en fonctions etc.),
2. la lisibilité de votre programme (choix pertinent pour les noms de variables etc.),
3. la présence de commentaires aux endroits appropriés,
4. la présence de documentation pour vos fonctions.

Attention : les points suivants ne rapportent rien, mais ne pas les respecter pourra retrancher jusqu'à 10 points sur la note finale :

• chaque fichier devra comporter un commentaire au début avec vos nom, prénom, filière et numéro du TP,
• votre code doit compiler avec les options -Wall -Werror -Wextra -pedantic -std=c99,
• le sujet de votre message email pour m'envoyer le TP devra comporter la chaîne info528, ou info-528 ou info 528,
• une exécution du programme principal « à vide » (./FMS) ne devra pas provoquer d'erreur.

Liens utiles

• page wikipedia sur RC4.

1. Rappels : RC4

« RC4 » peut-être vu comme un générateur pseudo-aléatoire pour crypter un flot de données sur le modèle du « bloc-notes à usage unique » : chaque octet du flot de données est combiné (avec un XOR) avec l'octet correspondant de RC4. Il n'existe, à ce jours, pas d'attaque pour RC4 général.

RC4 comporte deux phases :

1. initialisation à partir d'une clé de taille t, entre 1 et 256 octets,
2. génération d'octets aléatoires.

En pseudo C, si on note "cle" la clé, et "t" sa taille :

KSA:  (* Key Scheduling Algorithm *)
  for(i = 0; i < 256; i++)
    etat.S[i] = i

  j = 0
  for(i = 0; i < 256; i++)
    j = (j + etat.S[i] + cle[i % t])  %  256
    etat.S[i]  <->  etat.S[j]    (* échange *)
  etat.i = 0
  etat.j = 0

et

PRGA:  (* Pseudo Random Generator Algorithm *)
  etat.i = (etat.i + 1)  %  256
  etat.j = (etat.j + etat.S[etat.i])  %  256
  etat.S[etat.i]  <->  etat.S[etat.j];  (* échange *)
  return etat.S[ (etat.S[etat.i] + etat.S[etat.j])  %  256]

void code_RC4_drop(char *K, char *M, int n)

2. WEP et RC4

2.1. Introduction

Le WEP ("Wired Equivalent Privacy") crypte chaque paquet en utilisant deux clés :

1. la clé WEP, sur 40 ou 104 bits, càd sur 5 ou 13 octets,
2. une "clé" temporaire, ou vecteur d'initialisation sur 24 bits, càd sur 3 octets.

Chaque paquet est codé avec RC4 en utilisant la clé "vecteur d'initialisation + clé WEP" (sur 8 ou 16 octets donc) et est envoyé avec son vecteur d'initialisation.

Pour décoder, on récupère le vecteur d'initialisation, concatène la clé WEP derrière et décode avec RC4.

De cette manière, on ne peut décoder que si on possède la clé WEP, et on utilise quand même des clés différentes pour chaque paquet. (C'est important, car sinon, il suffirait d'un message décodé pour retrouver le début de la suite pseudo-aléatoire, et donc de pouvoir décoder tous les messages de taille inférieure.

2.2. Attaque de Fluhrer, Mantin et Shamir

En 2001, Fluhrer, Mantin et Shamir ont montré que l'utilisation de RC4 pour WEP rendait la clé facilement craquable. Il suffit de récupérer un nombre relativement faible de paquets cryptés dont on connaît le premier octet. (On garde également leurs vecteurs d'initialisation...)

Nous avons vu l'attaque de Fluhrer, Mantin et Shamir en cours. Pour ce TP, vous devrez l'implanter pour vérifier qu'on peut effectivement récupérer une clé à partir de suffisamment de paquets codés.

Rappel : si on connaît les "n" premiers octets de la clé WEP,

1. on récupère le vecteur d'initialisation IV,
2. on calcule le début du KSA (les 3+n premières étapes)
3. on vérifie si on avait un vecteur d'initialisation faible :
   • "P[1] < n+3"
   • "P[1] + P[P[1]] == n+3"
4. si oui, on prédit la clé avec "prediction = P'[o] - j - P[n+3]", où "P'[o]" est la position de o (premier octet généré par le PRGA) dans la permutation P.

On garde la prediction qui apparaît le plus souvent.

/**********************************************************************
 * devine le "n"-ième octet de la clé (en supposant qu'on connaît les *
 * n-1 octets précédents) en essayant tous les vecteurs               *
 * d'initialisations faibles.                                         *
 * L'argument "cle_wep_partielle" contient le début de la clé (octets *
 * 0 à "n"-1, non compris).                                           *
 * La fonction ne modifie pas les "n"-1 premières valeurs de          *
 * "cle_wep_partielle".                                               *
 *                                                                    *
 * L'argument "nb_IV_faibles" est le nombre de vecteurs faibles à     *
 * considérer.                                                        *
 * L'argument "nb_IV_total" est le nombre total de vecteurs à tester. *
 *                                                                    *
 * La fonction s'arrête quand l'une des deux bornes est atteinte.     *
 *                                                                    *
 * Si les 2 bornes sont nulles, on utilise alors uniquement la        *
 * famille de vecteurs (n+3, 255, ...). ATTENTION, ça n'est possible  *
 * que si "taille_IV = 3".                                            *
 *                                                                    *
 * La fonction renvoie "n" si l'opération c'est bien passée. Dans ce  *
 * cas, l'octet "n"-1 de "cle_wep_partielle" est positionné à sa      *
 * valeur.                                                            *
 *                                                                    *
 * La fonction renvoie "-1" en cas de problème. La "n"-ième valeur de *
 * "cle_wep_partielle" est alors quelconque.                          *
 **********************************************************************/
int predit_octet(int n, octet *cle_wep_partielle, int nb_IV_faibles, int nb_IV_total)
{
  ...

/**********************************************************************
 * teste un vecteur d'initialisation :                                *
 *   - "IV" est le vecteur en question                                *
 *   - "n" est l'octet de la clé que l'on recherche                   *
 *   - "cle_partielle" est la clé partielle que l'on a déjà calculée  *
 *                                                                    *
 * La fonction renvoie 1 si le vecteur était faible, et dans ce cas,  *
 * la prédiction correspondante se trouve dans le dernier paramètre   *
 * "prediction".                                                      *
 **********************************************************************/
int teste_IV(octet *IV, int n, octet *cle_partielle, octet *prediction)
{
  ...

$ ./test

$ ./test -h

2.3. Tests

2.4. Ouverture