G2 P8 PacketSniffingandSpoofing

Universidad de Cuenca
Facultad de Ingenierı́a
Ingenierı́a en Telecomunicaciones
Seguridad en Redes
PACKET SNIFFING AND SPOOFING LAB
Bryam Gomez Murillo

bryam.gomez@ucuenca.edu.ec
Pablo Pacheco Cherrez
pablo.pacheco@ucuenca.edu.ec
Christian Villa Lojano
christian.villa1701@ucuenca.edu.ec
Fecha de Entrega: 30 de noviembre de 2022
1. Marco teórico
1.1. Spoofing, Qué es y cómo evitarlo
La suplantación de identidad no es algo nuevo; el intento de hacerse pasar por otra persona
para sacar provecho de alguna manera es algo que siempre ha estado presente. En la era de la
comunicación, como no podı́a ser de otra manera, también existe y se conoce con el nombre
de spoofing, un anglicismo que podrı́amos traducir como burla o pantomima.
El spoofing consiste en una serie de técnicas hacking, por lo general, con intenciones
maliciosas, creadas para suplantar la identidad de entidades o personas en la red, con el
objetivo de obtener información privada o para conseguir acceder a páginas con una credencial
falsa.
1.1.1. Tipos de spoofing
Son múltiples las formas en las que se puede realizar un ataque spoofing, cualquiera de
las tecnologı́as de red actual es susceptible de ser utilizada para tal fin. Por tanto, podemos
hacer una clasificación según la fuente del ataque.
• Suplantación de dirección IP Los ciberdelincuentes utilizan la dirección IP de la

vı́ctima para enviar paquetes de datos TCP/IP o UDP/IP. Con este sistema pueden
atravesar protecciones Fireworks, ya que éstas se basan en conceder acceso a una red a
aquellas IP de confianza y rechazan el resto.
Este tipo de suplantación es muy utilizada en los ataques de DDoS, ya que la dirección
suplantada es quien recibe la respuesta al envı́o de paquetes. Ası́ pues, se puede hacer
una DDoS enviando muchos paquetes desde una IP robada, que acabará colapsado
con las respuestas recibidas o bien usurpando diferentes IP que envı́an paquetes para
sobrecargar el servidor.
1
• E-mail spoofing El atacante utilizará la dirección de correo de una persona o una en-
tidad confiable, ya sea para solicitar información confidencial, para hacer spam o enviar
de forma masiva cadenas de hoax o bulos. De la misma manera, una cuenta de correos
puede ser robada y utilizada para enviar cualquiera de sus correos malintencionados.
Esta suplantación se denomina phishing y se usa sobre todo para hacerse pasar por
entidades bancarias y solicitar de alguna manera las claves de acceso a la cuenta corriente
• Suplantación web
A diferencia del phishing, con este tipo de spoofing no se pretende imitar exactamente
una web. En este caso, los atacantes hacen una intermediación entre el atacado y las
páginas web que pretende visitar. De esta forma podrán monitorear su actividad, tener
un registro de sus visitas, acceder a sus contraseñas y sus datos personales.
• Suplantación de DNS Consiste en acceder a los servidores de nombres de dominio

de la vı́ctima, y modificar sus direcciones IP para redirigirlas a servidores maliciosos.
Además de ser otra forma de registrar los movimientos de la vı́ctima, el mayor peligro es
que puede burlar las conexiones cifradas ya que en realidad apuntan a servidores espejo.
1.1.2. Cómo detectar el spoofing

La suplantación de correo electrónico es la forma más usada y detectable. El contenido
de los e-mails nos debe hacer sospechar, pues intentará sonsacarnos las contraseñas o datos
personales. Además, suele ser de dudosa procedencia y su contenido es en esencia una estafa.
Un sı́ntoma claro de que una cuenta de correo ha sido intervenida y está siendo usada para
enviar spam es cuando se reciben mensajes informando de que ciertos correos no pueden ser
entregados.
1.2. ¿Qué es el Sniffing?, Ataque MITM.
El Sniffing, es una técnica utilizada para escuchar todo lo que ocurre dentro de una red,
esto se suele hacer en redes internas o de intranet, pero también se llega a ver en internet.
Todo esto se consigue mediante unas herramientas que están destinadas a la seguridad
informática y no al uso malintencionado de ellas, estas aplicaciones son capaces de actuar
sobre los sistemas que componen el tráfico de una red, como a la propia conexión que pueden
mantener host´s entre si, lo que hacen estas herramientas en si, es que capturan, interpretan
y almacenan paquetes de datos que son lanzados por la red, para que después sean analizados,
donde se podrá conseguir información como, contraseñas, correos electrónicos o incluso datos
bancarios.
Por eso cada vez es mas importante, que al estar navegando por la red, debemos mandar
todos estos datos encriptados, por que nunca sabemos quien podrı́a estar detrás de nuestros
datos.
1.2.1. ¿Como funcionan los Sniffers?
Los programas sniffer, son fáciles de entender, lo que hacen estos programas es trabajar
codo con codo con la tarjeta de red de nuestro equipo, para ası́ poder absorber todo el
tráfico que esta fluyendo por la red que estemos conectados, ya sea por cable o por conexión
inalámbrica.
2
2. Configuración y comandos del contenedor
En este laboratorio, usaremos dos máquinas conectadas a la misma LAN. Podemos usar
dos máquinas Virtuales o dos Contenedores. La Figura 1 describe la configuración del entorno
de laboratorio utilizando Contenedores. Realizaremos todos los ataques desde el Contenedor
del atacante, mientras que el otro contenedor sera la máquina del usuario.
Figura 1: Configuración del entorno
2.1. Setup del Contenedor y sus Comandos
A continuación, se muestran los comandos mas usados en Docker y Compose. Debido a

que estos comandos serán usados con mucha frecuencia, hemos creados un conjunto de alias
para los mismos, ubicados en del archivo .bashrc dentro de la máquina Virtual provista por
SEED (Ubuntu 20.04).
\$ docker-compose build #Build the container image

\$ docker-compose up #Start the container
\$ docker-compose down #Shut down the container
Sus alias en la máquina virtual son:
\$ dcbuild #Alias for: docker-compose build

