Simular Condiciones de Red en Nmap

Introducción

En este laboratorio, aprenderá a simular diversas condiciones de red utilizando Nmap. Esto incluye simular sumas de comprobación incorrectas y manipular la Unidad de Transmisión Máxima (MTU) para comprender su impacto en la exploración de redes.

Explorará comandos como nmap --badsum 192.168.1.1 para enviar paquetes con sumas de comprobación dañadas, nmap --mtu 1400 127.0.0.1 para establecer una MTU específica y combinaciones de los mismos. También aprenderá a agregar detalle con -v y guardar los resultados en un archivo utilizando -oN. Finalmente, analizará los efectos de estas simulaciones en la terminal Xfce.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL nmap(("Nmap")) -.-> nmap/NmapGroup(["Nmap"]) nmap/NmapGroup -.-> nmap/basic_syntax("Basic Command Syntax") nmap/NmapGroup -.-> nmap/output_formats("Output Formats") nmap/NmapGroup -.-> nmap/save_output("Save Output to File") nmap/NmapGroup -.-> nmap/scan_types("Scan Types and Techniques") nmap/NmapGroup -.-> nmap/target_specification("Target Specification") nmap/NmapGroup -.-> nmap/timing_performance("Timing and Performance") nmap/NmapGroup -.-> nmap/verbosity("Verbosity Levels") nmap/NmapGroup -.-> nmap/syn_scan("SYN Scan") subgraph Lab Skills nmap/basic_syntax -.-> lab-547113{{"Simular Condiciones de Red en Nmap"}} nmap/output_formats -.-> lab-547113{{"Simular Condiciones de Red en Nmap"}} nmap/save_output -.-> lab-547113{{"Simular Condiciones de Red en Nmap"}} nmap/scan_types -.-> lab-547113{{"Simular Condiciones de Red en Nmap"}} nmap/target_specification -.-> lab-547113{{"Simular Condiciones de Red en Nmap"}} nmap/timing_performance -.-> lab-547113{{"Simular Condiciones de Red en Nmap"}} nmap/verbosity -.-> lab-547113{{"Simular Condiciones de Red en Nmap"}} nmap/syn_scan -.-> lab-547113{{"Simular Condiciones de Red en Nmap"}} end

Simular una suma de comprobación incorrecta con nmap --badsum 192.168.1.1

En este paso, exploraremos cómo simular una suma de comprobación incorrecta utilizando Nmap. Las sumas de comprobación se utilizan para verificar la integridad de los datos transmitidos a través de una red. Una suma de comprobación incorrecta indica que los datos se han corrompido durante la transmisión. Simular una suma de comprobación incorrecta puede ser útil para probar cómo un sistema maneja paquetes corrompidos.

Primero, entendamos la sintaxis básica del comando:

nmap --badsum <target_ip>

Aquí, --badsum es la opción que le dice a Nmap que genere paquetes con una suma de comprobación inválida. <target_ip> es la dirección IP del objetivo que desea escanear.

Antes de ejecutar el comando, es importante entender que enviar paquetes con sumas de comprobación incorrectas puede ser interpretado como actividad maliciosa por algunos dispositivos de red o sistemas de seguridad. Por lo tanto, es mejor utilizar esta opción en una red de prueba o en un objetivo para el que tenga permiso explícito para escanear.

Ahora, ejecutemos el comando. Vamos a dirigirnos a la dirección IP 192.168.1.1. Asegúrese de tener los permisos necesarios y de que la escanear esta IP está permitida.

Abra su terminal Xfce y ejecute el siguiente comando:

sudo nmap --badsum 192.168.1.1

Es probable que vea una salida que indique que Nmap está enviando paquetes con una suma de comprobación incorrecta. La salida exacta dependerá del sistema objetivo y de la configuración de red.

Salida de ejemplo (puede variar):

