Ejercicio de fragmentación de tráfico con Hping3
| Ejercicio de fragmentación IP empleando HPING3 y Wireshark |
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.02.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.
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 (porque es este valor, 1480).
Un poco más en detalle, fíjense que el primer paquete (estos son los dos paquetes que generamos con hping3 cuando le dijimos que ocupe una posición de 1600 bytes) entonces, IP, como no puede meter más de 1500 bytes en una red Ethernet, lo partió como 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 lo que estamos viendo en azul aquí abajo). Toda esta línea en hexadecimal ocupa 16 bytes completos. El primer encabezado, que es Ethernet (que es lo que estoy marcando aquí), ocupa 14 bytes. Y el segundo encabezado, que se le degrada, es el de IP.
Si contamos lo que figura aquí abajo en esa decimal, tenemos dos objetos. Siempre el valor 45 es el que identifica el inicio de un encabezado IP. Luego los 14 bytes están en la segunda línea, y 2 bytes están abajo.
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, se 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.
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).
Entonces, 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 el proceso inverso es lo que sucedería en el otro extremo.