Evadir Firewalls con Nmap

Introducción

En este laboratorio, aprenderá técnicas avanzadas de Nmap para eludir las protecciones de firewall en escenarios reales de ciberseguridad. Practicará métodos de evasión como el escaneo fragmentado y el spoofing de IP de señuelo mientras trabaja con firewalls configurados con iptables.

Los ejercicios prácticos lo guiarán a través de la instalación de Nmap, la configuración de reglas de firewall y el análisis de resultados. Adquirirá experiencia práctica en la evaluación y el eludido de medidas de seguridad de red a través de experimentos de escaneo controlados.

Instalar Nmap

En este paso, instalará Nmap, una poderosa herramienta de escaneo de red utilizada para auditorías de seguridad y exploración de redes. Nmap ayuda a identificar hosts y servicios en una red enviando paquetes y analizando las respuestas. Piénsalo como un cartógrafo digital que descubre qué dispositivos están conectados a una red y qué servicios están ejecutando.

El entorno de la máquina virtual (VM) de LabEx ya tiene las dependencias necesarias instaladas, lo que hace que el proceso de instalación sea sencillo. Siga estos pasos para instalar Nmap:

Abra la terminal en su máquina virtual de LabEx (puede usar la terminal de Xfce o hacer clic derecho en el escritorio y seleccionar "Abrir Terminal"). La terminal es donde ingresará todos los comandos para este laboratorio.
Primero, actualice la lista de paquetes para asegurarse de obtener la última versión. Esto es como actualizar una tienda de aplicaciones antes de descargar nuevo software:
```
sudo apt update
```
Instale Nmap utilizando el siguiente comando. La bandera -y confirma automáticamente cualquier solicitud durante la instalación:
```
sudo apt install -y nmap
```
Después de que se complete la instalación, verifique que Nmap se haya instalado correctamente comprobando su versión. Esto confirma que la instalación fue exitosa:
```
nmap --version
```
Debería ver una salida similar a:
```
Nmap version 7.92 ( https://nmap.org )
```
Para una verificación adicional, realice un escaneo sencillo contra el localhost (su propia máquina). Esto le ayudará a entender cómo funciona Nmap antes de escanear otros objetivos:
```
nmap -sV 127.0.0.1
```
Este comando escanea su máquina local (127.0.0.1) y muestra los puertos abiertos (la bandera -sV detecta las versiones de los servicios). Verá una lista de servicios que se están ejecutando en su máquina, lo cual es útil para entender el formato de salida de Nmap.

Preparar un Objetivo con Firewall

En este paso, configurará un firewall sencillo utilizando iptables para crear un entorno de objetivo protegido para sus pruebas de escaneo con Nmap. Los firewalls actúan como barreras de seguridad que controlan el tráfico de red, y entender cómo escanear a través de ellos es esencial para los profesionales de la seguridad de redes. Esta configuración simulará un escenario del mundo real en el que el escaneo de red debe eludir las protecciones del firewall.

Primero, verifiquemos que iptables esté disponible en su sistema. iptables es un programa de utilidad en el espacio de usuario que permite a los administradores configurar reglas de firewall en Linux. Debería estar preinstalado en la máquina virtual de LabEx:
```
sudo iptables --version
```
Antes de crear nuevas reglas, es una buena práctica borrar cualquier regla de firewall existente. Esto asegura que comenzamos con una configuración limpia y evita conflictos con configuraciones previas:
```
sudo iptables -F
sudo iptables -X
```
Ahora estableceremos las políticas predeterminadas. La política predeterminada determina qué sucede con los paquetes que no coinciden con ninguna regla específica. Rechazaremos (DROP) todo el tráfico entrante y reenviado mientras permitimos las conexiones salientes:
```
sudo iptables -P INPUT DROP
sudo iptables -P FORWARD DROP
sudo iptables -P OUTPUT ACCEPT
```
Incluso con reglas de firewall estrictas, necesitamos permitir la comunicación en el localhost (lo). Muchos servicios del sistema dependen de la comunicación interna, por lo que esta excepción es necesaria:
```
sudo iptables -A INPUT -i lo -j ACCEPT
```
Creemos reglas específicas para simular un servidor web protegido. Estas reglas permitirán el tráfico entrante solo en los puertos estándar para SSH (22), HTTP (80) y HTTPS (443), imitando una configuración típica de un servidor de producción:
```
sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT  ## SSH
sudo iptables -A INPUT -p tcp --dport 80 -j ACCEPT  ## HTTP
sudo iptables -A INPUT -p tcp --dport 443 -j ACCEPT ## HTTPS
```
Después de configurar las reglas, es importante verificarlas. La bandera -L lista todas las reglas, -n muestra la salida numérica (más rápida y evita consultas DNS) y -v proporciona información detallada:
```
sudo iptables -L -n -v
```
Debería ver una salida que muestra las reglas configuradas con la política predeterminada de DROP para el tráfico no coincidente.
Finalmente, guardaremos las reglas para que sean persistentes. Este paso es particularmente importante en nuestro entorno de LabEx, ya que no podemos usar systemctl en Docker para mantener las reglas después de reinicios:
```
sudo sh -c "iptables-save > /etc/iptables.rules"
```

