Aprenda os Fundamentos do Nmap e Técnicas de Varredura

Introdução

Neste laboratório, você aprenderá os fundamentos do Nmap, uma poderosa ferramenta de network scanning (varredura de rede) comumente utilizada em cibersegurança para descoberta de rede e auditoria de segurança. Você explorará como usar o Nmap para escanear redes, descobrir portas abertas e identificar serviços em execução.

Ao dominar essas técnicas, você adquirirá habilidades essenciais para administração de rede e avaliação de segurança. Esta experiência prática oferecerá conhecimento aplicável em cenários do mundo real, ajudando você a entender a infraestrutura de rede e as considerações de segurança.

Entendendo os Fundamentos do Nmap

Nmap, abreviação de Network Mapper, é uma ferramenta de código aberto que desempenha um papel crucial na descoberta de rede e auditoria de segurança. No mundo da cibersegurança, é como um detetive que usa pacotes IP brutos para coletar informações. Com o Nmap, você pode descobrir quais hosts (hosts) estão presentes em uma rede, quais serviços esses hosts estão fornecendo, os sistemas operacionais que estão executando e outras características importantes.

Vamos começar nossa jornada com os fundamentos do Nmap. Primeiro, precisamos abrir um terminal. O terminal é como um centro de comando onde você pode digitar comandos para interagir com seu sistema. Você pode abri-lo clicando no ícone do terminal na barra de tarefas ou pressionando Ctrl+Alt+T.

Depois que o terminal estiver aberto, precisamos ter certeza de que estamos no diretório do projeto. O diretório do projeto é uma pasta específica onde todos os nossos arquivos e operações relacionados a este experimento ocorrerão. Para navegar até o diretório do projeto, use o seguinte comando:

cd /home/labex/project

Agora que estamos no lugar certo, vamos verificar a versão do Nmap instalada em nosso sistema. Saber a versão é importante porque diferentes versões podem ter diferentes recursos e comportamentos. Para verificar a versão, execute este comando:

nmap --version

Após executar o comando, você deverá ver uma saída semelhante a esta. Esta saída mostra a versão do Nmap instalada em seu sistema, juntamente com algumas outras informações sobre as bibliotecas com as quais foi compilado e os mecanismos nsock disponíveis.