\$ dcup #Alias for: docker-compose up
\$ dcdown #Alias for: docker-compose down
Se procede a levantar el entorno con los comandos descritos anteriormente, obteniendo asi la
figura 2.
3
Figura 2: Entorno levantado
Dado que todos los contenedores estarán corriendo en un segundo plano. Necesitamos
correr comandos para interactuar con los mismos, una de las operaciones fundamentales es
obtener una shell en el contenedor. Para este propósito usaremos docker pspara encontrar el
ID del contenedor deseado y ingresaremos docker exec para correr una shell en ese contene-
dor. Hemos creado un alias para ello dentro del archivo .bashrc.
Ahora se procede a realizar la conexión con la máquina atacante a través del comando docksh,
ver figura 3.
Figura 3: Conexión máquina atacante
2.2. El contenedor atacante

Para este laboratorio se utilizara la máquina Virtual y los contenedores de la máquina
atacante. Si revisamos el archivo de Docker Compose, observaremos que esta configurado de
manera diferente que el resto de contenedores. Estas diferencias son:
• Shared folder: Directorio compartido entre la máquina virtual y el contenedor, se usara

el contenedor del atacante para realizar los ataques para lo cual es necesario poner el
código de ataque dentro del contenedor.
• Host mode: El modo host permite que el contenedor del atacante vea el trafico de
toda la red. La siguiente entrada es usada para el contenedor del atacante:
4
\$ network_mode: host
Cuando un contenedor esta en modo host, este puede ver todas las interfaces de red de
los hosts que la componen, inclusive tiene la misma dirección IP como si fuera el host
principal. Básicamente es ponerlo en el mismo espacio de red como si fuera la máquina
Virtual de Host. Sin embargo, el contenedor sigue siendo una máquina diferente.
Obteniendo el nombre de la interfaz de red:

Cuando usamos el archivo de Compose para generar los contenedores para el laboratorio,
se crea una nueva red que conecta a la máquina Virtual y a los contenedores. El prefijo de
esta red es 10.9.0.0/24 y se configura dentro del archivo docker-compose.yml. La dirección
IP que se asigna a nuestra máquina Virtual es ´ 10.9.0.1. Se va a necesitar encontrar el
nombre de cada una de las interfaces de red en nuestra máquina virtual ya que se va utilizar
en nuestros programas. El nombre de la interfaz es la resultante de la concatenación de br -
y el ID de red creado por Docker. Cuando usamos ifconfig para listar las interfaces de red,
veremos algunas de ellas. Observe la dirección IP 10.9.0.1, ver figura 4.
Figura 4: Ip máquina atacante
Otra forma de obtener el nombre de la interfaz es usar el comando docker network y

encontrar el id de red por nuestra cuenta (el nombre de la red es net-10.9.0.0), ver figura 5
Figura 5: Nombre de la red atacante
5
3. Lab Task Set 1: Using Scapy to Sniff and Spoof Packets
Para realizar esta tarea se utilizara Scapy el cual es una herramienta que nos permite
integrar funcionalidad de sniffing y spoofing. Para usar Scapy, podemos escribir un programa
en Python y ejecutarlo usando este interprete, ver figura 6.
Figura 6: Scapy: pantalla de inicio
Código:
1 #!/bin/bin/python
2
3 from scapy.all import *

4
5 a = IP()
6
7 a.show()
Código 1: Init.py
Explicación:
En el código 1, el método IP crea y retorna una nueva IP por defecto y paquete vacı́o. Si
ejecutamos el comando show este nos mostrara el contenido del paquete.
Es necesario utilizar sudo ya que requiere de privilegios de root para la manipulación de
paquetes, ver figura 7.
6
Figura 7: Ejecución: init.py
3.1. Task 1.1: Sniffing Packets

El objetivo de esta Tarea es aprender a usar Scapy para hacer sniffing de paquetes a través
de programas de Python. A continuación se da un ejemplo, ver código 2:
1 #!/usr/bin/env python3
3
4 def print_pkt(pkt):
5 pkt.show()
6
7 pkt = sniff(iface=interfaces, filter='icmp', prn=print_pkt)
Código 2: Sniffer.py
El código mostrado anteriormente, hará sniffing de todos los paquetes en la interfaz

br-661ffaad862a.
Tarea 1.1A: En el programa anterior, por cada paquete capturado, la función print pkt()
sera invocada como un callback; esta función mostrara información detallada del paquete.
Ejecute el programa con privilegios de root y demuestre como captura los paquetes. Después
de eso corra el programa sin privilegios de root; Describa y explique sus observaciones.
Resolución:
Código: Para esta parte se utilizara el código 3.
7
1 #!/usr/bin/python
2

4
6 pkt.show()
7
8 interfaces = ['br-661ffaad862a','enp0s3','lo']
Código 3: Sniffer.py
Explicación:
1. Acerca del código: Se escoge las interfaces a auditar usando el comando ifconfig en
la terminal y se los menciona en una lista de las interfases de las que se desea hacer el
sniffing de los paquetes. Usando el filtro, Scapy nos mostrará sólo los paquetes ICMP.
2. Acerca de la pregunta: El orden para correr el programa debe ser con altos privilegios
es decir con root, se utiliza el comando sudo chmod a+x sniffer.py, con este comando
se otorga privilegios de ejecución a todos los usuarios. Para comprobar el funcionamiento
del programa se utiliza el comando ping direccionado a 8.8.8.8 el cual corresponde al
DNS de google, ver figura 8a. Y a través del programa sniffer.py se puede observar
que los paquetes ICMP son capturados, ver figura 8b.
Se vuelve a ejecutar el programa, pero esta vez, sin usar el privilegio de root. Como se
sabe, el método sudo (hacer de superusuario) requiere que el usuario esté configurado
con el poder de ejecutar çomo root”. Ası́ que esta vez, ejecutaremos el programa sin
sudo, ver figura 9.
(a) Creación de los paquetes ICMP a través

de ping (b) Captura paquetes ICMP
Figura 8: Sniffing de paquetes con privilegios root
8
Figura 9: Error de Sniffing
Esto ocurre porque para correr los programas de sniffing de paquetes, para ver y capturar el
trafico debe ser con privilegios altos.
Tarea 1.1B:
• Capturar solamente paquetes ICMP:

Código: Se va utilizar el código 4.
1 #!/usr/bin/python
2

4
6
7 if pkt[ICMP] is not None:

