Introdução
Ao realizar testes de invasão ou avaliações de segurança de rede, executar varreduras é apenas metade do trabalho. Documentar e salvar adequadamente os resultados das varreduras é crucial para a elaboração de relatórios, acompanhamento do progresso e alimentação de dados em outras ferramentas de segurança.
A escolha do formato de saída afeta o que você pode fazer com os resultados posteriormente. A saída legível por humanos é ideal para uma revisão rápida. A saída estruturada é ideal para automação. Fluxos de trabalho maduros geralmente preservam ambos.
O Nmap, o mapeador de rede padrão da indústria, oferece vários formatos de saída para atender a diferentes necessidades. Os três formatos mais comuns são Normal (legível por humanos), Grepable (projetado para análise via linha de comando) e XML (dados estruturados para importação em outros softwares).
Neste laboratório, você aprenderá como gerar esses três formatos de saída e como usar ferramentas básicas de linha de comando do Linux para analisar os resultados e extrair informações valiosas.
Saída em Formato Normal (-oN)
Nesta etapa, você aprenderá como salvar os resultados da varredura do Nmap no formato Normal. O formato Normal é essencialmente uma cópia direta do que você vê na tela do seu terminal ao executar uma varredura do Nmap. Ele é altamente legível e perfeito para revisar resultados rapidamente ou compartilhá-los com colegas em um documento de texto.
Este formato é otimizado para pessoas, não para pipelines. É a escolha certa quando o consumidor imediato é um analista humano lendo a varredura como um relatório.
Para salvar os resultados da sua varredura no formato Normal, você usa a flag -oN seguida pelo nome do arquivo que deseja criar. Vamos escanear nossa máquina local (127.0.0.1) para descobrir portas abertas e salvar a saída.
Execute o seguinte comando no seu terminal para realizar uma varredura e salvá-la como normal_scan.txt:
nmap -p 22,8080 -oN normal_scan.txt 127.0.0.1
Após a conclusão da varredura, você pode visualizar o conteúdo do arquivo usando o comando cat. Isso exibirá exatamente a mesma saída que foi impressa na sua tela durante a varredura.
cat normal_scan.txt
Você deverá ver uma saída semelhante a esta, mostrando as portas abertas e seus serviços associados:
## Nmap 7.80 scan initiated Sat Mar 7 16:07:07 2026 as: nmap -p 22,8080 -oN normal_scan.txt 127.0.0.1
Nmap scan report for localhost (127.0.0.1)
Host is up (0.000057s latency).
PORT STATE SERVICE
22/tcp open ssh
8080/tcp open http-proxy
## Nmap done at Sat Mar 7 16:07:07 2026 -- 1 IP address (1 host up) scanned in 0.02 seconds
Saída em Formato Grepable (-oG)
Nesta etapa, você explorará o formato de saída Grepable. Embora o formato Normal seja ótimo para os olhos humanos, é difícil processá-lo programaticamente porque as informações ocupam várias linhas. O formato Grepable resolve isso colocando todas as informações de um único host em uma única linha longa.
Achatar os dados dessa maneira torna a análise baseada em shell prática. É um exemplo clássico de moldar a saída para ferramentas subsequentes, em vez de focar no conforto da leitura direta.
Este formato foi projetado especificamente para ser usado com ferramentas de linha de comando do Linux, como grep, awk e cut. Para gerar uma saída Grepable, você usa a flag -oG.
Execute o seguinte comando para realizar a mesma varredura, mas desta vez salve os resultados no formato Grepable como grepable_scan.txt:
nmap -p 22,8080 -oG grepable_scan.txt 127.0.0.1
Agora, visualize o conteúdo do arquivo recém-criado:
cat grepable_scan.txt
A saída parecerá bem diferente do formato Normal. Observe como as informações do host e todas as suas portas abertas são condensadas em uma única linha:
## Nmap 7.80 scan initiated Sat Mar 7 16:07:20 2026 as: nmap -p 22,8080 -oG grepable_scan.txt 127.0.0.1
Host: 127.0.0.1 (localhost) Status: Up
Host: 127.0.0.1 (localhost) Ports: 22/open/tcp//ssh///, 8080/open/tcp//http-proxy///
## Nmap done at Sat Mar 7 16:07:20 2026 -- 1 IP address (1 host up) scanned in 0.02 seconds
Essa estrutura torna incrivelmente fácil pesquisar palavras-chave específicas, como "open", e extrair os endereços IP correspondentes, o que você praticará em uma etapa posterior.
Saída em Formato XML (-oX)
Nesta etapa, você aprenderá como gerar uma saída XML. O XML (eXtensible Markup Language) é um formato altamente estruturado que é amplamente suportado por muitos aplicativos de software diferentes.
A saída estruturada legível por máquina torna-se mais importante à medida que as avaliações aumentam de escala. Quando os resultados da sua varredura precisam ser movidos para outras ferramentas, a análise de texto ad hoc torna-se frágil e cara de manter.
No contexto de testes de invasão, o XML é o formato preferido quando você precisa importar os resultados da sua varredura do Nmap para outras ferramentas de segurança, como o Metasploit Framework, scanners de vulnerabilidade ou scripts de relatório personalizados. Para criar um arquivo de saída XML, você usa a flag -oX.
Execute o seguinte comando para realizar a varredura e salvar os resultados como xml_scan.xml:
nmap -p 22,8080 -oX xml_scan.xml 127.0.0.1
Você pode inspecionar o conteúdo do arquivo XML usando o comando cat:
cat xml_scan.xml
A saída será um grande bloco de tags XML estruturadas. Embora não seja muito fácil para humanos lerem rapidamente, está perfeitamente formatado para máquinas analisarem:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE nmaprun>
<?xml-stylesheet href="file:///usr/bin/../share/nmap/nmap.xsl" type="text/xsl"?>
<!-- Nmap 7.80 scan initiated Sat Mar 7 16:07:30 2026 as: nmap -p 22,8080 -oX xml_scan.xml 127.0.0.1 -->
<nmaprun scanner="nmap" args="nmap -p 22,8080 -oX xml_scan.xml 127.0.0.1" start="1772870850" startstr="Sat Mar 7 16:07:30 2026" version="7.80" xmloutputversion="1.04">
...
<host starttime="1772870850" endtime="1772870850"><status state="up" reason="conn-refused" reason_ttl="0"/>
<address addr="127.0.0.1" addrtype="ipv4"/>
<hostnames>
<hostname name="localhost" type="PTR"/>
</hostnames>
<ports><port protocol="tcp" portid="22"><state state="open" reason="syn-ack" reason_ttl="0"/><service name="ssh" method="table" conf="3"/></port>
...
Analisar Saída Grepable com Awk
Nesta etapa final, você colocará o formato de saída Grepable em uso prático. Um cenário comum em testes de invasão é escanear uma rede grande, encontrar hosts com portas abertas específicas e, em seguida, extrair apenas os endereços IP desses hosts para alimentar outra ferramenta (como um quebrador de senhas ou um exploit de vulnerabilidade).
Usaremos duas ferramentas poderosas de processamento de texto do Linux: grep e awk. O comando grep filtra linhas que contêm uma palavra específica, e o awk pode extrair colunas específicas dessas linhas.
Primeiro, vamos ver como podemos filtrar nosso arquivo Grepable para mostrar apenas as linhas que contêm a palavra "open":
grep "open" grepable_scan.txt
Este comando exibe a linha que contém o host e suas portas abertas.
Host: 127.0.0.1 (localhost) Ports: 22/open/tcp//ssh///, 8080/open/tcp//http-proxy///
Agora, queremos extrair apenas o endereço IP. No formato Grepable, o endereço IP é sempre a segunda "palavra" (ou coluna) na linha. Podemos usar o pipe (|) para enviar a saída do grep para o awk e dizer a ele para imprimir a segunda coluna ($2).
Execute o seguinte comando para extrair o endereço IP e salvá-lo em um novo arquivo chamado open_hosts.txt:
grep "open" grepable_scan.txt | awk '{print $2}' > open_hosts.txt
Vamos verificar o conteúdo do nosso novo arquivo:
cat open_hosts.txt
Você deverá ver apenas o endereço IP impresso:
127.0.0.1
Ao dominar essa combinação simples de comandos, você pode analisar rapidamente arquivos de varredura massivos e extrair exatamente os alvos de que precisa para a próxima fase da sua avaliação.
Resumo
Neste laboratório, você aprendeu como documentar e gerenciar efetivamente os resultados de varredura do Nmap usando diferentes formatos de saída. Você explorou o formato Normal (-oN) para legibilidade humana, o formato Grepable (-oG) para análise via linha de comando e o formato XML (-oX) para integração com ferramentas. Por fim, você praticou o uso de utilitários de processamento de texto do Linux, como grep e awk, para extrair informações específicas de alvos a partir de arquivos de saída Grepable. Essas habilidades são essenciais para organizar dados e otimizar fluxos de trabalho durante avaliações de segurança.
