Nmap: Guía completa de reconocimiento de redes para principiantes

Nmap (Network Mapper) es la herramienta de reconocimiento de redes más popular del mundo. Es gratuita, open source y extremadamente poderosa para descubrir dispositivos, puertos abiertos, servicios en ejecución y mucho más.

🎯 ¿Por qué es importante? En ciberseguridad, el reconocimiento es el primer paso. Nmap te permite “mapear” una red como un explorador, identificando qué hay disponible antes de cualquier acción.

🛠️ Instalación rápida

En Debian/Ubuntu:

sudo apt update && sudo apt install nmap

En otras distribuciones:

# Fedora/CentOS
sudo dnf install nmap

# Arch Linux
sudo pacman -S nmap

Verificar instalación:

nmap --version

🎯 Conceptos básicos antes de empezar

¿Qué hace Nmap?

• Descubre dispositivos en una red
• Identifica puertos abiertos en esos dispositivos
• Detecta servicios corriendo en esos puertos
• Determina sistemas operativos aproximados
• Evalúa seguridad con scripts especializados

⚖️ Uso ético y legal

⚠️ Importante: Solo usa Nmap en:

• Tu propia red/dispositivos
• Redes donde tengas permiso explícito
• Laboratorios de práctica legales

Escanear redes ajenas sin permiso puede ser ilegal.

🚀 Comandos básicos para principiantes

1. Tu primer escaneo

nmap 192.168.1.1

¿Qué hace? Escanea los 1000 puertos más comunes de esa IP.

Salida típica:

Starting Nmap 7.94 ( https://nmap.org )
Nmap scan report for 192.168.1.1
Host is up (0.001s latency).
Not shown: 996 closed ports
PORT     STATE SERVICE
22/tcp   open  ssh
80/tcp   open  http
443/tcp  open  https
8080/tcp open  http-proxy

2. Escanear un rango de IPs

nmap 192.168.1.1-10          # IPs del 1 al 10
nmap 192.168.1.0/24          # Toda la subred (254 IPs)
nmap 192.168.1.1 192.168.1.5 # IPs específicas

3. Escanear puertos específicos

nmap -p 22 192.168.1.1           # Solo puerto 22
nmap -p 22,80,443 192.168.1.1    # Puertos específicos
nmap -p 1-100 192.168.1.1        # Rango de puertos
nmap -p- 192.168.1.1             # TODOS los puertos (1-65535)

🔍 Tipos de escaneo (para entender qué pasa bajo el capó)

Escaneo TCP SYN (por defecto)

nmap -sS 192.168.1.1

• Más rápido y sigiloso
• No completa la conexión TCP
• Requiere privilegios root

Escaneo TCP Connect

nmap -sT 192.168.1.1

• Más lento pero no requiere root
• Completa la conexión TCP
• Más detectable en logs

Escaneo UDP

nmap -sU 192.168.1.1

• Escanea puertos UDP
• Más lento que TCP
• Útil para servicios como DNS, DHCP

📋 Detección de servicios y versiones

Detectar versiones de servicios

nmap -sV 192.168.1.1

Salida ejemplo:

PORT     STATE SERVICE VERSION
22/tcp   open  ssh     OpenSSH 8.2p1 Ubuntu 4ubuntu0.5
80/tcp   open  http    Apache httpd 2.4.41
443/tcp  open  ssl/http Apache httpd 2.4.41

Detectar sistema operativo

nmap -O 192.168.1.1

¿Qué hace? Analiza respuestas TCP/IP para adivinar el OS.

Escaneo con scripts por defecto

nmap -sC 192.168.1.1

¿Qué hace? Ejecuta scripts de Nmap para detectar vulnerabilidades comunes, información adicional, etc.

Combo poderoso: Versión + Scripts + OS

nmap -sC -sV -O 192.168.1.1

⚡ Controlando la velocidad del escaneo

nmap -T0 192.168.1.1    # Paranoid: MUY lento, sigiloso
nmap -T1 192.168.1.1    # Sneaky: Lento, difícil de detectar
nmap -T2 192.168.1.1    # Polite: Lento, menos agresivo
nmap -T3 192.168.1.1    # Normal: Velocidad por defecto
nmap -T4 192.168.1.1    # Aggressive: Rápido, recomendado
nmap -T5 192.168.1.1    # Insane: MUY rápido, puede perder info

💡 Tip: Para la mayoría de casos, -T4 es perfecto. Usa -T1 o -T2 si necesitas ser sigiloso.

🎯 Descubrimiento de hosts (¿quién está vivo?)

Ping scan (solo verificar si están activos)

nmap -sn 192.168.1.0/24

Útil para: Mapear rápidamente todos los dispositivos en una red.

Escaneo específico sin ping

nmap -Pn 192.168.1.1

Cuándo usar: Cuando el host bloquea pings pero tiene puertos abiertos.

📂 Guardando resultados

Formato normal (legible)

nmap -oN escaneo.txt 192.168.1.1

Formato XML (para herramientas)

nmap -oX escaneo.xml 192.168.1.1

Todos los formatos

nmap -oA escaneo_completo 192.168.1.1

Genera: escaneo_completo.nmap, escaneo_completo.xml, escaneo_completo.gnmap

🧪 Scripts de Nmap (NSE)

Nmap incluye más de 600 scripts para tareas específicas:

Ver scripts disponibles

ls /usr/share/nmap/scripts/ | grep -i "http"

Ejecutar script específico

nmap --script http-title 192.168.1.1
nmap --script ssh-brute 192.168.1.1
nmap --script vuln 192.168.1.1

Scripts por categoría

nmap --script "auth" 192.168.1.1      # Scripts de autenticación
nmap --script "brute" 192.168.1.1     # Scripts de fuerza bruta
nmap --script "discovery" 192.168.1.1 # Scripts de descubrimiento
nmap --script "vuln" 192.168.1.1      # Scripts de vulnerabilidades

🚀 Ejemplos prácticos paso a paso

Escenario 1: Reconocimiento básico de tu red

# 1. Descubrir dispositivos en tu red local
nmap -sn 192.168.1.0/24

# 2. Escanear un dispositivo específico
nmap -T4 -A 192.168.1.1

# 3. Buscar puertos web específicos
nmap -p 80,443,8080,8443 192.168.1.0/24

Escenario 2: Análisis detallado de un servidor

# Escaneo completo y profesional
nmap -T4 -A -v --script vuln -oA servidor_scan 192.168.1.100

¿Qué hace cada opción?

• -T4: Velocidad agresiva
• -A: Detección de OS, versión, scripts y traceroute
• -v: Modo verbose (más información)
• --script vuln: Scripts de vulnerabilidades
• -oA: Guardar en todos los formatos

Escenario 3: Buscar servicios específicos

# Buscar servidores web
nmap -p 80,443 --open 192.168.1.0/24

# Buscar servidores SSH
nmap -p 22 --open 192.168.1.0/24

# Buscar servicios de base de datos
nmap -p 3306,5432,1433 --open 192.168.1.0/24

🔧 Comando profesional para pentesting

sudo nmap -p- --open -sS -sC -sV --min-rate 5000 -vvv -n -Pn 192.168.1.100 -oN escaneo_completo

Desglose del comando:

• sudo: Permisos de administrador
• -p-: Escanear TODOS los puertos (1-65535)
• --open: Mostrar solo puertos abiertos
• -sS: Escaneo SYN (sigiloso y rápido)
• -sC: Scripts por defecto
• -sV: Detección de versiones
• --min-rate 5000: Mínimo 5000 paquetes por segundo
• -vvv: Máximo nivel de detalle
• -n: No resolver DNS (más rápido)
• -Pn: No hacer ping (asumir que está activo)
• -oN: Guardar resultado en archivo

📊 Interpretando resultados

Estados de puertos

• open: Puerto abierto y aceptando conexiones
• closed: Puerto cerrado pero responde
• filtered: Puerto filtrado por firewall
• unfiltered: Puerto accesible pero estado indeterminado

• **open

  filtered**: Nmap no puede determinar si está abierto o filtrado

Ejemplo de salida completa

Nmap scan report for 192.168.1.100
Host is up (0.00043s latency).
Not shown: 65530 closed ports
PORT     STATE SERVICE VERSION
22/tcp   open  ssh     OpenSSH 8.2p1 Ubuntu 4ubuntu0.5 (Ubuntu Linux; protocol 2.0)
| ssh-hostkey: 
|   3072 48:ad:d5:b8:3a:9f:bc:be:f7:e8:20:1e:f6:bf:de:ae (RSA)
80/tcp   open  http    Apache httpd 2.4.41 ((Ubuntu))
|_http-title: Apache2 Ubuntu Default Page
443/tcp  open  ssl/http Apache httpd 2.4.41 ((Ubuntu))
| ssl-cert: Subject: commonName=localhost

🛡️ Evasión básica de firewalls

# Fragmentar paquetes
nmap -f 192.168.1.1

# Usar señuelos (decoy)
nmap -D 192.168.1.5,192.168.1.6,ME 192.168.1.1

# Cambiar puertos source
nmap --source-port 53 192.168.1.1

# Escaneo idle/zombie
nmap -sI zombie_host target_host

📚 Recursos para seguir aprendiendo

Documentación oficial

man nmap                    # Manual completo
nmap --help                 # Ayuda rápida

Libros recomendados

• “Nmap Network Scanning” por Gordon Lyon (creador de Nmap)
• “The Official Nmap Project Guide”

Laboratorios de práctica

• VulnHub: Máquinas virtuales vulnerables
• HackTheBox: Plataforma de pentesting legal
• TryHackMe: Tutoriales interactivos

---

🎯 Próximos pasos

1. Practica en tu red local con dispositivos propios
2. Combina Nmap con otras herramientas como Wireshark
3. Aprende sobre scripts NSE específicos para tus intereses
4. Estudia evasión de firewalls para pentesting avanzado

💡 Recuerda: Nmap es solo el primer paso en el reconocimiento. La información que obtengas será la base para todo análisis posterior de seguridad.

---

🔥 Casos de uso profesionales avanzados

Auditoría de seguridad empresarial

1. Inventario de activos:

# Escaneo completo de la red corporativa
nmap -sn 192.168.0.0/16 > inventario_ips.txt

# Identificar sistemas operativos en la red
nmap -O --osscan-guess 192.168.1.0/24 -oX os_detection.xml

# Buscar servicios críticos expuestos
nmap -p 21,22,23,25,53,80,110,443,993,995,1433,3306,3389,5432 --open 192.168.1.0/24

2. Detección de vulnerabilidades:

# Escaneo completo de vulnerabilidades
nmap --script vuln -sV 192.168.1.100

# Buscar vulnerabilidades específicas
nmap --script smb-vuln* 192.168.1.100
nmap --script ssl-* 192.168.1.100

Pentesting y red team

3. Reconocimiento sigiloso:

# Escaneo ultra sigiloso
nmap -sS -T1 -f --randomize-hosts --data-length 25 -D 192.168.1.5,192.168.1.6,ME target

# Usando técnicas de evasión
nmap --source-port 53 --scan-delay 10s -T1 target
nmap --spoof-mac Apple target

4. Enumeración de servicios web:

# Enumerar aplicaciones web
nmap --script http-enum -p 80,443,8080,8443 target

# Buscar directorios ocultos
nmap --script http-brute-dirs target

# Identificar tecnologías web
nmap --script http-waf-detect,http-waf-fingerprint target

Análisis forense y incident response

5. Detección de backdoors:

# Buscar puertos inusuales abiertos
nmap -p 1-65535 --top-ports 1000 target

# Detectar servicios en puertos no estándar
nmap -sV --version-intensity 9 target

6. Monitoreo continuo:

# Script de monitoreo automático
#!/bin/bash
while true; do
    nmap -sn 192.168.1.0/24 | grep "Nmap scan report" | 
    awk '{print $5}' > current_hosts.txt
    
    if ! diff previous_hosts.txt current_hosts.txt > /dev/null; then
        echo "¡Cambios detectados en la red!" | mail admin@empresa.com
        cp current_hosts.txt previous_hosts.txt
    fi
    
    sleep 300  # Revisar cada 5 minutos
done

🛡️ Técnicas avanzadas de evasión

Fragmentación de paquetes

# Fragmentar paquetes IP
nmap -f target                    # Fragmentos de 8 bytes
nmap -ff target                   # Fragmentos de 16 bytes
nmap --mtu 24 target             # MTU personalizado (múltiplo de 8)

Señuelos (Decoys)

# Usar señuelos para ocultar origen
nmap -D decoy1,decoy2,decoy3,ME target
nmap -D RND:10 target            # 10 señuelos aleatorios

Modificación de puertos origen

# Simular tráfico DNS
nmap --source-port 53 target

# Simular tráfico web
nmap --source-port 80 target

# Puerto origen aleatorio
nmap -g 1337 target

Timing y velocidad

# Escaneo extremadamente lento (1 paquete cada 15 segundos)
nmap -T0 --scan-delay 15s target

# Control fino del timing
nmap --min-rate 100 --max-rate 1000 target
nmap --min-parallelism 10 --max-parallelism 50 target

📊 Análisis avanzado de resultados

Parsing automático con scripts

#!/bin/bash
# Script para analizar resultados de Nmap

# Extraer solo IPs con puertos abiertos
grep -E "^Nmap scan report|^[0-9]+/tcp.*open" nmap_scan.txt | 
awk '/Nmap scan report/ {ip=$NF} /open/ {print ip":"$1}' > puertos_abiertos.txt

# Crear reporte de servicios vulnerables
nmap -sV --script vulners target -oX scan.xml
xsltproc scan.xml > reporte.html

Integración con bases de datos

# Python script para analizar resultados
import xml.etree.ElementTree as ET
import sqlite3

def parse_nmap_xml(xml_file):
    tree = ET.parse(xml_file)
    root = tree.getroot()
    
    conn = sqlite3.connect('scan_results.db')
    cursor = conn.cursor()
    
    cursor.execute('''CREATE TABLE IF NOT EXISTS hosts
                     (ip TEXT, hostname TEXT, status TEXT)''')
    
    cursor.execute('''CREATE TABLE IF NOT EXISTS ports
                     (ip TEXT, port INTEGER, protocol TEXT, 
                      service TEXT, version TEXT)''')
    
    for host in root.findall('host'):
        ip = host.find('address').get('addr')
        status = host.find('status').get('state')
        
        cursor.execute("INSERT INTO hosts VALUES (?, ?, ?)", 
                      (ip, '', status))
        
        ports = host.find('ports')
        if ports is not None:
            for port in ports.findall('port'):
                port_num = port.get('portid')
                protocol = port.get('protocol')
                service = port.find('service')
                
                if service is not None:
                    service_name = service.get('name', '')
                    version = service.get('version', '')
                else:
                    service_name = version = ''
                
                cursor.execute("INSERT INTO ports VALUES (?, ?, ?, ?, ?)",
                              (ip, port_num, protocol, service_name, version))
    
    conn.commit()
    conn.close()

# Uso
parse_nmap_xml('scan_results.xml')

🔬 Scripts NSE personalizados

Crear tu propio script NSE

-- mi-script.nse
local nmap = require "nmap"
local shortport = require "shortport"
local http = require "http"

description = [[
Script personalizado para detectar aplicaciones web específicas
]]

author = "Tu Nombre"
license = "Same as Nmap"
categories = {"discovery", "safe"}

-- Definir en qué puertos ejecutar
portrule = shortport.http

action = function(host, port)
    local response = http.get(host, port, "/")
    
    if response and response.status == 200 then
        local body = response.body
        
        -- Buscar patrones específicos
        if string.match(body, "WordPress") then
            return "WordPress detectado"
        elseif string.match(body, "Joomla") then
            return "Joomla detectado"
        end
    end
    
    return nil
end

Ejecutar script personalizado:

nmap --script mi-script.nse target

🎯 Automatización con Nmap

Script de reconocimiento completo

#!/bin/bash
# recon.sh - Script de reconocimiento automático

TARGET=$1
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
OUTPUT_DIR="scan_${TARGET}_${TIMESTAMP}"

mkdir -p $OUTPUT_DIR

echo "[*] Iniciando reconocimiento de $TARGET"

# 1. Ping sweep
echo "[*] Descubrimiento de hosts..."
nmap -sn $TARGET > $OUTPUT_DIR/ping_sweep.txt

# 2. Escaneo de puertos rápido
echo "[*] Escaneo rápido de puertos..."
nmap -T4 --top-ports 1000 $TARGET -oN $OUTPUT_DIR/quick_scan.txt

# 3. Escaneo completo de puertos abiertos
OPEN_PORTS=$(grep -E "^[0-9]+/tcp.*open" $OUTPUT_DIR/quick_scan.txt | 
             cut -d'/' -f1 | tr '\n' ',' | sed 's/,$//')

if [ ! -z "$OPEN_PORTS" ]; then
    echo "[*] Escaneo detallado de puertos: $OPEN_PORTS"
    nmap -sC -sV -p $OPEN_PORTS $TARGET -oA $OUTPUT_DIR/detailed_scan
fi

# 4. Escaneo de vulnerabilidades
echo "[*] Escaneo de vulnerabilidades..."
nmap --script vuln -p $OPEN_PORTS $TARGET -oN $OUTPUT_DIR/vuln_scan.txt

# 5. Detección de OS
echo "[*] Detección de sistema operativo..."
nmap -O $TARGET -oN $OUTPUT_DIR/os_detection.txt

echo "[*] Reconocimiento completado. Resultados en: $OUTPUT_DIR"

Monitoreo continuo de red

#!/bin/bash
# monitor_network.sh - Monitoreo continuo

NETWORK="192.168.1.0/24"
BASELINE_FILE="network_baseline.txt"
ALERT_EMAIL="admin@empresa.com"

# Crear baseline si no existe
if [ ! -f $BASELINE_FILE ]; then
    nmap -sn $NETWORK | grep "Nmap scan report" > $BASELINE_FILE
    echo "Baseline creado: $BASELINE_FILE"
    exit 0
fi

# Escaneo actual
CURRENT_SCAN=$(mktemp)
nmap -sn $NETWORK | grep "Nmap scan report" > $CURRENT_SCAN

# Comparar con baseline
DIFF_OUTPUT=$(diff $BASELINE_FILE $CURRENT_SCAN)

if [ ! -z "$DIFF_OUTPUT" ]; then
    echo "¡Cambios detectados en la red!"
    echo "$DIFF_OUTPUT"
    
    # Enviar alerta por email (requiere mailutils)
    echo "Cambios detectados en la red $NETWORK:
    
$DIFF_OUTPUT" | mail -s "Alerta de Red" $ALERT_EMAIL
    
    # Actualizar baseline
    cp $CURRENT_SCAN $BASELINE_FILE
fi

rm $CURRENT_SCAN

📚 Recursos adicionales para maestría

Laboratorios de práctica

• Metasploitable: VM vulnerable para práctica
• DVWA: Aplicación web vulnerable
• VulnHub: Colección de VMs vulnerables
• HackTheBox: Plataforma de pentesting
• TryHackMe: Tutoriales interactivos

Herramientas complementarias

# Masscan - Escaneo masivo ultra rápido
masscan -p1-65535 192.168.1.0/24 --rate=1000

# Unicornscan - Escáner asíncrono
unicornscan -mT 192.168.1.1:1-65535

# Zmap - Internet-wide scanning
zmap -p 22 -o ssh_hosts.txt

# Rustscan - Scanner moderno en Rust
rustscan -a 192.168.1.1 -- -sC -sV

Integración con frameworks

# python-nmap integration
import nmap

nm = nmap.PortScanner()
result = nm.scan('192.168.1.1', '22-443')

for host in nm.all_hosts():
    print(f'Host: {host} ({nm[host].hostname()})')
    print(f'State: {nm[host].state()}')
    
    for protocol in nm[host].all_protocols():
        ports = nm[host][protocol].keys()
        for port in ports:
            service = nm[host][protocol][port]
            print(f'Port: {port} - {service["state"]} - {service["name"]}')

---

Andrés Nuñez - t4ifi