Aprende a Escanear con Nmap y Analizar Resultados

NmapNmapBeginner
Practicar Ahora

💡 Este tutorial está traducido por IA desde la versión en inglés. Para ver la versión original, puedes hacer clic aquí

Introducción

En este laboratorio, aprenderá cómo utilizar Nmap, una poderosa herramienta de escaneo de redes ampliamente utilizada por profesionales de seguridad para descubrir hosts y servicios en una red informática. Explorará varios formatos de salida proporcionados por Nmap, que son vitales para interpretar los resultados del escaneo y realizar un análisis más profundo.

Nmap, abreviatura de Network Mapper (Asistente de mapeo de redes), es una utilidad gratuita y de código abierto para la detección de redes y auditoría de seguridad. Utiliza paquetes IP sin procesar para recopilar información sobre los hosts de la red, como los servicios disponibles y los sistemas operativos. Este laboratorio lo guiará a través del proceso de configuración de un servicio de prueba y del escaneo de este con diferentes opciones de salida de Nmap, lo cual es fundamental para un análisis y documentación efectivos de la red.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL nmap(("Nmap")) -.-> nmap/NmapGroup(["Nmap"]) nmap/NmapGroup -.-> nmap/installation("Installation and Setup") nmap/NmapGroup -.-> nmap/output_formats("Output Formats") nmap/NmapGroup -.-> nmap/save_output("Save Output to File") nmap/NmapGroup -.-> nmap/port_scanning("Port Scanning Methods") nmap/NmapGroup -.-> nmap/scripting_basics("Scripting Engine Basics") subgraph Lab Skills nmap/installation -.-> lab-415926{{"Aprende a Escanear con Nmap y Analizar Resultados"}} nmap/output_formats -.-> lab-415926{{"Aprende a Escanear con Nmap y Analizar Resultados"}} nmap/save_output -.-> lab-415926{{"Aprende a Escanear con Nmap y Analizar Resultados"}} nmap/port_scanning -.-> lab-415926{{"Aprende a Escanear con Nmap y Analizar Resultados"}} nmap/scripting_basics -.-> lab-415926{{"Aprende a Escanear con Nmap y Analizar Resultados"}} end

Configuración de un entorno de prueba para el escaneo con Nmap

En este paso, vamos a crear un entorno sencillo donde puedas practicar el escaneo con Nmap. Nmap es una poderosa herramienta utilizada para la exploración de redes y la auditoría de seguridad. Al configurar un servidor web básico en tu máquina local y luego escanearlo con Nmap, podrás aprender sobre el escaneo de redes en un entorno seguro y controlado. De esta manera, puedes experimentar sin afectar las redes del mundo real.

Configuración de un servidor web local

Primero, necesitamos configurar un servidor web sencillo que podamos escanear con Nmap. Python ofrece una forma fácil de crear un servidor HTTP básico. Un servidor HTTP es un software que puede servir páginas web a clientes, como navegadores.

  1. Abre una terminal y navega hasta el directorio de tu proyecto:

    cd /home/labex/project

    El comando cd significa "cambiar directorio". Te permite moverte por tu sistema de archivos. En este caso, nos movemos al directorio /home/labex/project donde configuraremos nuestro servidor web.

  2. Crea un archivo HTML sencillo para servir:

    echo "Welcome to Nmap Testing Environment" > index.html

    El comando echo imprime texto en la terminal. El símbolo > redirige esa salida a un archivo. Así, estamos creando un archivo llamado index.html con el texto "Welcome to Nmap Testing Environment". Esta será la página web que nuestro servidor servirá.

  3. Inicia un servidor HTTP de Python en el puerto 8080:

    python3 -m http.server 8080 &

    El comando python3 -m http.server inicia un servidor HTTP sencillo utilizando Python. El 8080 especifica el número de puerto en el que el servidor escuchará. Un puerto es como una puerta a través de la cual el tráfico de red entra o sale de una computadora. El & al final del comando ejecuta el servidor en segundo plano, lo que te permite seguir usando la terminal para otros comandos.

  4. Verifica que tu servidor web esté en funcionamiento accediéndolo:

    curl http://localhost:8080

    El comando curl se utiliza para transferir datos de o hacia un servidor. Aquí, estamos intentando acceder al servidor web que acabamos de configurar en http://localhost:8080. localhost se refiere a la computadora actual.

    Deberías ver la siguiente salida:

    Welcome to Nmap Testing Environment

    Si ves esta salida, significa que tu servidor web está funcionando correctamente.

