Nmap: Maestría en Escaneo de Redes

Técnicas Avanzadas de Reconocimiento y Evasión

---

Autor: ViciousByte Security Team Nivel: Intermedio Duración: 8-10 horas de lectura práctica Versión: 1.0 Última actualización: June 2026

---

Lo que vas a dominar

Una guía práctica y densa sobre Nmap: Maestría en Escaneo de Redes, de nivel Intermedio, con Nmap, NSE, Zenmap, Masscan, Zmap.

• Instalación y configuración profesional (Linux, Windows, macOS y Docker)
• Comandos y flujos de trabajo del mundo real, explicados línea por línea
• Casos prácticos y troubleshooting con soluciones probadas
• Scripts y plantillas listos para usar

Duración: 8-10 horas de lectura práctica · Nivel: Intermedio

---

Nmap: Maestría en Escaneo de Redes — Guía Premium 2025

Introducción

---

1. Bienvenida y Contexto

En 2025, el perímetro de seguridad se ha disuelto. La nube híbrida, el trabajo remoto masivo, los entornos OT/ICS convergiendo con IT y la explosión de dispositivos IoT han multiplicado la superficie de ataque por un factor de 10x respecto a 2020. En este paisaje, Nmap no es una herramienta más: es el cimiento sobre el que se construye toda estrategia de visibilidad de red. Sin un inventario preciso de activos, puertos expuestos y servicios en ejecución, cualquier programa de seguridad opera a ciegas.

Las cifras no mienten: según el informe 2024 Attack Surface Threat Report de Palo Alto Networks, el 73% de las brechas comienzan con un activo desconocido o mal catalogado. El SANS 2025 SOC Survey revela que el 68% de los analistas SOC utilizan Nmap diariamente como primera herramienta de triaje. No es casualidad: Nmap ha evolucionado desde un simple escáner de puertos a un framework de reconocimiento completo con motor de scripting (NSE), detección de servicios por fingerprinting, evasión de firewalls y capacidades de escaneo a escala de Internet con Masscan y Zmap.

Esta guía nace de 15 años de experiencia real en pentesting, respuesta a incidentes y hardening de infraestructura crítica. Cada comando que encontrarás aquí ha sido ejecutado en entornos de producción, cada script NSE ha sido depurado contra falsos positivos, y cada técnica de evasión ha sido validada contra firewalls reales (Palo Alto, Fortinet, Cisco ASA, iptables). No es teoría: es conocimiento de trinchera.

Tendencias actuales que hacen Nmap indispensable en 2025:

• Escaneo de APIs y microservicios: con la proliferación de Kubernetes y Docker, los puertos efímeros y servicios REST sin documentar son el nuevo vector de ataque. Nmap con scripts http-* es la primera línea de defensa.
• Detección de vulnerabilidades sin agente: NSE permite validar CVEs sin desplegar agentes pesados, ideal para entornos air-gapped o industriales.
• Integración en pipelines DevSecOps: Nmap en modo XML (-oX) alimenta sistemas de gestión de vulnerabilidades como DefectDojo, Archery o Faraday.
• Escaneo de IPv6 masivo: la adopción de IPv6 ha superado el 45% global; Nmap es la herramienta más madura para descubrimiento en este espacio.

---

2. ¿Para Quién es Esta Guía?

Esta guía está diseñada para el profesional técnico que ya ha ejecutado nmap -sS pero quiere dominar el arte del escaneo a nivel experto. No es un tutorial para principiantes absolutos; asumo que conoces el modelo OSI, la diferencia entre TCP y UDP, y has usado alguna vez Wireshark.

Perfil del lector ideal:

• Pentester junior o mid-level que quiere llevar sus reconocimientos al siguiente nivel.
• Analista SOC/CSIRT que necesita extraer inteligencia accionable de escaneos masivos.
• Administrador de sistemas o redes responsable de hardening y auditoría interna.
• Estudiante de ciberseguridad preparando certificaciones como OSCP, eCPPTv3, PNPT o GPEN.
• Ingeniero DevSecOps que integra escaneo en CI/CD.

Prerrequisitos técnicos:

• Conocimiento sólido de TCP/IP, flags TCP, handshake de tres vías.
• Familiaridad con línea de comandos Linux/Windows.
• Conceptos básicos de firewalls, IDS/IPS y segmentación de red.
• Idealmente, haber ejecutado escaneos básicos con Nmap.

Qué aprenderás exactamente:

• Técnicas avanzadas de escaneo: SYN stealth, idle scan, fragmentación, decoys, spoofing.
• Dominio completo del Nmap Scripting Engine (NSE): más de 30 scripts analizados línea por línea.
• Evasión de firewalls y sistemas de detección en 12 escenarios reales.
• Automatización con Python y Bash para escaneos masivos y parsing de resultados.
• Integración con Metasploit, Nessus, Burp Suite y ELK Stack.
• Troubleshooting de falsos positivos, hosts que no responden y escaneos bloqueados.

---

3. Qué Hace Diferente a Esta Guía

