Evasão de Firewalls com Nmap: Técnicas e Dicas

Introdução

Neste laboratório, você aprenderá técnicas avançadas do Nmap para contornar proteções de firewall em cenários reais de segurança cibernética. Você praticará métodos de evasão como varredura fragmentada e spoofing de IP de isca (decoy IP spoofing) enquanto trabalha com firewalls configurados com iptables.

Os exercícios práticos irão guiá-lo através da instalação do Nmap, configuração de regras de firewall e análise de resultados. Você obterá experiência prática na avaliação e contorno de medidas de segurança de rede através de experimentos de varredura controlados.

Instalar Nmap

Nesta etapa, você instalará o Nmap, uma poderosa ferramenta de varredura de rede usada para auditoria de segurança e exploração de rede. O Nmap ajuda a identificar hosts e serviços em uma rede enviando pacotes e analisando as respostas. Pense nisso como um criador de mapas digitais que descobre quais dispositivos estão conectados a uma rede e quais serviços estão sendo executados.

O ambiente de VM do LabEx já possui as dependências necessárias instaladas, tornando o processo de instalação simples. Siga estas etapas para instalar o Nmap:

Abra o terminal em sua VM do LabEx (você pode usar o terminal Xfce ou clicar com o botão direito na área de trabalho e selecionar "Abrir Terminal"). O terminal é onde você inserirá todos os comandos para este laboratório.
Primeiro, atualize a lista de pacotes para garantir que você obtenha a versão mais recente. Isso é como atualizar uma loja de aplicativos antes de baixar um novo software:
```
sudo apt update
```
Instale o Nmap usando o seguinte comando. A flag -y confirma automaticamente quaisquer prompts durante a instalação:
```
sudo apt install -y nmap
```
Após a conclusão da instalação, verifique se o Nmap foi instalado corretamente, verificando sua versão. Isso confirma que a instalação foi bem-sucedida:
```
nmap --version
```
Você deve ver uma saída semelhante a:
```
Nmap version 7.92 ( https://nmap.org )
```
Para verificação adicional, execute uma varredura simples contra localhost (sua própria máquina). Isso ajuda você a entender como o Nmap funciona antes de varrer outros alvos:
```
nmap -sV 127.0.0.1
```
Este comando varre sua máquina local (127.0.0.1) e mostra as portas abertas (a flag -sV detecta as versões dos serviços). Você verá uma lista de serviços em execução em sua máquina, o que é útil para entender o formato de saída do Nmap.

Preparar um Alvo com Firewall

Nesta etapa, você configurará um firewall simples usando iptables para criar um ambiente de destino protegido para seus testes de varredura Nmap. Firewalls atuam como barreiras de segurança que controlam o tráfego de rede, e entender como varrer através deles é essencial para profissionais de segurança de rede. Esta configuração simulará um cenário do mundo real onde a varredura de rede precisa contornar as proteções do firewall.

Primeiro, vamos verificar se o iptables está disponível em seu sistema. iptables é um programa utilitário do espaço do usuário que permite aos administradores configurar regras de firewall no Linux. Ele deve estar pré-instalado na VM do LabEx:
```
sudo iptables --version
```
Antes de criar novas regras, é uma boa prática limpar quaisquer regras de firewall existentes. Isso garante que comecemos com uma tela limpa e evitemos conflitos com configurações anteriores:
```
sudo iptables -F
sudo iptables -X
```
Agora, definiremos as políticas padrão. A política padrão determina o que acontece com os pacotes que não correspondem a nenhuma regra específica. Vamos DROPAR (DROP) todo o tráfego de entrada e encaminhado, permitindo, ao mesmo tempo, conexões de saída:
```
sudo iptables -P INPUT DROP
sudo iptables -P FORWARD DROP
sudo iptables -P OUTPUT ACCEPT
```
Mesmo com regras de firewall rigorosas, precisamos permitir a comunicação localhost (lo). Muitos serviços do sistema dependem da comunicação interna, então essa exceção é necessária:
```
sudo iptables -A INPUT -i lo -j ACCEPT
```
Vamos criar regras específicas para simular um servidor web protegido. Essas regras permitirão o tráfego de entrada apenas nas portas padrão para SSH (22), HTTP (80) e HTTPS (443), imitando uma configuração típica de servidor de produção:
```
sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT  ## SSH
sudo iptables -A INPUT -p tcp --dport 80 -j ACCEPT  ## HTTP
sudo iptables -A INPUT -p tcp --dport 443 -j ACCEPT ## HTTPS
```
Após configurar as regras, é importante verificá-las. A flag -L lista todas as regras, -n mostra a saída numérica (mais rápida e evita pesquisas DNS) e -v fornece informações detalhadas:
```
sudo iptables -L -n -v
```
Você deve ver a saída mostrando suas regras configuradas com a política DROP padrão para tráfego não correspondido.
Finalmente, salvaremos as regras para torná-las persistentes. Esta etapa é particularmente importante em nosso ambiente LabEx, pois não podemos usar systemctl no Docker para manter as regras em reinicializações:
```
sudo sh -c "iptables-save > /etc/iptables.rules"
```

