Use Nmap para Detectar e Contornar Restrições de Firewall

NmapBeginner
Pratique Agora

Introdução

Neste laboratório, você aprenderá como usar o Nmap para detectar e contornar restrições de firewall no âmbito da segurança de rede. Firewalls são elementos de segurança vitais que filtram o tráfego de rede de acordo com regras predefinidas. Como profissional de segurança, é crucial entender como evadir firewalls para avaliações de segurança abrangentes e identificação de vulnerabilidades.

Exploraremos diversas técnicas de evasão de firewall com o Nmap, uma poderosa ferramenta de varredura de rede. Essas técnicas permitem que especialistas em segurança testem as defesas de rede, imitando as tentativas de potenciais atacantes de contornar as medidas de segurança. Ao final deste laboratório, você terá experiência prática com os recursos de evasão de firewall do Nmap e entenderá suas aplicações em segurança de rede.

Configurando um Serviço Local para Varredura

Antes de começarmos a praticar as técnicas de varredura do Nmap, é essencial ter um serviço alvo para varrer. Pense nisso como ter um alvo em um campo de tiro. Nesta etapa, criaremos um servidor HTTP simples em nossa máquina local. Este servidor atuará como o alvo para todos os nossos exercícios de varredura.

Primeiro, precisamos abrir um terminal. Um terminal é como um centro de comando onde podemos dar instruções ao nosso computador. Uma vez que o terminal esteja aberto, criaremos uma estrutura de diretórios para o nosso serviço HTTP. Um diretório é semelhante a uma pasta em seu computador e nos ajuda a organizar nossos arquivos.

mkdir -p /home/labex/project/http_service

O comando mkdir significa "make directory" (criar diretório). A opção -p garante que, se algum diretório intermediário no caminho não existir, ele será criado. Portanto, este comando cria um diretório chamado http_service dentro do caminho /home/labex/project.

Em seguida, precisamos navegar para o diretório recém-criado. Assim como você abriria uma pasta em seu computador para acessar seu conteúdo, usamos o comando cd para entrar no diretório.

cd /home/labex/project/http_service

Agora, criaremos um arquivo HTML simples. HTML é a linguagem usada para criar páginas da web. Nosso servidor HTTP servirá este arquivo HTML para qualquer pessoa que o solicitar.

echo "<html><body><h1>Welcome to the StarPath Exploration Server</h1></body></html>" > index.html

O comando echo imprime o texto dentro das aspas. O símbolo > redireciona essa saída para um arquivo chamado index.html. Portanto, este comando cria um arquivo chamado index.html com o conteúdo HTML básico especificado.

Para garantir que o arquivo foi criado corretamente, podemos visualizar seu conteúdo. Usamos o comando cat para esse fim.

cat index.html

O comando cat lê o conteúdo de um arquivo e o exibe no terminal. Você deve ver o conteúdo HTML que acabamos de criar:

<html><body><h1>Welcome to the StarPath Exploration Server</h1></body></html>

Agora, é hora de iniciar um servidor HTTP simples. Usaremos o módulo http.server embutido do Python. Python é uma linguagem de programação, e este módulo nos permite configurar rapidamente um servidor web.

python3 -m http.server 8000

A opção -m em Python é usada para executar um módulo como um script. Aqui, estamos executando o módulo http.server e dizendo a ele para ouvir na porta 8000. Uma porta é como uma porta pela qual os dados entram e saem de um computador.

Após executar este comando, você deve ver uma saída semelhante a:

Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ...

Esta saída indica que o servidor HTTP está em execução e está esperando por conexões na porta 8000. É importante deixar esta janela do terminal aberta porque, se você fechá-la, o servidor parará de ser executado.

Você configurou com sucesso um serviço local. Nas etapas seguintes, usaremos este serviço como um alvo para nossos exercícios de varredura do Nmap.

Varredura Nmap Básica com Contorno de Descoberta de Host

Nesta etapa, vamos realizar nossa primeira varredura Nmap. Mas antes de começarmos, vamos entender um conceito-chave. Muitos firewalls são configurados para bloquear solicitações de eco ICMP, que são comumente conhecidas como "ping". O Nmap geralmente usa essas solicitações de ping para verificar se um host está online antes de começar a varrer as portas. No entanto, ao ignorar esta fase de descoberta de host, ainda podemos varrer os alvos, mesmo quando o tráfego ICMP é bloqueado pelo firewall.

Primeiro, certifique-se de manter o servidor HTTP em execução no terminal anterior. Em seguida, abra uma nova janela do terminal. Neste novo terminal, precisamos navegar para o diretório do projeto. O diretório do projeto é onde todos os nossos arquivos e configurações relevantes para este experimento são armazenados. Para fazer isso, usaremos o comando cd, que significa "change directory" (mudar diretório). Aqui está o comando:

cd /home/labex/project