Ejecutar un Escaneo Fragmentado

En este paso, aprenderá cómo realizar un escaneo fragmentado utilizando Nmap para eludir las protecciones básicas de un firewall. Los firewalls a menudo inspeccionan paquetes de red completos, pero la fragmentación divide los paquetes en partes más pequeñas, lo que los hace más difíciles de detectar por reglas de firewall simples que no reensamblan los fragmentos.

Primero, verifique que las reglas de firewall del paso anterior sigan activas. Esto ayuda a establecer una línea base antes de probar técnicas de elusión:
```
sudo iptables -L -n -v
```
Realice un escaneo SYN estándar de Nmap contra el localhost para ver cómo responde el firewall sin ninguna técnica de elusión. Esto nos mostrará qué puertos están siendo bloqueados activamente:
```
nmap -sS 127.0.0.1
```
Tenga en cuenta qué puertos se muestran como filtrados o cerrados; estos son los que el firewall está protegiendo.
Ahora, realice un escaneo fragmentado utilizando la opción -f. Esto le indica a Nmap que divida los encabezados TCP en múltiples paquetes más pequeños (fragmentos de 8 bytes):
```
nmap -f -sS 127.0.0.1
```
Algunos firewalls pueden no reensamblar adecuadamente estos fragmentos, lo que permite que el escaneo pase a través.
Para una fragmentación más agresiva, utilice tamaños de paquete más pequeños con la opción --mtu. Esto establece la Unidad Máxima de Transmisión en 16 bytes, creando fragmentos aún más pequeños:
```
nmap --mtu 16 -sS 127.0.0.1
```
Fragmentos más pequeños pueden eludir implementaciones de firewall más primitivas.
Combine la fragmentación con el control de tiempo para mayor sigilo. La opción -T2 hace que el escaneo sea más lento y menos probable que active sistemas de detección de intrusiones:
```
nmap -f -T2 -sS 127.0.0.1
```
Este enfoque imita patrones de tráfico de red más normales.
Compare los resultados de diferentes tipos de escaneos para evaluar la efectividad de la fragmentación:
```
nmap -sS 127.0.0.1 | grep filtered
nmap -f -sS 127.0.0.1 | grep filtered
```
Note cualquier diferencia en el número de puertos filtrados; menos puertos filtrados indican una elusión exitosa del firewall.

Agregar IPs de Distracción

En este paso, aprenderá cómo utilizar la técnica de escaneo con distracciones de Nmap para ocultar su dirección IP real entre múltiples direcciones de origen falsas. Esto ayuda a eludir la detección al dificultar la identificación de la máquina real que está realizando el escaneo. Cuando los sistemas de seguridad ven tráfico proveniente de múltiples IPs, no pueden determinar fácilmente cuál es el escáner real.