Executar uma Varredura Fragmentada

Nesta etapa, você aprenderá como realizar uma varredura fragmentada usando o Nmap para contornar as proteções básicas do firewall. Firewalls frequentemente inspecionam pacotes de rede completos, mas a fragmentação divide os pacotes em pedaços menores, tornando-os mais difíceis de detectar por regras de firewall simples que não remontam os fragmentos.

Primeiro, verifique se as regras do firewall da etapa anterior ainda estão ativas. Isso ajuda a estabelecer uma linha de base antes de testar técnicas de evasão:
```
sudo iptables -L -n -v
```
Realize uma varredura SYN Nmap padrão contra localhost para ver como o firewall responde sem nenhuma técnica de evasão. Isso nos mostrará quais portas estão sendo ativamente bloqueadas:
```
nmap -sS 127.0.0.1
```
Observe quais portas são mostradas como filtradas ou fechadas - estas são as que o firewall está protegendo.
Agora, execute uma varredura fragmentada usando a opção -f. Isso diz ao Nmap para dividir os cabeçalhos TCP em vários pacotes menores (fragmentos de 8 bytes):
```
nmap -f -sS 127.0.0.1
```
Alguns firewalls podem não remontar corretamente esses fragmentos, permitindo que a varredura passe.
Para uma fragmentação mais agressiva, use tamanhos de pacotes menores com a opção --mtu. Isso define a Unidade Máxima de Transmissão (Maximum Transmission Unit - MTU) para 16 bytes, criando fragmentos ainda menores:
```
nmap --mtu 16 -sS 127.0.0.1
```
Fragmentos menores podem contornar implementações de firewall mais primitivas.
Combine a fragmentação com o controle de tempo para sigilo adicional. A opção -T2 torna a varredura mais lenta e menos propensa a acionar sistemas de detecção de intrusão:
```
nmap -f -T2 -sS 127.0.0.1
```
Essa abordagem imita padrões de tráfego de rede mais normais.
Compare os resultados de diferentes tipos de varredura para avaliar a eficácia da fragmentação:
```
nmap -sS 127.0.0.1 | grep filtered
nmap -f -sS 127.0.0.1 | grep filtered
```
Observe quaisquer diferenças no número de portas filtradas - menos portas filtradas indicam uma evasão bem-sucedida do firewall.

Adicionar IPs Decoy

Nesta etapa, você aprenderá como usar a técnica de varredura de isca do Nmap para mascar seu endereço IP real entre vários endereços de origem falsos. Isso ajuda a evitar a detecção, tornando mais difícil identificar a máquina de varredura real. Quando os sistemas de segurança veem tráfego vindo de vários IPs, eles não conseguem determinar facilmente qual é o scanner real.

