Explora y Crea Scripts de Nmap

Introducción

En este laboratorio, aprenderá sobre el Motor de Scripting de Nmap (NSE, por sus siglas en inglés) y cómo categorizar y actualizar los scripts de Nmap. Nmap, una poderosa herramienta de descubrimiento de redes y auditoría de seguridad de código abierto, tiene su funcionalidad extendida por el NSE. El NSE permite a los usuarios escribir y compartir scripts para automatizar diversas tareas de red.

Este laboratorio lo guiará a través de la exploración de las categorías de scripts de Nmap, la creación de directorios de scripts personalizados, la adición de sus propios scripts y la actualización de la base de datos de scripts de Nmap. Estas habilidades son cruciales para los administradores de red y profesionales de seguridad para escanear redes de manera eficiente e identificar vulnerabilidades.

Explorando categorías de scripts de Nmap

En este paso, vamos a explorar las categorías de scripts de Nmap que vienen preinstalados en su sistema. Los scripts de Nmap son herramientas poderosas en el campo de la ciberseguridad. Están organizados según su funcionalidad. Por ejemplo, algunos scripts se utilizan para la detección (discovery), lo que significa que pueden encontrar dispositivos y servicios en una red. Otros son para la evaluación de vulnerabilidades, lo que ayuda a identificar debilidades de seguridad en los sistemas.

Primero, necesitamos abrir una terminal. Una terminal es una interfaz basada en texto donde puede ingresar comandos para interactuar con su sistema. Una vez abierta la terminal, debemos asegurarnos de estar en el directorio correcto. El directorio es como una carpeta en su computadora donde se almacenan archivos y otras carpetas. Ejecute el siguiente comando en la terminal:

cd /home/labex/project

Este comando cambia el directorio de trabajo actual a /home/labex/project.

Ahora, veamos la versión de Nmap instalada en nuestro sistema. Saber la versión es importante porque diferentes versiones pueden tener diferentes características y compatibilidad. Ejecute este comando en la terminal:

nmap --version

La salida se verá similar a esto:

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

A continuación, examinaremos las categorías de scripts de Nmap disponibles. Los scripts de Nmap se almacenan en el directorio /usr/share/nmap/scripts/. Para tener una idea de qué scripts están disponibles, podemos listarlos y ordenarlos por sus nombres. Ejecute este comando en la terminal:

ls /usr/share/nmap/scripts/ | grep -v .lua | sort | head -10

Este comando primero lista todos los archivos en el directorio /usr/share/nmap/scripts/. Luego, utiliza grep -v .lua para excluir los archivos con la extensión .lua. Después, ordena los archivos restantes por sus nombres y muestra los primeros 10 resultados. La salida será similar 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 las categorías de scripts, podemos usar el siguiente comando:

grep -r categories /usr/share/nmap/scripts/*.nse | grep -o "categories = {[^}]*}" | sort | uniq | head -10

Este comando busca la cadena "categories" en todos los archivos de scripts .nse en el directorio /usr/share/nmap/scripts/. Luego, extrae la información de la categoría, la ordena, elimina las entradas duplicadas y muestra los primeros 10 resultados. La salida se verá algo así:

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 una mejor organización, crearemos una estructura de directorios para categorizar los scripts según su funcionalidad. Esto hará que sea más fácil encontrar y usar los scripts más adelante. Crearemos directorios separados para diferentes categorías. Ejecute estos comandos en la terminal:

mkdir -p /home/labex/project/NmapScripts/vulnerability
mkdir -p /home/labex/project/NmapScripts/discovery
mkdir -p /home/labex/project/NmapScripts/authentication

El comando mkdir -p crea directorios. Si los directorios padre no existen, los crea también.

Ahora, copiemos algunos scripts relacionados con vulnerabilidades a nuestro recién creado directorio de vulnerabilidades. Ejecute este comando en la terminal:

cp /usr/share/nmap/scripts/smb-vuln* /home/labex/project/NmapScripts/vulnerability/

Este comando copia todos los scripts en el directorio /usr/share/nmap/scripts/ cuyos nombres empiecen con smb - vuln al directorio /home/labex/project/NmapScripts/vulnerability/.

Verifiquemos que los archivos se hayan copiado correctamente. Ejecute este comando en la terminal:

ls -la /home/labex/project/NmapScripts/vulnerability/

La salida mostrará los scripts de vulnerabilidad 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

De manera similar, copiemos algunos scripts de detección y autenticación a sus respectivos directorios. Ejecute estos comandos en la terminal:

cp /usr/share/nmap/scripts/dns-* /home/labex/project/NmapScripts/discovery/
cp /usr/share/nmap/scripts/ssh-* /home/labex/project/NmapScripts/authentication/

Ahora ha organizado algunos scripts de Nmap en categorías según su funcionalidad, lo que facilita encontrar y usarlos para tareas específicas.

Comprendiendo la funcionalidad de los scripts

En este paso, aprenderemos cómo examinar y entender los scripts de Nmap para descubrir lo que pueden hacer. Saber esto es realmente importante porque te ayuda a elegir los scripts adecuados para diferentes tareas de escaneo de red.

Comencemos por analizar de cerca uno de los scripts de vulnerabilidad que copiamos en el paso anterior. Usaremos el comando cat para mostrar el contenido del script y luego head -20 para mostrar solo las primeras 20 líneas. De esta manera, podemos ver rápidamente la información importante al principio del script.

cat /home/labex/project/NmapScripts/vulnerability/smb-vuln-ms17-010.nse | head -20

La salida mostrará el inicio del script. Esta parte generalmente contiene detalles sobre para qué sirve el script y cómo usarlo.

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 está diseñado para verificar si un servidor Microsoft SMBv1 tiene la vulnerabilidad MS17 - 010, también conocida como EternalBlue.

Ahora, veamos la estructura de un script de Nmap para entender sus diferentes partes. La mayoría de los scripts de Nmap tienen estos componentes clave:

Una sección de descripción: Esto te dice lo que hace el script. Es como un resumen corto que te ayuda a entender rápidamente el propósito del script.
Una sección de autor: Esto da crédito a la persona que creó el script. Es importante saber quién hizo el script, especialmente si necesitas contactarlos o buscar más scripts del mismo autor.
Categorías: Estas agrupan scripts similares. Por ejemplo, los scripts relacionados con el escaneo de vulnerabilidades pueden estar en la categoría "vuln". Esto facilita la búsqueda y gestión de scripts.
Reglas: Estas determinan cuándo debe ejecutarse el script. Hay diferentes tipos de reglas, como portrule y hostrule. Por ejemplo, una hostrule puede especificar que el script solo se debe ejecutar en ciertos hosts.
La función de acción principal: Aquí es donde se realiza el trabajo real del script. Contiene el código que realiza la tarea, como comprobar una vulnerabilidad o obtener información sobre un host.

Vamos a crear nuestro propio script básico de Nmap para ver esta estructura en acción. Usaremos el comando cat para crear un nuevo archivo y escribir el script en él.

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

Desglosemos este script:

La sección description explica claramente que el script comprueba si un host responde a las solicitudes de ping.
La sección author indica que el script fue creado por un usuario de LabEx.
La sección categories agrupa este script con otros scripts de descubrimiento y seguros. Los scripts de descubrimiento se utilizan para encontrar información sobre hosts, y los scripts seguros son aquellos que no causan ningún daño al objetivo.
La función hostrule está configurada para devolver true, lo que significa que el script se ejecutará en todos los hosts.
La función action contiene la lógica principal. Comprueba si el host tiene una respuesta de ping y luego devuelve un mensaje que indica si el host responde a ping o no.

Ahora, ejecutemos nuestro script personalizado contra el localhost (127.0.0.1). Usaremos el comando nmap con la opción --script para especificar nuestro script personalizado.

nmap --script /home/labex/project/my-ping-check.nse 127.0.0.1

Deberías ver una salida similar 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 salida muestra que nuestro script está funcionando correctamente. Detectó que el localhost responde a las solicitudes de ping. Este es un ejemplo sencillo, pero muestra la estructura y función básicas de un script de Nmap.

Crear y agregar scripts personalizados a Nmap

En este paso, aprenderemos cómo crear un script personalizado de Nmap y agregarlo a la base de datos de scripts de Nmap. Nmap es una poderosa herramienta de escaneo de red, y al agregar scripts personalizados, puedes extender su funcionalidad para satisfacer tus necesidades específicas. Esto significa que puedes realizar tareas únicas durante los escaneos de red que no están cubiertas por los scripts predeterminados de Nmap.

Primero, creemos un nuevo script un poco más complejo. Este script verificará si un puerto específico está abierto. Los puertos son como puertas en una red; permiten que diferentes tipos de tráfico de red entren o salgan de un dispositivo. Al comprobar si un puerto está abierto, podemos averiguar si un servicio en particular está en funcionamiento en un 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

En el código anterior, primero definimos una descripción de lo que hace el script. Luego establecemos la información del autor y la licencia. La función portrule decide cuándo debe ejecutarse el script. Aquí, comprueba si el puerto utiliza el protocolo TCP y está abierto. La función action es la parte principal del script. Crea un mensaje que indica que un puerto específico está abierto en un host determinado.

Observa que hemos creado este script directamente en el directorio de scripts de Nmap (/usr/share/nmap/scripts/). Esto es importante porque Nmap busca scripts en este directorio. Sin embargo, solo crear el script no es suficiente. Nmap necesita conocer este nuevo script, por lo que debemos actualizar la base de datos de scripts de Nmap.

Para actualizar la base de datos de scripts de Nmap, ejecuta el siguiente comando:

sudo nmap --script-updatedb

La salida debe ser similar 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 salida muestra que la base de datos de scripts se ha actualizado correctamente. Ahora, verifiquemos que nuestro script se haya agregado a la base de datos de scripts de Nmap. Podemos hacer esto buscando nuestro script en el archivo script.db.

grep port-check /usr/share/nmap/scripts/script.db

Deberías ver una salida similar a:

Entry { filename = "port-check.nse", categories = { "discovery", "safe", } }

Esto confirma que nuestro script se ha agregado correctamente a la base de datos de scripts de Nmap.

Ahora, creemos otro script que demuestre cómo usar bibliotecas dentro de los scripts de Nmap. Las bibliotecas son código preescrito que podemos usar para hacer nuestros scripts más poderosos. Este script verificará los encabezados HTTP en servidores web. Los encabezados HTTP contienen información importante sobre una página web, como el tipo de servidor, la fecha de última modificación, 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 utiliza varias bibliotecas de Nmap:

http para realizar solicitudes HTTP. Esta biblioteca permite que nuestro script se comunique con servidores web y obtenga información de ellos.
shortport para determinar si un puerto probablemente está ejecutando un servicio HTTP. Nos ayuda a averiguar si un puerto en particular en un host se utiliza para tráfico web.
stdnse para dar formato a la salida. Esto hace que la información que obtenemos del servidor web sea más fácil de leer.

Actualicemos nuevamente la base de datos de scripts para que Nmap conozca nuestro nuevo script:

sudo nmap --script-updatedb

Ahora, ejecutemos nuestro nuevo script contra un servidor web. Con fines de demostración, usaremos un servidor web local en el puerto 3001 (que a menudo se utiliza por servidores de desarrollo).

nmap --script http-headers-check -p 3001 127.0.0.1

Si no hay un servidor web en funcionamiento en el puerto 3001, la salida indicará que el puerto está cerrado o filtrado. Si hay un servidor web, verás los encabezados HTTP que se recuperaron.

Finalmente, ejecutemos ambos scripts personalizados juntos. De esta manera, podemos ver los resultados de ambos scripts a la vez.

nmap --script "port-check,http-headers-check" -p 22,3001 127.0.0.1

Este comando ejecutará ambos scripts personalizados contra los puertos 22 y 3001 en el localhost. El puerto 22 se utiliza comúnmente para conexiones SSH (Secure Shell).

La salida mostrará si estos puertos están abiertos y, si el puerto 3001 está ejecutando un servicio HTTP, mostrará los encabezados HTTP.

Al crear y agregar scripts personalizados a Nmap, puedes extender su funcionalidad para realizar tareas específicas necesarias para tus requisitos de escaneo de red y evaluación de seguridad.

Ejecutar categorías de scripts y gestionar la salida de los scripts

En este paso, exploraremos cómo ejecutar scripts de Nmap por categoría y gestionar la salida de estos escaneos de scripts. Esta es una habilidad muy útil, ya que te permite ejecutar múltiples scripts relacionados sin tener que especificar cada uno por separado.

Los scripts de Nmap se agrupan en diferentes categorías según lo que hacen. Comprender estas categorías te ayuda a encontrar y ejecutar rápidamente los scripts que necesitas. Aquí están algunas categorías comunes:

auth: Estos son scripts relacionados con la autenticación. Pueden ayudarte a comprobar si los mecanismos de autenticación en un objetivo son seguros.
broadcast: Los scripts de esta categoría envían transmisiones (broadcasts) en la red local. Son útiles para descubrir dispositivos y servicios en la misma red.
brute: Estos son scripts de auditoría de contraseñas por fuerza bruta. Intentan diferentes contraseñas para ver si pueden obtener acceso no autorizado a un servicio.
default: Cuando usas la opción -sC en Nmap, estos son los scripts que se ejecutan por defecto. Proporcionan un buen punto de partida para un escaneo básico.
discovery: Estos scripts se utilizan para la descubrimiento de hosts y servicios. Pueden averiguar qué hosts están disponibles en una red y qué servicios están ejecutando.
dos: Los scripts de Denegación de Servicio (Denial of Service, DOS) están diseñados para sobrecargar un sistema objetivo y hacerlo inaccesible. Ten cuidado al usarlos, ya que pueden causar daño real.
exploit: Los scripts de explotación se utilizan para aprovechar vulnerabilidades conocidas en un sistema. Pueden usarse para pruebas de seguridad, pero deben usarse de manera responsable.
external: Estos scripts pueden enviar datos a bases de datos de terceros. Pueden proporcionar información adicional sobre el objetivo, pero debes ser consciente de las implicaciones de privacidad.
fuzzer: Los scripts de fuzzing utilizan técnicas de fuzzing. Envían datos aleatorios o malformados a un objetivo para ver si pueden causar errores o exponer vulnerabilidades.
intrusive: Los scripts de esta categoría pueden causar la caída de servicios o considerarse intrusivos. Úsalos con precaución, especialmente en un entorno de producción.
malware: Los scripts de detección de malware se utilizan para comprobar si un sistema objetivo está infectado con malware.
safe: Estos scripts se consideran seguros y no intrusivos. No causarán ningún daño al sistema objetivo.
version: Los scripts de detección de versiones te ayudan a averiguar la versión del software que se ejecuta en un servicio objetivo. Esta información puede ser útil para identificar posibles vulnerabilidades.
vuln: Los scripts de detección de vulnerabilidades se utilizan para encontrar debilidades de seguridad en un sistema objetivo.

Ahora, veamos cómo ejecutar scripts de una categoría específica. Por ejemplo, si quieres ejecutar todos los scripts de la categoría "discovery", puedes usar el siguiente comando:

nmap --script discovery 127.0.0.1

Este comando le dice a Nmap que ejecute todos los scripts de descubrimiento contra el localhost (127.0.0.1). La salida será bastante larga, ya que muestra los resultados de todos los scripts de descubrimiento.

A veces, es posible que desees ejecutar scripts de múltiples categorías. Puedes hacer esto usando una coma para separar los nombres de las categorías. Aquí tienes un ejemplo:

nmap --script "discovery,safe" -p 1-100 127.0.0.1

Este comando ejecuta todos los scripts de las categorías discovery y safe contra los puertos 1 - 100 en el localhost.

También puedes excluir categorías específicas usando el operador not. Por ejemplo:

nmap --script "discovery and not broadcast" 127.0.0.1

Este comando ejecuta los scripts de descubrimiento, pero excluye cualquier script que también esté en la categoría broadcast.

A continuación, veamos diferentes formas de formatear y guardar la salida de los escaneos de scripts de Nmap. Nmap ofrece varios formatos de salida, que son útiles para diferentes propósitos:

Salida normal (por defecto): Esta es la salida de texto estándar que Nmap muestra en la pantalla.
Salida XML: XML es un formato estructurado que puede ser fácilmente analizado por otras herramientas.
Salida grepable: Este formato está diseñado para ser fácilmente buscado usando herramientas como grep.
Salida JSON (con el script adecuado): JSON es otro formato estructurado que se utiliza ampliamente para el intercambio de datos.

Para guardar la salida en formato XML, puedes usar el siguiente comando:

nmap --script vuln -p 1-1000 127.0.0.1 -oX /home/labex/project/scan_results.xml

Este comando ejecuta todos los scripts de vulnerabilidades contra los puertos 1 - 1000 en el localhost y guarda los resultados en formato XML en el archivo /home/labex/project/scan_results.xml.

Veamos el contenido del archivo XML:

head -20 /home/labex/project/scan_results.xml

Este comando muestra las primeras 20 líneas de la salida en formato XML. Verás información sobre el escaneo, las opciones utilizadas y los resultados del escaneo.

Para la salida grepable, puedes usar este comando:

nmap --script "default" 127.0.0.1 -oG /home/labex/project/scan_results.gnmap

Este comando guarda los resultados en un formato que es fácil de analizar con herramientas como grep.

Veamos el contenido del archivo gnmap:

cat /home/labex/project/scan_results.gnmap

Verás que cada host está en una sola línea, lo que facilita la búsqueda de información específica.

Si quieres guardar la salida en formatos normal y XML al mismo tiempo, puedes 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 guarda la salida en formato de texto normal y en formato XML simultáneamente.

Finalmente, puedes usar la opción -oA para guardar la salida en los tres formatos (normal, XML y grepable) a la vez:

nmap --script "default" 127.0.0.1 -oA /home/labex/project/all_formats

Este comando crea tres archivos:

/home/labex/project/all_formats.nmap (salida normal)
/home/labex/project/all_formats.xml (salida XML)
/home/labex/project/all_formats.gnmap (salida grepable)

Al dominar estas técnicas para ejecutar categorías de scripts y gestionar la salida de los scripts, puedes realizar escaneos de red de manera eficiente y organizar los resultados para un análisis posterior.

Resumen

En este laboratorio, has aprendido habilidades esenciales para trabajar con el Motor de Scripting de Nmap (NSE, por sus siglas en inglés). Has explorado cómo categorizar y organizar los scripts de Nmap según su funcionalidad, lo cual es fundamental para realizar escaneos de red y evaluaciones de seguridad de manera eficiente.

Has adquirido experiencia práctica en múltiples aspectos, incluyendo la exploración de categorías de scripts, la creación de directorios organizados, la comprensión de las estructuras de los scripts, la creación de scripts personalizados, la adición de estos a la base de datos, la ejecución de scripts por categoría utilizando operadores lógicos y la gestión de la salida en diferentes formatos. Estas habilidades te permiten extender la funcionalidad de Nmap para satisfacer necesidades específicas. Al dominar la creación, categorización y actualización de scripts, puedes desarrollar flujos de trabajo de escaneo más específicos y eficientes. La capacidad de organizar y dar formato a los resultados de los escaneos también es útil para la documentación y la comunicación con miembros del equipo y partes interesadas. A medida que sigas utilizando Nmap, podrás basarte en estas habilidades para crear scripts más complejos y estrategias de escaneo más sofisticadas.