Introducción
Al realizar pruebas de penetración o evaluaciones de seguridad de red, ejecutar escaneos es solo la mitad del trabajo. Documentar y guardar correctamente los resultados es crucial para generar informes, realizar un seguimiento del progreso y alimentar de datos a otras herramientas de seguridad.
La elección del formato de salida afecta lo que puedes hacer posteriormente con los resultados. La salida legible por humanos es ideal para una revisión rápida, mientras que la salida estructurada es mejor para la automatización. Los flujos de trabajo profesionales suelen conservar ambos.
Nmap, el estándar de la industria para el mapeo de redes, ofrece varios formatos de salida para satisfacer diferentes necesidades. Los tres más comunes son Normal (legible por humanos), Grepable (diseñado para el análisis desde la línea de comandos) y XML (datos estructurados para importar en otro software).
En este laboratorio, aprenderás a generar estos tres formatos de salida y a utilizar herramientas básicas de la línea de comandos de Linux para analizar los resultados y extraer información valiosa.
Salida en formato Normal (-oN)
En este paso, aprenderás a guardar los resultados de un escaneo de Nmap en formato Normal. Este formato es esencialmente una copia directa de lo que ves en la pantalla de tu terminal al ejecutar un escaneo. Es altamente legible y perfecto para revisar resultados rápidamente o compartirlos con colegas en un documento de texto.
Este formato está optimizado para personas, no para procesos automatizados. Es la elección correcta cuando el consumidor inmediato es un analista humano que lee el escaneo como un informe.
Para guardar los resultados en formato Normal, utiliza el parámetro -oN seguido del nombre del archivo que deseas crear. Escanearemos nuestra máquina local (127.0.0.1) para descubrir puertos abiertos y guardar la salida.
Ejecuta el siguiente comando en tu terminal para realizar el escaneo y guardarlo como normal_scan.txt:
nmap -p 22,8080 -oN normal_scan.txt 127.0.0.1
Una vez finalizado el escaneo, puedes ver el contenido del archivo usando el comando cat. Esto mostrará exactamente la misma salida que se imprimió en tu pantalla durante el escaneo.
cat normal_scan.txt
Deberías ver una salida similar a esta, que muestra los puertos abiertos y sus servicios asociados:
## Nmap 7.80 scan initiated Sat Mar 7 16:07:07 2026 as: nmap -p 22,8080 -oN normal_scan.txt 127.0.0.1
Nmap scan report for localhost (127.0.0.1)
Host is up (0.000057s latency).
PORT STATE SERVICE
22/tcp open ssh
8080/tcp open http-proxy
## Nmap done at Sat Mar 7 16:07:07 2026 -- 1 IP address (1 host up) scanned in 0.02 seconds
Salida en formato Grepable (-oG)
En este paso, explorarás el formato de salida Grepable. Aunque el formato Normal es excelente para la vista humana, es difícil de procesar mediante programación porque la información abarca varias líneas. El formato Grepable resuelve esto colocando toda la información de un solo host en una única línea larga.
Aplanar los datos de esta manera hace que el análisis basado en la shell sea práctico. Es un ejemplo clásico de cómo adaptar la salida para herramientas posteriores en lugar de para la comodidad de lectura directa.
Este formato está diseñado específicamente para ser utilizado con herramientas de línea de comandos de Linux como grep, awk y cut. Para generar una salida Grepable, utiliza el parámetro -oG.
Ejecuta el siguiente comando para realizar el mismo escaneo, pero esta vez guarda los resultados en formato Grepable como grepable_scan.txt:
nmap -p 22,8080 -oG grepable_scan.txt 127.0.0.1
Ahora, visualiza el contenido del archivo recién creado:
cat grepable_scan.txt
La salida se verá bastante diferente al formato Normal. Observa cómo la información del host y todos sus puertos abiertos están condensados en una sola línea:
## Nmap 7.80 scan initiated Sat Mar 7 16:07:20 2026 as: nmap -p 22,8080 -oG grepable_scan.txt 127.0.0.1
Host: 127.0.0.1 (localhost) Status: Up
Host: 127.0.0.1 (localhost) Ports: 22/open/tcp//ssh///, 8080/open/tcp//http-proxy///
## Nmap done at Sat Mar 7 16:07:20 2026 -- 1 IP address (1 host up) scanned in 0.02 seconds
Esta estructura hace que sea increíblemente fácil buscar palabras clave específicas, como "open", y extraer las direcciones IP correspondientes, lo cual practicarás en un paso posterior.
Salida en formato XML (-oX)
En este paso, aprenderás a generar una salida XML. XML (eXtensible Markup Language) es un formato altamente estructurado que es ampliamente compatible con muchas aplicaciones de software diferentes.
La salida estructurada legible por máquina se vuelve más importante a medida que las evaluaciones escalan. Una vez que los resultados de tus escaneos deben integrarse en otras herramientas, el análisis de texto ad hoc se vuelve frágil y costoso de mantener.
En el contexto de las pruebas de penetración, XML es el formato preferido cuando necesitas importar los resultados de tus escaneos de Nmap en otras herramientas de seguridad, como Metasploit Framework, escáneres de vulnerabilidades o scripts de informes personalizados. Para crear un archivo de salida XML, utiliza el parámetro -oX.
Ejecuta el siguiente comando para realizar el escaneo y guardar los resultados como xml_scan.xml:
nmap -p 22,8080 -oX xml_scan.xml 127.0.0.1
Puedes inspeccionar el contenido del archivo XML usando el comando cat:
cat xml_scan.xml
La salida será un bloque grande de etiquetas XML estructuradas. Aunque no es muy fácil de leer rápidamente para los humanos, está perfectamente formateado para que las máquinas lo analicen:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE nmaprun>
<?xml-stylesheet href="file:///usr/bin/../share/nmap/nmap.xsl" type="text/xsl"?>
<!-- Nmap 7.80 scan initiated Sat Mar 7 16:07:30 2026 as: nmap -p 22,8080 -oX xml_scan.xml 127.0.0.1 -->
<nmaprun scanner="nmap" args="nmap -p 22,8080 -oX xml_scan.xml 127.0.0.1" start="1772870850" startstr="Sat Mar 7 16:07:30 2026" version="7.80" xmloutputversion="1.04">
...
<host starttime="1772870850" endtime="1772870850"><status state="up" reason="conn-refused" reason_ttl="0"/>
<address addr="127.0.0.1" addrtype="ipv4"/>
<hostnames>
<hostname name="localhost" type="PTR"/>
</hostnames>
<ports><port protocol="tcp" portid="22"><state state="open" reason="syn-ack" reason_ttl="0"/><service name="ssh" method="table" conf="3"/></port>
...
Analizar la salida Grepable con Awk
En este paso final, pondrás en práctica el formato de salida Grepable. Un escenario común en las pruebas de penetración es escanear una red grande, encontrar hosts con puertos abiertos específicos y luego extraer solo las direcciones IP de esos hosts para enviarlas a otra herramienta (como un crackeador de contraseñas o un exploit de vulnerabilidades).
Utilizaremos dos potentes herramientas de procesamiento de texto de Linux: grep y awk. El comando grep filtra las líneas que contienen una palabra específica, y awk puede extraer columnas específicas de esas líneas.
Primero, veamos cómo podemos filtrar nuestro archivo Grepable para mostrar solo las líneas que contienen la palabra "open":
grep "open" grepable_scan.txt
Este comando muestra la línea que contiene el host y sus puertos abiertos.
Host: 127.0.0.1 (localhost) Ports: 22/open/tcp//ssh///, 8080/open/tcp//http-proxy///
Ahora, queremos extraer solo la dirección IP. En el formato Grepable, la dirección IP es siempre la segunda "palabra" (o columna) de la línea. Podemos usar una tubería (|) para enviar la salida de grep a awk y decirle que imprima la segunda columna ($2).
Ejecuta el siguiente comando para extraer la dirección IP y guardarla en un nuevo archivo llamado open_hosts.txt:
grep "open" grepable_scan.txt | awk '{print $2}' > open_hosts.txt
Verifiquemos el contenido de nuestro nuevo archivo:
cat open_hosts.txt
Deberías ver solo la dirección IP impresa:
127.0.0.1
Al dominar esta sencilla combinación de comandos, podrás analizar rápidamente archivos de escaneo masivos y extraer exactamente los objetivos que necesitas para la siguiente fase de tu evaluación.
Resumen
En este laboratorio, aprendiste a documentar y gestionar eficazmente los resultados de los escaneos de Nmap utilizando diferentes formatos de salida. Exploraste el formato Normal (-oN) para la legibilidad humana, el formato Grepable (-oG) para el análisis desde la línea de comandos y el formato XML (-oX) para la integración con otras herramientas. Finalmente, practicaste el uso de utilidades de procesamiento de texto de Linux como grep y awk para extraer información específica de los objetivos a partir de archivos de salida Grepable. Estas habilidades son esenciales para organizar datos y optimizar los flujos de trabajo durante las evaluaciones de seguridad.