8 if pkt[ICMP].type == 0 or pkt[ICMP].type == 8:
9 print("ICMP Packet=====")
10 print(f"\tSource: {pkt[IP].src}")
11 print(f"\tDestination: {pkt[IP].dst}")
12
13 if pkt[ICMP].type == 0:
14 print(f"\tICMP type: echo-reply")
15
16 if pkt[ICMP].type == 8:
17 print(f"\tICMP type: echo-request")
18
19
20
21 interfaces = ['br-e12cb9117793','enp0s3','lo']
Código 4: Sniffero nlyi cmp.py
Explicación:
9
1. Acerca del código: Se esta utilizando el mismo filtro que el código sniffer.py
el cual acepta la sintaxis de Filtro de paquetes Berkeley.
2. Acerca de la pregunta: Igual que lo antes realizado se envı́a un ping a tra-
ves del comando ping -c 2 8.8.8.8, los cuales estos dos paquetes están siendo
capturados, ver figura 10.
Figura 10: Captura únicamente de paquetes ICMP
• Capturar cualquier paquete TCP que provenga de una IP y cuyo puerto

destino sea el puerto 23:
Código: Se va utilizar el código 5.
1 #!/usr/bin/python
2

4
6 if pkt[TCP] is not None:
7 print("TCP Packet=====")
8 print(f"\tSource: {pkt[IP].src}")
9 print(f"\tDestination: {pkt[IP].dst}")
10 print(f"\tTCP Source port: {pkt[TCP].sport}")
11 print(f"\tTCP Destination port: {pkt[TCP].dport}")
12
13
14 interfaces = ['br-e12cb9117793','enp0s3','lo']
15 pkt = sniff(iface=interfaces, filter='tcp port 23 and src host 10.9.0.1', prn=print_pkt)
Código 5: Captura paquetes TCP
Explicación:
10
1. Acerca del código: Esta vez he filtrado con tcpport 23 and src 10.9.0.1.
La sintaxis que se utilizo para este filtro es de la página web de sintaxis BPF. Y
de nuevo como el código anterior, se imprime sólo los datos relevantes para esta
pregunta. Por eso no se ocupo show.
2. Acerca de la pregunta: La IP de mi VM por defecto es 10.9.0.1 y se envı́a

a 10.0.2.5 que corresponde a otra VM. De esta manera, se envia un comando
telnet 10.0.2.5 desde mi VM atacante, y el programa tcp_snier.py snifio los
paquetes TCP. Se utiliza el puerto 23 porque es el puerto por el cual se establece
la conexión TCP.
Figura 11: Captura únicamente de paquetes TCP
• Capturar paquetes que vienen o se dirigen hacia una subnet en particular. Puede elegir
cualquier subnet como 128.230.0.0/16; no deberıa de elegir la subnet a la cual su
Maquina Virtual esta adjunta.
Código: Los códigos ha utilizar para este punto sera los códigos 6 y 7.
1 #!/usr/bin/python
2

4
6 pkt.show()
7
8 interfaces = ['br-661ffaad862a','enp0s3','lo']
9 pkt = sniff(iface=interfaces, filter='dst net 128.230.0.0/16', prn=print_pkt)
Código 6: subnet_sniffer.py
11
2
3 ip=IP()
4 ip.dst='128.230.0.0/16'
5 send(ip,4)
Código 7: send_subnet_packet.py
Explicación:
1. Acerca del código: En el programa send_subnet_packet.py se eligio el filtrado

utilizando la sintaxis de filtrado de Berkeley a la dirección: 128.230.0.0/16.
dst significa una posible dirección.
net devuelve true si existe una posible tipo de red, en este caso, una subred que
esta representada en los detalles de la tarea.
2. Acerca de la pregunta: Se envió un paquete a una subred en particular y el

programa olfateó sólo los paquetes que fueron enviados desde la fuente 10.0.2.5a
la IP de destino de la otra subred.
Figura 12: Ejecución: subnet_sniffer.py
12
Figura 13: Ejecución: send_subnet_packet.py
3.2. Task 1.2: Spoofing ICMP Packets
Spoofing de paquetes: Cuando un usuario normal envı́a un paquete, el sistema opera-

tivo normalmente no permite al usuario configurar todos los campos de las cabeceras de los
protocolos (como las cabeceras TCP, UDP y cabeceras IP). El sistema operativo establecerá
la mayorı́a de los campos, mientras que sólo permite a los usuarios establecer unos pocos cam-
pos, como la IP de destino, el número de puerto de destino, etc. Sin embargo, si los usuarios
tienen el privilegio de root, pueden establecer cualquier campo arbitrario en las cabeceras de
los paquetes. A esto se le llama ”packet spoofing”.
Código: El código a utilizar para esta tarea es el código 8.

2
3 a = IP()
4 a.src = '1.2.3.4'
5 a.dst = '10.9.0.5'
6 send(a/ICMP())
7 ls(a)
Código 8: icmp_spoofing.py
Explicación:
1. Acerca del código: Se va ocupar otra VM la IP destino en este caso sera la 10.9.0.5 y
se enviara un paquete ICMP utilizando una dirección IP aleatoria en este caso 1.2.3.4.
2. Acerca de la pregunta: Se ha falsificado el paquete de solicitud de ICMP y se lo ha

enviado a otra VM en la misma subred. Se utiliza Wireshark para observar si nuestra
solicitud será aceptada por el receptor. Usando la librerı́a Scapy, la IP de origen fue
sobrescrita con nuestra propia IP: 1.2.3.4 y enviamos el paquete al destino 10.9.0.5;
el paquete fue recibido por la IP receptor 10.9.0.5 y se envia un eco de respuesta a
1.2.3.4.
13
Figura 14: Ejecución: icmp_spoofing.py
Figura 15: Captura wireshark: Spoofing ICMP
3.3. Task 1.3: Traceroute
Traceroute: Es un comando de diagnóstico de redes informáticas para mostrar las posi-

bles rutas y medir los retrasos en el tránsito de los paquetes a través de una red de Internet.
Código: Para esta tarea se va utilizar el código 14.
14
2
3 inRoute = True
4 i = 1
5 while inRoute:
6 a = IP(dst='216.58.210.36', ttl=i)
7 response = sr1(a/ICMP(),timeout=7,verbose=0)
8
9 if response is None:
10 print(f"{i} Request timed out.")
11 elif response.type == 0:
12 print(f"{i} {response.src}")
13 inRoute = False
14 else:
16
17 i = i + 1
Código 9: traceroute.py
Explicación:
1. Acerca del código: Se a programado la version propia de traceroute usando la li-