Primero, verifique su dirección IP actual para entender lo que vamos a ocultar. Esto establece una línea base para que pueda ver cómo las IPs de distracción ocultarán su dirección real:
```
ip a
```
Tenga en cuenta su dirección IP real (por lo general, que comienza con 172 o 192). Esta es la dirección que vamos a ocultar entre las distracciones.
Realice un escaneo básico con IPs de distracción utilizando la opción -D. Aquí especificamos tres IPs falsas e incluimos nuestra IP real con el marcador ME:
```
sudo nmap -D 192.168.1.1,192.168.1.2,192.168.1.3,ME 127.0.0.1
```
El marcador ME representa su dirección IP real, que se mezclará con las distracciones.
Para distracciones más realistas, utilice direcciones IP aleatorias. Esto suele ser mejor que utilizar patrones de IP predecibles:
```
sudo nmap -D RND:5 127.0.0.1
```
Esto genera 5 direcciones IP de distracción aleatorias que parecen más naturales para los sistemas de monitoreo.
Combine las distracciones con técnicas de elusión anteriores como la fragmentación (-f) y el control de tiempo (-T2):
```
sudo nmap -D 10.0.0.1,10.0.0.2,10.0.0.3 -f -T2 127.0.0.1
```
Combinar múltiples métodos de elusión hace que la detección sea aún más difícil.
Verifique el efecto de las distracciones revisando los registros del firewall (simulados). Esto muestra cómo el firewall vería múltiples direcciones IP de origen:
```
sudo iptables -L -n -v | grep -E "192.168|10.0"
```
Debería ver entradas para todas las IPs de distracción que utilizamos en nuestros escaneos.
Para un uso avanzado, especifique redes de distracción. Esto crea un rango de direcciones de distracción de la misma red:
```
sudo nmap -D 192.168.1.1-10 127.0.0.1
```
Esto genera 10 IPs de distracción secuenciales de la red 192.168.1.0.

Verificar Éxito de Evasión

En este último paso, evaluará la efectividad de sus técnicas de elusión de escaneo analizando los registros del firewall y comparando los resultados de los escaneos realizados con diferentes métodos. Esto le ayudará a entender qué técnicas lograron eludir la detección del firewall y cuáles fueron marcadas como actividades sospechosas.

Primero, revise los registros actuales del firewall para ver los intentos de escaneo detectados. Esto le dará una idea de cómo se ve la actividad normal del firewall antes de probar las técnicas de elusión:
```
sudo iptables -L -n -v | grep -E "DROP|REJECT"
```
Este comando muestra cuántos paquetes fueron bloqueados por las reglas de su firewall, y los contadores indican los intentos de detección.
Ahora, cree dos informes de escaneo para comparar: uno utilizando un escaneo básico y otro con técnicas de elusión. La diferencia entre ellos mostrará la efectividad de su elusión:
```
nmap -sS 127.0.0.1 -oN basic_scan.txt
nmap -f -D RND:3 127.0.0.1 -oN evasion_scan.txt
```
El primer comando realiza un escaneo SYN estándar, mientras que el segundo utiliza fragmentación (-f) y direcciones IP de distracción (-D RND:3).
Analice las diferencias entre los resultados de los escaneos para ver qué puertos fueron filtrados en cada caso:
```
diff basic_scan.txt evasion_scan.txt
```
Presta especial atención al número de puertos "filtrados" en cada informe. Un menor número de puertos filtrados en el escaneo de elusión indica un éxito en la elusión del firewall.
Para comprobar específicamente si la elusión fue exitosa, restablezca los contadores del firewall y realice un escaneo de elusión mientras monitorea la detección:
```
sudo iptables -Z && sudo nmap -f -D RND:3 127.0.0.1 && sudo iptables -L -n -v
```
Los valores de los contadores muestran cuántos paquetes fueron detectados por el firewall durante su intento de elusión.
Para una prueba exhaustiva, combine múltiples técnicas de elusión para maximizar sus posibilidades de eludir la seguridad:
```
sudo nmap -f -D RND:5 -T2 --data-length 24 127.0.0.1 -oN final_scan.txt
```
Esto utiliza fragmentación, 5 direcciones IP de distracción, un tiempo de escaneo más lento (-T2) y relleno de datos aleatorio (--data-length 24).
Finalmente, genere un informe resumen comparando los puertos filtrados entre el escaneo básico y el de elusión:
```
echo "Basic scan filtered ports:" && grep filtered basic_scan.txt | wc -l
echo "Evasion scan filtered ports:" && grep filtered evasion_scan.txt | wc -l
```
Una reducción significativa en el número de puertos filtrados entre los dos escaneos demuestra una elusión exitosa del firewall.

Resumen

En este laboratorio, has aprendido técnicas esenciales de elusión de firewalls con Nmap para evaluaciones de ciberseguridad. Los ejercicios te han guiado a través de la instalación de Nmap, el escaneo básico y la creación de un entorno de prueba controlado utilizando iptables para simular redes protegidas.

Has practicado dos métodos principales de elusión: la fragmentación de paquetes para eludir los sistemas de detección y el uso de direcciones IP de distracción para ocultar el origen de los escaneos. Estas habilidades te permiten evaluar las defensas de una red replicando patrones de ataque del mundo real mientras se mantienen estándares de prueba ética.