Escaneo de Vulnerabilidades con Nmap

Introducción

En este laboratorio, aprenderá cómo utilizar Nmap para la detección de vulnerabilidades de red. Instalará Nmap, utilizará el Motor de Scripting de Nmap (Nmap Scripting Engine, NSE) para realizar análisis avanzados y analizará los resultados para identificar debilidades de seguridad.

A través de ejercicios prácticos, realizará análisis básicos y mejorados con scripts mientras aprende a interpretar y guardar sus hallazgos. Este laboratorio ofrece experiencia práctica con las características principales de Nmap para una evaluación efectiva de la seguridad de la red.

Skills Graph

Instalar Nmap

En este paso, instalará Nmap (Network Mapper), una poderosa herramienta de código abierto para la detección de redes y la auditoría de seguridad. Nmap se utiliza ampliamente para escanear redes y detectar hosts, servicios y vulnerabilidades. Puedes pensar en él como un cartógrafo digital que ayuda a los profesionales de la seguridad a entender qué dispositivos están conectados a una red y qué servicios están ejecutando.

El entorno de la máquina virtual (VM) de LabEx ya tiene instaladas las dependencias necesarias, por lo que podemos centrarnos en instalar Nmap en sí. Siga estos pasos atentamente:

Primero, necesitamos actualizar la lista de paquetes para asegurarnos de obtener la última versión de Nmap. Esto es como comprobar las actualizaciones más recientes del mapa antes de comenzar un viaje:
```
sudo apt update
```
Ahora, instale Nmap utilizando este comando. La opción -y confirma automáticamente la instalación, lo que nos ahorra tiempo:
```
sudo apt install -y nmap
```
Después de la instalación, verifiquemos que Nmap se haya instalado correctamente comprobando su versión. Esto confirma que tenemos la herramienta lista para usar:
```
nmap --version
```
Debería ver una salida similar a la siguiente:
```
Nmap version 7.92 ( https://nmap.org )
```
Para una verificación más práctica, ejecutaremos un escaneo simple en el localhost (su propia máquina). Esto le ayudará a entender cómo funciona Nmap antes de escanear otros sistemas:
```
nmap localhost
```
Este comando mostrará información básica sobre los puertos abiertos en su sistema, mostrándole qué servicios se están ejecutando localmente. Es como comprobar qué puertas y ventanas están abiertas en tu propia casa antes de inspeccionar otras.

Cargar el Motor de Scripting de Nmap

En este paso, exploraremos el poderoso Motor de Scripting de Nmap (Nmap Scripting Engine, NSE), que actúa como una caja de herramientas que amplía las capacidades básicas de escaneo de Nmap. Puedes pensar en el NSE como la adición de herramientas especializadas a tu escáner de red: contiene cientos de scripts preescritos que pueden detectar vulnerabilidades, recopilar información detallada sobre servicios y realizar tareas avanzadas de detección de redes.

Antes de comenzar, es importante entender que estos scripts ya están instalados con Nmap en tu sistema. Comencemos por explorar qué scripts están disponibles:

Primero, listaremos todos los scripts NSE instalados. Este comando muestra la colección completa de scripts en tu instalación de Nmap:
```
ls /usr/share/nmap/scripts/
```
Cada script tiene una documentación que explica lo que hace. Examinemos el script http-title como ejemplo: este script recupera el título de las páginas web. El siguiente comando muestra su propósito y uso:
```
nmap --script-help http-title
```
Ahora, realicemos nuestro primer escaneo real utilizando el NSE. Este comando escanea tu máquina local (localhost) con dos opciones importantes:
- -sC: Ejecuta el conjunto predeterminado de scripts NSE (seguros y útiles para la mayoría de los escaneos)
- -sV: Intenta determinar las versiones de los servicios (es fundamental para identificar software desactualizado)
```
nmap -sC -sV localhost
```
Para utilizar un script específico, escaneararemos scanme.nmap.org (un sitio de prueba proporcionado por Nmap) utilizando solo el script http-title. Esto demuestra cómo centrarse en información particular:
```
nmap --script http-title scanme.nmap.org
```
Finalmente, puedes combinar múltiples scripts para un escaneo más completo. Este ejemplo ejecuta tanto el script http-title como el script http-headers contra scanme.nmap.org:
```
nmap --script "http-title and http-headers" scanme.nmap.org
```

