NetGrok, InetVis, Scapy y Nmap. Detección y visualización scan de puertos. Parte I

Ya hemos visto como funcionan programas de visualización de tráfico de red como NetGrok e InetVis.También, a lo largo de los 6 artículos dedicados a Scapy estudiamos como fabricar, manipular y enviar paquetes.

En esta ocasión vamos a aplicar estos conocimientos para detectar, mediante las herramientas gráficas mencionadas, diversos ataques como Synflood, scan de puertos,etc mediante diversas técnicas usando Scapy y Nmap. Recordaremos y ampliaremos lo aprendido con Scapy referente a los escaneos de puertos.

NOTA. Las IPs públicas que aparecen en los ejemplos son ficticias. Scapy, por ejemplo, puede crear paquetes cuyos campos referidos a IPs de destino u origen estén falsificadas si interactuar realmente sobre ellas y en un escenario de red laboratorio sin acceso a internet.

Escaneando con Scapy.

Usaremos distintas técnicas de scan de puertos con Scapy para visualizar los resultados con las herramietas ya estudiadas. Bien podría ser este artículo una segunda parte de InetVis o séptima de Scapy.

Recordad, antes que nada que teníamos varias formas den enviar paquetes con scapy:

• sr: Envía paquetes y recive todas las respuestas en la capa  3.
• sr1: Envía paquetes y recive la primera respuestas en la capa  3.
• srbt: Envía y recibe usando bluetooth socket.
• srbt1: Envía y recive 1 respuesta usando a bluetooth socket.
• srloop: Envia un paquete para la capa 3 en de forma cíclica e imprime una sola respuesta cada vez.
• srp: Envía y recive paquetes para la capa 2
• srp1: Envia y recive paquetes para la capa 2. Recive el primer paquete de respuesta.
• send: Envía paquetes para la capa 3

Al lio….

Ejemplo 1.

send(IP(src=RandIP(‘213.96.0.0/16′), dst=’192.168.1.5’)/TCP(sport=53,dport=(1024,4096)), loop=1)

Construimos y enviamos un paquete IP. Usamos RandIP() para que las IP de origen sean aletorias pero dentro del rango que indicamos. El puerto de origen es el 53 y los  puertos de destino serán los comprendidos en el rango 1024-4096. Con loop=1 indicamos que el proceso se realice en un bucle infinito hasta que lo paremos manualmente (Control+Z).

Lo que vemos es lo siguiente:

• el eje de color rojo que representa las IP direcciones cuyo origen están en internet está cubierto en todo su rango. Acotando con Inetvis, vemos que el barrido de scan proviene de 213.96.0.0/16.
• el eje de color verde que corresponde a los puertos indica un rango de puertos de destino. En este caso 1024-4096.
• si nos situamos perpendicularmente al eje azul de IP internas, vemos que el objetivo es solo una IP. En este caso 192.168.1.5.

Ejemplo 2.

Vamos a ver ahora como representa InetVis un scan de puerto igual que el ejemplo anterior pero con varias IP de destino.

send(IP(src=RandIP(‘213.96.0.0/16’), dst=[‘192.168.1.5′,’192.168.1.136′,’192.168.1.92’])/TCP(sport=RandShort(),dport=(1024,4096)), loop=1) 

En este caso usamos RandShort() para indicar un puerto aleatorio.

El resultado:

Vemos las tres bandas indicando 3 IP de destino distintas.

Ejemplo 3.

Vamos a hora a escanear usando la opción sr para envio de paquetes.qué ya sabemos, envía y recibe paquetes en la capa 3. Usaremos tambén 3 opciones que son:

• inter intervalo, en segundo, entre paquetes enviados
• retry reintenar de nuevo si los paquetes que no obtuvieron respuesta
• timeout tiempo de espera máximo desde el último paquete

ans,unans = sr(IP(src=RandIP(‘213.96.140.0/24′), dst=’192.168.1.5’)/UDP(dport=[(1,1024)]),inter=0.5,retry=10,timeout=1)

..el resultado:

• He acotado el rango de puerto de destino, eje y (verde), para mostrar desde los puertos 1 a 2000. Observad la ispersión de los puntos.