Starting Nmap 7.80 ( https://nmap.org )
Nmap scan report for 192.168.1.1
Host is up (0.00043s latency).
All 1000 scanned ports on 192.168.1.1 are filtered
Nmap done: 1 IP address (1 host up) scanned in 4.63 seconds

Nota: La salida muestra que todos los puertos están filtrados. Esto es solo un ejemplo, y el resultado real depende del objetivo. Lo importante es que Nmap ejecutó el escaneo con la opción --badsum.

Este comando envía paquetes a 192.168.1.1 con sumas de comprobación deliberadamente corrompidas. Esto se puede utilizar para probar cómo un sistema maneja paquetes inválidos.

Establecer la MTU con nmap --mtu 1400 127.0.0.1

En este paso, aprenderemos cómo establecer el tamaño de la Unidad de Transmisión Máxima (MTU) utilizando Nmap. La MTU es el tamaño máximo de paquete (en bytes) que una interfaz de red puede transmitir. Por defecto, Nmap descubre automáticamente la MTU de su red. Sin embargo, puede establecer manualmente el valor de la MTU con fines de prueba.

El comando que utilizaremos es:

nmap --mtu <mtu_value> <target_ip>

Aquí, --mtu especifica el valor de la MTU que se utilizará para el escaneo, y <target_ip> es la dirección IP del objetivo.

En este caso específico, estableceremos la MTU en 1400 y direccionaremos la dirección de bucle 127.0.0.1. La dirección de bucle es una dirección IP especial que siempre se refiere a la máquina local. Esto nos permite probar la configuración de la MTU de Nmap sin enviar paquetes a través de una red.

Abra su terminal Xfce y ejecute el siguiente comando:

sudo nmap --mtu 1400 127.0.0.1

Verá la salida de Nmap que indica que está escanear la dirección de bucle. La salida también mostrará que la MTU está establecida en 1400.

Salida de ejemplo (puede variar):

Starting Nmap 7.80 ( https://nmap.org )
Nmap scan report for localhost (127.0.0.1)
Host is up (0.0000090s latency).
All 1000 scanned ports on localhost (127.0.0.1) are closed
Nmap done: 1 IP address (1 host up) scanned in 0.02 seconds

Este comando le dice a Nmap que use una MTU de 1400 cuando envía paquetes a 127.0.0.1. Esto puede ser útil para probar cómo un sistema maneja paquetes de un tamaño específico.

Combinar la MTU y el escaneo con nmap -sS --mtu 1000 192.168.1.1

En este paso, combinaremos la configuración de la MTU con un tipo de escaneo específico. Usaremos el escaneo SYN (-sS) junto con la opción --mtu para realizar un escaneo con un tamaño de MTU especificado.

El escaneo SYN (-sS) es un escaneo sigiloso que solo envía paquetes SYN al objetivo. Es más rápido y menos detectable que un escaneo de conexión TCP completo.

El comando que usaremos es:

nmap -sS --mtu <mtu_value> <target_ip>

Aquí, -sS especifica el tipo de escaneo SYN, --mtu establece el valor de la MTU y <target_ip> es la dirección IP del objetivo.

En este caso específico, estableceremos la MTU en 1000 y direccionaremos la dirección IP 192.168.1.1. Asegúrese de tener los permisos necesarios y de que el escaneo de esta IP esté permitido.

Abra su terminal Xfce y ejecute el siguiente comando:

sudo nmap -sS --mtu 1000 192.168.1.1

Verá la salida de Nmap que indica que está realizando un escaneo SYN con una MTU de 1000. La salida exacta dependerá del sistema objetivo y de la configuración de red.

Salida de ejemplo (puede variar):

Starting Nmap 7.80 ( https://nmap.org )
Nmap scan report for 192.168.1.1
Host is up (0.00043s latency).
All 1000 scanned ports on 192.168.1.1 are filtered
Nmap done: 1 IP address (1 host up) scanned in 4.63 seconds

Nota: La salida muestra que todos los puertos están filtrados. Esto es solo un ejemplo, y el resultado real depende del objetivo. Lo importante es que Nmap ejecutó el escaneo SYN con la opción --mtu.

Este comando combina un escaneo SYN con un tamaño de MTU específico. Esto puede ser útil para probar cómo un sistema responde a diferentes tamaños de paquetes durante un escaneo.

Agregar detalle con nmap -v --badsum 127.0.0.1

En este paso, agregaremos detalle al comando de Nmap. El detalle aumenta la cantidad de información mostrada durante el escaneo, lo que puede ser útil para la depuración y la comprensión de lo que está haciendo Nmap.

La opción -v aumenta el nivel de detalle. Puede usarlo varias veces (por ejemplo, -vv) para una salida aún más detallada.

Combinaremos la opción de detalle con la opción --badsum, que usamos en el primer paso, y direccionaremos la dirección de bucle 127.0.0.1.

Abra su terminal Xfce y ejecute el siguiente comando:

sudo nmap -v --badsum 127.0.0.1

Verá una salida más detallada de Nmap en comparación con los comandos anteriores. La salida incluirá información sobre los paquetes que se están enviando, las respuestas recibidas y el progreso del escaneo.

Salida de ejemplo (puede variar):

Starting Nmap 7.80 ( https://nmap.org )
NSE: Loaded 0 scripts for scanning.
Initiating Ping Scan at 15:00
Scanning localhost (127.0.0.1) [4 ports]
Completed Ping Scan at 15:00, 0.00s elapsed (1 total hosts)
Host localhost (127.0.0.1) appears to be up ... good.
Initiating Connect Scan at 15:00
Scanning localhost (127.0.0.1) [1000 ports]
Connect Scan Timing: About 0.00% done; ETC: 15:00 (0:00:00 remaining)
Completed Connect Scan at 15:00, 0.01s elapsed (1000 total ports)
Nmap scan report for localhost (127.0.0.1)
Host is up (0.0000090s latency).
All 1000 scanned ports on localhost (127.0.0.1) are closed

Read data files from: /usr/bin/../share/nmap
Nmap done: 1 IP address (1 host up) scanned in 0.02 seconds

La opción -v proporciona más información sobre el proceso de escaneo, lo que facilita la comprensión de lo que está haciendo Nmap y la solución de cualquier problema.

Guardar los resultados con nmap --mtu 1200 -oN sim.txt 192.168.1.1

En este paso, guardaremos los resultados del escaneo de Nmap en un archivo. Esto es útil para un análisis posterior o para compartir los resultados con otros.

La opción -oN especifica que la salida debe guardarse en formato normal en el archivo especificado.

El comando que usaremos es:

nmap --mtu <mtu_value> -oN <output_file> <target_ip>

Aquí, --mtu establece el valor de la MTU, -oN especifica el archivo de salida en formato normal, <output_file> es el nombre del archivo en el que se guardarán los resultados y <target_ip> es la dirección IP del objetivo.

En este caso específico, estableceremos la MTU en 1200, guardaremos la salida en un archivo llamado sim.txt en el directorio ~/project y direccionaremos la dirección IP 192.168.1.1. Asegúrese de tener los permisos necesarios y de que el escaneo de esta IP esté permitido.

Abra su terminal Xfce y ejecute el siguiente comando:

sudo nmap --mtu 1200 -oN sim.txt 192.168.1.1

Después de que se complete el escaneo, se creará un archivo llamado sim.txt en su directorio ~/project. Este archivo contendrá los resultados del escaneo de Nmap en un formato legible por humanos.

Para verificar que el archivo se creó y contiene los resultados del escaneo, puede usar el comando cat para mostrar el contenido del archivo:

cat sim.txt

Debería ver los resultados del escaneo de Nmap impresos en la terminal.

Salida de ejemplo (puede variar):

## Nmap 7.80 scan initiated Mon Oct 26 15:05:05 2020
Nmap scan report for 192.168.1.1
Host is up (0.00043s latency).
All 1000 scanned ports on 192.168.1.1 are filtered
## Nmap done: 1 IP address (1 host up) scanned in 4.63 seconds

Este comando guarda los resultados del escaneo de Nmap en un archivo, lo que le permite revisar y analizar los resultados más tarde.

Analizar los efectos de la simulación en la terminal Xfce

En este paso, analizaremos los efectos de las simulaciones que realizamos utilizando Nmap. Examinaremos la salida de los pasos anteriores para entender cómo las opciones --badsum y --mtu afectaron los resultados del escaneo.

Primero, revisemos el archivo sim.txt que creamos en el paso anterior. Abra su terminal Xfce y use el comando cat para mostrar el contenido del archivo:

cat sim.txt

Examine la salida. Tome nota de la dirección IP del objetivo, los puertos que se escanearon y el estado de esos puertos (por ejemplo, abierto, cerrado, filtrado).

A continuación, consideremos la opción --badsum. Esta opción corrupta intencionalmente la suma de comprobación de los paquetes de Nmap. En un escenario del mundo real, esto probablemente haría que los paquetes fueran descartados por la red o el host objetivo. Sin embargo, Nmap todavía puede proporcionar alguna información, incluso con paquetes dañados.

Recuerde el comando que usamos con --badsum:

sudo nmap --badsum 192.168.1.1

La salida de este comando (si no la guardó en un archivo) habría mostrado cómo Nmap intentó escanear el objetivo a pesar de los errores de suma de comprobación.

Ahora, consideremos la opción --mtu. Esta opción establece la Unidad de Transmisión Máxima (MTU) para los paquetes de Nmap. La MTU es el tamaño máximo de paquete que se puede transmitir a través de una red. Si la MTU se establece demasiado alta, los paquetes pueden ser fragmentados, lo que puede afectar los resultados del escaneo. Si la MTU se establece demasiado baja, el escaneo puede ser más lento.

Recuerde el comando que usamos con --mtu:

sudo nmap --mtu 1200 -oN sim.txt 192.168.1.1

Al establecer la MTU en 1200, potencialmente influimos en cómo el host objetivo recibió y procesó los paquetes de Nmap. El archivo sim.txt contiene los resultados de este escaneo, que debe comparar con un escaneo sin la opción --mtu para ver las diferencias.

Para analizar aún más los efectos, podría intentar ejecutar escaneos de Nmap con diferentes valores de MTU y comparar los resultados. Por ejemplo, pruebe un valor de MTU que sea más pequeño que el predeterminado (por lo general 1500) y uno que sea más grande.

En resumen, al usar las opciones --badsum y --mtu, simulamos condiciones de red que pueden afectar los escaneos de Nmap. Analizar los resultados de estas simulaciones nos ayuda a entender cómo se comporta Nmap en diferentes circunstancias y cómo interpretar los resultados del escaneo en consecuencia.

Este paso se centra principalmente en entender el impacto de los comandos anteriores. No hay un comando específico que ejecutar en este paso, aparte de revisar las salidas de los pasos anteriores.

Resumen

En este laboratorio, exploramos cómo simular condiciones de red utilizando Nmap. En particular, aprendimos cómo usar la opción --badsum para enviar paquetes con sumas de comprobación inválidas a una dirección IP objetivo, lo que nos permite probar cómo un sistema maneja datos dañados. También practicamos establecer el tamaño de la Unidad de Transmisión Máxima (MTU) utilizando la opción --mtu para controlar el tamaño de los paquetes enviados durante un escaneo.

Además, combinamos la opción --mtu con un tipo de escaneo y exploramos cómo agregar detalle con la bandera -v para obtener una salida más detallada. Finalmente, aprendimos cómo guardar los resultados del escaneo en un archivo utilizando la opción -oN para un análisis posterior, y se nos instruyó a analizar los efectos de estas simulaciones en la terminal Xfce.