Agora que estamos no diretório certo, é hora de executar uma varredura Nmap básica em nosso servidor HTTP local. Usaremos a opção -Pn no comando Nmap. Esta opção diz ao Nmap para pular a etapa de descoberta de host e assumir que o alvo está online. Aqui está o comando:

nmap -Pn --reason -p 8000 localhost

Vamos detalhar as opções de comando para entender o que cada uma faz:

  • -Pn: Esta opção ignora o processo de descoberta de host. Em vez de verificar se o alvo está online usando ping, o Nmap assumirá diretamente que o alvo está online e começará a varrer as portas.
  • --reason: Esta opção faz com que o Nmap mostre a razão pela qual uma porta está em um estado específico. Por exemplo, se uma porta estiver aberta, ela nos dirá por que ela é considerada aberta.
  • -p 8000: Esta opção diz ao Nmap para varrer apenas a porta 8000. Estamos interessados ​​nesta porta específica porque nosso servidor HTTP local está sendo executado nela.
  • localhost: Este é o alvo que queremos varrer. Neste caso, localhost se refere à nossa máquina local.

Após executar o comando, você deve ver uma saída semelhante a esta:

Starting Nmap 7.80 ( https://nmap.org ) at 2023-09-05 15:30 UTC
Nmap scan report for localhost (127.0.0.1)
Host is up, received localhost-response (0.000097s latency).

PORT     STATE SERVICE      REASON
8000/tcp open  http-alt     syn-ack

Nmap done: 1 IP address (1 host up) scanned in 0.03 seconds

A saída mostra que a porta 8000 está aberta e executando um serviço HTTP. A coluna "REASON" diz "syn-ack", o que significa que, quando o Nmap tentou se conectar à porta, a porta respondeu com um pacote SYN-ACK. Esta é uma maneira padrão para um servidor aceitar uma solicitação de conexão no protocolo TCP.

Em seguida, queremos salvar os resultados da varredura em um arquivo. Salvar os resultados é útil porque nos permite analisá-los mais tarde, compartilhá-los com outras pessoas ou compará-los com varreduras futuras. Para salvar os resultados, usaremos o símbolo >, que redireciona a saída do comando Nmap para um arquivo. Aqui está o comando:

nmap -Pn --reason -p 8000 localhost > /home/labex/project/nmap_scan.txt

Finalmente, vamos verificar os resultados da varredura salvos. Usaremos o comando cat, que significa "concatenate" (concatenar). Este comando lê o conteúdo de um arquivo e o exibe no terminal. Aqui está o comando:

cat /home/labex/project/nmap_scan.txt

Você deve ver os mesmos resultados da varredura que foram exibidos anteriormente no terminal.

Esta varredura básica nos mostra como a opção -Pn pode ser usada para ignorar as regras de firewall que bloqueiam as sondagens de ping. Em uma situação do mundo real, essa técnica pode ser muito útil quando você precisa varrer hosts que são protegidos por firewalls que bloqueiam o tráfego ICMP.

Evasão Avançada de Firewall com Fragmentação de Pacotes

Nesta etapa, vamos explorar uma técnica de evasão de firewall mais avançada chamada fragmentação de pacotes. Antes de mergulharmos, vamos entender o que é fragmentação de pacotes. Quando os dados são enviados por uma rede, eles são divididos em unidades menores chamadas pacotes. Alguns firewalls e Sistemas de Detecção de Intrusão (IDS) são projetados para inspecionar esses pacotes em busca de quaisquer sinais de atividade maliciosa. No entanto, esses sistemas de segurança podem ter dificuldade em processar pacotes fragmentados, que são pacotes que foram divididos em pedaços ainda menores. Essa dificuldade pode criar uma oportunidade para contornarmos certas medidas de segurança durante nossas varreduras.

Continuaremos usando nosso servidor HTTP local como o alvo para nossa varredura. Primeiro, precisamos navegar para o diretório apropriado no terminal onde realizamos nossa varredura anterior. Este diretório é onde nossos arquivos de projeto estão localizados, e é importante estar neste diretório para que nossos comandos funcionem corretamente. Para fazer isso, executaremos o seguinte comando:

cd /home/labex/project

Agora que estamos no diretório certo, estamos prontos para executar uma varredura usando a opção de fragmentação do Nmap. Esta opção dividirá os pacotes IP em fragmentos menores, tornando mais difícil para os filtros de pacotes detectarem nossa varredura. Aqui está o comando que usaremos:

sudo nmap -f -Pn --reason -p 8000 localhost

Vamos detalhar a opção adicional -f neste comando. A opção -f diz ao Nmap para fragmentar os pacotes IP. Ao fazer isso, estamos tornando mais desafiador para os filtros de pacotes analisarem os pacotes e detectarem que estamos realizando uma varredura.

Após executar o comando, você deve ver uma saída semelhante à seguinte:

Starting Nmap 7.80 ( https://nmap.org ) at 2025-03-18 16:46 CST
Nmap scan report for localhost (127.0.0.1)
Host is up, received user-set (0.000062s latency).
Other addresses for localhost (not scanned): ::1

PORT     STATE SERVICE  REASON
8000/tcp open  http-alt syn-ack ttl 64

Nmap done: 1 IP address (1 host up) scanned in 0.08 seconds

Esta saída nos mostra os resultados de nossa varredura. Ela nos diz que o host (localhost) está ativo e que a porta 8000 está aberta.

Em seguida, queremos salvar esses resultados em um arquivo separado. Dessa forma, podemos consultá-los mais tarde e compará-los com outros resultados de varredura. Para salvar os resultados, executaremos o seguinte comando:

sudo nmap -f -Pn --reason -p 8000 localhost > /home/labex/project/nmap_frag_scan.txt

O símbolo > neste comando redireciona a saída da varredura Nmap para o arquivo especificado.

Agora, vamos verificar o conteúdo deste arquivo para garantir que os resultados foram salvos corretamente. Usaremos o comando cat, que é usado para exibir o conteúdo de um arquivo:

cat /home/labex/project/nmap_frag_scan.txt

Os resultados da varredura podem parecer semelhantes à nossa varredura anterior, mas a técnica subjacente é diferente. Neste caso, o Nmap fragmentou os pacotes IP em pedaços menores, o que dificulta para os filtros de pacotes sem estado detectarem a varredura.

Vamos comparar os dois métodos de varredura que usamos até agora: a varredura regular e a varredura fragmentada. Criaremos um novo arquivo para armazenar esta comparação. Aqui estão os comandos para fazer isso:

echo "Comparing regular scan vs. fragmented scan:" > /home/labex/project/scan_comparison.txt
echo "---------------------------------------------" >> /home/labex/project/scan_comparison.txt
echo "" >> /home/labex/project/scan_comparison.txt
echo "1. Regular scan with -Pn:" >> /home/labex/project/scan_comparison.txt
cat /home/labex/project/nmap_scan.txt >> /home/labex/project/scan_comparison.txt
echo "" >> /home/labex/project/scan_comparison.txt
echo "2. Fragmented scan with -f -Pn:" >> /home/labex/project/scan_comparison.txt
cat /home/labex/project/nmap_frag_scan.txt >> /home/labex/project/scan_comparison.txt

Esses comandos primeiro escrevem um cabeçalho para o arquivo de comparação, depois adicionam os resultados da varredura regular e da varredura fragmentada ao arquivo.

Agora, vamos examinar nossa comparação exibindo o conteúdo do arquivo de comparação:

cat /home/labex/project/scan_comparison.txt

Em nosso ambiente controlado, os resultados das duas varreduras podem parecer semelhantes. No entanto, em cenários do mundo real, essas diferentes técnicas podem ter níveis variados de sucesso contra diferentes configurações de firewall. A fragmentação de pacotes (-f) é particularmente eficaz contra filtros de pacotes sem estado. Os filtros de pacotes sem estado examinam cada pacote de forma independente e geralmente não conseguem remontar os fragmentos para inspecionar o pacote completo, o que dá à nossa varredura fragmentada uma chance melhor de contornar esses filtros.

Para uma fragmentação ainda maior, o Nmap permite que você aumente o nível usando várias flags -f (por exemplo, -ff) ou especificando um tamanho de Unidade Máxima de Transmissão (MTU - Maximum Transmission Unit) personalizado com a opção --mtu. A MTU é o maior tamanho de um pacote que pode ser transmitido por uma rede. Ao especificar uma MTU personalizada, você pode controlar como os pacotes são fragmentados.

Esta técnica demonstra como a fragmentação de pacotes pode ser usada como um método adicional para evadir a detecção de firewall ao conduzir avaliações de segurança.

Resumo

Neste laboratório, você aprendeu como identificar e contornar restrições de firewall usando as técnicas de evasão de firewall do Nmap. Primeiro, você configurou um servidor HTTP local como alvo para varredura, criando um ambiente seguro para praticar diferentes métodos de varredura sem impactar sistemas externos. Em seguida, você realizou uma varredura Nmap básica com a opção -Pn para contornar a descoberta de host, o que é útil quando firewalls bloqueiam solicitações de eco ICMP. Isso permitiu que você varresse portas que podem estar ocultas atrás de regras de firewall.

Em seguida, você explorou uma técnica avançada de evasão: fragmentação de pacotes usando a opção -f. Este método fragmenta os pacotes IP, tornando mais difícil para os filtros de pacotes sem estado detectarem e bloquearem a varredura. Ao comparar os resultados de ambas as técnicas, você entendeu suas diferenças e aplicações. Essas técnicas são essenciais para que os profissionais de segurança conduzam avaliações de segurança completas. No entanto, lembre-se de usá-las apenas em avaliações autorizadas com as devidas permissões para evitar violar leis e políticas.