Recuerda que diferentes scripts tienen diferentes propósitos: algunos recopilan información mientras que otros prueban la presencia de vulnerabilidades. Siempre revisa la documentación de un script antes de usarlo en sistemas de producción.

Realizar un Escaneo de Vulnerabilidades

En este paso, aprenderás cómo utilizar el motor de scripting de Nmap para detectar vulnerabilidades de seguridad. El escaneo de vulnerabilidades ayuda a identificar debilidades en los sistemas antes de que los atacantes puedan explotarlas. Utilizaremos scanme.nmap.org como nuestro objetivo: este es un servidor seguro y intencionalmente vulnerable mantenido por los desarrolladores de Nmap con fines de prueba.

Primero, exploremos los scripts de vulnerabilidades disponibles. Nmap viene con cientos de scripts preinstalados en el directorio /usr/share/nmap/scripts/. El comando grep ayuda a filtrar solo los scripts relacionados con vulnerabilidades:
```
ls /usr/share/nmap/scripts/ | grep vuln
```
Ahora, realizaremos un escaneo básico de vulnerabilidades. La opción -sV habilita la detección de la versión del servicio, mientras que --script vuln carga todos los scripts de detección de vulnerabilidades. Esto nos da una visión general amplia de los posibles problemas:
```
nmap -sV --script vuln scanme.nmap.org
```
Para un escaneo más específico, podemos centrarnos en categorías de vulnerabilidades concretas. Este ejemplo solo comprueba las vulnerabilidades relacionadas con HTTP (comunes en servidores web). El asterisco (*) actúa como comodín para incluir todos los scripts http-vuln:
```
nmap -sV --script http-vuln-* scanme.nmap.org
```
Un escaneo completo comprueba todas las vulnerabilidades evitando pruebas intrusivas (marcadas como "seguras"). Esto tarda más, pero proporciona resultados exhaustivos sin poner en riesgo la estabilidad del sistema:
```
nmap -sV --script "vuln and safe" scanme.nmap.org
```
Es una buena práctica guardar los resultados del escaneo para la documentación y un análisis posterior. La opción -oN guarda la salida en formato normal en un archivo de texto. Utilizaremos estos resultados en pasos posteriores:
```
nmap -sV --script vuln -oN vuln_scan_results.txt scanme.nmap.org
```

Los resultados del escaneo mostrarán información importante de seguridad, incluyendo:

Puertos abiertos y servicios en ejecución (posibles puntos de entrada)
Vulnerabilidades específicas detectadas (debilidades de seguridad)
Referencias CVE (identificadores estándar de vulnerabilidades)
Niveles de riesgo (que ayudan a priorizar las correcciones)

Analizar la Salida de los Scripts

En este paso, examinaremos detenidamente los resultados del escaneo de vulnerabilidades generados por Nmap en el paso anterior. Como principiante, es importante entender que el escaneo es solo la primera parte: la interpretación adecuada de los resultados es donde comienza el verdadero análisis de seguridad. El archivo vuln_scan_results.txt contiene todos los datos en bruto que necesitamos para identificar posibles debilidades de seguridad.

Primero, veamos los resultados completos del escaneo. Esto nos da una visión general de lo que Nmap descubrió:
```
cat vuln_scan_results.txt
```
Dado que leer manualmente todo el archivo puede resultar abrumador, buscaremos indicadores específicos de vulnerabilidades. La palabra "VULNERABLE" en la salida de Nmap generalmente marca problemas de seguridad confirmados:
```
grep -i "vulnerable" vuln_scan_results.txt
```
A continuación, buscaremos referencias estandarizadas de vulnerabilidades. Los CVE (Common Vulnerabilities and Exposures, Vulnerabilidades y Exposiciones Comunes) son identificadores únicos de fallos de seguridad conocidos:
```
grep -i "CVE-" vuln_scan_results.txt
```
El estado de los puertos es crucial en la evaluación de vulnerabilidades. Los puertos abiertos a menudo representan posibles puntos de entrada para los atacantes:
```
grep -E "open|filtered|closed" vuln_scan_results.txt
```
Para obtener una visión general rápida de nuestros hallazgos, contaremos cuántas vulnerabilidades detectó Nmap. Esto ayuda a priorizar nuestro análisis:
```
echo "Total vulnerabilities found: $(grep -c -i "vulnerable" vuln_scan_results.txt)"
```
Cuando encuentres un CVE interesante, es esencial investigarlo. Este ejemplo muestra cómo obtener detalles sobre una vulnerabilidad específica (reemplaza el ID del CVE según sea necesario):
```
curl -s https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-44228 | grep -A10 "Description"
```