Primeiro, verifique seu endereço IP atual para entender o que estamos escondendo. Isso estabelece uma linha de base para que você possa ver como os IPs isca obscurecerão seu endereço real:
```
ip a
```
Anote seu endereço IP real (normalmente começando com 172 ou 192). Este é o endereço que estaremos escondendo entre as iscas.
Realize uma varredura básica com IPs isca usando a opção -D. Aqui, especificamos três IPs falsos e incluímos nosso IP real com o espaço reservado ME:
```
sudo nmap -D 192.168.1.1,192.168.1.2,192.168.1.3,ME 127.0.0.1
```
O espaço reservado ME representa seu endereço IP real, que será misturado com as iscas.
Para iscas mais realistas, use endereços IP aleatórios. Isso geralmente é melhor do que usar padrões de IP previsíveis:
```
sudo nmap -D RND:5 127.0.0.1
```
Isso gera 5 endereços IP isca aleatórios que parecem mais naturais para os sistemas de monitoramento.
Combine iscas com técnicas de evasão anteriores, como fragmentação (-f) e controle de tempo (-T2):
```
sudo nmap -D 10.0.0.1,10.0.0.2,10.0.0.3 -f -T2 127.0.0.1
```
A sobreposição de vários métodos de evasão torna a detecção ainda mais difícil.
Verifique o efeito isca verificando os logs do firewall (simulados). Isso mostra como o firewall veria vários IPs de origem:
```
sudo iptables -L -n -v | grep -E "192.168|10.0"
```
Você deve ver entradas para todos os IPs isca que usamos em nossas varreduras.
Para uso avançado, especifique redes isca. Isso cria uma faixa de endereços isca da mesma rede:
```
sudo nmap -D 192.168.1.1-10 127.0.0.1
```
Isso gera 10 IPs isca sequenciais da rede 192.168.1.0.

Verificar o Sucesso da Evasão

Nesta etapa final, você avaliará a eficácia de suas técnicas de evasão de varredura, analisando os logs do firewall e comparando os resultados da varredura de diferentes métodos. Isso ajuda você a entender quais técnicas contornaram com sucesso a detecção do firewall e quais foram sinalizadas como atividade suspeita.

Primeiro, verifique os logs atuais do firewall para ver as tentativas de varredura detectadas. Isso fornece uma linha de base do que a atividade normal do firewall parece antes de testar os métodos de evasão:
```
sudo iptables -L -n -v | grep -E "DROP|REJECT"
```
Este comando mostra quantos pacotes foram bloqueados pelas suas regras de firewall, com os contadores indicando tentativas de detecção.
Agora, crie dois relatórios de varredura para comparação - um usando a varredura básica e outro com técnicas de evasão. A diferença entre eles mostrará a eficácia da sua evasão:
```
nmap -sS 127.0.0.1 -oN basic_scan.txt
nmap -f -D RND:3 127.0.0.1 -oN evasion_scan.txt
```
O primeiro comando executa uma varredura SYN padrão, enquanto o segundo usa fragmentação (-f) e IPs isca (-D RND:3).
Analise as diferenças entre os resultados da varredura para ver quais portas foram filtradas em cada caso:
```
diff basic_scan.txt evasion_scan.txt
```
Preste atenção especial ao número de portas "filtradas" em cada relatório - menos portas filtradas na varredura de evasão indicam uma contornagem bem-sucedida.
Para verificar especificamente a evasão bem-sucedida, redefina os contadores do firewall e execute uma varredura de evasão enquanto monitora a detecção:
```
sudo iptables -Z && sudo nmap -f -D RND:3 127.0.0.1 && sudo iptables -L -n -v
```
Os valores do contador mostram quantos pacotes foram detectados pelo firewall durante sua tentativa de evasão.
Para testes abrangentes, combine várias técnicas de evasão para maximizar suas chances de contornar a segurança:
```
sudo nmap -f -D RND:5 -T2 --data-length 24 127.0.0.1 -oN final_scan.txt
```
Isso usa fragmentação, 5 IPs isca, tempo mais lento (-T2) e preenchimento de dados aleatórios (--data-length 24).
Finalmente, gere um relatório resumido comparando as portas filtradas entre as varreduras básicas e de evasão:
```
echo "Basic scan filtered ports:" && grep filtered basic_scan.txt | wc -l
echo "Evasion scan filtered ports:" && grep filtered evasion_scan.txt | wc -l
```
Uma redução significativa nas portas filtradas entre as duas varreduras demonstra uma evasão bem-sucedida do firewall.

Resumo

Neste laboratório, você aprendeu técnicas essenciais de evasão de firewall do Nmap para avaliações de segurança cibernética. Os exercícios o guiaram pela instalação do Nmap, varredura básica e criação de um ambiente de teste controlado usando iptables para simular redes protegidas.

Você praticou dois métodos principais de evasão: fragmentação de pacotes para contornar sistemas de detecção e endereços IP isca para obscurecer as origens da varredura. Essas habilidades permitem que você avalie as defesas de rede replicando padrões de ataque do mundo real, mantendo os padrões éticos de teste.

Evadir Firewalls no Nmap