brerı́a Scapy. Se solicita a la IP de destino 8.8.8.8 que es Google. La bandera ttl del
paquete el cual se incrementa en uno en cada paquete dado. Se utiliza un bucle while
que seguirá iterando mientras esté enrutando. El método sr1() de Scapy es un método
que escuchará y esperará la respuesta del paquete. (timeout()= tiempo lı́mite para la
respuesta, verbose = ignorar la impresión de detalles innecesarios).
2. Acerca de la pregunta: Este programa calcula cuántos routers (saltos) se necesitan

para enviar ese paquete hasta el destino de la dirección IP. Cada lı́nea en la pantalla
es un router diferente. El TTL se utiliza para devolver un error de cada salto hasta
el destino, de esta manera podemos imprimir cada enrutador IP hasta hasta que se
detenga. En este caso llegamos a 15 enrutadores diferentes, 5 de ellos están fuera de
tiempo. Un mensaje “Request timed out” al principio/medio de un traceroute es muy
común y puede ser ignorado. Esto es tı́picamente un dispositivo que no responde a ICMP
o solicitudes de traceroute.
15
Figura 16: Ejecución: traceroute.py
3.4. Task 1.4: Sniffing and-then Spoofing

ARP: Es un protocolo de comunicación utilizado para descubrir la dirección de capa de
enlace dirección de capa de enlace, como una dirección MAC, asociada a una dirección de
capa de Internet determinada, normalmente una dirección IPv4. Dicha solicitud consiste en
paquetes especiales comúnmente conocidos como paquetes who-has. Los paquetes son paque-
tes que el sistema IP difunde a todos los dispositivos de una red (o VLAN), para determinar
el propietario de una dirección IP especı́fica. un protocolo de comunicación utilizado para
descubrir la dirección de capa de enlace dirección de capa de enlace, como una dirección
MAC, asociada a una dirección de capa de Internet determinada, normalmente una dirección
IPv4. Dicha solicitud consiste en paquetes especiales comúnmente conocidos conocidos como
paquetes who-has. Los paquetes who-has son paquetes que el sistema IP difunde a todos
los dispositivos de una red (o VLAN), para determinar el propietario de una dirección IP
especı́fica.
Código:

2
3 inRoute = True
4 i = 1
5 while inRoute:
6 a = IP(dst='216.58.210.36', ttl=i)
7 response = sr1(a/ICMP(),timeout=7,verbose=0)
8
9 if response is None:
10 print(f"{i} Request timed out.")
11 elif response.type == 0:
13 inRoute = False
14 else:
16
17 i = i + 1
Código 10: traceroute.py
Explicación:
1. Acerca del código: El bloque if comprueba si un ICMP es una petición. Si es cierto,
el paquete de respuesta se basará en los detalles derivados del paquete original, pero
16
invertirá el dst y el src para que cada vez que vea una petición de eco ICMP, independien-
temente de cuál sea la dirección IP de destino, el programa envı́e inmediatamente una
respuesta de eco utilizando esta técnica de suplantación de paquetes. El pkt[Raw].load
se utiliza para almacenar la carga de datos del paquete original de esta manera volverá
correctamente al remitente.
2. Acerca de la pregunta: En esta tarea se va ha probar 3 escenarios de 3 IPs diferen-

tes para hacer ping. El programa sning_and_spoofi g.py buscará cualquier paquete
ICMP en la subred, y cuando atrape uno, el programa devolverá al remitente un paquete
de respuesta ICMP un paquete de respuesta ICMP. Ası́ que incluso si la petición de eco
IP no está disponible en absoluto, el programa siempre devolverá al remitente un paque-
te de respuesta. Se va utilizar dos VMs para esta tarea. Mi VM original será conocida
como ’VM1’ con la dirección IP de 10.0.2.4 y la otra será ’VM2’ con la dirección IP
de 10.9.0.5.
Primer escenario: VM2 envı́a un ping a 1.2.3.4 que es un host inexistente en Internet.
Sin el programa obtendremos una pérdida de paquetes del 100 % porque nunca va a volver
a la fuente. Podemos ver en la captura de pantalla del wireshark que el protocolo ARP está
preguntando por 1.2.3.4 y preguntando en la red ¿quién tiene ese destino IP? Ası́ que el
atacante (mi programa en VM1) devuelve con una respuesta a la misma y el paquete ICMP
vuelve a la VM2.
Figura 17: Ejecución: sning_and_spoofi g.py
17
Figura 18: Envió trazas ICMP
Figura 19: Captura wireshark, primer escenario
Segundo escenario: VM2 envı́a un ping a 10.9.0.99 que es un host inexistente en la

LAN. En este escenario se esta obteniendo el mismo concepto con la misma idea del protocolo
ARP. Aunque el host ni siquiera existe. El programa de la VM1 enviará de vuelta un paquete
de respuesta ICMP.
18
Figura 20: Escenario 2
Tercer escenario: VM2 envı́a un ping a 8.8.8.8 que es un host existente en Internet.
Este escenario es diferente de los otros porque realmente existe en la red. Ası́ que en este caso
estamos recibiendo respuestas duplicadas, eso es porque el destino real está respondiendo
a la fuente, pero el programa también está respondiendo a la fuente. Lo podemos ver muy
claramente en las capturas de pantalla y en la grabación de wireshark.
Figura 21: Ejecución, escenario 3: sning_and_spoofing.py
19
Figura 22: Envió trazas ICMP
Figura 23: Captura wireshark, tercer escenario
20
4. Lab Task Set 2: Escribiendo programas para hacer sniffing
y spoofing
Para este conjunto de Tareas, debe compilar codigo en C en la Máquina Virtual Host y
correrlo dentro del contenedor.
4.1. Task2.1: Escribiendo el programa para hacer Packet Sniffing
Los Sniffers pueden ser escritos usando la librerı́a pcap. Usar pcap facilita la tarea del
desarrollo de un sniffer ya que implica invocar una serie de funcione nativas de la librerı́a. Al
final de cada secuencia y a medida que vayan siendo capturados, los paquetes serán colocados
en un buffer para un procesamiento posterior.
PCAP es una interfaz de programación de aplicaciones (API) para capturar el tráfico de