El mercado está saturado de tutoriales que repiten el manual de Nmap. Esta guía es radicalmente distinta porque está escrita desde la experiencia de campo, no desde la documentación.

Enfoque práctico vs teórico: Cada capítulo incluye un laboratorio real. No te digo "puedes usar --script vuln"; te muestro un escaneo completo contra un entorno vulnerable (Metasploitable 3, DVWA, VulnHub) con el output real, los falsos positivos encontrados y cómo validarlos manualmente. Aprenderás a distinguir un puerto realmente abierto de un reset de firewall, a interpretar respuestas ICMP tipo 3 código 13, y a leer fingerprints de servicio como un forense digital.

Ejemplos reales del mundo laboral:

• Escaneo pre-engagement para un pentest externo contra una entidad financiera (con autorización).
• Mapeo de una red OT Modbus/TCP en una planta de tratamiento de agua.
• Descubrimiento de shadow IT en una red corporativa con 50,000 hosts.
• Análisis post-breach: cómo encontrar el C2 del adversario usando escaneo de puertos efímeros.

Scripts y comandos listos para usar: Cada comando está completo, con todos los parámetros explicados. No hay placeholders. Por ejemplo:

nmap -sS -p 1-65535 -T4 -A -v --script "default,safe,vuln" --script-args "http.useragent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',smbdomain=LAB,smbusername=guest,smbpassword=''" -oA full_scan_target 192.168.1.0/24

Te explico por qué -T4 y no -T5, por qué -A incluye OS detection y traceroute, y cómo los argumentos de script evitan bloqueos por WAF.

Troubleshooting de problemas comunes: He compilado 50+ errores reales que he encontrado en consultoría: "Host seems down", "filtered ports", "Nmap hangs on UDP scan", "NSE script crashes", "XML output malformed". Cada uno con diagnóstico, causa raíz y solución probada.

---

4. Estructura de la Guía

La guía sigue una progresión lógica desde los fundamentos hasta la automatización avanzada, con 8 capítulos densos:

1. Fundamentos y Técnicas de Escaneo: TCP flags, tipos de escaneo (SYN, TCP Connect, ACK, Window, Maimon, UDP), timing templates, fragmentación y MTU.
2. Detección de Servicios y OS Fingerprinting: Cómo funciona el motor de fingerprints, personalización de probes, detección de servicios en puertos no estándar.
3. Nmap Scripting Engine (NSE) en Profundidad: Anatomía de un script .nse, categorías, desarrollo de scripts propios en Lua, depuración.
4. Evasión de Firewalls, IDS/IPS y WAF: Decoys, source port spoofing, idle scan, fragmentación, MAC spoofing, proxies SOCKS, escaneo a través de VPN.
5. Escaneo de Redes Especiales: IPv6, entornos cloud (AWS, Azure, GCP), redes industriales (Modbus, DNP3, BACnet), contenedores Docker/K8s.
6. Automatización y Scripting: Python-Nmap, Bash loops, parsing XML/JSON, integración con ELK, generación de reportes ejecutivos.
7. Casos de Uso Profesionales: Pentest externo, auditoría interna, respuesta a incidentes, asset discovery, validación de segmentación PCI-DSS.
8. Troubleshooting y Referencia Rápida: Solución de errores comunes, cheat sheet de comandos, tabla de scripts NSE por categoría.

Metodología de aprendizaje: Cada capítulo incluye: teoría mínima necesaria → laboratorio práctico → ejercicios de consolidación → troubleshooting específico. Al final de cada capítulo, un "Desafío del Capítulo" te pone en un escenario realista que debes resolver con las técnicas aprendidas.

Cómo aprovechar al máximo el contenido:

• Ejecuta cada comando en tu laboratorio (proporciono instrucciones para montar entornos con VirtualBox/Docker).
• No copies y pegues: escribe los comandos para desarrollar memoria muscular.
• Resuelve los desafíos sin mirar la solución hasta haberlo intentado durante al menos 30 minutos.
• Únete a la comunidad de Discord (invitación al final de la guía) para discutir dudas y compartir hallazgos.

---

5. Disclaimer Legal y Ético

Esta guía es una herramienta educativa para profesionales de la ciberseguridad. Todo el conocimiento aquí contenido debe utilizarse exclusivamente en entornos sobre los que tengas autorización explícita por escrito para realizar pruebas de penetración, auditorías de seguridad o actividades de hardening.

El uso no autorizado de técnicas de escaneo contra sistemas de terceros puede constituir un delito en la mayoría de jurisdicciones, incluyendo pero no limitado a:

• Violación de la Computer Fraud and Abuse Act (CFAA) en EE.UU. (18 U.S.C. § 1030)
• Delitos informáticos tipificados en el Código Penal español (arts. 197-198, 264-264 ter)
• Leyes de protección de datos y privacidad (GDPR, LOPDGDD)
• Regulaciones sectoriales (PCI-DSS, HIPAA, NERC CIP)

Principios éticos que debes seguir:

1. Autorización previa: Nunca escanees una red o sistema sin un contrato firmado o una política de la organización que lo permita explícitamente.
2. Alcance definido: Limita tus pruebas a los activos, puertos y horarios acordados. Un escaneo agresivo puede tumbar servicios de producción.
3. Minimización de impacto: Usa timing templates conservadores (-T2, -T3) en entornos sensibles. Evita escaneos UDP masivos o scripts intrusivos sin coordinación previa.
4. Confidencialidad: Los resultados de un escaneo revelan la topología y vulnerabilidades de una organización. Trátalos como material clasificado.
5. Responsabilidad profesional: Si encuentras una vulnerabilidad crítica, repórtala por el canal acordado. No la explotes sin autorización adicional.

El autor y el editor no asumen ninguna responsabilidad por el uso indebido de la información contenida en esta guía. El conocimiento es poder, y con poder viene responsabilidad. Si usas estas técnicas para actividades no autorizadas, las consecuencias legales y profesionales serán exclusivamente tuyas.

---

6. Certificaciones y Carrera

Dominar Nmap al nivel que propone esta guía te posiciona para certificaciones de élite y roles de alta demanda. El mercado de ciberseguridad en 2025 tiene un déficit de 3.5 millones de profesionales (según (ISC)²), y el reconocimiento de redes es una habilidad transversal a todas las especialidades.

Certificaciones donde Nmap es critical: | Certificación | Entidad | Relevancia de Nmap | |---------------|---------|-------------------| | OSCP | OffSec | El 40% del examen depende de reconocimiento con Nmap y scripts NSE | | eCPPTv3 | eLearnSecurity | Escaneo avanzado, pivoting y tunneling requieren Nmap a fondo | | PNPT | TCM Security | El examen práctico exige escaneo externo e interno con evasión | | GPEN | SANS GIAC | Módulo completo de escaneo y enumeración con Nmap | | CEH Practical | EC-Council | 20% del examen práctico involucra Nmap | | CISSP | (ISC)² | Dominio 4 (Communication and Network Security) requiere comprensión de escaneo |

Oportunidades laborales y salarios (2025, España/LATAM):

• Pentester Junior: €35,000 – €45,000 (España) / $25,000 – $35,000 USD (LATAM)
• Pentester Senior: €55,000 – €75,000 / $45,000 – $65,000 USD
• Red Team Operator: €70,000 – €90,000 / $55,000 – $80,000 USD
• Security Engineer (Offensive): €60,000 – €85,000 / $50,000 – $75,000 USD
• SOC Analyst L2/L3: €40,000 – €60,000 / $30,000 – $50,000 USD

Roadmap profesional con Nmap como base:

1. Fase 1 (0-2 años): Domina escaneo básico y NSE → Consigue OSCP o eCPPTv3 → Entra como pentester junior.
2. Fase 2 (2-5 años): Especialízate en evasión y escaneo de entornos complejos (cloud, OT) → Certifícate como GPEN o PNPT → Asciende a pentester senior.
3. Fase 3 (5+ años): Desarrolla tus propios scripts NSE, contribuye a la comunidad, integra Nmap en frameworks de red teaming → Transiciona a Red Team Operator o Security Architect.

Esta guía es tu acelerador para la Fase 1 y tu referencia permanente para las Fases 2 y 3. No es un PDF que leerás una vez y archivarás: es un manual de combate que tendrás abierto en tu terminal durante los próximos 10 años.

---

¿Listo para dominar el arte del escaneo? Abre tu terminal, levanta tu laboratorio y sumérgete en el Capítulo 1. El camino a la maestría comienza con un solo paquete SYN.

---

Nmap: Maestría en Escaneo de Redes — Guía Premium 2025

Capítulo 1: Fundamentos y Setup Profesional

---

1.1 ¿Qué es Nmap?

Definición técnica completa

Nmap (Network Mapper) es una herramienta de código abierto para exploración de redes y auditoría de seguridad. Fue creada por Gordon Lyon (Fyodor) en 1997 y se ha convertido en el estándar de facto para el descubrimiento de hosts, servicios, sistemas operativos y vulnerabilidades en redes TCP/IP. Nmap utiliza paquetes IP crudos en formas innovadoras para determinar qué hosts están disponibles en la red, qué servicios (nombre y versión de la aplicación) ofrecen, qué sistemas operativos (y versiones) ejecutan, qué tipo de filtros de paquetes/firewalls están en uso, y docenas de otras características.

Historia y evolución

• 1997: Primera publicación en Phrack Magazine (artículo "The Art of Port Scanning").
• 1998: Versión 2.0 con escaneo de SO y scripts básicos.
• 2004: Nmap 3.70 introduce el motor de scripting NSE (Nmap Scripting Engine).
• 2009: Nmap 5.00 con soporte para IPv6, mejoras en NSE y detección de servicios.
• 2015: Nmap 7.00 con más de 500 scripts NSE, escaneo de topología y mejoras de rendimiento.
• 2025: Nmap 7.95+ con más de 600 scripts, integración con Zeek/Bro, soporte para TLS 1.3 fingerprinting y escaneo de contenedores.