• He acotado también el eje z (azul) con un rango de 213.96.140.0/24 (scapy: (src=RandIP(‘213.100.0.0/16’)). Así pues, se observa mejor la dispersión de los puntos debido a las opciones (inter=0.5, timeout=1).

• En esta caso vemos que solo hay un plano, además muy cercano al origen de ordenadas. Esto es así porque se trata de un solo host de destino del scan y con IP 192.158.1.5.

Ahora vamos a hacer lo mismo sin las opciones y eliminando RandIP().

ans,unans = sr(IP(src=RandIP(‘213.96.140.0/24′), dst=’192.168.1.5’)/UDP(dport=[(1,1024)]))

y el rersultado es….

Como podéis observar ya no existe la dispersión de puntos (representación de los paquetes).Es todo uniforme. Las opciones de un escaneo también cuentan y la representación es distinta.

Uso de la función range().

Python proporciona una función llamada range() (rango) que permite generar una lista  que vaya desde el primer número que le indiquemos al segundo.

Vamos ver como usarlo:

>> for ip in range(255):
…      scan = IP(src=RandIP(‘213.96.0.0/16′),dst=’192.168.1.%d’ %  ip)/TCP(sport=56, dport=RandNum(0,1024), flags=2)
…      sr(scan,timeout=2)

Usamos RandIP() para que, dentro del rango /16, use las IP de forma aleatoria. Para las IP de destino usamos la notación 192.168.1.%d’ %  ip para que el último octeto lo tome da la variable ip.Y usamos dport=RandNum(0,1024) para que use los puertos de destino del 0 al 1024 pero de forma aleatoria.

Hasta ahora hemos visto como la representación graáfica es en forma de planos o líneas. Ahora veremos como usado range() de esta forma, rellenamos el cubo en las tres dimensiones:

Que  pasaría si escaneamos solo un pequeño rango de máquinas (192.168.1.90-100), las cuales está casi todas activas. No usamos range() establecido como en el anterior. Vemos como la «nube» en InetVis se hace más densa:

>scan = IP(src=RandIP(‘213.96.10.0/24′),dst=’192.168.1.90-100′)/TCP(sport=56, dport=(0,1024), flags=2)
>sr(scan,timeout=3)

NetGrok:

• Dentro del circulo color verde más oscuro y nodos más grandes las máquinas activas escaneadas.
• Los dos círculos grades blancos las dos que no estaban activas dentro del rango 192.168.1.90-100.
• Los nodos verdes claros más pequeños los host que realizan el escaneo SYN de puertos 0-1024.

Escaneando con nmap.

Ejemplo 1.

Vamos a usar algunas de las opciones de optimización de tiempo, rendimeinto, etc, que nos ofrece nmap:

nmap -sS 192.168.1.0/24 -e eth0 -T5 –host-timeout 5m –max-retries 0 –initial-rtt-timeout 25ms –max-rtt-timeout 250ms –max-scan-delay 250ms –scan-delay 10ms –min-hostgroup 32 –max-hostgroup 32 -D 213.96.169.1,213.96.121.213,213.96.160.21,213.96.11.111,213.96.96.1   

Como veis, vamos a usar:

• –host-timeout 5ms  para abandonar el objetivo cuando pase el tiempo especificado.
• –max-rtt-timeout 250ms tiempo que toma en enviar un paquete desde un host cliente a un host servidor y viceversa. Aquí establecemos un máximo.
• –max-scan-delay 250ms / –scan-delay 10ms aquí ajustamos un rango de tiempo de retraso
• –min/max-hostgroup 32  escanear en paralelo en grupos de 32
• -D uso de decoys o direcciones spoofeadas
• -sS para TCP-SYN scan.
• -T5. Establecemos una plantilla específica para la tasa de envío de paquetes para el control de tiempos y rendimiento. Esta plantilla tiene inplícita una serie de opciones tales como max-rtt-timeout, etc. En nuestro caso algunas las hemos modificado.

Y el resultado:

Se observa lo siguiente:

• como en el eje azul vemos unas bandas que corresponden a las direcciones IP consecutivas que están activas.
• existen zonas intermedias que corresponden a IP que no están activas.
• en el eje rojo, que correpondiente a las IP externas de origen, vemos que hay 5 hosts que corresponden con cada una de las IP spoofeadas que indicamos con -D en nmap.

Vamos a ver la representación del tráfico con NetGrok:

Observad que:

• tenemos 5 nodos/hosts externos (falta uno por arriba del gráfico) que corresponden con las IP spoofeadas.
• vemos las conexiones con los nodos/host de color verde que son las IP de la red interna objetivo del scan.
• en el centro, color anaranjado, indicando mayor tráfico, el nodo/host desde donde se realiza el nmap scan.
• observad también la línea de tiempo con los períodos de mayor actividad.

Plantillas T0 – T5 nmap.

¿ Variará el resultado de la gráfica depndiendo del nivel de tasa de envió ?.

Lo vamos a ver.  Usaremos T2, y T4 por ejemplo.

Brévemente. Las plantillas -T0-T5  son opciones usan unos determinados valores de rendimiento y tiempo para el escaneo.

La plantilla T2 de Nmap denominada polite, la usaremos en el ejemplo sobre todo porque T0 y T1 pueden causar una ralentización muy grande en el escaneo. Si bien es cierto que T1 y T2 son muy parecidas, difieren en que para T1 el tiempo entre una sondoa y otra es de 15 segundos y 0,4 para T2. Una gran diferencia de tiempos. T0 y T1 se usan para evasión de IDS.

Podemos personalizar, ya lo hemos hecho en uno de los ejemplos anteriores, indicando valores exactos para:

• –scan-delay
• –min-hostgroup
• –max-hostgroup
• –min-rate
• –max-rate
• –min-parallelism
• –max-parallelism
• –min-rtt-timeout
• –max-rtt-timeout
• –initial-rtt-timeout
• –max-retries
• –host-timeout

Por ejemplo. Para explicarlo algo mejor:

–host-timeout para especificar el tiempo máximo que nmap espera una respuesta. Se puede especificar en milisegundos si no se añade opción alguna o en segundos y minutos e incluso horas (s,m,h). De esta forma si un host tarda en responder o simplemente no esta «activo», no tenemos porqué perder tiempo. Ejemplo: –host-timeout 100s.

–scan-delay para el tiempo de espera entre un «scan» o sonda y otro para limitar tráfico, etc.

Bien, vamos con los ejemplos.

nmap -sS 192.168.1.0/24 -e eth0 -T2 -p1-1024 -S 213.96.160.32

=========

…..

Bueno, creo que por esta vez esta bien. Dejamos las representaciones gráficas T2 y T4 para la próxima. Tambien veremos otros tipos de escaneos con nmap / scapy.