red. A continuación se muestra el código del sniffer.
21
1 #include <stdlib.h>
2 #include <stdio.h>
3 #include <pcap.h>
4 #include <arpa/inet.h>
5
6
7 /* Ethernet header */
8 struct ethheader {
9 u_char ether_dhost[6]; /* destination host address */
10 u_char ether_shost[6]; /* source host address */
11 u_short ether_type; /* protocol type (IP, ARP, RARP, etc) */
12 };
13
14 /* IP Header */
15 struct ipheader {
16 unsigned char iph_ihl:4, //IP header length
17 iph_ver:4; //IP version
18 unsigned char iph_tos; //Type of service
19 unsigned short int iph_len; //IP Packet length (data + header)
20 unsigned short int iph_ident; //Identification
21 unsigned short int iph_flag:3, //Fragmentation flags
22 iph_offset:13; //Flags offset
23 unsigned char iph_ttl; //Time to Live
24 unsigned char iph_protocol; //Protocol type
25 unsigned short int iph_chksum; //IP datagram checksum
26 struct in_addr iph_sourceip; //Source IP address
27 struct in_addr iph_destip; //Destination IP address
28 };
29
30 void got_packet(u_char *args, const struct pcap_pkthdr *header,
31 const u_char *packet)
32 {
33 printf("Paquete capturado\n");
34 struct ethheader *eth = (struct ethheader *)packet;
35
36 if (ntohs(eth->ether_type) == 0x0800) { // 0x0800 is IP type
37 struct ipheader * ip = (struct ipheader *)
38 (packet + sizeof(struct ethheader));
39
40 printf(" IP origen: %s\n", inet_ntoa(ip->iph_sourceip));
41 printf(" IP destino: %s\n", inet_ntoa(ip->iph_destip));
42
43 }
44 }
45
46 int main()
47 {
48 pcap_t *handle;
49 char errbuf[PCAP_ERRBUF_SIZE];
50 struct bpf_program fp;
51 char filter_exp[] = "icmp";
52 bpf_u_int32 net;
53
54 // Step 1: Open live pcap session on NIC with name enp0s3
55 handle = pcap_open_live("enp0s3", BUFSIZ, 1, 1000, errbuf);
56
57 // Step 2: Compile filter_exp into BPF psuedo-code
58 pcap_compile(handle, &fp, filter_exp, 0, net);
59 if (pcap_setfilter(handle, &fp) !=0) {
60 pcap_perror(handle, "Error:");
61 exit(EXIT_FAILURE);
62 }
63
64 // Step 3: Capture packets
65 pcap_loop(handle, -1, got_packet, NULL);
66
67 pcap_close(handle); //Close the handle
68 return 0;
69 }
70
22
Código 11: sniff.c
En el código 11 se modifico la interfaz de red de ’enp0s3’ a ’br-3ba397d38a2c’. Esta interfaz
pertenece a la red de contenedores creada con docker.
Task 2.1A: Comprender como funciona un Sniffer En esta Tarea, se impelementa un

