Nmap

TAG -> herramientas | recognition

Nmap (Network Mapper) es una herramienta de código abierto utilizada para el descubrimiento y auditoría de seguridad de redes. Permite explorar hosts y servicios en una red mediante el envío de paquetes y el análisis de sus respuestas. Es muy popular en pruebas de penetración, ya que proporciona información detallada sobre los dispositivos conectados, puertos abiertos, servicios y sistemas operativos.

Escaneos en Nmap

1. Escaneo TCP

El protocolo TCP (Transmission Control Protocol) es uno de los más utilizados en redes. Nmap ofrece varios tipos de escaneos TCP:

• Escaneo SYN (-sS): Conocido como "Half-open Scan", envía un paquete SYN para establecer una conexión. Si recibe un SYN/ACK, el puerto está abierto; si recibe un RST, el puerto está cerrado. Es rápido y sigiloso, ya que no completa la conexión.

nmap -sS 192.168.1.1

• Escaneo Connect (-sT): Completa la conexión TCP (SYN, SYN/ACK, ACK) y luego la cierra. Es más fácil de detectar y más lento que el escaneo SYN.

nmap -sT 192.168.1.1

• Escaneo ACK (-sA): Envia un paquete ACK para verificar si un puerto está filtrado por un firewall. Un RST indica que el puerto no está filtrado, mientras que la falta de respuesta o un ICMP indica que está filtrado.

nmap -sA 192.168.1.1

• Escaneo FIN, Xmas y Null (-sF, -sX, -sN): Envían paquetes con diferentes flags (FIN, Xmas o sin ningún flag) para evadir firewalls y detectar puertos abiertos basándose en respuestas no estándar.

nmap -sF 192.168.1.1
nmap -sX 192.168.1.1
nmap -sN 192.168.1.1

2. Escaneo UDP (-sU)

El escaneo UDP es más complejo y lento que el escaneo TCP debido a la naturaleza del protocolo (sin estado y sin confirmación). Nmap envía un paquete UDP vacío o con datos específicos y espera una respuesta ICMP “puerto inalcanzable” para determinar si está cerrado. La falta de respuesta puede indicar que el puerto está abierto o filtrado.

nmap -sU 192.168.1.1

Para mejorar la velocidad y precisión, se suele combinar con un escaneo SYN:

nmap -sS -sU 192.168.1.1

3. Reconocimiento de Red

El reconocimiento de red implica identificar los hosts activos y obtener información básica sobre ellos. Nmap utiliza varias técnicas para esto:

• Ping Scan (-sn): Verifica qué hosts están activos sin realizar un escaneo de puertos. Se envía un paquete ICMP Echo Request, TCP SYN a puerto 443, y un paquete ICMP Timestamp o Address Mask.

nmap -sn 192.168.1.0/24

• Detección de Sistema Operativo (-O): Nmap intenta determinar el sistema operativo y versión basándose en las características de los paquetes de red.

nmap -O 192.168.1.1

• Detección de Hosts (-PE, -PS, -PA): Usa diferentes tipos de paquetes para descubrir hosts. Por ejemplo, -PE envía pings ICMP, -PS envía SYN y -PA envía ACK a puertos específicos.

nmap -PS80 192.168.1.0/24 
nmap -PA80 192.168.1.0/24

Combinaciones de Escaneos

Combinar diferentes tipos de escaneos puede proporcionar una visión más completa de la red y sus vulnerabilidades.

Escaneo rápido de puertos abiertos

nmap -p- --open -sS --min-rate 5000 -vvv -n -Pn 172.17.0.2 -oG allPorts.txt

Descripción: Este comando realiza un escaneo SYN rápido de todos los puertos abiertos en el objetivo y guarda la salida en formato grepeable para fácil manipulación posterior.

• -p-: Escanea todos los puertos (0-65535).

• --open: Muestra solo los puertos abiertos.

• -sS: Realiza un escaneo SYN (Stealth).

