Aprenda a Varredura Nmap e Análise de Saída

NmapBeginner
Pratique Agora

Introdução

Neste laboratório, você aprenderá como usar o Nmap, uma poderosa ferramenta de varredura de rede amplamente utilizada por profissionais de segurança para descobrir hosts e serviços em uma rede de computadores. Você explorará vários formatos de saída fornecidos pelo Nmap, que são vitais para interpretar os resultados da varredura e conduzir análises adicionais.

Nmap, abreviação de Network Mapper, é um utilitário gratuito e de código aberto para descoberta de rede e auditoria de segurança. Ele usa pacotes IP brutos para reunir informações sobre hosts de rede, como serviços disponíveis e sistemas operacionais. Este laboratório irá guiá-lo através da configuração de um serviço de teste e da sua varredura com diferentes opções de saída do Nmap, o que é crucial para uma análise e documentação de rede eficazes.

Este é um Lab Guiado, que fornece instruções passo a passo para ajudá-lo a aprender e praticar. Siga as instruções cuidadosamente para completar cada etapa e ganhar experiência prática. Dados históricos mostram que este é um laboratório de nível iniciante com uma taxa de conclusão de 83%. Recebeu uma taxa de avaliações positivas de 97% dos estudantes.

Configurando um Ambiente de Teste para Varredura Nmap

Nesta etapa, vamos criar um ambiente simples onde você pode praticar a varredura com Nmap. Nmap é uma ferramenta poderosa usada para exploração de rede e auditoria de segurança. Ao configurar um servidor web básico em sua máquina local e, em seguida, varrê-lo com Nmap, você poderá aprender sobre varredura de rede em um ambiente seguro e controlado. Desta forma, você pode experimentar sem afetar redes do mundo real.

Configurando um Servidor Web Local

Primeiro, precisamos configurar um servidor web simples que possamos varrer com Nmap. Python fornece uma maneira fácil de criar um servidor HTTP básico. Um servidor HTTP é um software que pode servir páginas web para clientes, como navegadores.

  1. Abra um terminal e navegue até o diretório do seu projeto:

    cd /home/labex/project

    O comando cd significa "change directory" (mudar diretório). Ele permite que você se mova pelo seu sistema de arquivos. Neste caso, estamos indo para o diretório /home/labex/project onde configuraremos nosso servidor web.

  2. Crie um arquivo HTML simples para servir:

    echo "Welcome to Nmap Testing Environment" > index.html

    O comando echo imprime texto no terminal. O símbolo > redireciona essa saída para um arquivo. Então, estamos criando um arquivo chamado index.html com o texto "Welcome to Nmap Testing Environment". Esta será a página web que nosso servidor servirá.

  3. Inicie um servidor HTTP Python na porta 8080:

    python3 -m http.server 8080 &

    O comando python3 -m http.server inicia um servidor HTTP simples usando Python. O 8080 especifica o número da porta em que o servidor ouvirá. Uma porta é como uma porta pela qual o tráfego de rede entra ou sai de um computador. O & no final do comando executa o servidor em segundo plano, permitindo que você continue usando o terminal para outros comandos.

  4. Verifique se seu servidor web está em execução acessando-o:

    curl http://localhost:8080

    O comando curl é usado para transferir dados de ou para um servidor. Aqui, estamos tentando acessar o servidor web que acabamos de configurar em http://localhost:8080. localhost se refere ao computador atual.

    Você deve ver a seguinte saída:

    Welcome to Nmap Testing Environment

    Se você vir esta saída, significa que seu servidor web está executando corretamente.

Varredura Básica com Nmap

