Aprenda as Técnicas de Especificação de Alvos no Nmap

NmapBeginner
Pratique Agora

Introdução

Neste laboratório, você aprenderá sobre o Nmap, uma poderosa ferramenta de varredura de rede amplamente utilizada por profissionais de segurança. O laboratório se concentra especificamente nas técnicas de especificação de alvos no Nmap, que são cruciais para definir os hosts e as redes a serem varridos.

Compreender essas técnicas é essencial para uma efetiva reconhecimento de rede e avaliação de segurança. Ao final deste laboratório, você será capaz de usar vários métodos para especificar alvos no Nmap e interpretar os resultados da varredura de forma eficaz.

Instalação e Exploração do Nmap

Nesta etapa, vamos garantir que o Nmap esteja instalado corretamente em seu sistema e começar a explorar suas funções básicas. Nmap, abreviação de Network Mapper, é uma ferramenta de código aberto. É amplamente utilizada para descoberta de rede e auditoria de segurança. Com o Nmap, você pode descobrir quais dispositivos estão conectados a uma rede e quais serviços esses dispositivos estão oferecendo. Isso é crucial em segurança cibernética, pois ajuda você a entender o cenário da rede e identificar potenciais riscos de segurança.

Primeiro, precisamos verificar se o Nmap já está instalado em seu sistema. Para fazer isso, usaremos o terminal. O terminal é uma interface baseada em texto onde você pode inserir comandos para interagir com seu computador. Abra um terminal e execute o seguinte comando:

nmap --version

Este comando solicita ao sistema que mostre a versão do Nmap instalada. Se o Nmap estiver instalado corretamente, você verá uma saída semelhante a esta, que inclui a versão do Nmap e informações de compilação:

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

Em seguida, queremos entender como especificar alvos para as varreduras do Nmap. A especificação de alvos é importante porque informa ao Nmap quais dispositivos ou redes você deseja varrer. Para aprender sobre isso, vamos analisar alguma documentação básica do Nmap. Execute o seguinte comando no terminal:

nmap -h | grep -A 10 "TARGET SPECIFICATION"

Este comando primeiro usa nmap -h para obter o texto de ajuda do Nmap. Em seguida, ele canaliza a saída para grep -A 10 "TARGET SPECIFICATION", que pesquisa a seção "TARGET SPECIFICATION" no texto de ajuda e mostra as 10 linhas seguintes. Você verá uma explicação de diferentes maneiras de especificar alvos para as varreduras do Nmap.

Agora, precisamos de um lugar para armazenar os resultados de nossas varreduras do Nmap. Criaremos um diretório para essa finalidade. Um diretório é como uma pasta em seu computador onde você pode organizar arquivos. Execute os seguintes comandos no terminal:

mkdir -p /home/labex/project/nmap_scans
cd /home/labex/project/nmap_scans

O comando mkdir -p cria um diretório chamado nmap_scans no caminho /home/labex/project. A opção -p garante que, se algum diretório intermediário não existir, ele também será criado. O comando cd então altera o diretório de trabalho atual para o diretório nmap_scans recém-criado.

Vamos ver o Nmap em ação executando uma varredura simples em sua máquina local. A máquina local é o computador que você está usando atualmente. Execute o seguinte comando:

nmap localhost > local_scan.txt

Este comando varre sua máquina local usando o Nmap. O símbolo > redireciona a saída da varredura para um arquivo chamado local_scan.txt. Dessa forma, podemos salvar os resultados da varredura para análise posterior.

Finalmente, vamos analisar os resultados da varredura. Execute o seguinte comando:

cat local_scan.txt

O comando cat exibe o conteúdo do arquivo local_scan.txt. Você verá uma lista de portas que o Nmap varreu em sua máquina local. Juntamente com os números das portas, você encontrará informações sobre quais portas estão abertas e quais serviços podem estar sendo executados nessas portas abertas. Essas informações podem ajudá-lo a entender o status de segurança de sua máquina local.

Configurando um Serviço e Varrendo Portas Específicas

Nesta etapa, vamos aprender como iniciar um servidor web local e, em seguida, usar uma ferramenta poderosa chamada Nmap para encontrá-lo, varrendo portas específicas. Compreender este processo é crucial porque mostra como o Nmap pode ser usado para identificar serviços que estão atualmente em execução em uma rede ou em uma máquina.