• --min-rate 5000: Establece una tasa mínima de paquetes a 5000 paquetes por segundo.

• -vvv: Muestra salida detallada y verbosa.

• -n: Desactiva la resolución DNS inversa.

• -Pn: Omite el paso de descubrimiento de host, asume que el host está activo.

• -oG allPorts.txt: Guarda la salida en formato grepeable en el archivo allPorts.txt.

Escaneo de versiones y vulnerabilidades

nmap -sCV -p 22,80 172.17.0.2 -oN targeted.txt

Descripción*: Este comando escanea los puertos 22 y 80 del objetivo para identificar servicios y versiones, y guarda la salida en un archivo de texto.

• -sC: Ejecuta los scripts predeterminados de Nmap.

• -sV: Detecta versiones del servicio.

• -p 22,80: Escanea los puertos 22 y 80 específicamente.

• -oN targeted.txt: Guarda la salida en formato legible (Normal) en el archivo targeted.txt.

Escaneo exhaustivo

nmap -A 172.17.0.2 -oN targeted_A.txt -oX xml

Descripción: Este comando realiza un escaneo exhaustivo del objetivo, incluyendo detección de SO y traceroute, y guarda la salida en dos formatos (texto y XML).

• -A: Realiza escaneo de detección avanzada, incluyendo OS detection, traceroute y scripts predeterminados.

• -oN targeted_A.txt: Guarda la salida en formato legible (Normal) en el archivo targeted_A.txt.

• -oX xml: Guarda la salida en formato XML en el archivo xml.

Tratamiento posterior para el xml:

Para convertir el xml a html podemos usar el comando:

xsltproc xml > index.html

Si queremos ver el html en la terminal como texto plano podemos usar el siguiente comando:

html2text index.html

Ejecución de scripts específicos

nmap -p 22,80 --script http-title,http-headers,vuln 172.17.0.2 -oN webScan.txt

Descripción: Este comando escanea los puertos 22 y 80 y ejecuta scripts específicos relacionados con el servicio HTTP, almacenando la salida en un archivo de texto.

• -p 22,80: Escanea los puertos 22 y 80 específicamente.

• --script http-title,http-headers,vuln: Ejecuta scripts específicos:

• http-title: Recupera el título del sitio web.

• http-headers: Muestra las cabeceras HTTP.

• vuln: Ejecuta scripts de detección de vulnerabilidades.

• -oN webScan.txt: Guarda la salida en formato legible (Normal) en el archivo webScan.txt.

Escaneo rápido de puertos UDP

nmap -sU --top-ports 1000 --open -T5 -v -n 192.168.43.26 -oG allPorts_UDP.txt

Descripción: Este comando realiza un escaneo de los 1000 puertos UDP más comunes en el objetivo, mostrando solo los puertos abiertos y generando la salida en formato grepeble.

• -sU: Realiza un escaneo de puertos UDP.

• --top-ports 1000: Escanea los 1000 puertos más comunes.

• --open: Muestra solo los puertos que están abiertos.

• -T5: Establece el nivel de velocidad de escaneo en 5 (el más rápido).

• -v: Muestra la salida en modo detallado (verbose).

• -n: Desactiva la resolución DNS inversa.

• -oG allPorts_UDP: Guarda la salida en formato grepable en el archivo allPorts_UDP.

Técnicas avanzadas para evadir firewalls

En Nmap, existen varias técnicas avanzadas para evadir firewalls y sistemas de detección de intrusiones (IDS). Estas técnicas no garantizan eludir todos los mecanismos de seguridad, pero aumentan las posibilidades de explorar una red de forma sigilosa.

1. MTU (Maximum Transmission Unit)

La opción de MTU permite fragmentar los paquetes de forma que las herramientas de monitoreo o firewalls que esperan recibir paquetes completos tengan dificultades para reconstruirlos correctamente.

Comando:

nmap --mtu 16 <objetivo>