Al analizar la salida de Nmap, presta especial atención a estos elementos críticos:

Puertos marcados como "open" - estos representan servicios activos
Versiones de los servicios - el software desactualizado a menudo contiene vulnerabilidades conocidas
Indicadores "VULNERABLE" - problemas de seguridad confirmados
Referencias CVE - identificadores estandarizados de vulnerabilidades
Puntuaciones de riesgo (cuando están disponibles) - ayuda a priorizar la remediación

Guardar los Hallazgos del Escaneo

En este último paso, aprenderás cómo documentar y guardar adecuadamente los resultados de tu escaneo de vulnerabilidades. Guardar los informes es crucial para el análisis de seguridad, la documentación y el intercambio de hallazgos con los miembros del equipo. Nmap ofrece múltiples formatos de salida para adaptarse a diferentes necesidades.

Primero, creemos un directorio dedicado para organizar todos tus informes de escaneo. Esto ayuda a mantener un espacio de trabajo ordenado y facilita la búsqueda de tus resultados más adelante:
```
mkdir -p ~/project/reports
```
Ahora, ejecutaremos el escaneo de vulnerabilidades nuevamente mientras guardamos los resultados en dos formatos estándar. La opción -oN guarda la salida en texto normal, mientras que -oX crea un archivo XML que puede ser procesado por otras herramientas:
```
nmap -sV --script vuln -oN ~/project/reports/scan_results.txt scanme.nmap.org
nmap -sV --script vuln -oX ~/project/reports/scan_results.xml scanme.nmap.org
```
Los archivos XML no son fáciles de leer directamente, así que los convertiremos en un informe HTML más visual utilizando xsltproc. Esto crea una página web bien formateada con los resultados de tu escaneo:
```
xsltproc ~/project/reports/scan_results.xml -o ~/project/reports/scan_results.html
```
Para una referencia rápida, extraeremos solo los hallazgos de vulnerabilidades críticas utilizando grep. Esto crea un resumen condensado que muestra solo las líneas que contienen indicadores de vulnerabilidad:
```
grep -iE "vulnerable|CVE-" ~/project/reports/scan_results.txt > ~/project/reports/summary.txt
```
Verifiquemos que todos nuestros archivos de informe se hayan creado correctamente. Las opciones -lh muestran los tamaños de los archivos en un formato legible para humanos:
```
ls -lh ~/project/reports/
```
(Opcional) Si necesitas compartir estos informes con otros, puedes comprimirlos en un solo archivo de archivo:
```
tar -czvf ~/project/reports.tar.gz ~/project/reports/
```

Explicación de los formatos de salida principales:

.txt: Formato de texto simple que es fácil de leer en cualquier editor de texto
.xml: Formato de datos estructurado que puede ser procesado por otras herramientas de seguridad
.html: Informe visual ideal para presentaciones y documentación
Archivo de resumen: Referencia rápida que contiene solo los hallazgos de vulnerabilidad más importantes

Resumen

En este laboratorio, has aprendido cómo realizar un escaneo de vulnerabilidades con Nmap, desde la instalación en sistemas Linux hasta la realización de escaneos básicos y la verificación de la funcionalidad. Los ejercicios presentaron características clave como el Motor de Scripting de Nmap (Nmap Scripting Engine, NSE), demostrando cómo ejecutar scripts predeterminados y personalizados para un análisis de red completo.

Practicaste técnicas de escaneo esenciales, como la detección de versiones de servicios (-sV) y la ejecución de scripts (-sC), mientras aprendías a interpretar y guardar los resultados del escaneo. Estas habilidades proporcionan una base sólida para las evaluaciones de seguridad de red utilizando las poderosas capacidades de escaneo de Nmap.