Escaneamento de Vulnerabilidades com Nmap

Introdução

Neste laboratório, você aprenderá os fundamentos do escaneamento de rede usando o Nmap (Network Mapper), uma poderosa ferramenta de código aberto para descoberta de rede e auditoria de segurança. Você começará com varreduras básicas de portas, avançará para a detecção de serviços e versões e, em seguida, explorará o Nmap Scripting Engine (NSE) para realizar verificações de vulnerabilidades. Por fim, aprenderá como analisar e salvar os resultados de suas varreduras em vários formatos para fins de relatório. Este laboratório oferece uma introdução prática e passo a passo aos principais recursos do Nmap para uma avaliação eficaz da segurança de rede.

Realizar uma Varredura Básica de Rede

Nesta primeira etapa, você se familiarizará com o Nmap realizando uma varredura básica. Uma varredura básica é usada para descobrir quais portas estão abertas em uma máquina alvo. Uma porta aberta indica que um serviço (como um servidor web ou SSH) está em execução e aguardando conexões.

O ambiente do laboratório foi pré-configurado com vários serviços rodando em localhost (sua própria máquina virtual) para você praticar. A ferramenta nmap já está instalada.

Primeiro, vamos verificar se o Nmap está instalado e conferir sua versão. Abra o terminal e execute o seguinte comando:

nmap --version

Você deve ver uma saída confirmando a versão do Nmap, semelhante a esta:

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

Agora, realize sua primeira varredura contra o localhost. Este comando instrui o Nmap a verificar as portas abertas mais comuns em sua máquina local.
```
nmap localhost
```

Examine a saída. O Nmap listará as portas que encontrou abertas, junto com o estado e o serviço comum associado a essa porta. A saída será parecida com esta, mostrando os serviços preparados para este laboratório:

Starting Nmap 7.80 ( https://nmap.org ) at ...
Nmap scan report for localhost (127.0.0.1)
Host is up (0.000092s latency).
Not shown: 995 closed ports
PORT     STATE SERVICE
22/tcp   open  ssh
2121/tcp open  ccproxy-ftp
2222/tcp open  EtherNetIP-1
3001/tcp open  nessus
8080/tcp open  http-proxy

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

Esta varredura inicial fornece um mapa dos serviços em execução, que é o primeiro passo em qualquer avaliação de segurança de rede.

Detectar Versões de Serviços

Saber quais portas estão abertas é útil, mas conhecer o software exato e a versão em execução nessas portas é muito mais poderoso para um analista de segurança. Softwares desatualizados são uma das principais fontes de vulnerabilidades. Nesta etapa, você usará o Nmap para realizar a detecção de serviços e versões.

Usaremos a flag -sV, que instrui o Nmap a sondar as portas abertas para determinar informações detalhadas de serviço e versão.

Execute uma varredura de detecção de versão contra o localhost. Para tornar a varredura mais eficiente, focaremos nas portas específicas que descobrimos na Etapa 1 (22, 2121, 2222, 3001, 8080) em vez de escanear todas as portas.
```
nmap -sV -p 22,8080 localhost
```
Dica de Especialista: Focar em portas específicas reduz drasticamente o tempo de varredura. Uma varredura completa de portas com -sV pode levar vários minutos, enquanto esta abordagem direcionada geralmente termina em segundos.

Compare a saída com a varredura básica da Etapa 1. Você verá agora uma coluna adicional, VERSION, que fornece detalhes sobre o software em execução em cada porta.

A saída será mais detalhada, semelhante a esta:

Starting Nmap 7.80 ( https://nmap.org ) at ...
Nmap scan report for localhost (127.0.0.1)
Host is up (0.00011s latency).
Not shown: 995 closed ports
PORT     STATE SERVICE VERSION
22/tcp   open  ssh     OpenSSH 8.9p1 Ubuntu 3ubuntu0.13 (Ubuntu Linux; protocol 2.0)
8080/tcp open  http    nginx 1.18.0 (Ubuntu)
Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel

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

Esta informação é crítica. Por exemplo, se a varredura revelasse uma versão antiga do nginx com uma vulnerabilidade crítica conhecida, você saberia exatamente onde focar seus esforços de remediação.

Usar o Nmap Scripting Engine (NSE)

O Nmap Scripting Engine (NSE) é um dos recursos mais poderosos do Nmap. Ele permite automatizar uma ampla variedade de tarefas de rede usando uma biblioteca de scripts. Esses scripts podem ser usados para descoberta avançada, detecção de vulnerabilidades e até exploração.

Nesta etapa, você usará a flag -sC, que executa um conjunto de scripts padrão considerados seguros e úteis para descoberta.

Execute uma varredura Nmap com os scripts padrão ativados contra o localhost. A flag -sC é uma maneira conveniente de obter mais informações sem especificar scripts individuais.
```
nmap -sC localhost
```

Revise a saída. Você verá informações adicionais recuadas sob cada porta. Esta é a saída dos scripts NSE. Por exemplo, o script http-title pode capturar o título da página web na porta 8080, e scripts SSL podem relatar detalhes do certificado.

A saída será ainda mais detalhada:

Starting Nmap 7.80 ( https://nmap.org ) at ...
Nmap scan report for localhost (127.0.0.1)
Host is up (0.000099s latency).
Other addresses for localhost (not scanned): ::1
Not shown: 995 closed ports
PORT     STATE SERVICE
22/tcp   open  ssh
2121/tcp open  ccproxy-ftp
2222/tcp open  EtherNetIP-1
3001/tcp open  nessus
| ssl-cert: Subject: commonName=localhost
| Subject Alternative Name: DNS:localhost
| Not valid before: 2024-07-18T03:37:05
|_Not valid after:  2034-07-16T03:37:05
8080/tcp open  http-proxy
|_http-open-proxy: Proxy might be redirecting requests
|_http-title: Site doesn't have a title (text/html).

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

Como você pode ver, os scripts padrão descobriram que o login FTP anônimo é permitido na porta 2121 e recuperaram o título da página web na porta 8080. Esta é uma inteligência valiosa coletada automaticamente.

Executar uma Varredura de Vulnerabilidades

Agora é hora de caçar vulnerabilidades. O NSE inclui uma categoria de scripts projetados especificamente para verificar falhas de segurança conhecidas. Você pode executar todos os scripts na categoria vuln para realizar uma varredura de vulnerabilidades abrangente.

É uma boa prática sempre salvar a saída de varreduras longas ou importantes em um arquivo. Usaremos a flag -oN para salvar a saída no formato normal do Nmap.

Primeiro, vamos combinar o que você aprendeu. Execute uma varredura que inclua detecção de serviço (-sV) e execute todos os scripts de vulnerabilidade (--script vuln). Salve a saída em um arquivo chamado vuln_scan.txt.
```
nmap -sV --script vuln -oN vuln_scan.txt localhost
```
Esta varredura pode levar alguns minutos, pois está executando muitos scripts contra cada porta aberta.
Assim que a varredura for concluída, um arquivo chamado vuln_scan.txt será criado no seu diretório atual (/home/labex/project). Você pode visualizar seu conteúdo usando o comando cat:
```
cat vuln_scan.txt
```
O arquivo de saída é longo, então é mais eficiente procurar por palavras-chave. Use o grep para procurar linhas que indiquem uma vulnerabilidade. O termo "VULNERABLE" é um forte indicador.
```
grep "VULNERABLE" vuln_scan.txt
```
Você deve ver uma saída mostrando quaisquer vulnerabilidades encontradas. Neste ambiente de laboratório, você provavelmente verá uma vulnerabilidade relacionada ao filtro byterange do Apache:
```
|   VULNERABLE:
|     State: VULNERABLE
```
Para ver os detalhes completos da vulnerabilidade, você pode pesquisar pelo CVE específico ou olhar a saída completa da varredura. Por exemplo, você pode encontrar uma vulnerabilidade de DoS no Apache (CVE-2011-3192) na porta 8080. Note que você também pode ver alguns erros de script (como clamav-exec: ERROR), o que é normal e pode ser ignorado — eles ocorrem quando certos scripts de vulnerabilidade não conseguem ser executados corretamente no ambiente de laboratório.

Esta etapa demonstra como sondar ativamente por fraquezas, passando da simples descoberta para uma auditoria de segurança direcionada.

Salvar e Formatar Descobertas da Varredura

Documentar e relatar adequadamente suas descobertas é uma habilidade crítica para qualquer profissional de segurança. O Nmap suporta vários formatos de saída adequados para diferentes propósitos. Nesta etapa final, você aprenderá como salvar seus resultados em múltiplos formatos e criar um relatório HTML amigável.

Primeiro, crie um diretório dedicado para manter seus relatórios organizados.
```
mkdir -p ~/project/reports
```
Agora, execute a varredura novamente, mas desta vez salve a saída em dois formatos simultaneamente: texto normal (-oN) e XML (-oX). O XML é um formato estruturado ideal para processamento com outras ferramentas.
```
nmap -sV -p 8080 --script vuln -oN ~/project/reports/scan_report.txt -oX ~/project/reports/scan_report.xml localhost
```
O formato XML não é muito legível para humanos. O Nmap fornece um utilitário chamado xsltproc para converter o arquivo XML em um relatório HTML limpo. Execute o seguinte comando para gerar o scan_report.html.
```
xsltproc ~/project/reports/scan_report.xml -o ~/project/reports/scan_report.html
```

Vamos verificar se todos os seus arquivos de relatório foram criados no diretório ~/project/reports. Use o comando ls -l para listar os arquivos e seus detalhes.

ls -l ~/project/reports

Você deve ver seus três arquivos de relatório:

total 40
-rw-rw-r-- 1 labex labex 14276 Aug 28 15:12 scan_report.html
-rw-rw-r-- 1 labex labex  5686 Aug 28 15:11 scan_report.txt
-rw-rw-r-- 1 labex labex 14924 Aug 28 15:11 scan_report.xml

Agora você tem um arquivo de texto simples para revisão rápida, um arquivo XML para processamento automatizado e um arquivo HTML para fácil compartilhamento e apresentação.

Resumo

Neste laboratório, você adquiriu experiência prática com o Nmap, uma ferramenta fundamental em cibersegurança. Você começou realizando varreduras de portas básicas para identificar serviços abertos em um host de rede. Em seguida, progrediu para técnicas mais avançadas, incluindo a detecção de versão de serviço (-sV) para identificar softwares específicos e suas versões. Você também explorou o poder do Nmap Scripting Engine (NSE) executando scripts padrão (-sC) e uma varredura completa de vulnerabilidades (--script vuln). Por fim, aprendeu a prática profissional de salvar resultados de varredura em múltiplos formatos (-oN, -oX) e convertê-los em um relatório HTML legível para análise e documentação. Essas habilidades formam uma base sólida para o uso do Nmap em avaliações de segurança de rede no mundo real.