Casos de uso reales en empresas

• Pentesting: Identificación de superficie de ataque, enumeración de servicios vulnerables.
• Gestión de activos: Inventario automatizado de dispositivos conectados a la red corporativa.
• Cumplimiento normativo: Verificación de puertos abiertos no autorizados (PCI-DSS, ISO 27001).
• Respuesta a incidentes: Mapeo rápido de la red comprometida para identificar movimientos laterales.
• DevSecOps: Integración en pipelines CI/CD para validar exposición de puertos en contenedores.

Comparación con alternativas

| Herramienta | Licencia | Escaneo de SO | Scripting | Velocidad | Curva de aprendizaje | |-------------|----------|---------------|-----------|----------|----------------------| | Nmap | GPLv2 | Sí (fingerprinting avanzado) | NSE (Lua) | Alta (paralelismo) | Media | | Masscan | AGPLv3 | No | No | Extrema (10M pps) | Baja | | Zmap | Apache 2.0 | No | No | Alta (escaneo Internet) | Baja | | RustScan | MIT | No | No | Muy alta | Baja | | Angry IP Scanner | GPLv2 | No | No | Media | Muy baja | | Netcat | GPLv2 | No | No | Baja | Baja |

Ventajas y limitaciones

Ventajas:

• Motor NSE con más de 600 scripts para detección de vulnerabilidades, enumeración de usuarios, fuerza bruta, etc.
• Fingerprinting de SO extremadamente preciso (base de datos con más de 3000 firmas).
• Evasión de firewalls/IDS mediante fragmentación, decoys, timing y spoofing.
• Salida en múltiples formatos: texto, XML, grepable, JSON.
• Integración con Metasploit, Nessus, Burp Suite y herramientas SIEM.

Limitaciones:

• No es un escáner de vulnerabilidades completo (requiere complementos como Vulners NSE).
• El escaneo UDP es inherentemente lento debido a la falta de confirmación.
• En redes muy grandes (>100k hosts), Masscan o Zmap son más eficientes para descubrimiento inicial.
• La detección de SO puede fallar contra sistemas altamente customizados o con stacks TCP/IP modificados.

---

1.2 Arquitectura y Componentes

Arquitectura interna

Nmap está diseñado con una arquitectura modular en C++ que separa el motor de escaneo, la generación de paquetes, el análisis de respuestas y la interfaz de usuario. El núcleo es nmap.cc, que orquesta las fases de escaneo. La generación de paquetes crudos se realiza mediante libdnet (manipulación de interfaces de red) y libpcap (captura de respuestas). El motor NSE se ejecuta en un intérprete Lua embebido que carga scripts desde /usr/share/nmap/scripts/.

Componentes principales

1. Motor de escaneo de puertos (scan_engine.cc): Implementa técnicas SYN, TCP connect, UDP, ACK, Window, Maimon, etc. Maneja paralelismo, temporización y reintentos.
2. Motor de detección de SO (osscan2.cc): Envía hasta 16 sondas TCP/UDP/ICMP y compara respuestas con nmap-os-db.
3. Motor de detección de servicios (service_scan.cc): Envía sondas de protocolo (NULL, GenericLines, GetRequest, etc.) y analiza banners con expresiones regulares de nmap-service-probes.
4. Motor NSE (nse_main.cc): Carga, ejecuta y gestiona scripts Lua con reglas de puerto/host.
5. Generación de paquetes (tcpip.cc): Construye paquetes Ethernet/IP/TCP/UDP/ICMP crudos usando libdnet.
6. Captura de respuestas (tcpip.cc): Utiliza libpcap con filtros BPF para recibir solo paquetes relevantes.
7. Interfaz de usuario (nmap.cc, output.cc): Formatea salida en texto, XML, grepable y normal.

Dependencias y librerías

• libpcap: Captura de paquetes (requerida).
• libdnet (dumbnet): Envío de paquetes crudos a nivel 2/3 (requerida).
• OpenSSL: Para escaneo SSL/TLS y scripts NSE que usan cifrado.
• Lua 5.3: Intérprete para NSE.
• libssh2: Para scripts NSE de SSH.
• zlib: Compresión en transferencia de archivos NSE.

Flujo de trabajo típico

1. Resolución DNS (opcional) → 2. Descubrimiento de hosts (ping scan) → 3. Escaneo de puertos (SYN/connect/UDP) → 4. Detección de servicios y versiones → 5. Detección de SO → 6. Ejecución de scripts NSE → 7. Generación de reportes

Diagrama ASCII de arquitectura

+-------------------+ +------------------+ +-------------------+
| Interfaz de línea | --> | Motor de escaneo | --> | Generación de |
| de comandos | | (nmap.cc) | | paquetes (tcpip) |
+-------------------+ +------------------+ +-------------------+
| |
v v
+------------------+ +-------------------+
| Motor de detección| | libdnet (envío) |
| de SO (osscan2) | | libpcap (captura) |
+------------------+ +-------------------+
|
v
+------------------+
| Motor NSE (Lua) |
+------------------+

