Usar Nmap para Detectar y Evadir Firewalls con Nmap

Introducción

En este laboratorio, aprenderá cómo utilizar Nmap para detectar y eludir las restricciones de los firewalls en el ámbito de la seguridad de redes. Los firewalls son elementos de seguridad vitales que filtran el tráfico de red de acuerdo con reglas predefinidas. Como profesional de la seguridad, es fundamental entender cómo eludir los firewalls para realizar evaluaciones de seguridad completas e identificar vulnerabilidades.

Exploraremos diversas técnicas de elusión de firewalls con Nmap, una potente herramienta de escaneo de redes. Estas técnicas permiten a los expertos en seguridad probar las defensas de la red imitando los intentos de posibles atacantes para eludir las medidas de seguridad. Al final de este laboratorio, obtendrá experiencia práctica con las funciones de elusión de firewalls de Nmap y entenderá sus aplicaciones en la seguridad de redes.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL nmap(("Nmap")) -.-> nmap/NmapGroup(["Nmap"]) nmap/NmapGroup -.-> nmap/installation("Installation and Setup") nmap/NmapGroup -.-> nmap/save_output("Save Output to File") nmap/NmapGroup -.-> nmap/port_scanning("Port Scanning Methods") nmap/NmapGroup -.-> nmap/target_specification("Target Specification") nmap/NmapGroup -.-> nmap/firewall_evasion("Firewall Evasion Techniques") subgraph Lab Skills nmap/installation -.-> lab-415921{{"Usar Nmap para Detectar y Evadir Restricciones de Firewall"}} nmap/save_output -.-> lab-415921{{"Usar Nmap para Detectar y Evadir Restricciones de Firewall"}} nmap/port_scanning -.-> lab-415921{{"Usar Nmap para Detectar y Evadir Restricciones de Firewall"}} nmap/target_specification -.-> lab-415921{{"Usar Nmap para Detectar y Evadir Restricciones de Firewall"}} nmap/firewall_evasion -.-> lab-415921{{"Usar Nmap para Detectar y Evadir Restricciones de Firewall"}} end

Configuración de un servicio local para el escaneo

Antes de poder comenzar a practicar técnicas de escaneo con Nmap, es esencial tener un servicio objetivo para escanear. Piénsalo como tener un blanco en un campo de tiro. En este paso, crearemos un simple servidor HTTP en nuestra máquina local. Este servidor actuará como el objetivo de todos nuestros ejercicios de escaneo.

Primero, necesitamos abrir una terminal. Una terminal es como un centro de comandos donde podemos dar instrucciones a nuestra computadora. Una vez abierta la terminal, crearemos una estructura de directorios para nuestro servicio HTTP. Un directorio es similar a una carpeta en tu computadora y nos ayuda a organizar nuestros archivos.

mkdir -p /home/labex/project/http_service

El comando mkdir significa "crear directorio". La opción -p asegura que si algún directorio intermedio en la ruta no existe, se creará. Entonces, este comando crea un directorio llamado http_service dentro de la ruta /home/labex/project.

A continuación, necesitamos navegar al directorio recién creado. Al igual que abrirías una carpeta en tu computadora para acceder a su contenido, usamos el comando cd para movernos al directorio.

cd /home/labex/project/http_service

Ahora, crearemos un simple archivo HTML. HTML es el lenguaje utilizado para crear páginas web. Nuestro servidor HTTP servirá este archivo HTML a cualquiera que lo solicite.

echo "<html><body><h1>Welcome to the StarPath Exploration Server</h1></body></html>" > index.html

El comando echo imprime el texto dentro de las comillas. El símbolo > redirige esa salida a un archivo llamado index.html. Entonces, este comando crea un archivo llamado index.html con el contenido HTML básico especificado.

Para asegurarnos de que el archivo se haya creado correctamente, podemos ver su contenido. Usamos el comando cat para este propósito.

cat index.html

El comando cat lee el contenido de un archivo y lo muestra en la terminal. Deberías ver el contenido HTML que acabamos de crear:

<html><body><h1>Welcome to the StarPath Exploration Server</h1></body></html>

Ahora, es hora de iniciar un simple servidor HTTP. Usaremos el módulo incorporado http.server de Python. Python es un lenguaje de programación y este módulo nos permite configurar rápidamente un servidor web.

python3 -m http.server 8000

La opción -m en Python se utiliza para ejecutar un módulo como un script. Aquí, estamos ejecutando el módulo http.server y le estamos indicando que escuche en el puerto 8000. Un puerto es como una puerta por la cual los datos entran y salen de una computadora.

Después de ejecutar este comando, deberías ver una salida similar a:

Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ...

Esta salida indica que el servidor HTTP está en funcionamiento y está esperando conexiones en el puerto 8000. Es importante dejar esta ventana de terminal abierta porque si la cierras, el servidor dejará de funcionar.

Has configurado con éxito un servicio local. En los siguientes pasos, usaremos este servicio como objetivo para nuestros ejercicios de escaneo con Nmap.

Escaneo básico con Nmap evadiendo la detección de hosts

En este paso, realizaremos nuestro primer escaneo con Nmap. Pero antes de comenzar, entendamos un concepto clave. Muchos firewalls están configurados para bloquear las solicitudes de eco ICMP, comúnmente conocidas como "ping". Nmap generalmente utiliza estas solicitudes de ping para verificar si un host está en línea antes de comenzar a escanear los puertos. Sin embargo, al evadir esta fase de detección de hosts, todavía podemos escanear los objetivos incluso cuando el tráfico ICMP está bloqueado por el firewall.

Primero, asegúrate de mantener el servidor HTTP en ejecución en la terminal anterior. Luego, abre una nueva ventana de terminal. En esta nueva terminal, necesitamos navegar al directorio del proyecto. El directorio del proyecto es donde se almacenan todos nuestros archivos y configuraciones relevantes para este experimento. Para hacer esto, usaremos el comando cd, que significa "cambiar de directorio". Aquí está el comando:

cd /home/labex/project

Ahora que estamos en el directorio correcto, es hora de ejecutar un escaneo básico con Nmap en nuestro servidor HTTP local. Usaremos la opción -Pn en el comando de Nmap. Esta opción le dice a Nmap que omita el paso de detección de hosts y asuma que el objetivo está en línea. Aquí está el comando:

nmap -Pn --reason -p 8000 localhost

Desglosemos las opciones del comando para entender lo que hace cada una:

-Pn: Esta opción omite el proceso de detección de hosts. En lugar de verificar si el objetivo está en línea usando ping, Nmap asumirá directamente que el objetivo está en línea y comenzará a escanear los puertos.
--reason: Esta opción hace que Nmap muestre la razón por la cual un puerto está en un estado particular. Por ejemplo, si un puerto está abierto, nos dirá por qué se considera abierto.
-p 8000: Esta opción le dice a Nmap que escanee solo el puerto 8000. Estamos interesados en este puerto específico porque nuestro servidor HTTP local está ejecutándose en él.
localhost: Este es el objetivo que queremos escanear. En este caso, localhost se refiere a nuestra máquina local.

Después de ejecutar el comando, deberías ver una salida similar a esta:

Starting Nmap 7.80 ( https://nmap.org ) at 2023-09-05 15:30 UTC
Nmap scan report for localhost (127.0.0.1)
Host is up, received localhost-response (0.000097s latency).

PORT     STATE SERVICE      REASON
8000/tcp open  http-alt     syn-ack

Nmap done: 1 IP address (1 host up) scanned in 0.03 seconds

La salida muestra que el puerto 8000 está abierto y ejecutando un servicio HTTP. La columna "REASON" dice "syn-ack", lo que significa que cuando Nmap intentó conectarse al puerto, el puerto respondió con un paquete SYN-ACK. Esta es una forma estándar en la que un servidor acepta una solicitud de conexión en el protocolo TCP.

A continuación, queremos guardar los resultados del escaneo en un archivo. Guardar los resultados es útil porque nos permite analizarlos más tarde, compartirlos con otros o compararlos con futuros escaneos. Para guardar los resultados, usaremos el símbolo >, que redirige la salida del comando de Nmap a un archivo. Aquí está el comando:

nmap -Pn --reason -p 8000 localhost > /home/labex/project/nmap_scan.txt

Finalmente, veamos los resultados del escaneo guardados. Usaremos el comando cat, que significa "concatenar". Este comando lee el contenido de un archivo y lo muestra en la terminal. Aquí está el comando:

cat /home/labex/project/nmap_scan.txt

Deberías ver los mismos resultados del escaneo que se mostraron previamente en la terminal.

Este escaneo básico nos muestra cómo se puede usar la opción -Pn para evadir las reglas de firewall que bloquean las sondas de ping. En una situación del mundo real, esta técnica puede ser muy útil cuando necesitas escanear hosts que están protegidos por firewalls que bloquean el tráfico ICMP.

Evasión avanzada de firewall con fragmentación de paquetes

En este paso, exploraremos una técnica de evasión de firewall más avanzada llamada fragmentación de paquetes. Antes de profundizar, entendamos qué es la fragmentación de paquetes. Cuando se envían datos a través de una red, se dividen en unidades más pequeñas llamadas paquetes. Algunos firewalls y Sistemas de Detección de Intrusiones (IDS, por sus siglas en inglés) están diseñados para inspeccionar estos paquetes en busca de signos de actividad maliciosa. Sin embargo, estos sistemas de seguridad pueden tener dificultades para procesar paquetes fragmentados, que son paquetes que se han dividido en piezas aún más pequeñas. Esta dificultad puede brindarnos una oportunidad para eludir ciertas medidas de seguridad durante nuestros escaneos.

Seguiremos utilizando nuestro servidor HTTP local como objetivo para nuestro escaneo. Primero, necesitamos navegar al directorio adecuado en la terminal donde realizamos nuestro escaneo anterior. Este directorio es donde se encuentran nuestros archivos de proyecto, y es importante estar en este directorio para que nuestros comandos funcionen correctamente. Para hacer esto, ejecutaremos el siguiente comando:

cd /home/labex/project

Ahora que estamos en el directorio correcto, estamos listos para ejecutar un escaneo utilizando la opción de fragmentación de Nmap. Esta opción dividirá los paquetes IP en fragmentos más pequeños, lo que dificultará que los filtros de paquetes detecten nuestro escaneo. Aquí está el comando que usaremos:

sudo nmap -f -Pn --reason -p 8000 localhost

Desglosemos la opción adicional -f en este comando. La opción -f le dice a Nmap que fragmente los paquetes IP. Al hacer esto, estamos dificultando que los filtros de paquetes analicen los paquetes y detecten que estamos realizando un escaneo.

Después de ejecutar el comando, deberías ver una salida similar a la siguiente:

Starting Nmap 7.80 ( https://nmap.org ) at 2025-03-18 16:46 CST
Nmap scan report for localhost (127.0.0.1)
Host is up, received user-set (0.000062s latency).
Other addresses for localhost (not scanned): ::1

PORT     STATE SERVICE  REASON
8000/tcp open  http-alt syn-ack ttl 64

Nmap done: 1 IP address (1 host up) scanned in 0.08 seconds

Esta salida nos muestra los resultados de nuestro escaneo. Nos dice que el host (localhost) está activo y que el puerto 8000 está abierto.

A continuación, queremos guardar estos resultados en un archivo separado. De esta manera, podemos consultarlos más tarde y compararlos con otros resultados de escaneo. Para guardar los resultados, ejecutaremos el siguiente comando:

sudo nmap -f -Pn --reason -p 8000 localhost > /home/labex/project/nmap_frag_scan.txt

El símbolo > en este comando redirige la salida del escaneo de Nmap al archivo especificado.

Ahora, veamos el contenido de este archivo para asegurarnos de que los resultados se hayan guardado correctamente. Usaremos el comando cat, que se utiliza para mostrar el contenido de un archivo:

cat /home/labex/project/nmap_frag_scan.txt

Los resultados del escaneo pueden parecer similares a nuestro escaneo anterior, pero la técnica subyacente es diferente. En este caso, Nmap fragmentó los paquetes IP en piezas más pequeñas, lo que dificulta que los filtros de paquetes sin estado detecten el escaneo.

Comparemos los dos métodos de escaneo que hemos utilizado hasta ahora: el escaneo regular y el escaneo fragmentado. Crearemos un nuevo archivo para almacenar esta comparación. Aquí están los comandos para hacerlo:

echo "Comparing regular scan vs. fragmented scan:" > /home/labex/project/scan_comparison.txt
echo "---------------------------------------------" >> /home/labex/project/scan_comparison.txt
echo "" >> /home/labex/project/scan_comparison.txt
echo "1. Regular scan with -Pn:" >> /home/labex/project/scan_comparison.txt
cat /home/labex/project/nmap_scan.txt >> /home/labex/project/scan_comparison.txt
echo "" >> /home/labex/project/scan_comparison.txt
echo "2. Fragmented scan with -f -Pn:" >> /home/labex/project/scan_comparison.txt
cat /home/labex/project/nmap_frag_scan.txt >> /home/labex/project/scan_comparison.txt

Estos comandos primero escriben un encabezado en el archivo de comparación, luego agregan los resultados del escaneo regular y del escaneo fragmentado al archivo.

Ahora, examinemos nuestra comparación mostrando el contenido del archivo de comparación:

cat /home/labex/project/scan_comparison.txt

En nuestro entorno controlado, los resultados de los dos escaneos pueden parecer similares. Sin embargo, en escenarios del mundo real, estas diferentes técnicas pueden tener niveles variables de éxito frente a diferentes configuraciones de firewall. La fragmentación de paquetes (-f) es particularmente efectiva contra los filtros de paquetes sin estado. Los filtros de paquetes sin estado examinan cada paquete de forma independiente y, a menudo, no pueden reensamblar los fragmentos para inspeccionar el paquete completo, lo que da a nuestro escaneo fragmentado más posibilidades de eludir estos filtros.

Para una fragmentación aún mayor, Nmap te permite aumentar el nivel utilizando múltiples marcas -f (por ejemplo, -ff) o especificando un tamaño personalizado de Unidad Máxima de Transmisión (MTU, por sus siglas en inglés) con la opción --mtu. La MTU es el tamaño máximo de un paquete que se puede transmitir a través de una red. Al especificar una MTU personalizada, puedes controlar cómo se fragmentan los paquetes.

Esta técnica demuestra cómo se puede utilizar la fragmentación de paquetes como un método adicional para eludir la detección del firewall al realizar evaluaciones de seguridad.

Resumen

En este laboratorio, has aprendido cómo identificar y eludir las restricciones de firewall utilizando las técnicas de evasión de firewall de Nmap. Primero, configuraste un servidor HTTP local como objetivo para el escaneo, creando un entorno seguro para practicar diferentes métodos de escaneo sin afectar a sistemas externos. Luego, realizaste un escaneo básico con Nmap utilizando la opción -Pn para eludir la detección de hosts, lo cual es útil cuando los firewalls bloquean las solicitudes de eco ICMP. Esto te permitió escanear puertos que podrían estar ocultos detrás de las reglas del firewall.

A continuación, exploraste una técnica de evasión avanzada: la fragmentación de paquetes utilizando la opción -f. Este método fragmenta los paquetes IP, lo que dificulta que los filtros de paquetes sin estado detecten y bloqueen el escaneo. Al comparar los resultados de ambas técnicas, comprendiste sus diferencias y aplicaciones. Estas técnicas son esenciales para los profesionales de seguridad para realizar evaluaciones de seguridad exhaustivas. Sin embargo, recuerda utilizarlas solo en evaluaciones autorizadas con los permisos adecuados para evitar violar leyes y políticas.