Primeiro, precisamos navegar para o nosso diretório de projeto. É aqui que configuraremos nosso simples servidor web. Depois de estarmos no lugar certo, iniciaremos um servidor HTTP Python que ouvirá na porta 8000. A porta 8000 é uma porta comum usada para testar servidores web. Aqui está o comando para fazer isso:

cd /home/labex/project/nmap_scans
python3 -m http.server 8000 &

O & no final do comando é importante. Ele executa o servidor em segundo plano. Isso significa que você pode continuar usando o terminal para outras tarefas enquanto o servidor está em execução. Depois de executar o comando, você deverá ver alguma saída indicando que o servidor foi iniciado com sucesso:

Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ...

Agora que nosso servidor está em execução, queremos ter certeza de que ele está realmente ouvindo na porta 8000. Podemos usar o comando lsof, que significa "list open files" (listar arquivos abertos). Este comando nos ajuda a verificar quais processos estão atualmente usando uma porta específica. Veja como o usamos:

lsof -i :8000

Se o servidor estiver sendo executado corretamente, você deverá ver uma saída semelhante a esta:

COMMAND   PID USER   FD   TYPE DEVICE SIZE/OFF NODE NAME
python3 12345 labex   4u  IPv4 123456      0t0  TCP *:8000 (LISTEN)

Esta saída nos diz que o Python está ouvindo na porta 8000, o que significa que nosso servidor está funcionando como esperado.

Em seguida, usaremos o Nmap para varrer a porta 8000 na máquina local. O objetivo é detectar nosso servidor HTTP. Aqui está o comando:

nmap -p 8000 localhost > http_server_scan.txt

Neste comando, a flag -p é usada para especificar qual porta queremos varrer. Em nosso caso, estamos varrendo a porta 8000 no localhost, que é nossa própria máquina. O símbolo > redireciona a saída da varredura do Nmap para um arquivo chamado http_server_scan.txt. Dessa forma, podemos revisar facilmente os resultados mais tarde.

Vamos verificar os resultados da varredura:

cat http_server_scan.txt

Se a varredura for bem-sucedida, você deverá ver uma saída semelhante a esta:

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

PORT     STATE SERVICE
8000/tcp open  http-alt

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

Esta saída mostra que a porta 8000 está aberta e executando um serviço HTTP, o que significa que o Nmap foi capaz de detectar nosso servidor.

Finalmente, vamos tentar varrer uma faixa de portas para ver se há outros serviços em execução em nossa máquina local. Aqui está o comando:

nmap -p 1-1000 localhost > port_range_scan.txt

Este comando diz ao Nmap para varrer todas as portas de 1 a 1000 no localhost. Novamente, estamos redirecionando a saída para um arquivo chamado port_range_scan.txt.

Vamos examinar os resultados:

cat port_range_scan.txt

A saída mostrará quais portas na faixa de 1 a 1000 estão abertas em sua máquina local. Esta é uma maneira útil de descobrir serviços que você pode não saber que estavam em execução.

Especificação Avançada de Alvos

Nesta etapa, vamos nos aprofundar em técnicas mais avançadas de especificação de alvos do Nmap. O Nmap é uma ferramenta poderosa em reconhecimento de rede e oferece várias maneiras de especificar vários alvos em um único comando. Isso é extremamente útil quando você precisa varrer vários hosts ou redes de uma vez, economizando tempo e esforço.

Vamos começar criando um arquivo de texto que contenha vários endereços IP que queremos varrer. Incluiremos o localhost (127.0.0.1) e alguns outros endereços IP locais. O localhost é um endereço IP especial que se refere ao próprio dispositivo atual. Ao incluí-lo, podemos testar o processo de varredura em nossa própria máquina.

cd /home/labex/project/nmap_scans
echo "127.0.0.1" > targets.txt
echo "127.0.0.2" >> targets.txt
echo "127.0.0.3" >> targets.txt

