Introdução
Neste laboratório, você aprenderá sobre o Nmap Scripting Engine (NSE) e como categorizar e atualizar scripts do Nmap. O Nmap, uma poderosa ferramenta de código aberto para descoberta de rede e auditoria de segurança, tem sua funcionalidade estendida pelo NSE. O NSE permite que os usuários escrevam e compartilhem scripts para automatizar várias tarefas de rede.
Este laboratório irá guiá-lo através da exploração das categorias de scripts do Nmap, da criação de diretórios de scripts personalizados, da adição de seus próprios scripts e da atualização do banco de dados de scripts do Nmap. Essas habilidades são cruciais para administradores de rede e profissionais de segurança para escanear redes de forma eficiente e identificar vulnerabilidades.
Explorando as Categorias de Scripts Nmap
Nesta etapa, vamos explorar as categorias de scripts do Nmap que vêm pré-instalados em seu sistema. Os scripts do Nmap são ferramentas poderosas no campo da segurança cibernética. Eles são organizados de acordo com sua funcionalidade. Por exemplo, alguns scripts são usados para descoberta, o que significa que podem encontrar dispositivos e serviços em uma rede. Outros são para avaliação de vulnerabilidade, o que ajuda a identificar pontos fracos de segurança em sistemas.
Primeiro, precisamos abrir um terminal. Um terminal é uma interface baseada em texto onde você pode inserir comandos para interagir com seu sistema. Depois que o terminal estiver aberto, precisamos ter certeza de que estamos no diretório correto. O diretório é como uma pasta em seu computador onde arquivos e outras pastas são armazenados. Execute o seguinte comando no terminal:
cd /home/labex/project
Este comando altera o diretório de trabalho atual para /home/labex/project.
Agora, vamos verificar a versão do Nmap instalada em nosso sistema. Conhecer a versão é importante porque diferentes versões podem ter diferentes recursos e compatibilidade. Execute este comando no terminal:
nmap --version
A saída será 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 libpcre-8.39 libpcap-1.9.1 nmap-libdnet-1.12 ipv6
Compiled without:
Available nsock engines: epoll poll select
Em seguida, examinaremos as categorias de scripts do Nmap disponíveis. Os scripts do Nmap são armazenados no diretório /usr/share/nmap/scripts/. Para ter uma ideia de quais scripts estão disponíveis, podemos listá-los e classificá-los por seus nomes. Execute este comando no terminal:
ls /usr/share/nmap/scripts/ | grep -v .lua | sort | head -10
Este comando primeiro lista todos os arquivos no diretório /usr/share/nmap/scripts/. Em seguida, ele usa grep -v .lua para excluir arquivos com a extensão .lua. Depois disso, ele classifica os arquivos restantes por seus nomes e mostra os primeiros 10 resultados. A saída será semelhante a:
address-info.nse
afp-brute.nse
afp-ls.nse
afp-path-vuln.nse
afp-serverinfo.nse
afp-showmount.nse
ajp-auth.nse
ajp-brute.nse
ajp-headers.nse
ajp-methods.nse
Para ver todas as categorias de scripts, podemos usar o seguinte comando:
grep -r categories /usr/share/nmap/scripts/*.nse | grep -o "categories = {[^}]*}" | sort | uniq | head -10
Este comando pesquisa em todos os arquivos .nse no diretório /usr/share/nmap/scripts/ a string "categories". Em seguida, ele extrai as informações da categoria, as classifica, remove quaisquer entradas duplicadas e mostra os primeiros 10 resultados. A saída será semelhante a:
categories = {"auth", "brute", "intrusive"}
categories = {"auth", "default", "discovery", "safe"}
categories = {"auth", "discovery", "safe"}
categories = {"auth", "intrusive"}
categories = {"auth", "safe"}
categories = {"broadcast", "discovery"}
categories = {"broadcast", "discovery", "safe"}
categories = {"default", "discovery"}
categories = {"default", "discovery", "safe"}
categories = {"default", "discovery", "safe", "version"}
Para uma melhor organização, criaremos uma estrutura de diretórios para categorizar scripts com base em sua funcionalidade. Isso tornará mais fácil encontrar e usar os scripts mais tarde. Criaremos diretórios separados para diferentes categorias. Execute estes comandos no terminal:
mkdir -p /home/labex/project/NmapScripts/vulnerability
mkdir -p /home/labex/project/NmapScripts/discovery
mkdir -p /home/labex/project/NmapScripts/authentication
O comando mkdir -p cria diretórios. Se os diretórios pai não existirem, ele os criará também.
Agora, vamos copiar alguns scripts relacionados à vulnerabilidade para nosso diretório de vulnerabilidade recém-criado. Execute este comando no terminal:
cp /usr/share/nmap/scripts/smb-vuln* /home/labex/project/NmapScripts/vulnerability/
Este comando copia todos os scripts no diretório /usr/share/nmap/scripts/ cujos nomes começam com smb - vuln para o diretório /home/labex/project/NmapScripts/vulnerability/.
Vamos verificar se os arquivos foram copiados corretamente. Execute este comando no terminal:
ls -la /home/labex/project/NmapScripts/vulnerability/
A saída mostrará os scripts de vulnerabilidade copiados:
total 88
drwxr-xr-x 2 labex labex 4096 Mar 15 12:30 .
drwxr-xr-x 4 labex labex 4096 Mar 15 12:30 ..
-rw-r--r-- 1 labex labex 3355 Mar 15 12:30 smb-vuln-conficker.nse
-rw-r--r-- 1 labex labex 8045 Mar 15 12:30 smb-vuln-cve2009-3103.nse
-rw-r--r-- 1 labex labex 5100 Mar 15 12:30 smb-vuln-cve-2017-7494.nse
-rw-r--r-- 1 labex labex 9595 Mar 15 12:30 smb-vuln-ms06-025.nse
-rw-r--r-- 1 labex labex 11645 Mar 15 12:30 smb-vuln-ms07-029.nse
-rw-r--r-- 1 labex labex 12558 Mar 15 12:30 smb-vuln-ms08-067.nse
-rw-r--r-- 1 labex labex 9719 Mar 15 12:30 smb-vuln-ms10-054.nse
-rw-r--r-- 1 labex labex 7326 Mar 15 12:30 smb-vuln-ms10-061.nse
-rw-r--r-- 1 labex labex 8091 Mar 15 12:30 smb-vuln-ms17-010.nse
-rw-r--r-- 1 labex labex 4245 Mar 15 12:30 smb-vuln-regsvc-dos.nse
Da mesma forma, vamos copiar alguns scripts de descoberta e autenticação para seus respectivos diretórios. Execute estes comandos no terminal:
cp /usr/share/nmap/scripts/dns-* /home/labex/project/NmapScripts/discovery/
cp /usr/share/nmap/scripts/ssh-* /home/labex/project/NmapScripts/authentication/
Agora você organizou alguns scripts do Nmap em categorias com base em sua funcionalidade, o que facilita a localização e o uso para tarefas específicas.
Entendendo a Funcionalidade dos Scripts
Nesta etapa, vamos aprender como examinar e entender os scripts do Nmap para descobrir o que eles podem fazer. Saber disso é realmente importante porque ajuda você a escolher os scripts certos para diferentes tarefas de varredura de rede.
Vamos começar analisando de perto um dos scripts de vulnerabilidade que copiamos na etapa anterior. Usaremos o comando cat para exibir o conteúdo do script e, em seguida, usaremos head -20 para mostrar apenas as primeiras 20 linhas. Dessa forma, podemos ver rapidamente as informações importantes no início do script.
cat /home/labex/project/NmapScripts/vulnerability/smb-vuln-ms17-010.nse | head -20
A saída mostrará o início do script. Esta parte geralmente tem detalhes sobre o que o script serve e como usá-lo.
local smb = require "smb"
local vulns = require "vulns"
local stdnse = require "stdnse"
local string = require "string"
description = [[
Attempts to detect if a Microsoft SMBv1 server is vulnerable to a remote code
execution vulnerability (ms17-010, a.k.a. EternalBlue). The vulnerability affects
Windows Vista, 7, 8.1, 10, Server 2008, Server 2008 R2, Server 2012 Gold and R2, and Server 2016.
The script connects to the $IPC tree, executes a transaction on FID 0 and
checks if the error "STATUS_INSUFF_SERVER_RESOURCES" is returned to
determine if the target is not patched against ms17-010. Additionally it checks
for a matching error code on EternalChampion.
References:
* https://technet.microsoft.com/en-us/library/security/ms17-010.aspx
* https://blogs.technet.microsoft.com/msrc/2017/05/12/customer-guidance-for-wannacrypt-attacks/
* https://msrc-blog.microsoft.com/2017/05/12/customer-guidance-for-wannacrypt-attacks/
* https://github.com/rapid7/metasploit-framework/pull/8654/files
Este script foi projetado para verificar se um servidor Microsoft SMBv1 possui a vulnerabilidade MS17-010, também conhecida como EternalBlue.
Agora, vamos analisar a estrutura de um script do Nmap para entender suas diferentes partes. A maioria dos scripts do Nmap tem estes componentes-chave:
- Uma seção de descrição: Isso informa o que o script faz. É como um resumo curto que ajuda você a entender rapidamente o propósito do script.
- Uma seção de autor: Isso dá crédito à pessoa que criou o script. É importante saber quem fez o script, especialmente se você precisar entrar em contato com ele ou procurar mais scripts do mesmo autor.
- Categorias: Estes agrupam scripts semelhantes. Por exemplo, scripts relacionados à varredura de vulnerabilidade podem estar na categoria "vuln". Isso facilita a localização e o gerenciamento de scripts.
- Regras: Estas determinam quando o script deve ser executado. Existem diferentes tipos de regras, como
portruleehostrule. Por exemplo, umahostrulepode especificar que o script deve ser executado apenas em determinados hosts. - A função de ação principal: É aqui que o trabalho real do script acontece. Ele contém o código que executa a tarefa, como verificar uma vulnerabilidade ou obter informações sobre um host.
Vamos criar nosso próprio script básico do Nmap para ver essa estrutura em ação. Usaremos o comando cat para criar um novo arquivo e escrever o script nele.
cat << 'EOF' > /home/labex/project/my-ping-check.nse
description = [[
A simple script that checks if a host responds to ICMP echo requests (ping).
]]
author = "LabEx User"
categories = {"discovery", "safe"}
-- The rule section determines when the script should be run
hostrule = function(host)
return true -- Run the script for all hosts
end
-- The action section contains the main function of the script
action = function(host)
local output = "Host status: "
if host.pingresponse then
output = output .. "Responds to ping"
else
output = output .. "Does not respond to ping"
end
return output
end
EOF
Vamos detalhar este script:
- A seção
descriptionexplica claramente que o script verifica se um host responde a solicitações de ping. - A seção
authordiz que o script foi criado por um LabEx User. - A seção
categoriesagrupa este script com outros scripts de descoberta e seguros. Scripts de descoberta são usados para encontrar informações sobre hosts, e scripts seguros são aqueles que não causam nenhum dano ao alvo. - A função
hostruleestá definida para retornartrue, o que significa que o script será executado para todos os hosts. - A função
actioncontém a lógica principal. Ele verifica se o host tem uma resposta de ping e, em seguida, retorna uma mensagem indicando se o host responde ao ping ou não.
Agora, vamos executar nosso script personalizado contra o localhost (127.0.0.1). Usaremos o comando nmap com a opção --script para especificar nosso script personalizado.
nmap --script /home/labex/project/my-ping-check.nse 127.0.0.1
Você deve ver uma saída semelhante a esta:
Starting Nmap 7.80 ( https://nmap.org )
Nmap scan report for localhost (127.0.0.1)
Host is up (0.000091s latency).
Not shown: 998 closed ports
PORT STATE SERVICE
22/tcp open ssh
| my-ping-check: Host status: Responds to ping
3001/tcp open nessus
|_my-ping-check: Host status: Responds to ping
Nmap done: 1 IP address (1 host up) scanned in 0.24 seconds
Esta saída mostra que nosso script está funcionando corretamente. Ele detectou que o localhost responde a solicitações de ping. Este é um exemplo simples, mas mostra a estrutura básica e a função de um script do Nmap.
Criando e Adicionando Scripts Personalizados ao Nmap
Nesta etapa, vamos aprender como criar um script Nmap personalizado e adicioná-lo ao banco de dados de scripts do Nmap. O Nmap é uma ferramenta poderosa de varredura de rede e, adicionando scripts personalizados, você pode estender sua funcionalidade para atender às suas necessidades específicas. Isso significa que você pode executar tarefas exclusivas durante as varreduras de rede que não são cobertas pelos scripts Nmap padrão.
Primeiro, vamos criar um novo script, um pouco mais complexo. Este script verificará se uma porta específica está aberta. Portas são como portas em uma rede; elas permitem que diferentes tipos de tráfego de rede entrem ou saiam de um dispositivo. Ao verificar se uma porta está aberta, podemos descobrir se um serviço específico está sendo executado em um dispositivo.
cat << 'EOF' > /usr/share/nmap/scripts/port-check.nse
description = [[
A script that checks if a specific port is open and reports its status.
]]
author = "LabEx User"
license = "Same as Nmap--See https://nmap.org/book/man-legal.html"
categories = {"discovery", "safe"}
-- The portrule determines when the script should be run
portrule = function(host, port)
return port.protocol == "tcp" and port.state == "open"
end
-- The action section contains the main function of the script
action = function(host, port)
local output = string.format("Port %d is open on host %s", port.number, host.ip)
return output
end
EOF
No código acima, primeiro definimos uma descrição do que o script faz. Em seguida, definimos as informações do autor e da licença. A função portrule decide quando o script deve ser executado. Aqui, ele verifica se a porta usa o protocolo TCP e está aberta. A função action é a parte principal do script. Ele cria uma mensagem indicando que uma porta específica está aberta em um host específico.
Observe que criamos este script diretamente no diretório de scripts do Nmap (/usr/share/nmap/scripts/). Isso é importante porque o Nmap procura scripts neste diretório. No entanto, apenas criar o script não é suficiente. O Nmap precisa saber sobre este novo script, então precisamos atualizar o banco de dados de scripts do Nmap.
Para atualizar o banco de dados de scripts do Nmap, execute o seguinte comando:
sudo nmap --script-updatedb
A saída deve ser semelhante a:
Starting Nmap 7.80 ( https://nmap.org )
NSE: Updating rule database.
NSE: Script Database updated successfully.
Nmap done: 0 IP addresses (0 hosts up) scanned in 0.36 seconds
Esta saída mostra que o banco de dados de scripts foi atualizado com sucesso. Agora, vamos verificar se nosso script foi adicionado ao banco de dados de scripts do Nmap. Podemos fazer isso pesquisando nosso script no arquivo script.db.
grep port-check /usr/share/nmap/scripts/script.db
Você deve ver uma saída semelhante a:
Entry { filename = "port-check.nse", categories = { "discovery", "safe", } }
Isso confirma que nosso script foi adicionado com sucesso ao banco de dados de scripts do Nmap.
Agora, vamos criar mais um script que demonstra como usar bibliotecas dentro dos scripts do Nmap. Bibliotecas são códigos pré-escritos que podemos usar para tornar nossos scripts mais poderosos. Este script verificará os cabeçalhos HTTP em servidores web. Os cabeçalhos HTTP contêm informações importantes sobre uma página da web, como o tipo de servidor, a data em que foi modificada pela última vez, etc.
cat << 'EOF' > /usr/share/nmap/scripts/http-headers-check.nse
description = [[
A script that retrieves and displays HTTP headers from web servers.
]]
author = "LabEx User"
license = "Same as Nmap--See https://nmap.org/book/man-legal.html"
categories = {"discovery", "safe"}
local http = require "http"
local shortport = require "shortport"
local stdnse = require "stdnse"
-- The portrule determines when the script should be run
portrule = function(host, port)
return shortport.http(host, port)
end
-- The action section contains the main function of the script
action = function(host, port)
local response = http.get(host, port, "/")
if not response or not response.status then
return "Failed to retrieve HTTP headers"
end
local output = stdnse.output_table()
output["Status"] = response.status
if response.header then
output["Headers"] = {}
for name, value in pairs(response.header) do
output["Headers"][name] = value
end
end
return output
end
EOF
Este script usa várias bibliotecas do Nmap:
httppara fazer solicitações HTTP. Esta biblioteca permite que nosso script se comunique com servidores web e obtenha informações deles.shortportpara determinar se uma porta provavelmente está executando um serviço HTTP. Ele nos ajuda a descobrir se uma porta específica em um host é usada para tráfego da web.stdnsepara formatar a saída. Isso torna as informações que obtemos do servidor web mais fáceis de ler.
Vamos atualizar o banco de dados de scripts novamente para que o Nmap saiba sobre nosso novo script:
sudo nmap --script-updatedb
Agora, vamos executar nosso novo script contra um servidor web. Para fins de demonstração, usaremos um servidor web local na porta 3001 (que é frequentemente usado por servidores de desenvolvimento).
nmap --script http-headers-check -p 3001 127.0.0.1
Se não houver um servidor web em execução na porta 3001, a saída indicará que a porta está fechada ou filtrada. Se houver um servidor web, você verá os cabeçalhos HTTP que foram recuperados.
Finalmente, vamos executar ambos os nossos scripts personalizados juntos. Desta forma, podemos ver os resultados de ambos os scripts de uma vez.
nmap --script "port-check,http-headers-check" -p 22,3001 127.0.0.1
Este comando executará nossos dois scripts personalizados nas portas 22 e 3001 no localhost. A porta 22 é comumente usada para conexões SSH (Secure Shell).
A saída mostrará se essas portas estão abertas e, se a porta 3001 estiver executando um serviço HTTP, exibirá os cabeçalhos HTTP.
Ao criar e adicionar scripts personalizados ao Nmap, você pode estender sua funcionalidade para executar tarefas específicas necessárias para seus requisitos de varredura de rede e avaliação de segurança.
Executando Categorias de Scripts e Gerenciando a Saída de Scripts
Nesta etapa, exploraremos como executar scripts do Nmap por categoria e gerenciar a saída dessas varreduras de script. Esta é uma habilidade muito útil porque permite que você execute vários scripts relacionados sem ter que especificar cada um separadamente.
Os scripts do Nmap são agrupados em diferentes categorias com base no que eles fazem. Compreender essas categorias ajuda você a encontrar e executar rapidamente os scripts de que precisa. Aqui estão algumas categorias comuns:
auth: Estes são scripts relacionados à autenticação. Eles podem ajudá-lo a verificar se os mecanismos de autenticação em um alvo são seguros.broadcast: Scripts nesta categoria enviam broadcasts na rede local. Eles são úteis para descobrir dispositivos e serviços na mesma rede.brute: Estes são scripts de auditoria de senha por força bruta. Eles tentam diferentes senhas para ver se conseguem obter acesso não autorizado a um serviço.default: Quando você usa a opção-sCno Nmap, esses são os scripts que são executados por padrão. Eles fornecem um bom ponto de partida para uma varredura básica.discovery: Esses scripts são usados para descoberta de host e serviço. Eles podem descobrir quais hosts estão disponíveis em uma rede e quais serviços estão executando.dos: Scripts de Negação de Serviço (DoS) são projetados para sobrecarregar um sistema alvo e torná-lo indisponível. Tenha cuidado ao usá-los, pois eles podem causar danos reais.exploit: Scripts de exploração são usados para tirar proveito de vulnerabilidades conhecidas em um sistema. Eles podem ser usados para testes de segurança, mas devem ser usados com responsabilidade.external: Esses scripts podem enviar dados para bancos de dados de terceiros. Eles podem fornecer informações adicionais sobre o alvo, mas você precisa estar ciente das implicações de privacidade.fuzzer: Scripts fuzzer usam técnicas de fuzzing. Eles enviam dados aleatórios ou malformados para um alvo para ver se podem causar erros ou expor vulnerabilidades.intrusive: Scripts nesta categoria podem travar serviços ou ser considerados intrusivos. Use-os com cautela, especialmente em um ambiente de produção.malware: Scripts de detecção de malware são usados para verificar se um sistema alvo está infectado com malware.safe: Esses scripts são considerados seguros e não intrusivos. Eles não causarão nenhum dano ao sistema alvo.version: Scripts de detecção de versão ajudam você a descobrir a versão do software em execução em um serviço alvo. Essas informações podem ser úteis para identificar possíveis vulnerabilidades.vuln: Scripts de detecção de vulnerabilidade são usados para encontrar pontos fracos de segurança em um sistema alvo.
Agora, vamos ver como executar scripts de uma categoria específica. Por exemplo, se você deseja executar todos os scripts na categoria "discovery", pode usar o seguinte comando:
nmap --script discovery 127.0.0.1
Este comando diz ao Nmap para executar todos os scripts de descoberta contra o localhost (127.0.0.1). A saída será bastante longa porque mostra os resultados de todos os scripts de descoberta.
Às vezes, você pode querer executar scripts de várias categorias. Você pode fazer isso usando uma vírgula para separar os nomes das categorias. Aqui está um exemplo:
nmap --script "discovery,safe" -p 1-100 127.0.0.1
Este comando executa todos os scripts nas categorias discovery e safe nas portas 1 a 100 no localhost.
Você também pode excluir categorias específicas usando o operador not. Por exemplo:
nmap --script "discovery and not broadcast" 127.0.0.1
Este comando executa os scripts de descoberta, mas exclui aqueles que também estão na categoria broadcast.
Em seguida, vamos analisar diferentes maneiras de formatar e salvar a saída das varreduras de script do Nmap. O Nmap oferece vários formatos de saída, que são úteis para diferentes propósitos:
- Saída normal (padrão): Esta é a saída de texto padrão que o Nmap mostra na tela.
- Saída XML: XML é um formato estruturado que pode ser facilmente analisado por outras ferramentas.
- Saída grepable: Este formato foi projetado para ser facilmente pesquisado usando ferramentas como
grep. - Saída JSON (com o script apropriado): JSON é outro formato estruturado que é amplamente usado para troca de dados.
Para salvar a saída no formato XML, você pode usar o seguinte comando:
nmap --script vuln -p 1-1000 127.0.0.1 -oX /home/labex/project/scan_results.xml
Este comando executa todos os scripts de vulnerabilidade nas portas 1 a 1000 no localhost e salva os resultados no formato XML no arquivo /home/labex/project/scan_results.xml.
Vamos verificar o conteúdo do arquivo XML:
head -20 /home/labex/project/scan_results.xml
Este comando mostra as primeiras 20 linhas da saída formatada em XML. Você verá informações sobre a varredura, as opções usadas e os resultados da varredura.
Para saída grepable, você pode usar este comando:
nmap --script "default" 127.0.0.1 -oG /home/labex/project/scan_results.gnmap
Este comando salva os resultados em um formato que é fácil de analisar com ferramentas como grep.
Vamos verificar o conteúdo do arquivo gnmap:
cat /home/labex/project/scan_results.gnmap
Você verá que cada host está em uma única linha, o que facilita a pesquisa de informações específicas.
Se você deseja salvar a saída nos formatos normal e XML ao mesmo tempo, pode usar este comando:
nmap --script "default" 127.0.0.1 -oX /home/labex/project/scan_results2.xml -oN /home/labex/project/scan_results.txt
Este comando salva a saída nos formatos de texto normal e XML simultaneamente.
Finalmente, você pode usar a opção -oA para salvar a saída em todos os três formatos (normal, XML e grepable) de uma vez:
nmap --script "default" 127.0.0.1 -oA /home/labex/project/all_formats
Este comando cria três arquivos:
/home/labex/project/all_formats.nmap(saída normal)/home/labex/project/all_formats.xml(saída XML)/home/labex/project/all_formats.gnmap(saída grepable)
Ao dominar essas técnicas para executar categorias de scripts e gerenciar a saída de scripts, você pode conduzir varreduras de rede de forma eficiente e organizar os resultados para análise posterior.
Resumo
Neste laboratório, você aprendeu habilidades essenciais para trabalhar com o Nmap Scripting Engine (NSE). Você explorou como categorizar e organizar scripts do Nmap de acordo com sua funcionalidade, o que é vital para a varredura de rede e avaliações de segurança eficientes.
Você adquiriu experiência prática em vários aspectos, incluindo a exploração de categorias de scripts, a criação de diretórios organizados, a compreensão das estruturas de scripts, a criação de scripts personalizados, a adição deles ao banco de dados, a execução de scripts por categoria com operadores lógicos e o gerenciamento da saída em diferentes formatos. Essas habilidades permitem que você estenda a funcionalidade do Nmap para necessidades específicas. Ao dominar a criação, categorização e atualização de scripts, você pode desenvolver fluxos de trabalho de varredura mais direcionados e eficientes. A capacidade de organizar e formatar os resultados da varredura também é útil para documentação e comunicação com membros da equipe e partes interessadas. À medida que você continua usando o Nmap, pode construir sobre essas habilidades para scripts e estratégias de varredura mais complexas.