Nmap version 7.80 ( https://nmap.org )
Platform: x86_64-pc-linux-gnu
Compiled with: liblua-5.3.3 openssl-1.1.1f libpcre-8.39 libpcap-1.9.1 nmap-libdnet-1.12 ipv6
Compiled without:
Available nsock engines: epoll poll select

Agora, vamos realizar nossa primeira varredura básica do Nmap. Vamos escanear nosso localhost, que é como uma auto-verificação do seu próprio sistema. Esta varredura nos ajudará a ver quais portas estão abertas em nosso sistema. Portas são como portas em um prédio; diferentes serviços usam portas diferentes para se comunicar. Execute o seguinte comando:

nmap localhost

Este comando verifica as 1000 portas mais comuns em seu localhost. Após executar o comando, você deverá ver uma saída semelhante a esta. A saída nos diz quais portas estão abertas em nosso sistema. Por exemplo, a porta 22 é normalmente usada para SSH (Secure Shell), que é um protocolo para acessar com segurança um computador remoto, e a porta 80 é usada para HTTP (serviços web). Tenha em mente que sua saída pode mostrar portas abertas diferentes, dependendo dos serviços em execução em seu sistema.

Starting Nmap 7.80 ( https://nmap.org ) at 2023-10-30 15:45 UTC
Nmap scan report for localhost (127.0.0.1)
Host is up (0.000097s latency).
Not shown: 998 closed ports
PORT   STATE SERVICE
22/tcp open  ssh
80/tcp open  http

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

Para nosso próximo exercício, precisamos de um serviço para escanear. Criaremos um serviço simples usando netcat, que é um utilitário de rede versátil. Este serviço ouvirá na porta 8888. Execute o seguinte comando:

nc -lk 8888 &

Vamos detalhar este comando. A opção -l diz ao netcat para ouvir as conexões de entrada. A opção -k faz com que o netcat continue ouvindo mesmo depois que um cliente se desconecta. O & no final executa o comando em segundo plano, para que você possa continuar usando o terminal para outras tarefas.

Para verificar se o serviço está em execução, podemos usar o seguinte comando:

netstat -tuln | grep 8888

Este comando lista todas as conexões de rede e filtra a saída para mostrar apenas as informações relacionadas à porta 8888. Se o serviço estiver em execução, você deverá ver uma saída semelhante a esta:

tcp        0      0 0.0.0.0:8888            0.0.0.0:*               LISTEN

Esta saída confirma que nosso serviço simulado está em execução e ouvindo na porta 8888.

Explorando as Técnicas de Varredura de Portas do Nmap

Nmap é uma ferramenta poderosa no campo da cibersegurança, especialmente quando se trata de port scanning (varredura de portas). A varredura de portas é um método usado para descobrir quais portas em um sistema de destino estão abertas e quais serviços podem estar sendo executados nessas portas. Existem diferentes tipos de técnicas de varredura de portas, cada uma com suas próprias vantagens exclusivas e casos de uso específicos. Nesta etapa, exploraremos algumas dessas técnicas, escaneando nosso serviço simulado.

Primeiro, vamos realizar uma varredura básica de conexão TCP, visando especificamente nossa porta 8888. Uma varredura de conexão TCP é uma maneira direta de verificar se uma porta está aberta. Funciona tentando estabelecer uma conexão TCP completa com a porta de destino. Se a conexão for bem-sucedida, a porta é considerada aberta.

nmap -p 8888 localhost

Neste comando, a opção -p é usada para especificar quais portas queremos escanear. Aqui, estamos dizendo ao Nmap para escanear a porta 8888 no localhost, que se refere à máquina atual. Após executar este comando, você deverá ver uma saída semelhante a esta:

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

PORT     STATE SERVICE
8888/tcp open  sun-answerbook

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

Esta saída confirma que nossa porta 8888 está aberta. O Nmap também identificou o nome do serviço associado a esta porta de acordo com seu banco de dados interno.

Agora, vamos tentar uma varredura SYN. Uma varredura SYN é uma abordagem mais furtiva em comparação com a varredura de conexão TCP. Ela não completa a conexão TCP completa, o que a torna menos provável de ser detectada por sistemas de detecção de intrusão.

sudo nmap -sS -p 8888 localhost

A opção -sS especifica que queremos realizar uma varredura SYN. Este tipo de varredura requer privilégios de root porque envolve o envio de pacotes de rede brutos, que é uma operação de baixo nível. É por isso que usamos o comando sudo. A saída deve ser semelhante à varredura anterior:

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

PORT     STATE SERVICE
8888/tcp open  sun-answerbook

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

Em seguida, vamos tentar uma varredura UDP. UDP (User Datagram Protocol) é um tipo diferente de protocolo de rede em comparação com TCP. Enquanto o TCP fornece um serviço confiável e orientado a conexão, o UDP é um protocolo sem conexão. Usaremos uma varredura UDP para verificar se a porta 8888 está aberta para tráfego UDP.

sudo nmap -sU -p 8888 localhost

A opção -sU especifica uma varredura UDP. As varreduras UDP podem consumir mais tempo do que as varreduras TCP porque o UDP não possui o mesmo mecanismo de reconhecimento embutido que o TCP, então o Nmap precisa esperar mais tempo para determinar se uma porta está aberta ou fechada. A saída pode ser assim:

Starting Nmap 7.80 ( https://nmap.org ) at 2023-10-30 16:00 UTC
Nmap scan report for localhost (127.0.0.1)
Host is up (0.000097s latency).

PORT     STATE  SERVICE
8888/udp closed sun-answerbook

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

Observe que a porta UDP é mostrada como fechada. Isso é esperado porque nosso serviço netcat está ouvindo conexões TCP, não UDP.

Finalmente, vamos realizar uma varredura de detecção de versão do serviço. Este tipo de varredura nos ajuda a identificar qual serviço específico e sua versão estão sendo executados em uma porta específica.

nmap -sV -p 8888 localhost

A opção -sV diz ao Nmap para realizar a detecção de serviço/versão. Ele tenta enviar sondas específicas para as portas abertas e analisar as respostas para determinar o serviço e sua versão. A saída pode ser assim:

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

PORT     STATE SERVICE VERSION
8888/tcp open  http    Apache httpd
Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel

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

A detecção de versão pode não identificar com precisão nosso serviço netcat como uma aplicação genuína, mas demonstra como o Nmap tenta determinar o que está sendo executado nas portas abertas.

Vamos salvar nossas descobertas em um arquivo para referência futura. Salvar os resultados da varredura nos permite revisá-los mais tarde, compartilhá-los com outras pessoas ou usá-los para análise posterior.

nmap -p 8888 localhost > /home/labex/project/nmap_scan_results.txt

Neste comando, o símbolo > é usado para redirecionar a saída da varredura do Nmap para um arquivo chamado nmap_scan_results.txt localizado no diretório /home/labex/project.

Você pode visualizar os resultados salvos com:

cat /home/labex/project/nmap_scan_results.txt

O comando cat é usado para exibir o conteúdo de um arquivo.

Isso conclui nossa exploração de diferentes técnicas de varredura de portas do Nmap.

Compreendendo os Templates de Tempo e Desempenho

Ao conduzir varreduras do Nmap, o tempo desempenha um papel crucial. Se suas varreduras forem muito agressivas, elas podem ser detectadas por sistemas de detecção de intrusão (IDS). Um IDS é uma ferramenta de segurança que monitora o tráfego de rede em busca de atividades suspeitas. Varreduras agressivas também podem sobrecarregar o sistema de destino, fazendo com que ele funcione mal ou fique sem resposta. Por outro lado, se suas varreduras forem muito lentas, elas podem levar um tempo impraticável para serem concluídas, o que não é eficiente, especialmente quando você tem um grande número de alvos para escanear.

O Nmap fornece modelos de tempo que dão a você controle sobre a velocidade e a agressividade de suas varreduras. Esses modelos variam de T0 (paranóico) a T5 (insano). Quanto maior o número, mais rápida e agressiva será a varredura.

Aqui está uma análise detalhada dos modelos de tempo:

• -T0 (Paranoid): Este é um modelo de tempo extremamente lento. Ele é usado principalmente quando você deseja evitar sistemas de detecção de intrusão. Ao enviar solicitações muito lentamente, é menos provável que acione quaisquer alarmes no IDS.
• -T1 (Sneaky): Semelhante ao modelo paranóico, também é lento e usado para evasão de IDS. Ele envia solicitações em um ritmo um pouco mais rápido do que o modelo paranóico, mas ainda lento o suficiente para evitar a detecção.
• -T2 (Polite): Este modelo diminui a velocidade da varredura para usar menos largura de banda e recursos na máquina de destino. É uma boa escolha quando você não deseja causar nenhuma interrupção no sistema de destino.
• -T3 (Normal): Este é o modelo de tempo padrão do Nmap. Ele encontra um equilíbrio entre velocidade e confiabilidade, adequado para a maioria das varreduras de uso geral.
• -T4 (Aggressive): Este modelo acelera a varredura, assumindo que você está trabalhando em uma rede razoavelmente rápida e confiável. Ele envia solicitações mais rapidamente, o que pode reduzir o tempo geral da varredura.
• -T5 (Insane): Este é um modelo de tempo muito agressivo. Ele assume que você tem uma rede extraordinariamente rápida. Ele envia solicitações em uma taxa muito alta, o que pode reduzir significativamente o tempo da varredura, mas também aumenta o risco de ser detectado.

Vamos começar tentando uma varredura com o modelo de tempo padrão (T3). Usaremos o comando time para medir quanto tempo a varredura leva. O comando time é uma ferramenta útil que mostra quanto tempo real, tempo do usuário e tempo do sistema um comando leva para ser executado.

time nmap -T3 -p 8888 localhost

Após executar este comando, você deverá ver uma saída semelhante à seguinte:

Starting Nmap 7.80 ( https://nmap.org ) at 2023-10-30 16:10 UTC
Nmap scan report for localhost (127.0.0.1)
Host is up (0.000097s latency).

PORT     STATE SERVICE
8888/tcp open  sun-answerbook

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

real    0m0.115s
user    0m0.033s
sys     0m0.015s

Agora, vamos tentar um modelo de tempo mais agressivo (T4). Usaremos o mesmo comando time para medir o tempo da varredura.

time nmap -T4 -p 8888 localhost

Você pode notar que a varredura é concluída um pouco mais rápido. Aqui está um exemplo de como a saída pode ser:

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

PORT     STATE SERVICE
8888/tcp open  sun-answerbook

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

real    0m0.105s
user    0m0.032s
sys     0m0.014s

Para ver uma diferença mais notável no tempo de varredura, vamos tentar escanear todas as portas com os modelos T3 e T4.

time nmap -T3 -p- --max-retries 0 localhost | grep "open" > /dev/null

A opção -p- diz ao Nmap para escanear todas as 65535 portas no sistema de destino. A opção --max - retries 0 reduz o número de tentativas para cada varredura de porta, o que ajuda a acelerar a varredura. Estamos redirecionando a saída para grep para filtrar apenas as linhas que contêm a palavra "open" e, em seguida, redirecionando o resultado para /dev/null para que possamos nos concentrar no tempo da varredura.

time nmap -T4 -p- --max-retries 0 localhost | grep "open" > /dev/null

Você deve notar uma diferença mais significativa no tempo de varredura com essas varreduras abrangentes.

Agora, conforme solicitado no laboratório original, vamos salvar um resultado de varredura furtiva em um arquivo. Usaremos o modelo de tempo T4 para equilibrar velocidade e confiabilidade.

nmap -T4 -p 8888 localhost > /home/labex/project/nmap_stealthy_scan.txt

Você pode visualizar os resultados salvos usando o comando cat:

cat /home/labex/project/nmap_stealthy_scan.txt

O modelo de tempo T4 é uma boa escolha para a maioria dos cenários, pois equilibra velocidade e confiabilidade. Ao conduzir avaliações de segurança, é importante ajustar o modelo de tempo com base em seus requisitos e restrições específicas, como velocidade da rede, a sensibilidade do sistema de destino e o risco de detecção.

Formatos de Saída e Análise dos Resultados da Varredura

O Nmap oferece múltiplos formatos de saída, que são extremamente úteis para vários propósitos. Por exemplo, eles podem ser usados para documentação, para registrar seus resultados de varredura, para análise mais aprofundada ou para integração com outras ferramentas de segurança. Nesta etapa, analisaremos mais de perto esses formatos de saída e aprenderemos como analisar os resultados da varredura de forma eficaz.

O Nmap suporta os seguintes formatos de saída principais:

1. Saída normal (padrão): Este é um formato de texto legível por humanos. Ele apresenta os resultados da varredura de uma forma que é fácil para você entender à primeira vista, semelhante a um relatório.
2. Saída XML (-oX): XML é um formato estruturado. Ele organiza os dados de maneira hierárquica e organizada, o que é muito conveniente para os programas analisarem e processarem.
3. Saída Greppable (-oG): Este formato foi projetado para ser facilmente analisado usando ferramentas como grep e outros utilitários de processamento de texto. Ele tem uma estrutura específica que torna simples extrair informações relevantes.
4. Todos os formatos (-oA): Quando você usa esta opção, o Nmap salvará os resultados da varredura nos formatos normal, XML e greppable simultaneamente. Isso é útil quando você deseja ter todos os tipos de saídas para diferentes necessidades.

Vamos tentar cada um desses formatos um por um:

Primeiro, salvaremos uma varredura no formato normal. O seguinte comando irá escanear a porta 8888 no localhost e salvar os resultados em um arquivo de texto:

nmap -p 8888 localhost -oN /home/labex/project/normal_output.txt

Agora, vamos salvar uma varredura no formato XML. Este comando executará a mesma varredura na porta 8888 do localhost e salvará os resultados em um arquivo XML:

nmap -p 8888 localhost -oX /home/labex/project/xml_output.xml

Em seguida, salvaremos uma varredura no formato greppable. O comando abaixo irá escanear a porta 8888 no localhost e salvar os resultados em um arquivo que pode ser facilmente analisado pelo grep:

nmap -p 8888 localhost -oG /home/labex/project/grep_output.txt

Finalmente, vamos salvar uma varredura em todos os formatos. O seguinte comando criará três arquivos com formatos diferentes para a mesma varredura na porta 8888 do localhost:

nmap -p 8888 localhost -oA /home/labex/project/all_formats

Isso criará três arquivos: all_formats.nmap, all_formats.xml e all_formats.gnmap.

Agora, vamos examinar cada um desses arquivos para entender as diferenças em seus formatos.

Para visualizar a saída normal, usamos o comando cat:

cat /home/labex/project/normal_output.txt

Você deve ver a saída padrão do Nmap, que é fácil para os humanos lerem. Aqui está um exemplo de como pode ser:

## Nmap 7.80 scan initiated Mon Oct 30 16:45:00 2023 as: nmap -p 8888 -oN /home/labex/project/normal_output.txt localhost
Nmap scan report for localhost (127.0.0.1)
Host is up (0.00010s latency).

PORT     STATE SERVICE
8888/tcp open  sun-answerbook

## Nmap done at Mon Oct 30 16:45:00 2023 -- 1 IP address (1 host up) scanned in 0.04 seconds

Para visualizar a saída XML, também usamos o comando cat:

cat /home/labex/project/xml_output.xml

Este formato é estruturado para fácil análise por programas. Aqui está um exemplo da saída XML:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE nmaprun>
<nmaprun scanner="nmap" args="nmap -p 8888 -oX /home/labex/project/xml_output.xml localhost" start="1698684307" startstr="Mon Oct 30 16:45:07 2023" version="7.80" xmloutputversion="1.04">
<scaninfo type="connect" protocol="tcp" numservices="1" services="8888"/>
<verbose level="0"/>
<debugging level="0"/>
<host starttime="1698684307" endtime="1698684307"><status state="up" reason="conn-refused" reason_ttl="0"/>
<address addr="127.0.0.1" addrtype="ipv4"/>
<hostnames>
<hostname name="localhost" type="user"/>
<hostname name="localhost" type="PTR"/>
</hostnames>
<ports><port protocol="tcp" portid="8888"><state state="open" reason="syn-ack" reason_ttl="0"/><service name="sun-answerbook" method="table" conf="3"/></port>
</ports>
<times srtt="100" rttvar="5000" to="100000"/>
</host>
<runstats><finished time="1698684307" timestr="Mon Oct 30 16:45:07 2023" elapsed="0.04" summary="Nmap done at Mon Oct 30 16:45:07 2023; 1 IP address (1 host up) scanned in 0.04 seconds" exit="success"/><hosts up="1" down="0" total="1"/>
</runstats>
</nmaprun>

Para visualizar a saída greppable, usamos o comando cat novamente:

cat /home/labex/project/grep_output.txt

Este formato foi projetado para ser facilmente analisado com ferramentas como grep. Aqui está um exemplo da saída greppable:

## Nmap 7.80 scan initiated Mon Oct 30 16:45:15 2023 as: nmap -p 8888 -oG /home/labex/project/grep_output.txt localhost
Host: 127.0.0.1 (localhost) Status: Up
Host: 127.0.0.1 (localhost) Ports: 8888/open/tcp//sun-answerbook///
## Nmap done at Mon Oct 30 16:45:15 2023 -- 1 IP address (1 host up) scanned in 0.04 seconds

Vamos praticar o uso de grep para extrair informações específicas da saída greppable. O seguinte comando mostrará todas as linhas com portas abertas:

grep "open" /home/labex/project/grep_output.txt

A saída deve ser:

Host: 127.0.0.1 (localhost) Ports: 8888/open/tcp//sun-answerbook///

Você também pode usar filtros mais complexos. O seguinte comando extrai apenas o número da porta das portas abertas:

grep -E "Ports:.*open" /home/labex/project/grep_output.txt | cut -d':' -f3 | cut -d'/' -f1

A saída será:

 8888

Esses diferentes formatos de saída permitem que você integre os resultados da varredura do Nmap com outras ferramentas e fluxos de trabalho, tornando-o uma adição versátil ao seu kit de ferramentas de segurança.

Resumo

Neste laboratório, você aprendeu os fundamentos do Nmap, uma poderosa ferramenta de varredura de rede e avaliação de segurança. Você começou dominando o uso básico do Nmap, como a varredura de hosts e a identificação de portas abertas. Posteriormente, você explorou várias técnicas de varredura de portas, como varreduras TCP connect, varreduras SYN e varreduras UDP, cada uma com vantagens e casos de uso exclusivos.

Você também praticou o uso de modelos de tempo para equilibrar a velocidade e o sigilo da varredura. Por fim, você aprendeu a salvar os resultados da varredura em diferentes formatos e analisá-los com ferramentas de processamento de texto. Essas habilidades formam uma base para descoberta de rede, avaliação de segurança e identificação de vulnerabilidades. O Nmap é crucial para administradores de rede, profissionais de segurança e hackers éticos. Lembre-se de usar essas ferramentas de forma responsável e ética, e sempre obter a autorização adequada antes de escanear redes ou sistemas desconhecidos.