• Uso: --mtu establece el tamaño del paquete en un valor específico (en bytes), fragmentando el escaneo en paquetes pequeños. Los firewalls pueden ignorar paquetes muy fragmentados o no ensamblarlos correctamente, lo que ayuda a evitar la detección.

• Ejemplo de Valores: Comienza con un valor bajo, como 16, y prueba con diferentes tamaños si detectas que el firewall no bloquea paquetes fragmentados.

2. Data Length

El tamaño de Data Length añade datos arbitrarios al paquete, ayudando a disimular los paquetes de escaneo, ya que pueden parecer tráfico de aplicaciones legítimas.

Comando:

nmap --data-length 25 <objetivo>

• Uso: --data-length define la cantidad de datos aleatorios (en bytes) que se añaden a cada paquete de escaneo.

• Ventaja: Esto confunde a los IDS y firewalls que dependen del tamaño del paquete para detectar patrones de escaneo.

• Consejo: Experimenta con diferentes tamaños (entre 10 y 50 suele ser efectivo). Es una buena táctica para intentar disimular los paquetes de escaneo al hacerlos parecer solicitudes legítimas.

3. Source Port (Puerto de Origen)

Especificar un Puerto de Origen imita el tráfico de servicios confiables, como el DNS o HTTP, para evitar el bloqueo.

Comando:

nmap -g 53 <objetivo>

• Uso: -g o --source-port configura el puerto de origen de los paquetes, como el puerto 53 (DNS) o 80 (HTTP).

• Estrategia: Algunos firewalls permiten tráfico entrante desde ciertos puertos conocidos. Usar un puerto como 53 puede hacer que los paquetes se vean como tráfico DNS, que a menudo se permite en las redes.

4. Decoy (Cebo)

La técnica Decoy permite simular múltiples direcciones IP como fuentes del escaneo, enmascarando la IP real entre varias “direcciones señuelo.”

Comando:

nmap -D RND:10 <objetivo>

• Uso: -D especifica múltiples direcciones IP para generar tráfico “cebo.” Puedes escribir direcciones IP manualmente o usar RND:x para generar x direcciones IP aleatorias.

• Ejemplo: -D 192.168.1.5,10.0.0.1,ME (donde ME es tu IP real) o -D RND:10 para agregar 10 IPs falsas aleatorias.

• Beneficio: Esto hace difícil para los sistemas de monitoreo identificar cuál es la IP de origen real, ya que el tráfico parecerá venir de varias direcciones.

5. Idle Scan

El Idle Scan es una técnica avanzada de escaneo en la cual se utiliza un sistema "zombi" (una máquina con una IP diferente y sin actividad) para realizar el escaneo indirectamente.

Comando:

nmap -sI <IP_zombi> <objetivo>

• Uso: -sI usa un "zombi" que actúa como intermediario en el escaneo. El zombi envía el paquete en lugar de la máquina del atacante.

• Requisito: Necesitas una IP de una máquina inactiva o con tráfico mínimo que puedas usar como zombi. La máquina debe tener un contador de IP ID secuencial para este escaneo.

• Ventaja: Como el zombi envía los paquetes, la IP real permanece oculta.

6. Técnicas de Timing (Velocidad del Escaneo)

Controlar la velocidad y los intervalos de los paquetes enviados permite reducir la probabilidad de detección. Nmap ofrece varias opciones para ajustar la velocidad de escaneo, conocidas como niveles de Timing.

Comando:

nmap -T2 <objetivo>

• Uso: -T0 a -T5 controla la agresividad del escaneo. -T0 es el más sigiloso, pero también el más lento, mientras que -T5 es el más rápido y menos sigiloso.

• Recomendación: Utiliza -T2 o -T3 para reducir la posibilidad de detección y mantener un balance entre velocidad y sigilo.

7. Fragmentación de Paquetes

La fragmentación de paquetes envía los paquetes en pequeños fragmentos en lugar de un paquete completo, lo que puede evitar que los firewalls los identifiquen correctamente.

Comando:

nmap -f <objetivo>