No código acima, o comando cd altera o diretório de trabalho atual para /home/labex/project/nmap_scans. O comando echo é usado para gerar texto. O operador > cria um novo arquivo e grava o texto nele, enquanto o operador >> anexa o texto a um arquivo existente. Portanto, primeiro criamos um arquivo chamado targets.txt e escrevemos 127.0.0.1 nele. Em seguida, anexamos 127.0.0.2 e 127.0.0.3 ao mesmo arquivo.

Agora, vamos dar uma olhada no arquivo que acabamos de criar para garantir que os endereços IP sejam adicionados corretamente.

cat targets.txt

O comando cat é usado para exibir o conteúdo de um arquivo. Após executar este comando, você deverá ver a seguinte saída:

127.0.0.1
127.0.0.2
127.0.0.3

Em seguida, usaremos a flag -iL no Nmap para varrer todos os endereços IP listados no arquivo targets.txt de uma vez. A flag -iL informa ao Nmap para ler os alvos de um arquivo.

nmap -iL targets.txt > multiple_targets_scan.txt

Aqui, o comando nmap é usado para executar a varredura da rede. A flag -iL especifica o arquivo contendo os alvos. O operador > redireciona a saída da varredura para um arquivo chamado multiple_targets_scan.txt.

Vamos verificar os resultados da varredura:

cat multiple_targets_scan.txt

Após executar este comando, você deverá ver os resultados da varredura para todos os três endereços IP. Observe que 127.0.0.1 geralmente mostrará portas abertas porque é o localhost e pode haver alguns serviços em execução nele. No entanto, 127.0.0.2 e 127.0.0.3 podem não responder porque normalmente não são configurados na maioria dos sistemas.

Outra maneira de especificar vários alvos é usar a notação de espaço ou a notação CIDR diretamente no comando Nmap.

nmap 127.0.0.1 127.0.0.2 > space_notation_scan.txt

Neste comando, usamos espaços para separar os endereços IP. Isso informa ao Nmap para varrer 127.0.0.1 e 127.0.0.2. A saída da varredura é redirecionada para um arquivo chamado space_notation_scan.txt.

Vamos verificar os resultados:

cat space_notation_scan.txt

Também podemos usar a notação CIDR para varrer uma faixa de endereços IP. A notação CIDR (Classless Inter-Domain Routing) é uma maneira de representar uma faixa de endereços IP de forma concisa.

nmap 127.0.0.0/30 > cidr_notation_scan.txt

O 127.0.0.0/30 na notação CIDR representa uma faixa de endereços IP de 127.0.0.0 a 127.0.0.3, que é um total de 4 endereços. A saída desta varredura é redirecionada para um arquivo chamado cidr_notation_scan.txt.

Vamos verificar os resultados:

cat cidr_notation_scan.txt

Finalmente, vamos explorar como excluir alvos específicos de uma varredura. Isso é útil quando você deseja varrer uma rede, mas não deseja incluir determinados hosts.

nmap 127.0.0.0/30 --exclude 127.0.0.3 > exclude_scan.txt

Neste comando, usamos a flag --exclude para informar ao Nmap para ignorar o endereço IP 127.0.0.3 ao varrer a faixa 127.0.0.0/30. A saída da varredura é redirecionada para um arquivo chamado exclude_scan.txt.

Vamos verificar os resultados:

cat exclude_scan.txt

Você deverá ver os resultados da varredura para 127.0.0.0, 127.0.0.1 e 127.0.0.2, mas não para 127.0.0.3.

Essas técnicas avançadas de especificação de alvos permitem que você controle com precisão quais hosts o Nmap varre, tornando seu reconhecimento de rede mais eficiente e direcionado.

Resumo

Neste laboratório, você aprendeu a usar o Nmap para reconhecimento de rede, com foco em técnicas de especificação de alvos. Primeiro, você instalou o Nmap e explorou suas funções básicas, realizando varreduras simples em sua máquina local. Em seguida, você configurou um servidor HTTP local e usou o Nmap para encontrá-lo, varrendo portas específicas.

Essas habilidades são essenciais para administradores de rede e profissionais de segurança para descobrir e avaliar dispositivos de rede. Dominar a especificação de alvos do Nmap permite que você varra redes de qualquer escala e complexidade de forma eficiente, direcionando hosts e serviços específicos relevantes para sua tarefa. Use sempre o Nmap de forma responsável e apenas em redes autorizadas para evitar problemas legais e éticos.