Escaneo básico con Nmap

Ahora que tienes un servidor web en funcionamiento, puedes escanearlo utilizando Nmap. Escanear un servidor te ayuda a descubrir qué puertos están abiertos y qué servicios pueden estar ejecutándose en ellos.

  1. Ejecuta un escaneo básico de Nmap en tu servidor web local:

    nmap -p 8080 localhost

    La opción -p en el comando nmap especifica el puerto a escanear. En este caso, le estamos diciendo a Nmap que escanee solo el puerto 8080 en localhost (que es la dirección IP 127.0.0.1).

    Deberías ver una salida similar a esta:

    Starting Nmap 7.80 ( https://nmap.org ) at 2023-11-08 12:34 UTC
    Nmap scan report for localhost (127.0.0.1)
    Host is up (0.000097s latency).
    
    PORT     STATE SERVICE
    8080/tcp open  http-proxy
    
    Nmap done: 1 IP address (1 host up) scanned in 0.05 seconds

    Esta salida está en el formato predeterminado de Nmap, que es legible por humanos y muestra la información básica sobre el escaneo.

Comprensión de la salida predeterminada de Nmap

Vamos a entender lo que muestra la salida predeterminada:

  • Starting Nmap: Esta línea muestra la versión de Nmap que estás utilizando y la hora en que se inició el escaneo. Te ayuda a llevar un registro de cuándo se inició el escaneo.
  • Nmap scan report: Esto indica el objetivo del escaneo. En nuestro caso, el objetivo es localhost.
  • Host is up: Esto confirma que el objetivo está en línea. El tiempo de latencia muestra cuánto tiempo tardó Nmap en obtener una respuesta del objetivo.
  • PORT: Esto muestra el número de puerto que se escaneó. En nuestro escaneo, escaneamos el puerto 8080.
  • STATE: Esto indica si el puerto está abierto, cerrado o filtrado. Un puerto abierto significa que un servicio está escuchando en ese puerto y aceptando conexiones.
  • SERVICE: Nmap intenta adivinar qué servicio puede estar ejecutándose en ese puerto. Aquí, adivinó http - proxy.
  • Nmap done: Esto es un resumen del escaneo. Te dice cuántas direcciones IP se escanearon y cuánto tiempo tardó el escaneo.

Ahora has configurado con éxito un entorno de prueba y realizado un escaneo básico con Nmap. En el siguiente paso, explorarás diferentes formatos de salida que ofrece Nmap.

Exploración de diferentes formatos de salida de Nmap

En este paso, vamos a aprender sobre los diversos formatos de salida que ofrece Nmap. Los formatos de salida son cruciales en ciberseguridad porque nos permiten presentar los resultados del escaneo de diferentes maneras, según nuestras necesidades. Por ejemplo, algunos formatos son fáciles de leer para los humanos, mientras que otros están diseñados para que las máquinas los analicen, lo cual es útil cuando se integra con otras herramientas.

Descripción general de los formatos de salida de Nmap

Nmap admite varios formatos de salida, cada uno con sus propias características únicas y casos de uso:

  1. Salida normal (predeterminada): Este es un formato legible por humanos. Presenta los resultados del escaneo de una manera que es fácil de entender a simple vista, lo que lo hace ideal para un análisis manual rápido.
  2. Salida XML (-oX): XML significa Extensible Markup Language (Lenguaje de marcado extensible). Es un formato estructurado, lo que significa que los datos están organizados de manera jerárquica. Esto facilita que los programas y scripts analicen los datos y se utiliza comúnmente al integrar Nmap con otras herramientas de seguridad.
  3. Salida grepable (-oG): Este es un formato basado en líneas. Está diseñado para ser fácilmente procesado con herramientas Unix como grep, awk y cut. Este formato es útil cuando se desea extraer rápidamente información específica de los resultados del escaneo.
  4. Salida Script Kiddie (-oS): Este formato es similar a la salida normal, pero incluye arte ASCII. Sin embargo, se utiliza raramente en escenarios prácticos.
  5. Todos los formatos (-oA): Esta opción permite guardar los resultados del escaneo en formatos normal, XML y grepable simultáneamente. Es una forma conveniente de tener todos los tipos de salidas disponibles de una vez.

Exploremos estos formatos volviendo a escanear tu servidor web local.

Formato de salida XML

XML, o Extensible Markup Language, es un formato estructurado que se utiliza ampliamente para el almacenamiento y el intercambio de datos. Su estructura jerárquica facilita que los programas analicen los datos, por lo que se utiliza comúnmente para la integración con otras herramientas de seguridad.

  1. Ejecuta un escaneo de Nmap y guarda la salida en formato XML:

    nmap -p 8080 localhost -oX /home/labex/project/scan_results.xml

    En este comando, -p 8080 especifica que estamos escaneando el puerto 8080, localhost es el objetivo que estamos escaneando (nuestra máquina local) y -oX le dice a Nmap que guarde la salida en formato XML en la ruta de archivo especificada.

  2. Visualiza la salida XML:

    cat /home/labex/project/scan_results.xml

    El comando cat se utiliza para mostrar el contenido de un archivo. Cuando ejecutes este comando, verás una salida en formato XML que se parece a esto (abreviado):

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE nmaprun>
    <nmaprun scanner="nmap" args="nmap -p 8080 localhost -oX /home/labex/project/scan_results.xml" ...>
      <scaninfo type="connect" protocol="tcp" .../>
      <verbose level="0"/>
      <debugging level="0"/>
      <host>
        <status state="up" reason="conn - refused" reason_ttl="0"/>
        <address addr="127.0.0.1" addrtype="ipv4"/>
        <hostnames>
          <hostname name="localhost" type="user"/>
          <hostname name="localhost" type="PTR"/>
        </hostnames>
        <ports>
          <port protocol="tcp" portid="8080">
            <state state="open" reason="syn - ack" reason_ttl="0"/>
            <service name="http - proxy" method="table" conf="3"/>
          </port>
        </ports>
        <times srtt="97" rttvar="5000" to="100000"/>
      </host>
      <runstats>...</runstats>
    </nmaprun>
  3. El formato XML incluye información detallada organizada en una estructura jerárquica. Extraigamos la información específica del puerto:

    grep -A5 "<port " /home/labex/project/scan_results.xml > /home/labex/project/port_details.txt

    El comando grep se utiliza para buscar un patrón específico en un archivo. -A5 significa mostrar 5 líneas después de la línea que coincide con el patrón. Estamos buscando líneas que contengan <port en el archivo XML y guardando los resultados en un nuevo archivo llamado port_details.txt.

  4. Visualiza los detalles del puerto extraídos:

    cat /home/labex/project/port_details.txt

    Ejecutar este comando mostrará la sección de información del puerto del XML.

Formato de salida grepable

La salida grepable está específicamente diseñada para ser fácilmente procesada con herramientas como grep, awk y cut. Estas herramientas Unix son muy poderosas para el procesamiento de texto y pueden ayudarnos a extraer rápidamente la información que necesitamos de los resultados del escaneo.

  1. Ejecuta un escaneo de Nmap y guarda la salida en formato grepable:

    nmap -p 8080 localhost -oG /home/labex/project/scan_results.grep

    Aquí, -oG le dice a Nmap que guarde la salida en formato grepable en el archivo especificado.

  2. Visualiza la salida grepable:

    cat /home/labex/project/scan_results.grep

    La salida se parecerá a esto:

    ## Nmap 7.80 scan initiated Wed Nov 8 12:40:00 2023 as: nmap -p 8080 localhost -oG /home/labex/project/scan_results.grep
    Host: 127.0.0.1 (localhost)   Status: Up
    Host: 127.0.0.1 (localhost)   Ports: 8080/open/tcp//http - proxy///
    ## Nmap done at Wed Nov 8 12:40:00 2023 -- 1 IP address (1 host up) scanned in 0.05 seconds
  3. El formato grepable coloca toda la información del host en una sola línea, lo que facilita su uso con herramientas de procesamiento de texto. Por ejemplo, puedes extraer solo la línea que contiene la información del puerto:

    grep "Ports:" /home/labex/project/scan_results.grep > /home/labex/project/ports_info.txt

    Este comando busca líneas que contengan la palabra "Ports:" en el archivo de salida grepable y guarda la línea coincidente en un nuevo archivo llamado ports_info.txt.

  4. Visualiza la información de los puertos extraída:

    cat /home/labex/project/ports_info.txt

Guardar en todos los formatos simultáneamente

Nmap ofrece una opción conveniente para guardar la salida en múltiples formatos a la vez utilizando la opción -oA. Esto puede ahorrarte tiempo si necesitas diferentes tipos de salidas para diferentes fines.

  1. Ejecuta un escaneo de Nmap y guarda la salida en todos los formatos:

    nmap -p 8080 localhost -oA /home/labex/project/all_formats

    Este comando escanea el puerto 8080 en la máquina local y guarda los resultados en formatos normal, XML y grepable.

  2. Verifica los archivos creados:

    ls -la /home/labex/project/all_formats.*

    El comando ls -la lista todos los archivos en un directorio con información detallada. Cuando ejecutes este comando, deberías ver tres archivos:

    • all_formats.nmap (salida normal)
    • all_formats.xml (salida XML)
    • all_formats.gnmap (salida grepable)

Ahora entiendes los diferentes formatos de salida que ofrece Nmap y cómo utilizarlos. Cada formato tiene sus propias ventajas:

  • La salida normal es fácil de leer para los humanos.
  • La salida XML está estructurada para el análisis por máquina y la integración con otras herramientas.
  • La salida grepable está diseñada para un análisis rápido con herramientas de procesamiento de texto Unix.

En el siguiente paso, aprenderás cómo analizar estas salidas en más detalle.

Análisis de la salida de Nmap y extracción de información útil

En este paso, aprenderás cómo extraer y analizar información específica de los resultados de un escaneo de Nmap. Esta es una habilidad crucial para administradores de redes y profesionales de seguridad. Cuando se trata de escaneos de red, a menudo se obtiene una gran cantidad de datos. Ser capaz de extraer las partes relevantes de manera eficiente te ayuda a entender el estado de seguridad de la red e identificar posibles problemas.

Análisis de la salida XML

La salida XML es muy útil para un análisis detallado y se puede integrar fácilmente con otras herramientas. XML es un formato estructurado que organiza los datos de manera jerárquica, lo que facilita la localización y extracción de información específica. Exploremos cómo extraer información específica de la salida XML.

  1. Primero, veamos la estructura de la salida XML para entender qué información está disponible. Usaremos el comando grep para encontrar el inicio de la sección de host en el archivo XML. El comando grep busca un patrón especificado en un archivo.

    grep "<host" -A2 /home/labex/project/scan_results.xml

    Este comando busca la etiqueta <host> en el archivo scan_results.xml y muestra las dos líneas siguientes después de la coincidencia. Esto nos ayuda a ver el inicio de la sección de host en el archivo XML.

  2. Ahora, extraigamos información sobre el estado del puerto. Usaremos grep de nuevo para encontrar todas las líneas que contengan la etiqueta <state y guardaremos los resultados en un nuevo archivo.

    grep "<state " /home/labex/project/scan_results.xml > /home/labex/project/port_state.txt
  3. Veamos el estado del puerto extraído. Usaremos el comando cat, que se utiliza para mostrar el contenido de un archivo.

    cat /home/labex/project/port_state.txt

    Deberías ver algo como:

    <state state="open" reason="syn-ack" reason_ttl="0"/>

    Esto nos dice que el puerto está abierto. Nmap determinó esto porque recibió un paquete SYN - ACK en respuesta a su paquete SYN. Esto es parte del handshake TCP de tres vías, que es cómo se establece una conexión TCP entre dos dispositivos en una red.

Uso de expresiones regulares para extracciones más complejas

Para extracciones de datos más complejas, puedes usar expresiones regulares con herramientas como grep, sed o awk. Las expresiones regulares son una forma poderosa de buscar y coincidir patrones en texto. Te permiten definir criterios de búsqueda complejos.

  1. Extraigamos tanto el número de puerto como su estado. Usaremos grep con una expresión regular para encontrar la información relevante en el archivo XML y la guardaremos en un nuevo archivo.

    grep -o 'portid="[0-9]*".*state="[^"]*"' /home/labex/project/scan_results.xml > /home/labex/project/port_and_state.txt
  2. Veamos la información extraída usando el comando cat.

    cat /home/labex/project/port_and_state.txt

    Deberías ver una salida como:

    portid="8080" state="open"

Análisis de la salida grepable

El formato de salida grepable está diseñado para ser fácilmente procesado con herramientas estándar de Unix. Es un formato basado en texto que hace que sea sencillo buscar información específica usando comandos como grep.

  1. Extraigamos solo los puertos abiertos de la salida grepable. Usaremos grep para encontrar todas las líneas que contengan la palabra "open" y guardaremos los resultados en un nuevo archivo.

    grep "open" /home/labex/project/scan_results.grep > /home/labex/project/open_ports.txt
  2. Veamos la información extraída usando el comando cat.

    cat /home/labex/project/open_ports.txt

    Esto debería mostrarte la línea que contiene todos los puertos abiertos.

  3. Puedes procesar esto aún más para extraer solo los números de puerto. Usaremos una combinación de los comandos grep y cut. El comando cut se utiliza para extraer partes específicas de una línea basadas en un delimitador.

    grep "open" /home/labex/project/scan_results.grep | grep -o "8080/open" | cut -d "/" -f1 > /home/labex/project/port_numbers.txt
  4. Veamos los números de puerto extraídos usando el comando cat.

    cat /home/labex/project/port_numbers.txt

    Deberías ver:

    8080

Creación de un informe de resumen sencillo

Ahora, creemos un informe de resumen sencillo que combine información de diferentes partes del escaneo. Un informe de resumen te ayuda a entender rápidamente los hallazgos clave del escaneo.

  1. Creemos un informe de resumen. Usaremos el comando echo para escribir texto en un archivo. El operador >> agrega el texto al final del archivo.

    echo "Nmap Scan Summary" > /home/labex/project/scan_summary.txt
    echo "----------------" >> /home/labex/project/scan_summary.txt
    echo "Target: localhost (127.0.0.1)" >> /home/labex/project/scan_summary.txt
    echo "Open ports:" >> /home/labex/project/scan_summary.txt
    grep "open" /home/labex/project/scan_results.grep | grep -o "[0-9]*/open/tcp//[^/]*" >> /home/labex/project/scan_summary.txt
  2. Veamos el informe de resumen usando el comando cat.

    cat /home/labex/project/scan_summary.txt

    La salida debería verse así:

    Nmap Scan Summary
    ----------------
    Target: localhost (127.0.0.1)
    Open ports:
    8080/open/tcp//http - proxy

Al aprender cómo extraer y analizar información específica de los resultados de un escaneo de Nmap, puedes procesar e interpretar eficientemente los datos de reconocimiento de red. Esta habilidad es especialmente valiosa cuando se escanean redes grandes con numerosos hosts y servicios.

En el siguiente paso, aprenderás sobre técnicas de escaneo de Nmap más avanzadas.

Técnicas avanzadas de escaneo con Nmap

En este paso, exploraremos técnicas de escaneo más avanzadas de Nmap. Estas técnicas son cruciales ya que pueden proporcionar información adicional y detallada sobre los servicios de red. En particular, nos centraremos en la detección de versiones de servicios y el escaneo con scripts. Comprender estas técnicas te ayudará a obtener una visión más profunda de los servicios de red que estás escaneando, lo cual es esencial para evaluaciones de seguridad, inventarios de red y resolución de problemas.

Detección de versiones de servicios

Nmap tiene una función poderosa que le permite intentar determinar la versión específica de un servicio que se ejecuta en un puerto. Esto se hace utilizando la opción -sV. Saber la versión del servicio puede ser muy útil, ya que diferentes versiones pueden tener diferentes vulnerabilidades de seguridad o características.

  1. Ejecuta un escaneo de Nmap con detección de versiones de servicios:

    nmap -p 8080 -sV localhost -oN /home/labex/project/version_scan.txt

    En este comando, la opción -sV le dice a Nmap que explore los puertos abiertos. Al hacer esto, Nmap puede recopilar información sobre los servicios que se ejecutan en esos puertos, incluyendo sus versiones. La opción -oN se utiliza para guardar la salida del escaneo en un formato normal en el archivo especificado /home/labex/project/version_scan.txt. Guardar la salida en un archivo te permite revisar los resultados más tarde.

  2. Visualiza los resultados del escaneo:

    cat /home/labex/project/version_scan.txt

    Después de ejecutar el comando cat, deberías ver una salida similar a esta:

    Starting Nmap 7.80 ( https://nmap.org ) at 2023-11-08 13:20:00 UTC
    Nmap scan report for localhost (127.0.0.1)
    Host is up (0.000097s latency).
    
    PORT     STATE SERVICE VERSION
    8080/tcp open  http    Python/3.10 aiohttp/3.8.1 (Python httpd)
    
    Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
    Nmap done: 1 IP address (1 host up) scanned in 6.52 seconds

    Observa que Nmap ahora muestra no solo el nombre del servicio, sino también información de la versión. En este caso, detectó que el servidor HTTP se está ejecutando con Python 3.10. Esta información detallada se puede utilizar para identificar posibles riesgos de seguridad o para entender las capacidades del servicio.

Uso de scripts de Nmap (NSE)

El Motor de Scripts de Nmap (Nmap Script Engine, NSE) es una herramienta poderosa que te permite ejecutar scripts para realizar diversas tareas. Estas tareas van desde la detección de servicios hasta el escaneo de vulnerabilidades. Al utilizar scripts NSE, puedes extender la funcionalidad de Nmap y recopilar más información sobre la red objetivo.

  1. Ejecuta un script básico de información HTTP en tu servidor web:

    nmap -p 8080 --script=http-title localhost -oN /home/labex/project/script_scan.txt

    El script http-title está diseñado para obtener el título de las páginas web HTTP. Esto puede ser útil para identificar rápidamente el contenido o el propósito de una página web. La opción -oN guarda la salida del escaneo del script en un formato normal en el archivo especificado /home/labex/project/script_scan.txt.

  2. Visualiza los resultados del escaneo del script:

    cat /home/labex/project/script_scan.txt

    La salida debería incluir algo como:

    Starting Nmap 7.80 ( https://nmap.org ) at 2023-11-08 13:25:00 UTC
    Nmap scan report for localhost (127.0.0.1)
    Host is up (0.000097s latency).
    
    PORT     STATE SERVICE
    8080/tcp open  http-proxy
    |_http-title: Directory listing for /
    
    Nmap done: 1 IP address (1 host up) scanned in 0.42 seconds

    El script http-title recuperó el título de la página web, que en este caso es una lista de directorios. Esta información puede ayudarte a entender la estructura y el contenido del servidor web.

  3. Intentemos otro script que proporcione más información sobre el servidor HTTP:

    nmap -p 8080 --script=http-server-header localhost -oN /home/labex/project/server_header_scan.txt

    El script http-server-header se utiliza para recuperar el encabezado del servidor HTTP. El encabezado del servidor a menudo contiene información sobre el software del servidor, como la versión y el tipo. Esta información puede ser valiosa para evaluaciones de seguridad e inventarios de red. La opción -oN guarda la salida del escaneo en un formato normal en el archivo especificado /home/labex/project/server_header_scan.txt.

  4. Visualiza los resultados del escaneo del encabezado del servidor:

    cat /home/labex/project/server_header_scan.txt

    La salida debería incluir información sobre el software del servidor:

    Starting Nmap 7.80 ( https://nmap.org ) at 2023-11-08 13:30:00 UTC
    Nmap scan report for localhost (127.0.0.1)
    Host is up (0.000097s latency).
    
    PORT     STATE SERVICE
    8080/tcp open  http-proxy
    |_http-server-header: SimpleHTTP/0.6 Python/3.10.12
    
    Nmap done: 1 IP address (1 host up) scanned in 0.13 seconds

Combinación de múltiples técnicas

Puedes combinar múltiples técnicas de escaneo en un solo comando de Nmap para realizar un escaneo más completo. Esto te permite recopilar una amplia gama de información sobre la red objetivo de una sola vez.

  1. Ejecuta un escaneo completo que incluya escaneo de puertos, detección de versiones de servicios y escaneo con scripts:

    nmap -p 8080 -sV --script=http-title,http-server-header localhost -oA /home/labex/project/comprehensive_scan

    Este comando hace varias cosas:

    • Escanea el puerto 8080 (-p 8080), lo que significa que comprueba si este puerto está abierto en el host objetivo.
    • Detecta las versiones de los servicios (-sV), proporcionando información sobre las versiones específicas de los servicios que se ejecutan en el puerto.
    • Ejecuta los scripts http-title y http-server-header (--script=http-title,http-server-header), que recuperan el título de la página web y la información del encabezado del servidor respectivamente.
    • Guarda los resultados en todos los formatos (-oA). Guardar en todos los formatos asegura que tienes diferentes representaciones de los resultados del escaneo para diferentes fines.
  2. Visualiza los resultados del escaneo completo:

    cat /home/labex/project/comprehensive_scan.nmap

    La salida incluirá toda la información de los escaneos anteriores combinados. Esto te da una visión holística del servicio de red objetivo que se ejecuta en el puerto 8080.

  3. Crea un informe de análisis final que resuma todos tus hallazgos:

    echo "Final Nmap Analysis Report" > /home/labex/project/final_report.txt
    echo "------------------------" >> /home/labex/project/final_report.txt
    echo "Target: localhost (127.0.0.1)" >> /home/labex/project/final_report.txt
    echo "Port: 8080/tcp (open)" >> /home/labex/project/final_report.txt
    echo "Service:" >> /home/labex/project/final_report.txt
    grep "SERVICE VERSION" -A1 /home/labex/project/version_scan.txt | tail -1 >> /home/labex/project/final_report.txt
    echo "HTTP Server Header:" >> /home/labex/project/final_report.txt
    grep "http-server-header:" /home/labex/project/server_header_scan.txt >> /home/labex/project/final_report.txt
    echo "HTTP Page Title:" >> /home/labex/project/final_report.txt
    grep "http-title:" /home/labex/project/script_scan.txt >> /home/labex/project/final_report.txt

    Este conjunto de comandos crea un archivo de texto llamado final_report.txt y lo llena con un resumen de toda la información recopilada de los escaneos anteriores. Incluye detalles sobre el objetivo, el puerto, la versión del servicio, el encabezado del servidor y el título de la página web.

  4. Visualiza tu informe final:

    cat /home/labex/project/final_report.txt

    Tu informe final debería contener un resumen completo de toda la información que has recopilado sobre el servidor web que se ejecuta en el puerto 8080. Este informe se puede utilizar para análisis adicionales, evaluaciones de seguridad o fines de documentación.

Al aprender estas técnicas avanzadas de escaneo con Nmap, puedes recopilar información detallada sobre los servicios de red que es valiosa para evaluaciones de seguridad, inventarios de red y resolución de problemas.

Resumen

En este laboratorio, has aprendido cómo utilizar Nmap, una poderosa herramienta de escaneo de red para la detección de redes y la auditoría de seguridad. Has adquirido experiencia práctica en diversas operaciones de Nmap, incluyendo la configuración de un entorno de prueba con un servidor web local, la realización de escaneos básicos de puertos, la exploración de diferentes formatos de salida, la extracción y el análisis de los resultados del escaneo, y el uso de técnicas avanzadas como la detección de versiones de servicios y el escaneo con scripts.

Estas habilidades son esenciales para administradores de red, analistas de seguridad y probadores de penetración. Te permiten descubrir hosts y servicios de red, documentar la infraestructura de red, identificar problemas de seguridad y automatizar el escaneo y la generación de informes. Dominar Nmap y sus formatos de salida permite realizar un reconocimiento de red efectivo, integrar con otras herramientas de seguridad y construir inventarios de red completos. Las habilidades de línea de comandos que has practicado también son transferibles a otras tareas de administración de sistemas y seguridad.