---

1.3 Instalación Paso a Paso

REQUISITOS DEL SISTEMA

• Hardware mínimo: CPU 1 GHz, 512 MB RAM, 1 GB disco. Recomendado: CPU multi-core, 2 GB RAM para escaneos masivos.
• Sistema operativo: Linux (cualquier distribución), Windows 10/11, macOS 11+, FreeBSD, Solaris.
• Dependencias previas: gcc, make, libpcap-dev, libdnet-dev, openssl, lua5.3.

---

Linux (Ubuntu/Debian)

Instalación desde repositorios oficiales (recomendada)

## Actualizar índices de paquetes
sudo apt update

## Instalar Nmap y herramientas complementarias
sudo apt install -y nmap ncat ndiff

## Verificar versión instalada
nmap --version
## Output esperado: Nmap version 7.94 ( https://nmap.org )

Compilación desde código fuente (última versión)

## Instalar dependencias de compilación
sudo apt install -y build-essential libssl-dev libpcap-dev libdnet-dev lua5.3 liblua5.3-dev

## Descargar fuente oficial
cd /tmp
wget https://nmap.org/dist/nmap-7.95.tar.bz2
tar xjf nmap-7.95.tar.bz2
cd nmap-7.95

## Configurar, compilar e instalar
./configure --with-libdnet=included --with-libpcap=included --with-libpcre=included
make -j$(nproc)
sudo make install

## Verificar
nmap --version

Resolución de dependencias faltantes

## Si ./configure falla por libpcap:
sudo apt install libpcap0.8-dev

## Si falla por OpenSSL:
sudo apt install libssl-dev

## Si falla por Lua:
sudo apt install liblua5.3-dev lua5.3

Post-instalación y paths

• Binario principal: /usr/local/bin/nmap (compilado) o /usr/bin/nmap (paquete).
• Scripts NSE: /usr/local/share/nmap/scripts/ o /usr/share/nmap/scripts/.
• Base de datos de SO: /usr/local/share/nmap/nmap-os-db.
• Actualizar scripts NSE: sudo nmap --script-updatedb.

---

Linux (RedHat/CentOS/Rocky)

## Instalar EPEL (si no está habilitado)
sudo dnf install -y epel-release

## Instalar Nmap desde repositorios
sudo dnf install -y nmap

## Para compilar desde fuente (mismos pasos que Debian, pero con dnf)
sudo dnf groupinstall -y "Development Tools"
sudo dnf install -y libpcap-devel libdnet-devel openssl-devel lua-devel
## Luego seguir pasos de compilación igual que Debian

---

Windows

Descarga oficial: https://nmap.org/dist/nmap-7.95-setup.exe

Instalación paso a paso

1. Ejecutar el instalador como Administrador.
2. Aceptar licencia GPLv2.
3. Seleccionar componentes: marcar Nmap, Ncat, Ndiff, Zenmap (GUI opcional).
4. ¡Importante! Marcar la casilla "Install Npcap" (driver de captura de paquetes). Sin Npcap, Nmap no puede realizar escaneos SYN ni detección de SO.
5. En la instalación de Npcap, seleccionar:

• "Support raw 802.11 traffic" si se necesita escaneo WiFi.
• "Install Npcap in WinPcap API-compatible Mode" para compatibilidad con Wireshark.

6. Finalizar instalación.

Variables de entorno

El instalador agrega automáticamente C:\Program Files (x86)\Nmap al PATH. Verificar:

## PowerShell como Admin
$env:Path -split ';' | Select-String "Nmap"
## Debe mostrar la ruta de instalación

## Si no aparece, agregar manualmente:
[Environment]::SetEnvironmentVariable("Path", $env:Path + ";C:\Program Files (x86)\Nmap", [EnvironmentVariableTarget]::Machine)

PowerShell setup

## Verificar instalación
nmap --version

## Actualizar scripts NSE (requiere conexión a Internet)
cd "C:\Program Files (x86)\Nmap"
.\nmap.exe --script-updatedb

## Probar escaneo básico
nmap -sS 127.0.0.1

---

macOS

Instalación con Homebrew

## Instalar Homebrew si no está presente
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

## Instalar Nmap
brew install nmap

## Verificar
nmap --version

Troubleshooting M1/M2 (Apple Silicon)

## Si brew install falla por arquitectura:
arch -arm64 brew install nmap

## Si hay problemas con libpcap:
brew install libpcap
## Luego reinstalar nmap:
brew reinstall nmap --build-from-source

Compilación manual en macOS

## Instalar dependencias
brew install autoconf automake libtool openssl lua libpcap libdnet

## Descargar y compilar
cd /tmp
curl -O https://nmap.org/dist/nmap-7.95.tar.bz2
tar xjf nmap-7.95.tar.bz2
cd nmap-7.95
./configure --with-openssl=/usr/local/opt/openssl
make -j$(sysctl -n hw.ncpu)
sudo make install