sniffer para mostrar la dirección IP de origen y destino de cada paquete capturado. Para ello se
descargo el cádigo de ejemplo del libro de SEED (https://www.handsonsecurity.net/figurecode.html).
El código 11 muestra un programa de sniffing que usa la biblioteca pcap para capturar el tráfi-
co de la red y mostrar las direcciones IP de origen y destino. Se uso la misma sintaxis de filtro
de BPF para filtrar solo paquetes ICMP. Cuando el programa captura un paquete, verifica si
el encabezado es de tipo IPv4 y, si es cierto, imprimirá el origen y el destino de ese paquete
de encabezado IP. En la figura 24 y 25 se muestra la ejecucion del godigo la hacer peticiones
’ping’ desde el Host A al Host B.
Figura 24: Paquetes capturados al realizar un ping desde el host A al host B
23
Figura 25: Ping realizado del Host A al Hos B
• Pregunta 1 Por favor explique con sus propias palabras la secuencia de llamados que
realiza la librerı́a y que son esenciales para el sniffer. Esta explicación no debe ser tan
detallada como la del libro o el tutorial.
◦ Primer paso,se abre una sesión de pcap en vivo en NIC con el nombre ’br-3ba397d38a2c’,
que corresponde a la interfaz del los contenedores, esta operación la realiza ’pcap open live’
(una función de la biblioteca pcap). Esta función permite ver todo el tráfico de red
en la interfaz y enlaza el socket.
◦ Segundo paso, configuración del filtro usando los siguientes métodos: pcap compile()
se usa para compilar la cadena ’str’ en un programa de filtro pcap setfilter() que
se usa para especificar un programa de filtro.
◦ Tercer paso, se capturan los paquetes en un bucle y se procesan los paquetes cap-
turados usando la función ’pcap loop’, el -1 significa un bucle infinito.
• Pregunta 2 ¿Por qué se necesitan privilegios de root para correr el sniffer? ¿En dónde
falla el programa si es ejecutado sin privilegios de root?
◦ Se requiere de un privilegio de root para configurar la tarjeta en modo promiscuo y

los raw socket, de esta manera se puede ver todo el tráfico de red en la interfaz. Si
se realiza la ejecución del programa sin un usuario root, la función pcap open live
no puede acceder al dispositivo y causará un error en todo el programa.
• Pregunta 3 Por favor active y desactive el modo promiscuo en su sniffer. ¿Puede

mostrar la diferencia cuando este modo esta activado y desactivado? Por favor describa
como puede demostrar esto.
◦ El modo promiscuo es una parte del chip la tarjeta NIC (tarjeta de red), que está
dentro de la computadora, se activa al usar la función ’pcap open live’. Si se cambia
el tercer parámetro de la función ’pcap open live’ a 0 = OFF y todo lo que no sea
0 estará ENCENDIDO.
◦ Si se desactiva el modo promiscuo, el host rastreará solo el tráfico que está directa-
mente relacionado con él. Por lo tanto, el sniffer solo captará el tráfico hacia, desde
o enrutado a través del host.
24
◦ Por otro lado, si se activa el modo promiscuo, rastrea todo el tráfico en la red y
obtendrá todos los paquetes que ve su dispositivo, ya sea que estén destinados o
no al host.
Task 2.1B: Filtros de escritura Por favor escriba filtros en su sniffer. Puede usar los
manuales que están en la red para obtener más información sobre los filtros en pcap. Incluir
screenshots que muestren los resultados después de aplicar cada uno de los filtros que se piden
a continuación.
• Capturar paquetes ICMP entre dos hosts diferentes
◦ Partiendo del código 11, se agregó algunas funciones. El filtro pcap que se basa
en la sintaxis BPF ahora es: ı̈p proto icmp”. La direccion IP actual es 10.9.0.5. El
programa comprueba si el paquete capturado es de tipo IPv4 y si es cierto, también
comprueba si el protocolo es ICMP. Adicionalmente se mostrará en pantalla a que
tipo de protocolo pertenece el paquete capturado.
◦ En las figuras 26 y 27 se muestran el sniffer para capturar datos del protocolo
ICMP y la petición ’ping’ realizada hacia 8.8.8.8.
Figura 26: Captura del ping realizado del Host A al DNS de Google
Figura 27: Ping realizado del Host A al servidor DNS de Google
• Capturar paquetes TCP cuyo puerto destino este en el rango de 10 a 100
25
◦ Para capturar los paquetes TCP se uso telnet para conectarnos con el contenedor
Host B con dirección IP 10.9.0.6. El programa captura el paquete y lo muestra.
Para ello se implemento un filtro que solo lea paquetes que pertenezcan al protocolo
TCP.
◦ En las figuras 28 y 29 se muestran la capturas de los paquetes, la dirección IP de
origen y destino y adicionalmente el protocolo del paquete capturado
Figura 28: Captura de la conexión mediante Telnet entre el host A y Host B
Figura 29: Conexión mediante Telnet desde el host A al Host B
Task 2.1C: Sniffing passwords Por favor muestre como puede usar su sniffer para
capturar passwords cuando alguien use telnet en la red que esta monitorizando. Es posible
que necesite modificar el código de su sniffer para mostrar la parte de los datos que son
capturados en el paquete TCP (telnet usa TCP). Puede imprimir toda la parte de los datos
y marcar manualmente donde se encuentra el password (o parte de este)
• El programa se configuró para rastrear los paquetes tcp de telnet. Para ello se realizó
una conexión telnet desde la máquina 10.9.0.5 a la 10.9.0.6; se capturaron los datos que
en los cuales se incluye contraseña.
• El programa ’sniffPAssw.c’ al ser ejecutadp escucha los paquetes TCP. Como telnet
establece conexión mediante el protocolo TCP, los paquetes se capturan y la carga útil
se muestra como caracteres de texto plano.
26
• En las Figuras 30 y 31 se muestra la captura del password de la conexión Telnet
Figura 30: Captura de la contraseña de la conexión Telnet entre el Host A y Host B
27
Figura 31: Conexión mediante Telnet desde el host A al Host B
En la figura 32 se muestras los paquetes generados y capturados con ’Wireshark’ al realizar

la conexión telnet entre 10.9.0.5 y 10.9.0.6.
Figura 32: Captura de paquetes mediante Wireshark a la conexión Telnet
Al código mostrado a continuación es el que se implemento para captura la contraseña de

la conexión Telnet.
28
1 #include <pcap.h>
3 #include <stdlib.h>
5 #include <ctype.h>
6
7
8 #define ETHER_ADDR_LEN 6
9 #define SIZE_ETHERNET 14
10
15 u_short ether_type; /* IP? ARP? RARP? etc */
16 };
17
18 /* IP Header */
32 };
33 #define IP_HL(ip) (((ip)->iph_ihl) & 0x0f)
34
35 /* TCP header */
36 typedef unsigned int tcp_seq;
37
38 struct sniff_tcp {
39 unsigned short th_sport; /* source port */
40 unsigned short th_dport; /* destination port */
41 tcp_seq th_seq; /* sequence number */
42 tcp_seq th_ack; /* acknowledgement number */
43 unsigned char th_offx2; /* data offset, rsvd */
44 #define TH_OFF(th) (((th)->th_offx2 & 0xf0) >> 4)
45 unsigned char th_flags;
46 #define TH_FIN 0x01
47 #define TH_SYN 0x02
48 #define TH_RST 0x04
49 #define TH_PUSH 0x08
50 #define TH_ACK 0x10
51 #define TH_URG 0x20
52 #define TH_ECE 0x40
53 #define TH_CWR 0x80
54 #define TH_FLAGS (TH_FIN | TH_SYN | TH_RST | TH_ACK | TH_URG | TH_ECE | TH_CWR)
55 unsigned short th_win; /* window */
56 unsigned short th_sum; /* checksum */
57 unsigned short th_urp; /* urgent pointer */
58 };
59
60 void print_payload(const u_char * payload, int len) {
61 const u_char * ch;
62 ch = payload;
63 printf("Payload: \n\t\t");
64
65 for(int i=0; i < len; i++){
66 if(isprint(*ch)){
67 if(len == 1) {
68 printf("\t%c", *ch);
69 }
70 else {
71 printf("%c", *ch);
72 } 29
73 }
74 ch++;
75 }
76 printf("\n____________________________________________\n");
4.2. Task 2.2: Spoofing
Cuando un usuario no privilegiado envı́a un paquete, los sistemas operativos usualmente

no le permiten establecer los valores para todos los campos que componen los encabezados de
un paquete que son parte de un protocolo (como TCP, UDP y IP). Los sistemas operativos se
encargaran de llenar estos campos, permitiendo que este tipo de usuarios puedan establecer
valores solamente para unos pocos campos (dirección IP de destino, puerto de destino, etc). Sin
embargo, si el usuario tiene privilegios de root, puede establecer valores para cualquier campo
en los encabezados del paquete. Esto es llamado packet spoofing y se puede hacer usando
raw sockets. Los Raw sockets le dan al programador absoluto control sobre la construcción de
un paquete, permitiéndole crear cualquier tipo de paquete arbitrario, esto incluye establecer
los valores de su encabezados y su payload. El uso de los raw sockets es bastante simple;
involucra cuatro pasos: (1) crear el raw socket, (2) configurar sus opciones, (3) construir el
paquete, (4) enviar el paquete a través del raw socket. Existen muchos tutoriales online que
ensenan como programar raw sockets en C. Hemos agregado alguno de ellos en la pagina
oficial del laboratorio. Por favor léalos y aprenda a escribir un programa para hacer spoofing
de paquetes. A continuacion se brinda un código genérico de un spoofer que deberá de ser
completado:
Task 2.2A: Escribir un programa de Spoofing Por favor escriba su propio programa
de spoofing en C. Para demostrar que su programa funciona y realiza el spoofing de paquetes
IP, deberá de proveer evidencias (Por ejemplo, un packet trace usando Wireshark).
• se creo un programa de spoofing entre el contenedor ’Host A’ (10.9.0.5) a 4.3.2.1. To-

mando el codigo de ejemplo dado en la gia de la practica, se agregó un encabezado de
protocolo UDP y y se lo envió al destino 10.9.0.5 (desde - 4.3.2.1). En el programa se
creó con una biblioteca pcap y se realizó la modificación de los encabezados de IP para
usar la IP de origen como 4.3.2.1 y el destino como IP vı́ctima (10.9.0.5). Al ejecutar el
programa, el paquete se creó con la IP 4.3.2.1 y se envió al a contenedor vı́ctima.
• se trabajó con 2 contenedores. El programa de Spoofing se creo utilizando la biblioteca

pcap y cuando se ejecutó en el contenedor atacante (10.9.0.1) se envió un paquete a la
máquina vı́ctima (10.9.0.5) con una dirección IP falsa (4.3.2.1).
• En la figura 33 se muestra el paguete capturado la ejecutar el programa ’spoof.c’.
30
Figura 33: Captura de paquetes mediante Wireshark al ejecutar el script de spoofing.
A continuación se muestra el codigo del script ’spoof.c’
31
1 #include <unistd.h>
3 #include <string.h>
4 #include <sys/socket.h>
5 #include <netinet/ip.h>
7
13 };
14
15 /* IP Header */
29 };
30
31 /* ICMP Header */
32 struct icmpheader {
33 unsigned char icmp_type; // ICMP message type
34 unsigned char icmp_code; // Error code
35 unsigned short int icmp_chksum; //Checksum for ICMP Header and data
36 unsigned short int icmp_id; //Used for identifying request
37 unsigned short int icmp_seq; //Sequence number
38 };
39
40 /* UDP Header */
41 struct udpheader
42 {
43 u_int16_t udp_sport; /* source port */
44 u_int16_t udp_dport; /* destination port */
45 u_int16_t udp_ulen; /* udp length */
46 u_int16_t udp_sum; /* udp checksum */
47 };
48
49 /* TCP Header */
50 struct tcpheader {
51 u_short tcp_sport; /* source port */
52 u_short tcp_dport; /* destination port */
53 u_int tcp_seq; /* sequence number */
54 u_int tcp_ack; /* acknowledgement number */
55 u_char tcp_offx2; /* data offset, rsvd */
56 #define TH_OFF(th) (((th)->tcp_offx2 & 0xf0) >> 4)
57 u_char tcp_flags;
66 #define TH_FLAGS (TH_FIN|TH_SYN|TH_RST|TH_ACK|TH_URG|TH_ECE|TH_CWR)
67 u_short tcp_win; /* window */
68 u_short tcp_sum; /* checksum */
69 u_short tcp_urp; /* urgent pointer */
70 };
71
72 /* Psuedo TCP header */ 32
73 struct pseudo_tcp
74 {
75 unsigned saddr, daddr;
76 unsigned char mbz;
Task 2.2B: Suplantar una solicitud ICMP
Haga spoof de un paquete ICMP echo request en nombre de otra maquina (es decir, use
la dirección IP de otra máquina que no sea la suya como dirección IP origen). Este paquete
deberı́a ser enviado a una maquina remota en Internet (debe estar online). Abra el Wireshark
y si su spoofing es exitoso deberı́a de recibir un paquete ICMP echo reply como respuesta de
la maquina remota.
Aunque la solicitud ICMP se originó en 10.0.2.15, la VM atacante creó el paquete con una
IP falsificada (la de la vı́ctima). Entonces, una vez que el servidor remoto recibió el paquete
ICMP, respondió a la IP de origen que está presente en el paquete en lugar de enviarlo al
atacante. Por lo tanto, el atacante falsificó una solicitud ICMP Echo.
Para esta parte de la practica se usaron 2 maquina virtuales, el atacante y la vı́ctima. En
la figura 34 se muestra la captura de paquete ICMP con la cual se hizo spoofin a la VM con
IP 10.0.2.5 a 4.3.2.1 mediante la implementación del script ’sppof2.c’
Figura 34: Paquetes ICMP al hacer ejecutar el segundo script de spoofing
• Pregunta 4 ¿Es posible modificar el campo length de un paquete IP usando cualquier

valor, sin importar cuan grande sea el paquete en cuestión?
◦ Sı́, el campo de longitud del paquete IP puede tener cualquier valor arbitrario. Pero
la longitud total del paquete se sobrescribe a su tamaño original cuando se envı́a.
• Pregunta 5 Al programar con raw sockets, ¿Debe de calcular el checksum para un
encabezado IP?
◦ Al usar los sockets sin procesar, puede decirle al kernel que calcule la suma de
verificación para el encabezado IP. En los campos de encabezado de IP, en realidad
es la opción predeterminada, ip check = 0 permitirá que el kernel lo haga a menos
que lo cambie a un valor diferente, pero luego tendrá que usar un método de suma
de verificación.
• Pregunta 6 ¿Por que necesita privilegios de root para correr un programa que usa raw
sockets? ´ ¿Donde falla el programa si no se ejecuta con privilegios de root?
33
◦ Los privilegios de root son necesarios para ejecutar programas que implementan
sockets sin procesar. Los usuarios sin privilegios no tienen los permisos para cam-
biar todos los campos en los encabezados de protocolo. Los usuarios con privilegios
de root pueden establecer cualquier campo en los encabezados de los paquetes y ac-
ceder a los sockets y poner la tarjeta de interfaz en modo promiscuo. Si ejecutamos
el programa sin el privilegio de root, fallará en la configuración del socket
4.3. Task 2.3: Sniff y luego spoof

En esta Tarea, va a combinar las tecnicas de sniffing y spoofing para implementar un
programa de sniff-and-then-spoof. Para lograr esto, necesita tener dos Maquinas Virtuales en
la misma LAN. Desde la máquina A hará ping hacia una IP X. Esto va a generar un paquete
ICMP echo request. Si X esta viva, el programa de ping recibira una echo reply y mostrar
´ a la respuesta. Su programa de sniff-and-then-spoof correrá en la Maquina B que va a
monitorear la LAN usando packet sniffing. Cada vez que vea un paquete ICMP echo request,
sin importar cual es la direccion IP destino, el programa deber ´ a de enviar inmediatamente
un paquete ICMP echo reply usando la tecnica de packet spoofing. Adem ´ as, sin importar si
la m ´ aquina X este viva o no, el programa de ping siempre recibira una reply, indicando que
X est ´ a viva. Su tarea es escribir un programa de estas caracterı́sticas usando C y incluir
screenshots en su informe de laboratorio que muestren que su programa funciona. Por favor
también incluya el código de su programa.
La máquina atacante estaba en modo promiscuo y luego, cuando ejecutamos nuestro pro-
grama de Spoofin, la NIC capturó todos los paquetes que llegaron y el programa luego los
procesó de tal manera que modificó el destino como fuente y la fuente como destino. Una vez
que se crea el paquete, envı́a el paquete y la vı́ctima recibe. Por lo tanto, el script implemen-
tado realiza la falsificación la solicitud de eco ICMP.
Como dato adicional los paquetes falsificados tinen un checksum incorrecto, esto se puede
verifican en la captura de la figura 35.
Figura 35: Captura de paquetes mediante Wireshark al ejecutar el script implementada pora
hacer Sniffing y spoofing.
Adicionalmente se muestra el codigo implementado para realizar el sniffing y spoofing.
34
1 #include <pcap.h>
3 #include <string.h>
5 #include <fcntl.h> // for open
6 #include <unistd.h> // for close
7
13 };
14
15 /* IP Header */
29 };
30
31 /* ICMP Header */
32 struct icmpheader {
33 unsigned char icmp_type; // ICMP message type
34 unsigned char icmp_code; // Error code
35 unsigned short int icmp_chksum; //Checksum for ICMP Header and data
36 unsigned short int icmp_id; //Used for identifying request
37 unsigned short int icmp_seq; //Sequence number
38 };
39
40 /* UDP Header */
41 struct udpheader
42 {
43 u_int16_t udp_sport; /* source port */
44 u_int16_t udp_dport; /* destination port */
45 u_int16_t udp_ulen; /* udp length */
46 u_int16_t udp_sum; /* udp checksum */
47 };
48
49 /* TCP Header */
50 struct tcpheader {
51 u_short tcp_sport; /* source port */
52 u_short tcp_dport; /* destination port */
53 u_int tcp_seq; /* sequence number */
54 u_int tcp_ack; /* acknowledgement number */
55 u_char tcp_offx2; /* data offset, rsvd */
56 #define TH_OFF(th) (((th)->tcp_offx2 & 0xf0) >> 4)
57 u_char tcp_flags;
66 #define TH_FLAGS (TH_FIN|TH_SYN|TH_RST|TH_ACK|TH_URG|TH_ECE|TH_CWR)
67 u_short tcp_win; /* window */
68 u_short tcp_sum; /* checksum */
69 u_short tcp_urp; /* urgent pointer */
70 };
71
72 /* Psuedo TCP header */ 35
73 struct pseudo_tcp
74 {
75 unsigned saddr, daddr;
76 unsigned char mbz;
Referencias
[1] ,Spoofing, Qué es y cómo evitarlo,https://www.ambit-bst.com/blog/spoofing-
que-es-y-cómo-evitarlo, 10 de diciembre, 2019
[2] ¿Qué es el Sniffing?, Ataque MITM.,https://hardsoftsecurity.es/index.php/2014/10/02/que-

es-el-sniffing
[3] ,Packet Sniffing and Spoofing Lab,https://dorazaria.github.io/network/packet-

sniffing-and-spoofing-lab
36

G2 P8 PacketSniffingandSpoofing

Cargado por

Copyright:

Formatos disponibles

G2 P8 PacketSniffingandSpoofing

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

G2 P8 PacketSniffingandSpoofing

Cargado por

Copyright:

Formatos disponibles

Universidad de Cuenca

PACKET SNIFFING AND SPOOFING LAB

Bryam Gomez Murillo

• Suplantación de dirección IP Los ciberdelincuentes utilizan la dirección IP de la

• Suplantación de DNS Consiste en acceder a los servidores de nombres de dominio

1.1.2. Cómo detectar el spoofing

Figura 1: Configuración del entorno

2.1. Setup del Contenedor y sus Comandos

A continuación, se muestran los comandos mas usados en Docker y Compose. Debido a

\$ docker-compose build #Build the container image

Sus alias en la máquina virtual son:

\$ dcbuild #Alias for: docker-compose build

Figura 3: Conexión máquina atacante

2.2. El contenedor atacante

• Shared folder: Directorio compartido entre la máquina virtual y el contenedor, se usara

Obteniendo el nombre de la interfaz de red:

Figura 4: Ip máquina atacante

Otra forma de obtener el nombre de la interfaz es usar el comando docker network y

Figura 5: Nombre de la red atacante

Figura 6: Scapy: pantalla de inicio

3 from scapy.all import *

3.1. Task 1.1: Sniffing Packets

7 pkt = sniff(iface=interfaces, filter='icmp', prn=print_pkt)

El código mostrado anteriormente, hará sniffing de todos los paquetes en la interfaz

3 from scapy.all import *

(a) Creación de los paquetes ICMP a través

Figura 8: Sniffing de paquetes con privilegios root

• Capturar solamente paquetes ICMP:

3 from scapy.all import *

7 if pkt[ICMP] is not None:

Código 4: Sniffero nlyi cmp.py

Figura 10: Captura únicamente de paquetes ICMP

• Capturar cualquier paquete TCP que provenga de una IP y cuyo puerto

3 from scapy.all import *

Código 5: Captura paquetes TCP

2. Acerca de la pregunta: La IP de mi VM por defecto es 10.9.0.1 y se envı́a

Figura 11: Captura únicamente de paquetes TCP

3 from scapy.all import *

1. Acerca del código: En el programa send_subnet_packet.py se eligio el filtrado

2. Acerca de la pregunta: Se envió un paquete a una subred en particular y el

Figura 12: Ejecución: subnet_sniffer.py

3.2. Task 1.2: Spoofing ICMP Packets

Spoofing de paquetes: Cuando un usuario normal envı́a un paquete, el sistema opera-

Código: El código a utilizar para esta tarea es el código 8.

1 from scapy.all import *

2. Acerca de la pregunta: Se ha falsificado el paquete de solicitud de ICMP y se lo ha

Figura 15: Captura wireshark: Spoofing ICMP

3.3. Task 1.3: Traceroute

Traceroute: Es un comando de diagnóstico de redes informáticas para mostrar las posi-

Código: Para esta tarea se va utilizar el código 14.

1. Acerca del código: Se a programado la version propia de traceroute usando la li-

2. Acerca de la pregunta: Este programa calcula cuántos routers (saltos) se necesitan

3.4. Task 1.4: Sniffing and-then Spoofing

1 from scapy.all import *

Código 10: traceroute.py

2. Acerca de la pregunta: En esta tarea se va ha probar 3 escenarios de 3 IPs diferen-

Figura 17: Ejecución: sning_and_spoofi g.py

Figura 19: Captura wireshark, primer escenario

Segundo escenario: VM2 envı́a un ping a 10.9.0.99 que es un host inexistente en la