• Uso: -f divide el escaneo en fragmentos pequeños (usualmente 8 bytes), lo que complica el análisis del tráfico para los firewalls.

• Advertencia: Esta técnica no es compatible con todos los sistemas, y algunos firewalls más avanzados son capaces de detectar y bloquear paquetes fragmentados.

8. Randomize Hosts

Si tienes una lista grande de objetivos, Nmap puede escanearlos en un orden aleatorio, dificultando la detección de patrones en el tráfico.

Comando:

nmap --randomize-hosts -iL lista_objetivos.txt

• Uso: --randomize-hosts mezcla los objetivos en el archivo lista_objetivos.txt antes de realizar el escaneo, evitando que un IDS detecte un escaneo sistemático.

• Consejo: Esto es útil al escanear subredes grandes donde una secuencia continua de escaneo sería fácil de detectar.

9. Uso de MAC Address Spoofing

Modificando la dirección MAC puedes aparentar que el tráfico viene de un dispositivo de red diferente. Esto puede hacer que el escaneo se vea como tráfico de un dispositivo de confianza.

Comando:

nmap --spoof-mac <mac_address|vendor_name> <objetivo>

• Uso: --spoof-mac cambia la dirección MAC. Puedes especificar una MAC exacta o usar nombres de proveedores comunes (como Apple, Cisco, etc.) para que Nmap asigne una MAC aleatoria que coincide con el proveedor.

• Ejemplo: nmap --spoof-mac 00:11:22:33:44:55 o nmap --spoof-mac Cisco <objetivo>.

• Ventaja: Si el firewall permite tráfico de ciertos dispositivos, esta técnica puede facilitar que tus paquetes pasen desapercibidos.

---

Ejemplo Completo Combinado

Aquí tienes un ejemplo completo que combina varias técnicas para un escaneo avanzado y sigiloso:

nmap -sS -F -T2 --mtu 16 --data-length 25 --source-port 53 --spoof-mac Apple -D RND:10 <objetivo>

En este comando:

1. -sS realiza un escaneo SYN.

2. -F analizar sólo los puertos listados en el archivo nmap-services.

3. -T2 establece una velocidad de escaneo moderada.

4. --mtu 16 fragmenta los paquetes.

5. --data-length 25 añade datos al azar para confundir IDS.

6. --source-port 53 usa el puerto 53 como puerto de origen.

7. --spoof-mac Apple cambia la MAC por una de Apple.

8. -D RND:10 añade 10 IPs señuelo.

Esta configuración crea un escaneo distribuido, fragmentado y con datos aleatorios, mejorando las posibilidades de pasar desapercibido ante un firewall o IDS.

Estas técnicas requieren pruebas y ajustes, ya que la configuración de cada firewall y red puede ser diferente. Algunas combinaciones pueden no funcionar en todas las situaciones, y es recomendable probar diferentes enfoques en ambientes controlados para familiarizarte con sus efectos.

---

Scripts de Nmap

Los scripts de Nmap están escritos en Lua y forman parte del Nmap Scripting Engine (NSE). Estos scripts son utilizados para realizar tareas específicas como detección de vulnerabilidades, recolección de información y explotación básica.

A continuación, hay ejemplos de cómo crear un script básico en Lua para Nmap que detecta vulnerabilidades comunes en servicios como FTP, SSH, HTTP, MariaDB y Samba.

Estructura básica de un script de Nmap

Un script de Nmap tiene esta estructura básica:

-- Descripción del script
description = [[
Este script verifica vulnerabilidades comunes en un servicio específico.
]]

-- Categorías y dependencias
categories = {"vuln", "auth"}
dependencies = {}

-- Definición de argumentos (opcional)
portrule = shortport.port_or_service(21, "ftp")

-- Función principal
action = function(host, port)
    -- Lógica del script
    return "Resultados del escaneo"
end

1. Ejemplo: Script para detectar configuraciones débiles en FTP