---

Docker

Dockerfile completo

FROM alpine:3.19

RUN apk add --no-cache nmap nmap-scripts ncat

ENTRYPOINT ["nmap"]

docker-compose.yml

version: '3.8'
services:
nmap:
build: .
network_mode: "host" # Necesario para enviar paquetes crudos
cap_add:
- NET_ADMIN
- NET_RAW
volumes:
- ./results:/results
command: -sS -sV -oN /results/scan.txt 192.168.1.0/24

Build y run commands

## Construir imagen
docker build -t nmap-custom .

## Ejecutar escaneo básico (requiere --net=host para escaneo SYN)
docker run --rm --net=host nmap-custom -sS 192.168.1.1

## Escaneo con salida persistente
docker run --rm --net=host -v $(pwd)/output:/output nmap-custom -oN /output/resultado.txt 10.0.0.0/24

## Escaneo UDP (necesita NET_RAW)
docker run --rm --net=host --cap-add=NET_RAW nmap-custom -sU -p 53,161 192.168.1.1

---

Verificación de instalación

Comandos para verificar

## Versión y capacidades compiladas
nmap --version
## Debe mostrar: Nmap version 7.95, plataforma, compilado con: libpcap, libdnet, openssl, lua

## Verificar scripts NSE disponibles
ls /usr/share/nmap/scripts/ | wc -l
## Debe mostrar >600 scripts

## Prueba básica de conectividad
nmap -sn 127.0.0.1
## Output esperado: Host is up (0.000010s latency).

## Prueba de escaneo SYN (requiere privilegios root)
sudo nmap -sS -p 22,80,443 scanme.nmap.org

Troubleshooting de errores comunes