Agora que você tem um servidor web em execução, você pode varrê-lo usando Nmap. A varredura de um servidor ajuda você a descobrir quais portas estão abertas e quais serviços podem estar sendo executados nelas.

  1. Execute uma varredura básica com Nmap em seu servidor web local:

    nmap -p 8080 localhost

    A opção -p no comando nmap especifica a porta a ser varrida. Neste caso, estamos dizendo ao Nmap para varrer apenas a porta 8080 em localhost (que é o endereço IP 127.0.0.1).

    Você deve ver uma saída semelhante a esta:

    Starting Nmap 7.80 ( https://nmap.org ) at 2023-11-08 12:34 UTC
    Nmap scan report for localhost (127.0.0.1)
    Host is up (0.000097s latency).
    
    PORT     STATE SERVICE
    8080/tcp open  http-proxy
    
    Nmap done: 1 IP address (1 host up) scanned in 0.05 seconds

    Esta saída está no formato padrão do Nmap, que é legível por humanos e exibe as informações básicas sobre a varredura.

Entendendo a Saída Padrão do Nmap

Vamos entender o que a saída padrão mostra:

  • Starting Nmap: Esta linha mostra a versão do Nmap que você está usando e a hora em que a varredura começou. Isso ajuda você a controlar quando a varredura foi iniciada.
  • Nmap scan report: Isso indica o alvo da varredura. Em nosso caso, o alvo é localhost.
  • Host is up: Isso confirma que o alvo está online. O tempo de latência mostra quanto tempo o Nmap levou para obter uma resposta do alvo.
  • PORT: Isso mostra o número da porta que foi varrida. Em nossa varredura, varremos a porta 8080.
  • STATE: Isso indica se a porta está aberta, fechada ou filtrada. Uma porta aberta significa que um serviço está ouvindo nessa porta e aceitando conexões.
  • SERVICE: Nmap tenta adivinhar qual serviço pode estar sendo executado nessa porta. Aqui, ele adivinhou http - proxy.
  • Nmap done: Este é um resumo da varredura. Ele informa quantos endereços IP foram varridos e quanto tempo a varredura levou.

Agora você configurou com sucesso um ambiente de teste e realizou uma varredura básica com Nmap. Na próxima etapa, você explorará diferentes formatos de saída que o Nmap oferece.

Explorando Diferentes Formatos de Saída do Nmap

Nesta etapa, vamos aprender sobre os vários formatos de saída que o Nmap oferece. Os formatos de saída são cruciais em segurança cibernética porque nos permitem apresentar os resultados da varredura de diferentes maneiras, dependendo de nossas necessidades. Por exemplo, alguns formatos são fáceis de ler para humanos, enquanto outros são projetados para máquinas analisarem, o que é útil ao integrar com outras ferramentas.

Visão Geral dos Formatos de Saída do Nmap

O Nmap suporta vários formatos de saída, cada um com suas próprias características e casos de uso exclusivos:

  1. Saída Normal (padrão): Este é um formato legível por humanos. Ele apresenta os resultados da varredura de uma forma que é fácil para nós entendermos à primeira vista, tornando-o ótimo para análise manual rápida.
  2. Saída XML (-oX): XML significa Extensible Markup Language (Linguagem de Marcação Extensível). É um formato estruturado, o que significa que os dados são organizados de forma hierárquica. Isso facilita para programas e scripts analisarem os dados, e é comumente usado ao integrar o Nmap com outras ferramentas de segurança.
  3. Saída Grepable (-oG): Este é um formato baseado em linhas. Ele é projetado para ser facilmente processado com ferramentas Unix como grep, awk e cut. Este formato é útil quando você deseja extrair rapidamente informações específicas dos resultados da varredura.
  4. Saída Script Kiddie (-oS): Este formato é semelhante à saída normal, mas inclui arte ASCII. No entanto, raramente é usado em cenários práticos.
  5. Todos os Formatos (-oA): Esta opção permite que você salve os resultados da varredura nos formatos normal, XML e grepable simultaneamente. É uma maneira conveniente de ter todos os tipos de saídas disponíveis de uma vez.

Vamos explorar esses formatos varrendo seu servidor web local novamente.

Formato de Saída XML

XML, ou Extensible Markup Language (Linguagem de Marcação Extensível), é um formato estruturado que é amplamente usado para armazenamento e troca de dados. Sua estrutura hierárquica facilita para os programas analisarem os dados, e é por isso que é comumente usado para integração com outras ferramentas de segurança.

  1. Execute uma varredura Nmap e salve a saída no formato XML:

    nmap -p 8080 localhost -oX /home/labex/project/scan_results.xml

    Neste comando, -p 8080 especifica que estamos varrendo a porta 8080, localhost é o alvo que estamos varrendo (nossa máquina local), e -oX diz ao Nmap para salvar a saída no formato XML no caminho do arquivo especificado.

  2. Visualize a saída XML:

    cat /home/labex/project/scan_results.xml

    O comando cat é usado para exibir o conteúdo de um arquivo. Quando você executa este comando, você verá uma saída formatada em XML que se parece com isto (abreviado):

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE nmaprun>
    <nmaprun scanner="nmap" args="nmap -p 8080 localhost -oX /home/labex/project/scan_results.xml" ...>
      <scaninfo type="connect" protocol="tcp" .../>
      <verbose level="0"/>
      <debugging level="0"/>
      <host>
        <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="8080">
            <state state="open" reason="syn - ack" reason_ttl="0"/>
            <service name="http - proxy" method="table" conf="3"/>
          </port>
        </ports>
        <times srtt="97" rttvar="5000" to="100000"/>
      </host>
      <runstats>...</runstats>
    </nmaprun>
  3. O formato XML inclui informações detalhadas organizadas em uma estrutura hierárquica. Vamos extrair as informações específicas da porta:

    grep -A5 "<port " /home/labex/project/scan_results.xml > /home/labex/project/port_details.txt

    O comando grep é usado para procurar um padrão específico em um arquivo. -A5 significa exibir 5 linhas após a linha que corresponde ao padrão. Estamos procurando linhas que contenham <port no arquivo XML e salvando os resultados em um novo arquivo chamado port_details.txt.

  4. Visualize os detalhes da porta extraída:

    cat /home/labex/project/port_details.txt

    A execução deste comando mostrará a seção de informações da porta do XML.

Formato de Saída Grepable

A saída Grepable é projetada especificamente para ser facilmente processada com ferramentas como grep, awk e cut. Essas ferramentas Unix são muito poderosas para processamento de texto e podem nos ajudar a extrair rapidamente as informações de que precisamos dos resultados da varredura.

  1. Execute uma varredura Nmap e salve a saída no formato grepable:

    nmap -p 8080 localhost -oG /home/labex/project/scan_results.grep

    Aqui, -oG diz ao Nmap para salvar a saída no formato grepable no arquivo especificado.

  2. Visualize a saída grepable:

    cat /home/labex/project/scan_results.grep

    A saída se parecerá com isto:

    ## Nmap 7.80 scan initiated Wed Nov 8 12:40:00 2023 as: nmap -p 8080 localhost -oG /home/labex/project/scan_results.grep
    Host: 127.0.0.1 (localhost)   Status: Up
    Host: 127.0.0.1 (localhost)   Ports: 8080/open/tcp//http - proxy///
    ## Nmap done at Wed Nov 8 12:40:00 2023 -- 1 IP address (1 host up) scanned in 0.05 seconds
  3. O formato grepable coloca todas as informações do host em uma única linha, facilitando o uso com ferramentas de processamento de texto. Por exemplo, você pode extrair apenas a linha contendo informações da porta:

    grep "Ports:" /home/labex/project/scan_results.grep > /home/labex/project/ports_info.txt

    Este comando procura linhas contendo a palavra "Ports:" no arquivo de saída grepable e salva a linha correspondente em um novo arquivo chamado ports_info.txt.

  4. Visualize as informações das portas extraídas:

    cat /home/labex/project/ports_info.txt

Salvando em Todos os Formatos Simultaneamente

O Nmap fornece uma opção conveniente para salvar a saída em vários formatos de uma vez usando a opção -oA. Isso pode economizar tempo se você precisar de diferentes tipos de saídas para diferentes propósitos.

  1. Execute uma varredura Nmap e salve a saída em todos os formatos:

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

    Este comando varre a porta 8080 na máquina local e salva os resultados nos formatos normal, XML e grepable.

  2. Verifique os arquivos criados:

    ls -la /home/labex/project/all_formats.*

    O comando ls -la lista todos os arquivos em um diretório com informações detalhadas. Quando você executa este comando, você deve ver três arquivos:

    • all_formats.nmap (saída normal)
    • all_formats.xml (saída XML)
    • all_formats.gnmap (saída grepable)

Agora você entende os diferentes formatos de saída que o Nmap oferece e como usá-los. Cada formato tem suas próprias vantagens:

  • A saída normal é fácil de ler para humanos
  • A saída XML é estruturada para análise por máquina e integração com outras ferramentas
  • A saída Grepable é projetada para análise rápida com ferramentas de processamento de texto Unix

Na próxima etapa, você aprenderá como analisar essas saídas com mais detalhes.

Analisando a Saída do Nmap e Extraindo Informações Úteis

Nesta etapa, você aprenderá como extrair e analisar informações específicas dos resultados da varredura do Nmap. Esta é uma habilidade crucial para administradores de rede e profissionais de segurança. Ao lidar com varreduras de rede, você geralmente obtém uma grande quantidade de dados. Ser capaz de extrair as partes relevantes de forma eficiente ajuda você a entender o status de segurança da rede e identificar possíveis problemas.

Analisando a Saída XML

A saída XML é muito útil para análise detalhada e pode ser facilmente integrada com outras ferramentas. XML é um formato estruturado que organiza os dados de forma hierárquica, tornando mais fácil localizar e extrair informações específicas. Vamos explorar como extrair informações específicas da saída XML.

  1. Primeiro, vamos analisar a estrutura da saída XML para entender quais informações estão disponíveis. Usaremos o comando grep para encontrar o início da seção do host no arquivo XML. O comando grep procura um padrão especificado em um arquivo.

    grep "<host" -A2 /home/labex/project/scan_results.xml

    Este comando procura a tag <host> no arquivo scan_results.xml e mostra as duas linhas seguintes após a correspondência. Isso nos ajuda a ver o início da seção do host no arquivo XML.

  2. Agora, vamos extrair informações sobre o estado da porta. Usaremos grep novamente para encontrar todas as linhas contendo a tag <state e salvar os resultados em um novo arquivo.

    grep "<state " /home/labex/project/scan_results.xml > /home/labex/project/port_state.txt
  3. Visualize o estado da porta extraída. Usaremos o comando cat, que é usado para exibir o conteúdo de um arquivo.

    cat /home/labex/project/port_state.txt

    Você deve ver algo como:

    <state state="open" reason="syn-ack" reason_ttl="0"/>

    Isso nos diz que a porta está aberta. O Nmap determinou isso porque recebeu um pacote SYN - ACK em resposta ao seu pacote SYN. Isso faz parte do handshake de três vias TCP, que é como uma conexão TCP é estabelecida entre dois dispositivos em uma rede.

Usando Expressões Regulares para Extração Mais Complexa

Para uma extração de dados mais complexa, você pode usar expressões regulares com ferramentas como grep, sed ou awk. Expressões regulares são uma maneira poderosa de pesquisar e corresponder padrões em texto. Elas permitem que você defina critérios de pesquisa complexos.

  1. Vamos extrair o número da porta e seu estado. Usaremos grep com uma expressão regular para encontrar as informações relevantes no arquivo XML e salvá-las em um novo arquivo.

    grep -o 'portid="[0-9]*".*state="[^"]*"' /home/labex/project/scan_results.xml > /home/labex/project/port_and_state.txt
  2. Visualize as informações extraídas usando o comando cat.

    cat /home/labex/project/port_and_state.txt

    Você deve ver uma saída como:

    portid="8080" state="open"

Analisando a Saída Grepable

O formato de saída grepable é projetado para ser facilmente processado com ferramentas Unix padrão. É um formato baseado em texto que torna simples pesquisar informações específicas usando comandos como grep.

  1. Vamos extrair apenas as portas abertas da saída grepable. Usaremos grep para encontrar todas as linhas contendo a palavra "open" e salvar os resultados em um novo arquivo.

    grep "open" /home/labex/project/scan_results.grep > /home/labex/project/open_ports.txt
  2. Visualize as informações extraídas usando o comando cat.

    cat /home/labex/project/open_ports.txt

    Isso deve mostrar a linha contendo todas as portas abertas.

  3. Você pode processar isso ainda mais para extrair apenas os números das portas. Usaremos uma combinação de comandos grep e cut. O comando cut é usado para extrair partes específicas de uma linha com base em um delimitador.

    grep "open" /home/labex/project/scan_results.grep | grep -o "8080/open" | cut -d "/" -f1 > /home/labex/project/port_numbers.txt
  4. Visualize os números das portas extraídas usando o comando cat.

    cat /home/labex/project/port_numbers.txt

    Você deve ver:

    8080

Criando um Relatório Resumo Simples

Agora, vamos criar um relatório resumo simples que combina informações de diferentes partes da varredura. Um relatório resumo ajuda você a entender rapidamente as principais descobertas da varredura.

  1. Crie um relatório resumo. Usaremos o comando echo para escrever texto em um arquivo. O operador >> anexa o texto ao final do arquivo.

    echo "Nmap Scan Summary" > /home/labex/project/scan_summary.txt
    echo "----------------" >> /home/labex/project/scan_summary.txt
    echo "Target: localhost (127.0.0.1)" >> /home/labex/project/scan_summary.txt
    echo "Open ports:" >> /home/labex/project/scan_summary.txt
    grep "open" /home/labex/project/scan_results.grep | grep -o "[0-9]*/open/tcp//[^/]*" >> /home/labex/project/scan_summary.txt
  2. Visualize o relatório resumo usando o comando cat.

    cat /home/labex/project/scan_summary.txt

    A saída deve ser semelhante a:

    Nmap Scan Summary
    ----------------
    Target: localhost (127.0.0.1)
    Open ports:
    8080/open/tcp//http - proxy

Ao aprender como extrair e analisar informações específicas dos resultados da varredura do Nmap, você pode processar e interpretar dados de reconhecimento de rede de forma eficiente. Essa habilidade é particularmente valiosa ao varrer grandes redes com vários hosts e serviços.

Na próxima etapa, você aprenderá sobre técnicas de varredura Nmap mais avançadas.

Técnicas Avançadas de Varredura Nmap

Nesta etapa, exploraremos técnicas de varredura Nmap mais avançadas. Essas técnicas são cruciais, pois podem fornecer informações adicionais e detalhadas sobre os serviços de rede. Especificamente, focaremos na detecção da versão do serviço e na varredura de scripts. A compreensão dessas técnicas ajudará você a obter uma visão mais profunda dos serviços de rede que você está varrendo, o que é essencial para avaliações de segurança, inventário de rede e solução de problemas.

Detecção da Versão do Serviço

O Nmap possui um recurso poderoso que permite que ele tente determinar a versão específica de um serviço em execução em uma porta. Isso é feito usando a opção -sV. Conhecer a versão do serviço pode ser muito útil, pois diferentes versões podem ter diferentes vulnerabilidades de segurança ou recursos.

  1. Execute uma varredura Nmap com detecção da versão do serviço:

    nmap -p 8080 -sV localhost -oN /home/labex/project/version_scan.txt

    Neste comando, a opção -sV diz ao Nmap para sondar as portas abertas. Ao fazer isso, o Nmap pode coletar informações sobre os serviços em execução nessas portas, incluindo suas versões. A opção -oN é usada para salvar a saída da varredura em um formato normal no arquivo especificado /home/labex/project/version_scan.txt. Salvar a saída em um arquivo permite que você revise os resultados posteriormente.

  2. Visualize os resultados da varredura:

    cat /home/labex/project/version_scan.txt

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

    Starting Nmap 7.80 ( https://nmap.org ) at 2023-11-08 13:20:00 UTC
    Nmap scan report for localhost (127.0.0.1)
    Host is up (0.000097s latency).
    
    PORT     STATE SERVICE VERSION
    8080/tcp open  http    Python/3.10 aiohttp/3.8.1 (Python httpd)
    
    Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
    Nmap done: 1 IP address (1 host up) scanned in 6.52 seconds

    Observe que o Nmap agora mostra não apenas o nome do serviço, mas também informações da versão. Neste caso, ele detectou que o servidor HTTP está em execução com Python 3.10. Essas informações detalhadas podem ser usadas para identificar possíveis riscos de segurança ou para entender as capacidades do serviço.

Usando Scripts Nmap (NSE)

O Nmap Script Engine (NSE) é uma ferramenta poderosa que permite que você execute scripts para realizar várias tarefas. Essas tarefas variam da detecção de serviços à varredura de vulnerabilidades. Ao usar scripts NSE, você pode estender a funcionalidade do Nmap e coletar mais informações sobre a rede de destino.

  1. Execute um script básico de informações HTTP em seu servidor web:

    nmap -p 8080 --script=http-title localhost -oN /home/labex/project/script_scan.txt

    O script http-title foi projetado para buscar o título das páginas web HTTP. Isso pode ser útil para identificar rapidamente o conteúdo ou o propósito de uma página web. A opção -oN salva a saída da varredura do script em um formato normal no arquivo especificado /home/labex/project/script_scan.txt.

  2. Visualize os resultados da varredura do script:

    cat /home/labex/project/script_scan.txt

    A saída deve incluir algo como:

    Starting Nmap 7.80 ( https://nmap.org ) at 2023-11-08 13:25:00 UTC
    Nmap scan report for localhost (127.0.0.1)
    Host is up (0.000097s latency).
    
    PORT     STATE SERVICE
    8080/tcp open  http-proxy
    |_http-title: Directory listing for /
    
    Nmap done: 1 IP address (1 host up) scanned in 0.42 seconds

    O script http-title recuperou o título da página web, que neste caso é uma listagem de diretórios. Essas informações podem ajudá-lo a entender a estrutura e o conteúdo do servidor web.

  3. Vamos tentar outro script que fornece mais informações sobre o servidor HTTP:

    nmap -p 8080 --script=http-server-header localhost -oN /home/labex/project/server_header_scan.txt

    O script http-server-header é usado para recuperar o cabeçalho do servidor HTTP. O cabeçalho do servidor geralmente contém informações sobre o software do servidor, como a versão e o tipo. Essas informações podem ser valiosas para avaliações de segurança e inventário de rede. A opção -oN salva a saída da varredura em um formato normal no arquivo especificado /home/labex/project/server_header_scan.txt.

  4. Visualize os resultados da varredura do cabeçalho do servidor:

    cat /home/labex/project/server_header_scan.txt

    A saída deve incluir informações sobre o software do servidor:

    Starting Nmap 7.80 ( https://nmap.org ) at 2023-11-08 13:30:00 UTC
    Nmap scan report for localhost (127.0.0.1)
    Host is up (0.000097s latency).
    
    PORT     STATE SERVICE
    8080/tcp open  http-proxy
    |_http-server-header: SimpleHTTP/0.6 Python/3.10.12
    
    Nmap done: 1 IP address (1 host up) scanned in 0.13 seconds

Combinando Múltiplas Técnicas

Você pode combinar várias técnicas de varredura em um único comando Nmap para realizar uma varredura mais abrangente. Isso permite que você colete uma ampla gama de informações sobre a rede de destino de uma só vez.

  1. Execute uma varredura abrangente que inclua varredura de portas, detecção da versão do serviço e varredura de scripts:

    nmap -p 8080 -sV --script=http-title,http-server-header localhost -oA /home/labex/project/comprehensive_scan

    Este comando faz várias coisas:

    • Ele varre a porta 8080 (-p 8080), o que significa que ele verifica se essa porta está aberta no host de destino.
    • Ele detecta as versões do serviço (-sV), fornecendo informações sobre as versões específicas dos serviços em execução na porta.
    • Ele executa os scripts http-title e http-server-header (--script=http-title,http-server-header), que buscam o título da página web e as informações do cabeçalho do servidor, respectivamente.
    • Ele salva os resultados em todos os formatos (-oA). Salvar em todos os formatos garante que você tenha diferentes representações dos resultados da varredura para diferentes propósitos.
  2. Visualize os resultados da varredura abrangente:

    cat /home/labex/project/comprehensive_scan.nmap

    A saída incluirá todas as informações das varreduras anteriores combinadas. Isso fornece uma visão holística do serviço de rede de destino em execução na porta 8080.

  3. Crie um relatório de análise final que resuma todas as suas descobertas:

    echo "Final Nmap Analysis Report" > /home/labex/project/final_report.txt
    echo "------------------------" >> /home/labex/project/final_report.txt
    echo "Target: localhost (127.0.0.1)" >> /home/labex/project/final_report.txt
    echo "Port: 8080/tcp (open)" >> /home/labex/project/final_report.txt
    echo "Service:" >> /home/labex/project/final_report.txt
    grep "SERVICE VERSION" -A1 /home/labex/project/version_scan.txt | tail -1 >> /home/labex/project/final_report.txt
    echo "HTTP Server Header:" >> /home/labex/project/final_report.txt
    grep "http-server-header:" /home/labex/project/server_header_scan.txt >> /home/labex/project/final_report.txt
    echo "HTTP Page Title:" >> /home/labex/project/final_report.txt
    grep "http-title:" /home/labex/project/script_scan.txt >> /home/labex/project/final_report.txt

    Este conjunto de comandos cria um arquivo de texto chamado final_report.txt e o preenche com um resumo de todas as informações coletadas das varreduras anteriores. Ele inclui detalhes sobre o destino, a porta, a versão do serviço, o cabeçalho do servidor e o título da página web.

  4. Visualize seu relatório final:

    cat /home/labex/project/final_report.txt

    Seu relatório final deve conter um resumo abrangente de todas as informações que você coletou sobre o servidor web em execução na porta 8080. Este relatório pode ser usado para análise posterior, avaliações de segurança ou fins de documentação.

Ao aprender essas técnicas avançadas de varredura Nmap, você pode coletar informações detalhadas sobre os serviços de rede que são valiosas para avaliações de segurança, inventário de rede e solução de problemas.

Resumo

Neste laboratório, você aprendeu como usar o Nmap, uma poderosa ferramenta de varredura de rede para descoberta de rede e auditoria de segurança. Você adquiriu experiência prática em várias operações do Nmap, incluindo a configuração de um ambiente de teste com um servidor web local, a execução de varreduras de portas básicas, a exploração de diferentes formatos de saída, a extração e análise de resultados de varredura e o uso de técnicas avançadas como detecção da versão do serviço e varredura de scripts.

Essas habilidades são essenciais para administradores de rede, analistas de segurança e testadores de penetração. Elas permitem que você descubra hosts e serviços de rede, documente a infraestrutura de rede, identifique problemas de segurança e automatize a varredura e a geração de relatórios. Dominar o Nmap e seus formatos de saída permite uma reconhecimento de rede eficaz, a integração com outras ferramentas de segurança e a construção de inventários de rede abrangentes. As habilidades de linha de comando que você praticou também são transferíveis para outras tarefas de administração de sistema e segurança.