-- ftp-weak-auth.nse
description = [[
Detecta configuraciones débiles en servidores FTP, como acceso anónimo habilitado.
]]

categories = {"vuln", "auth"}
portrule = shortport.port_or_service(21, "ftp")

action = function(host, port)
    local socket = nmap.new_socket()
    local status, err = socket:connect(host.ip, port.number)
    
    if not status then
        return ("Error al conectar: %s"):format(err)
    end
    
    socket:send("USER anonymous\r\n")
    local response = socket:receive_lines(1)
    
    if response and response:match("331") then
        socket:send("PASS [e-mail]\r\n")
        local pass_response = socket:receive_lines(1)
        
        if pass_response and pass_response:match("230") then
            return "El servidor FTP permite acceso anónimo. Esto es inseguro."
        else
            return "El servidor FTP no permite acceso anónimo."
        end
    end
    
    socket:close()
    return "No se pudo determinar el estado del servidor FTP."
end

1. Ejemplo: Script para detectar encabezados inseguros en HTTP

-- http-header-check.nse
description = [[
Verifica si el servidor HTTP tiene encabezados de seguridad faltantes como X-Frame-Options o Content-Security-Policy.
]]

categories = {"vuln", "safe"}
portrule = shortport.port_or_service(80, "http")

action = function(host, port)
    local socket = nmap.new_socket()
    local status, err = socket:connect(host.ip, port.number)
    
    if not status then
        return ("Error al conectar: %s"):format(err)
    end
    
    socket:send("GET / HTTP/1.1\r\nHost: " .. host.ip .. "\r\n\r\n")
    local response = socket:receive_lines(10)
    
    local issues = {}
    if not response:match("X%-Frame%-Options") then
        table.insert(issues, "Falta el encabezado X-Frame-Options.")
    end
    if not response:match("Content%-Security%-Policy") then
        table.insert(issues, "Falta el encabezado Content-Security-Policy.")
    end
    
    socket:close()
    
    if #issues > 0 then
        return "Problemas encontrados:\n" .. table.concat(issues, "\n")
    else
        return "Todos los encabezados de seguridad están configurados."
    end
end

1. Ejemplo: Script para verificar vulnerabilidades en Samba

-- samba-vuln-check.nse
description = [[
Busca vulnerabilidades conocidas en servidores Samba, como acceso a carpetas compartidas sin autenticación.
]]

categories = {"vuln", "safe"}
portrule = shortport.port_or_service(139, "netbios-ssn")

action = function(host, port)
    local smb = require "smb"
    local status, err = smb.start_session(host, port)
    
    if not status then
        return ("Error al conectar con Samba: %s"):format(err)
    end
    
    local shares = smb.list_shares()
    local issues = {}
    for _, share in ipairs(shares) do
        if share.access == "read/write" then
            table.insert(issues, "Carpeta compartida accesible: " .. share.name)
        end
    end
    
    smb.end_session()
    
    if #issues > 0 then
        return "Vulnerabilidades encontradas:\n" .. table.concat(issues, "\n")
    else
        return "No se encontraron carpetas compartidas vulnerables."
    end
end

Guardar y ejecutar los scripts

1. Guarda el archivo con la extensión .nse en el directorio de scripts de Nmap, como /usr/share/nmap/scripts/.

2. Actualiza la base de datos de scripts de Nmap:

nmap --script-updatedb

1. Ejecuta el script especificando el servicio:

nmap -p 21 --script ftp-weak-auth <IP>
nmap -p 80 --script http-header-check <IP>
nmap -p 139 --script samba-vuln-check <IP>

---

Consejos para crear scripts en Lua para Nmap

• Familiarízate con las bibliotecas internas de Nmap, como http, smb, ftp, etc.

• Usa el comando nmap --script-help <script> para probar y depurar tus scripts.

• Consulta la documentación oficial de NSE: Nmap NSE Docs.

Estos ejemplos son solo una base; puedes personalizarlos para adaptarlos a necesidades específicas o agregar lógica más avanzada.