| Error | Causa | Solución | |-------|-------|----------| | dnet: Failed to open device eth0 | Permisos insuficientes | Ejecutar con sudo o --privileged en Docker | | `pcap

---

Nmap: Maestría en Escaneo de Redes — Guía Premium 2025

Capítulo 2: Uso Avanzado

---

2.1 Comandos Esenciales — El Arsenal del Operador

Dominar Nmap no es memorizar cien flags; es conocer los 20 comandos que resuelven el 95% de los escenarios reales. Aquí tienes cada uno con su sintaxis completa, parámetros explicados y el output que verás en consola. No son ejemplos académicos: son los que ejecuto en assessments semanales.

1. Escaneo SYN rápido de puertos comunes

nmap -sS -T4 -p 1-1000 --open --reason 192.168.1.0/24

• -sS: SYN scan (half-open), no completa el three-way handshake. Rápido y sigiloso.
• -T4: Timing template agresivo (asume red rápida y fiable). Reduce tiempos de espera.
• -p 1-1000: Rango de puertos estándar. Para top 1000, usa --top-ports 1000.
• --open: Muestra solo puertos abiertos, filtra closed/filtered.
• --reason: Explica por qué Nmap determinó el estado (syn-ack, reset, no-response).

Output real esperado:

Nmap scan report for 192.168.1.15
Host is up (0.0012s latency).
Not shown: 997 closed ports
PORT STATE SERVICE REASON
22/tcp open ssh syn-ack
80/tcp open http syn-ack
443/tcp open https syn-ack
MAC Address: 00:0C:29:3A:2F:1B (VMware)

2. Detección de sistema operativo y servicios agresiva

nmap -A -T4 -p- --script vuln 10.0.0.5

• -A: Habilita OS detection, version detection, script scanning y traceroute.
• -p-: Todos los 65535 puertos TCP. En entornos reales, los servicios críticos suelen esconderse en puertos altos.
• --script vuln: Ejecuta toda la categoría de scripts de vulnerabilidades. Busca CVEs conocidos, misconfiguraciones, backdoors.

Fragmento de output con hallazgo:

PORT STATE SERVICE VERSION
22/tcp open ssh OpenSSH 7.4 (protocol 2.0)
| vulners: 
| cpe:/a:openbsd:openssh:7.4: 
| CVE-2017-15906 5.0 https://vulners.com/cve/CVE-2017-15906
|_ CVE-2018-15473 5.0 https://vulners.com/cve/CVE-2018-15473
80/tcp open http Apache httpd 2.4.6 ((CentOS))
|_http-server-header: Apache/2.4.6 (CentOS)
| http-vuln-cve2017-5638: 
| VULNERABLE:
| Apache Struts 2 Remote Code Execution
| State: VULNERABLE
| IDs: CVE:CVE-2017-5638
| Risk factor: Critical

3. Escaneo UDP de servicios clave

nmap -sU -T4 -p 53,67,68,69,123,161,162,500,514,520,1900,5353 10.0.0.0/24 --max-retries 2

• -sU: UDP scan. Lento por naturaleza; limitamos puertos a los más relevantes.
• --max-retries 2: Reduce reintentos para acelerar. UDP no confirma entrega, Nmap espera respuestas ICMP o timeout.
• Puertos seleccionados: DNS, DHCP, TFTP, NTP, SNMP, ISAKMP, syslog, RIP, SSDP, mDNS.

4. Escaneo de red completo con fingerprinting y salida a todos los formatos

nmap -sS -sU -T4 -A -v -p- -oA full_scan_10.0.0.0_24 10.0.0.0/24

• -sS -sU: TCP y UDP simultáneo.
• -v: Verbose, muestra puertos abiertos en tiempo real.
• -oA: Genera los tres formatos (.nmap, .gnmap, .xml) con el prefijo dado. El XML es vital para importar a Metasploit o herramientas de reporting.

5. Escaneo de vulnerabilidades específicas con scripts NSE

nmap --script "smb-vuln*,ssl-*,http-*" -p 139,445,443,80 192.168.1.100

• Comodines en categorías NSE: smb-vuln* cubre ms08-067, ms17-010, etc. ssl-* busca heartbleed, poodle, certificados débiles.

6. Evasión de firewall con fragmentación y decoys

nmap -f -D RND:10 -T2 -p 80,443 --data-length 50 203.0.113.5

• -f: Fragmenta paquetes en fragmentos IP de 8 bytes, dificulta detección por firewalls simples.
• -D RND:10: Genera 10 direcciones IP señuelo aleatorias, mezclando el tráfico real.
• -T2: Timing paranoico, ideal para evadir IDS basados en umbrales de velocidad.
• --data-length 50: Añade 50 bytes aleatorios al payload, normaliza el tamaño de paquete.

7. Escaneo de puertos específicos con versiones y scripts de enumeración

nmap -sV --script "banner,http-title,ssl-cert,ssh-hostkey" -p 22,80,443,3306,8080 10.10.10.10

• -sV: Version detection intensiva. Envía probes específicas para obtener el servicio exacto y versión.
• Scripts: banner extrae banners genéricos, http-title el título HTML, ssl-cert detalles del certificado, ssh-hostkey la clave pública SSH.

8. Escaneo de lista de hosts desde archivo con output grepable

nmap -iL targets.txt -sS -T4 -p 1-65535 -oG scan_results.gnmap

• -iL: Lee objetivos de un archivo (uno por línea, formato IP o CIDR).
• -oG: Formato grepable, fácil de parsear con awk o grep para extraer IPs con puerto abierto.

9. Detección de firewall y filtrado con traceroute

nmap --traceroute --script firewall-bypass 192.168.1.1

• --traceroute: Mapea la ruta de paquetes hasta el objetivo, útil para identificar puntos de filtrado.
• --script firewall-bypass: Script NSE que prueba reglas de firewall con paquetes malformados (fragmentados, con flags extraños).

10. Escaneo de subred con ping sweep y resolución DNS inversa

nmap -sn -R 10.0.0.0/24

• -sn: Ping sweep (no escanea puertos). Envía ICMP echo, TCP SYN al 443, TCP ACK al 80 y ARP en local.
• -R: Fuerza resolución DNS inversa para todas las IPs activas, incluso si no responden a ping.

11. Escaneo de puertos con timing agresivo y paralelismo máximo

nmap -T5 --min-parallelism 100 --max-rtt-timeout 300ms -p 1-1000 10.0.0.0/24

• -T5: Insane timing. Solo para redes locales o de muy baja latencia.
• --min-parallelism 100: Mantiene al menos 100 sondas en paralelo.
• --max-rtt-timeout 300ms: Timeout máximo de 300ms; si no hay respuesta en ese tiempo, descarta.

12. Escaneo de puertos UDP con payloads específicos

nmap -sU --script "dns-recursion,ntp-monlist,snmp-info" -p 53,123,161 10.0.0.50

• Scripts UDP: dns-recursion prueba recursión abierta, ntp-monlist amplificación DDoS, snmp-info extrae información SNMP.

13. Escaneo de red con exclusión de hosts ruidosos

nmap 10.0.0.0/24 --exclude 10.0.0.1,10.0.0.254 -sS -T4

• --exclude: Omite IPs que son firewalls o dispositivos que generan alertas.

14. Escaneo de puertos con detección de servicio y guardado en XML para Metasploit

nmap -sV -p 1-65535 -oX scan.xml 192.168.1.0/24

• Luego en msfconsole: db_import scan.xml para poblar la base de datos de hosts y servicios.

15. Escaneo de puertos con scripts de fuerza bruta controlada

nmap --script "ssh-brute,ftp-brute,http-brute" --script-args "brute.threads=5,brute.timeout=10s" -p 22,21,80 10.0.0.10

• --script-args: Limita hilos y timeout para no saturar el servicio ni disparar lockouts.

16. Escaneo de puertos con detección de OS y fingerprinting TCP/IP

nmap -O --osscan-guess --fuzzy -p 22,80,443 10.0.0.5

• -O: OS detection basada en TCP/IP stack fingerprinting.
• --osscan-guess: Muestra las mejores conjeturas aunque la coincidencia no sea perfecta.
• --fuzzy: Activa detección de OS incluso si no hay puertos abiertos (usa puertos cerrados y respuestas ICMP).

17. Escaneo de puertos con scripts de enumeración SMB

nmap --script "smb-enum-*,smb-os-discovery" -p 139,445 10.0.0.20

• smb-enum-shares, smb-enum-users, smb-enum-domains, smb-os-discovery: enumeración completa de recursos compartidos, usuarios, dominio y versión de Windows.

18. Escaneo de puertos con detección de WAF y load balancers

nmap --script "http-waf-detect,http-lb-detection" -p 80,443 10.0.0.30

• http-waf-detect: Prueba patrones de ataque y analiza respuestas para identificar WAF (Cloudflare, ModSecurity, etc.).
• http-lb-detection: Detecta balanceadores de carga por diferencias en headers, cookies o respuestas.

19. Escaneo de puertos con generación de reporte HTML

nmap -sS -sV -T4 -p- -oA full_scan 10.0.0.0/24
xsltproc full_scan.xml -o report.html

• xsltproc transforma el XML a HTML usando la hoja de estilo por defecto de Nmap. Para reportes profesionales, usa nmap-bootstrap-xsl desde GitHub.

20. Escaneo de puertos con scripts de descubrimiento de vulnerabilidades web

nmap --script "http-vuln-*,http-sql-injection,http-shellshock" -p 80,443,8080,8443 10.0.0.40

• http-vuln-*: Cubre CVEs en servidores web (Apache, IIS, Nginx).
• http-sql-injection: Prueba inyecciones SQL básicas en parámetros GET/POST.
• http-shellshock: Detecta la vulnerabilidad Shellshock en CGI.

Estos 20 comandos cubren reconocimiento, enumeración, detección de vulnerabilidades y evasión. Practícalos en tu laboratorio hasta que los escribas sin pensar. En un assessment real, el tiempo es oro y no puedes permitirte buscar en el manual.

---

2.2 Automatización con Scripts — De Operador a Ingeniero

El escaneo manual está bien para un solo host. Cuando tienes 50 subredes, activos que cambian diariamente y necesitas alimentar un SIEM con resultados frescos, la automatización es obligatoria. Aquí tienes tres niveles: scripts Bash para tareas rápidas, Python para flujos complejos, y cron para ejecución periódica con logging profesional.

2.2.1 Bash: Escaneo Programado con Rotación de Logs

Este script ejecuta un escaneo SYN rápido de una subred, guarda los resultados con timestamp y limpia logs antiguos. Ideal para monitoreo continuo de superficie de ataque.

#!/bin/bash
## scan_daily.sh - Escaneo diario de red con logging rotativo
## Uso: ./scan_daily.sh 192.168.1.0/24

SUBNET="$1"
DATE=$(date +%Y%m%d_%H%M%S)
OUTDIR="/var/log/nmap_scans"
RETENTION_DAYS=30

mkdir -p "$OUTDIR"

## Escaneo SYN rápido, solo puertos abiertos, output en los 3 formatos
nmap -sS -T4 -p 1-1000 --open --reason -oA "${OUTDIR}/scan_${DATE}" "$SUBNET"

## Generar reporte HTML si hay resultados
if [ -f "${OUTDIR}/scan_${DATE}.xml" ]; then
xsltproc "${OUTDIR}/scan_${DATE}.xml" -o "${OUTDIR}/scan_${DATE}.html" 2>/dev/null
fi

## Crear resumen grepable: IPs con puertos abiertos
grep "Ports:" "${OUTDIR}/scan_${DATE}.gnmap" | awk '{print $2, $5}' > "${OUTDIR}/summary_${DATE}.txt"

## Rotación: eliminar logs más antiguos que RETENTION_DAYS
find "$OUTDIR" -type f -name "scan_*" -mtime +$RETENTION_DAYS -delete

echo "[+] Escaneo completado: ${OUTDIR}/scan_${DATE}"

Explicación línea por línea:

• SUBNET="$1": Toma la subred como argumento. Sin argumento, fallará; puedes añadir validación.
• DATE: Formato ordenable cronológicamente.
• nmap ... -oA: Genera .nmap (legible), .gnmap (grepable), .xml (estructurado).
• xsltproc: Convierte XML a HTML usando la transformación XSL por defecto de Nmap. Si no existe, instala nmap y xsltproc.
• grep "Ports:" ... | awk: Extrae del formato grepable la IP y los puertos abiertos. Ejemplo de línea: Host: 192.168.1.15 (hostname) Ports: 22/open/tcp//ssh///, 80/open/tcp//http///
• find ... -delete: Elimina archivos

---

Nmap: Maestría en Escaneo de Redes — Guía Premium 2025

---

Contenido Premium

Los siguientes capítulos están disponibles en la versión completa:

• Capítulo 3: Análisis de Casos Reales
• Capítulo 4: Ejercicios Prácticos Guiados
• Capítulo 5: Troubleshooting y FAQs
• Capítulo 6: Recursos y Certificaciones
• Scripts completos y plantillas
• Soporte técnico incluido

Desbloquear Contenido Completo