Descubra Serviços de Rede com Nmap e seu Scripting Engine

NmapNmapBeginner
Pratique Agora

💡 Este tutorial foi traduzido do inglês com assistência de IA. Para ver o original, você pode mudar para a versão em inglês

Introdução

Neste laboratório, você aprenderá sobre o Nmap Scripting Engine (NSE), uma parte poderosa da ferramenta de varredura de rede Nmap. O NSE aprimora as funções do Nmap, permitindo que você execute descoberta de rede avançada, detecção de vulnerabilidades e enumeração de serviços.

Este motor é crucial para administradores de rede modernos, especialistas em segurança e hackers éticos. Eles precisam entender as topologias de rede, identificar potenciais problemas de segurança e coletar informações detalhadas sobre os serviços de rede. Neste laboratório, você configurará um serviço de rede local e usará o Nmap para descobri-lo e analisá-lo. Ao final, você entenderá os fundamentos do uso do Nmap e seu mecanismo de script para explorar e coletar dados sobre serviços de rede.

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 100%. Recebeu uma taxa de avaliações positivas de 100% dos estudantes.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL nmap(("Nmap")) -.-> nmap/NmapGroup(["Nmap"]) nmap/NmapGroup -.-> nmap/installation("Installation and Setup") nmap/NmapGroup -.-> nmap/save_output("Save Output to File") nmap/NmapGroup -.-> nmap/port_scanning("Port Scanning Methods") nmap/NmapGroup -.-> nmap/target_specification("Target Specification") nmap/NmapGroup -.-> nmap/service_detection("Service Detection") subgraph Lab Skills nmap/installation -.-> lab-415931{{"Descubra Serviços de Rede com Nmap e seu Scripting Engine"}} nmap/save_output -.-> lab-415931{{"Descubra Serviços de Rede com Nmap e seu Scripting Engine"}} nmap/port_scanning -.-> lab-415931{{"Descubra Serviços de Rede com Nmap e seu Scripting Engine"}} nmap/target_specification -.-> lab-415931{{"Descubra Serviços de Rede com Nmap e seu Scripting Engine"}} nmap/service_detection -.-> lab-415931{{"Descubra Serviços de Rede com Nmap e seu Scripting Engine"}} end

Configurando um Serviço de Rede Local para Varredura

Nesta etapa, vamos criar um serviço de rede simples. Por que fazemos isso? Bem, no mundo real da segurança cibernética, você frequentemente precisa encontrar e analisar os serviços em execução em uma rede. Ao criar este serviço simples, podemos praticar o uso do Nmap para escaneá-lo mais tarde, assim como você faria em uma situação do mundo real.

Primeiro, precisamos abrir um terminal. Um terminal é uma interface baseada em texto onde você pode inserir comandos para interagir com seu computador. Depois de abrir o terminal, você precisa ter certeza de que está no diretório do projeto. O diretório do projeto é como uma pasta onde todos os arquivos relacionados a este projeto são armazenados. Para navegar até o diretório do projeto, insira o seguinte comando no terminal:

cd /home/labex/project

Em seguida, vamos criar um arquivo HTML simples. HTML significa HyperText Markup Language (Linguagem de Marcação de Hipertexto) e é usado para criar páginas da web. Este arquivo será hospedado pelo nosso servidor, assim como as páginas da web que você vê na internet. O conteúdo deste arquivo é o que um servidor web do mundo real pode servir aos usuários. Para criar o arquivo, use o seguinte comando:

echo "<h1>Welcome to the hidden treasure chamber</h1>" > treasure.html

Este comando faz duas coisas. Primeiro, ele cria uma string com um cabeçalho HTML. Em seguida, ele redireciona essa string para um arquivo chamado treasure.html. Para verificar se o arquivo foi criado corretamente, você pode usar o comando cat. O comando cat é usado para exibir o conteúdo de um arquivo. Insira o seguinte comando no terminal:

cat treasure.html

Se tudo correu bem, você deverá ver o conteúdo HTML que acabamos de adicionar:

<h1>Welcome to the hidden treasure chamber</h1>

Agora, vamos iniciar um servidor HTTP simples. HTTP significa HyperText Transfer Protocol (Protocolo de Transferência de Hipertexto) e é o protocolo usado para transferir páginas da web pela internet. Usaremos o módulo embutido do Python para iniciar este servidor. Este servidor ouvirá na porta 8000. Uma porta é como uma porta no seu computador onde o tráfego de rede pode entrar ou sair. O servidor servirá arquivos do diretório atual, que é o diretório do projeto para o qual navegamos anteriormente. Para iniciar o servidor, insira o seguinte comando no terminal:

python3 -m http.server 8000

Após executar este comando, você deverá 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á agora em execução e aguardando conexões na porta 8000. Certifique-se de deixar esta janela do terminal aberta. Se você fechá-la, o servidor parará de ser executado e não poderemos escaneá-lo com o Nmap mais tarde.

Descobrindo Serviços de Rede com Nmap

Agora que configuramos com sucesso um serviço de rede, é hora de usar o Nmap para descobri-lo e analisá-lo. Nmap, abreviação de Network Mapper (Mapeador de Rede), é uma ferramenta de código aberto bem conhecida e poderosa. É amplamente utilizada para descoberta de rede, o que significa descobrir quais dispositivos e serviços estão disponíveis em uma rede, e auditoria de segurança, que ajuda a identificar potenciais riscos de segurança.

Primeiro, abra uma nova janela do terminal. Certifique-se de manter a janela do terminal anterior aberta, pois ela está executando o servidor HTTP. Depois de abrir o novo terminal, você precisa navegar até o diretório do projeto. Isso é importante porque todos os comandos relacionados a este projeto serão executados a partir deste diretório. Use o seguinte comando para alterar o diretório:

cd /home/labex/project

Vamos começar com uma varredura de porta básica. Uma varredura de porta é uma técnica usada para verificar quais portas em um dispositivo estão abertas e executando serviços. Portas são como portas pelas quais o tráfego de rede entra e sai de um dispositivo. Neste caso, vamos escanear a porta 8000 no localhost, que se refere à máquina atual em que estamos trabalhando. Execute o seguinte comando:

nmap -p 8000 localhost

Este comando instrui o Nmap a escanear especificamente a porta 8000 na máquina local. Após executar o comando, você deverá ver uma saída semelhante a esta:

Starting Nmap 7.80 ( https://nmap.org ) at 2023-XX-XX XX:XX XXX
Nmap scan report for localhost (127.0.0.1)
Host is up (0.000016s latency).

PORT     STATE SERVICE
8000/tcp open  http-alt

Nmap done: 1 IP address (1 host up) scanned in X.XX seconds

A saída nos diz que a porta 8000 está aberta, o que significa que há um serviço em execução nela. "http-alt" é a maneira padrão do Nmap de identificar serviços HTTP alternativos.

Em seguida, queremos reunir informações mais detalhadas sobre este serviço. Usaremos a flag -sV com o Nmap. Esta flag diz ao Nmap para tentar determinar a versão do serviço em execução. Conhecer a versão do serviço pode ser crucial para fins de segurança, pois ajuda a identificar se há alguma vulnerabilidade conhecida associada a essa versão específica. Execute o seguinte comando:

sudo nmap -sV -p 8000 localhost > /home/labex/project/nmap_output_service_version.txt

Este comando executa uma varredura de detecção de versão na porta 8000. O sudo é usado para executar o comando com privilégios administrativos, o que pode ser necessário para algumas operações do Nmap. O símbolo > redireciona a saída do comando para um arquivo chamado nmap_output_service_version.txt. Desta forma, podemos salvar os resultados para análise posterior.

Para visualizar os resultados, use o seguinte comando:

cat /home/labex/project/nmap_output_service_version.txt

Você deverá ver informações mais detalhadas sobre o serviço HTTP, incluindo a possível versão do software. A saída pode ser semelhante a esta:

Starting Nmap 7.80 ( https://nmap.org ) at 2023-XX-XX XX:XX XXX
Nmap scan report for localhost (127.0.0.1)
Host is up (0.000016s latency).

PORT     STATE SERVICE VERSION
8000/tcp open  http    Python http.server 3.10.X (Python 3.10.X)

Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in X.XX seconds

Esta saída confirma que o serviço é um servidor HTTP alimentado por Python, o que corresponde ao que configuramos na etapa anterior.

Usando o Nmap Scripting Engine (NSE)

O Nmap Scripting Engine (NSE) é uma ferramenta poderosa que permite expandir as capacidades do Nmap usando scripts Lua. Lua é uma linguagem de programação leve, e esses scripts podem executar uma ampla variedade de tarefas. Por exemplo, eles podem ajudar na detecção avançada de serviços, o que significa identificar com mais precisão quais serviços estão sendo executados em um dispositivo de rede. Eles também podem ser usados para varredura de vulnerabilidades, o que é crucial para encontrar pontos fracos de segurança em um sistema.

Vamos usar o NSE para reunir mais informações sobre nosso servidor HTTP. Os scripts NSE são agrupados em diferentes categorias. Essas categorias incluem "default" (padrão), que contém scripts comumente usados e seguros; "discovery" (descoberta), que serve para encontrar serviços de rede; "safe" (seguro), que não causará nenhum dano ao sistema de destino; e "vuln" (vulnerabilidade), que é usado para varredura de vulnerabilidades.

Primeiro, queremos ver quais scripts relacionados a HTTP estão disponíveis. Para fazer isso, usaremos o seguinte comando:

ls /usr/share/nmap/scripts/http*

Este comando lista todos os scripts NSE no diretório /usr/share/nmap/scripts/ que começam com http. Quando você executa este comando, verá uma lista de scripts projetados para interagir com serviços HTTP. Esses scripts podem executar diferentes funções, desde a coleta de informações simples, como obter o título de uma página da web, até tarefas mais complexas, como a varredura de vulnerabilidades em um serviço HTTP.

Agora, vamos usar o script http-title para extrair o título da nossa página da web. O script http-title foi projetado para analisar um serviço HTTP e encontrar o título da página da web que ele serve. Aqui está o comando para executar este script:

sudo nmap --script=http-title -p 8000 localhost > /home/labex/project/nmap_script_output.txt

Neste comando, sudo é usado para executar o comando com privilégios administrativos porque algumas operações do Nmap podem exigi-los. nmap é o comando principal, e --script=http-title diz ao Nmap para usar o script http-title. -p 8000 especifica que estamos direcionando a porta 8000, que é onde nosso servidor HTTP está sendo executado. localhost é o alvo, o que significa que estamos executando a varredura em nossa própria máquina. O símbolo > redireciona a saída do comando para o arquivo /home/labex/project/nmap_script_output.txt.

Vamos verificar a saída do comando. Podemos fazer isso usando o seguinte comando:

cat /home/labex/project/nmap_script_output.txt

O comando cat é usado para exibir o conteúdo de um arquivo. Quando você executa este comando, você deve ver uma saída que inclui informações sobre o título da nossa página da web. A saída pode ser semelhante a esta:

Starting Nmap 7.80 ( https://nmap.org ) at 2023-XX-XX XX:XX XXX
Nmap scan report for localhost (127.0.0.1)
Host is up (0.000040s latency).

PORT     STATE SERVICE
8000/tcp open  http-alt
|_http-title: Directory listing for /

Nmap done: 1 IP address (1 host up) scanned in X.XX seconds

Agora, vamos tentar uma varredura mais abrangente usando vários scripts. A categoria "default" inclui scripts seguros que fornecem informações úteis sobre o alvo. Para executar todos os scripts na categoria "default" em nosso servidor HTTP na porta 8000, usamos o seguinte comando:

sudo nmap --script=default -p 8000 localhost > /home/labex/project/nmap_default_scripts.txt

Este comando é semelhante ao anterior, mas, em vez de especificar um único script, estamos dizendo ao Nmap para executar todos os scripts na categoria "default".

Vamos examinar os resultados desta varredura. Podemos fazer isso usando o comando cat novamente:

cat /home/labex/project/nmap_default_scripts.txt

A saída conterá informações mais detalhadas sobre nosso servidor HTTP, reunidas por vários scripts NSE que são executados por padrão.

Finalmente, vamos explorar o recurso de ajuda do script para aprender mais sobre um script específico. Se você quiser saber mais sobre o script http-title, pode usar o seguinte comando:

nmap --script-help=http-title

Este comando exibe a documentação do script http-title. A documentação inclui o propósito do script, como usá-lo e o formato de sua saída. Compreender a documentação do script é essencial ao usar o NSE para tarefas específicas, pois ajuda você a saber o que o script faz e como usá-lo corretamente.

Resumo

Neste laboratório, você aprendeu como usar o Nmap Scripting Engine (NSE) para descoberta e análise de serviços de rede. Você primeiro configurou um servidor HTTP local e, em seguida, empregou vários comandos Nmap para escanear e coletar informações sobre este serviço.

Você adquiriu habilidades como configurar um serviço de rede básico para testes, usar o Nmap para encontrar portas abertas e serviços em execução, realizar detecção de versão com a flag -sV, aproveitar scripts NSE para obter informações detalhadas do serviço e interpretar os resultados da varredura do Nmap para entender as características do serviço. Essas habilidades são essenciais para administradores de rede, profissionais de segurança e hackers éticos. À medida que você progride em segurança cibernética, o Nmap e seu Scripting Engine serão valiosos para descoberta de rede e avaliação de segurança.

OSZAR »