Si deseas seguir esta práctica con un vídeo explicativo, aquí te dejamos el enlace:

Ejercicio de fragmentación de tráfico con Hping3

Esta vez, usando una herramienta nueva que se llama hping3, como siempre a través de nuestro Kali. Para hacer este ejercicio, vamos a abrir una línea de comandos. Dentro de esta consola de línea de comandos, veremos cuál es la dirección IP que tenemos, en nuestro caso nos indica que es la 10.0.2.15. Desde esta IP, vamos a abrir también Wireshark para poder hacer capturas de tráfico.

Nuevamente, nos da el mensaje de que debemos ejecutarlo como administradores. Tened cuidado con este tipo de funciones, una vez nos iniciamos en esta podemos tener serios problemas si no lo sabemos tratar. Os guiaremos paso a paso para evitar peligros. Vamos a elegir la interfaz "eth0", que es desde la que vamos a capturar tráfico.

Creación de varios paquetes de tráfico

Desde aquí vamos a operar con este comando que se llama hping3. Esta herramienta es muy útil desde seguridad en redes para poder generar tráfico y analizar la respuesta de la red. Vamos a empezar a usarla en este ejercicio. En este caso, vamos a usar el parámetro "set" que me dice la cantidad de paquetes que quiere utilizar. Le vamos a decir que sólo genere un paquete. En la opción "d", le decimos el tamaño de datos que queremos que emplee. Debemos detallar también para este primer ejercicio que genere un paquete con 1600 bytes. Y como dirección destino, vamos a elegir, en este caso, la dirección IP 10.50.240.132, que es la IP real que tengo en mi portátil. Entonces, generamos esto e inmediatamente vemos cómo se han inyectado dos tramas, dos paquetes a nivel IP o datagramas, como deberíamos llamarlos.

Creación de un paquetes de tráfico

Vamos a probar otro ejemplo más. En este caso, lo mismo. Le vamos a decir que genere un solo paquete, pero esta vez de tamaño 5000 bytes. Entonces, le decimos a hping3 que ejecute un paquete a esta dirección IP destino de tamaño 5000 bytes y que sólo sea cantidad 1. Esto se realiza a través del comando hping3 -c 1 -d 5000 y añadiendo la IP destino, en este caso 10.50.240.132. siendo de esta forma que -c estipula la cantidad de paquetes y -d la densidad del mismo

Vamos a ejecutarlo nuevamente y vemos que Wireshark ha capturado de estos paquetes. Vamos a agrandar ahora Wireshark para analizar bien qué es lo que ha sucedido. Y empecemos por nuestro primer paquete.

Análisis de los resultados obtenidos

Vamos a analizar qué es lo que ha sucedido en este paquete, desde la IP fuente 215 (que es la mía) hacia la IP destino. Ampliamos el campo "data" y lo primero que vemos es que en este primer paquete, el protocolo IP le está diciendo que él, en este protocolo, tiene un flag que informa que hay "more fragments". Entonces, le está diciendo que ha usado la función de fragmentación. Ha colocado este "ID" en este caso = 187, que hay "more fragments" y que el fragment offset ocupa la posición 0. Es decir, ha generado una trama de longitud total de 1514 bytes que se corresponde al identificador 187 y que vienen más fragmentos dentro de este datagrama.

Si analizamos el segundo, me está diciendo que sigue siendo el ID 187, que ya no tiene más fragmentos ("no more fragments") y que ocupa la posición 1480. estudiemos más en detalle por qué este valor de 1480.

Fíjense que el primero de estos dos paquetes que generamos con hping3 cuando le dijimos que ocupe una posición de 1600 bytes, es menor de 1600. Como no puede meter más de 1500 bytes en una red Ethernet, lo partió en un primer paquete con la máxima longitud que soporta una red Ethernet, que son 1514 bytes. Y estos 1514 bytes están divididos en 14 bytes del encabezado Ethernet (que es toda esa línea en hexadecimal ocupa 14 bytes completos y que se marca en azul cuando clicamos sobre la entrada "Ethernet II Src:"). Y el segundo encabezado, que se le degrada, es el de IP. Este segundo siempre comenzará por 45 que es lo que demarca el comienzo de un encabezado IP, 14 bytes en la segunda línea y dos últimos que cierran el encabezado IP que siempre serán 20.

Estos son los 20 bytes del encabezado IP, más 14 bytes del encabezado Ethernet, son 34. 34 más 1480, que es la posición que ocupa este dato, suman los 1514 del que aparece en la longitud total del primer datagrama. Es decir, cuando le dijimos a hping3 que genere un datagrama de 1600 bytes, él generó primero 1514. Entonces, en este primer, me dice el ID es 187, tengo "more fragments" y ocupó la posición 0. En el segundo, me dice "sigo siendo el ID 187", ya no tengo más fragmentos, y este lo empiezo a contar a partir de la posición 1480, porque 1480 más los 20 del encabezado IP más los 14 del encabezado de Ethernet, suman los 1514 bytes que son los que realmente puso en el canal de comunicación.

Analizando el segundo comando ejecutado por hping3

Vamos a analizar el segundo comando que nosotros ejecutamos, hping3. Le dijimos que era de 5000 bytes. En este caso, vamos a ver que lo partió en cuatro paquetes. El primer paquete, al igual que el anterior, dice que tiene "more fragments". En este caso, le dio el ID 189 y ocupa la posición 0.

El segundo paquete, vemos que igual que antes, ocupa la posición 1480. En este caso, me dice que tengo "more fragments" y sigue siendo de 1514.

El tercer paquete sigue siendo el ID 189, sigue teniendo "more fragments", y ocupa la posición 2960.

Y el último paquete ya no tiene "more fragments", se acabó. Ocupa la posición 4440 y sigue siendo el ID 180.

Conclusiones

Es decir, para meter en la red una información de 5000 bytes, que es lo que le hemos ordenado con hping3, lo partió en cuatro paquetes sin excederse del máximo tamaño que permite la red Ethernet, que recuerdo es 1514.

En un primer paquete lo llamó 189, "more fragments", y ocupa la posición cero. Un segundo paquete, también 189, también "more fragments", ocupa 1480. En un tercer paquete, también 189, "more fragments", ocupa 2960 (que es 1480 por 2). Y en un último paquete, que también es ID 189, ya no hay más fragmentos, este es el último y ocupa la posición 4440 (que es 1480 por 3). El último tiene una longitud de 614.

Así es como IP fragmenta un volumen grande que puede recibir de los niveles de transporte o de aplicación. Así es como cuando nosotros queremos enviar una película a través de internet de un gigabyte, pues lo va a partir en tantos paquetitos como necesite para que esta información llegue desde el origen en que enviamos hasta el destino que queremos llegar con la tele.

Así es como trabaja IP en fragmentación y reensamble. Y el proceso inverso es lo que sucedería en el otro extremo. Así es como trabaja hping3 que en nuestro primer ejemplo, lo hemos visto para generar datagramas IP de distintas longitudes y obligarlos a que hagan uso de la función de fragmentación.