Sie sind auf Seite 1von 12

2018 - Telecomunicaciones - FI-UNRC

TCP Monitor
TCP Monitor
Netem
Emulando delay en un enlace
Pérdida de paquetes (Packet loss)
Duplicación de paquetes
Paquetes corruptos
Reordenamiento de paquetes
Netem y Token Bucket
Asignar nuestra propia distribución a Netem
Usando netem con distribución propia
IPERF3
Instalación
Lista de servidores Iperf públicos
Utilización
TCPPROBE
Instalación
Utilización
Interactuando con el KERNEL, Comando sysctl
Opciones para tcp desde el kernel de Linux
CAPTCP
Instalación
Dependencias
Descarga e instalación
Módulos de Análisis
Statistic Module
Throughput Module
Socket Statistic Module
Time Sequence Module
Posibles errores
TCPDUMP
Ejemplo:

Netem
Netem proporciona a la red la funcionalidad de emulación para pruebas de protocolos. La
versión actual emula la variable de retraso, pérdida, corrupción, duplicación y reordenamiento.
Para kernel 2.6 netem ya está habilitado en el núcleo junto a una versión actual de iproute2. El
componente del núcleo netem está habilitada en:

Networking --> Networking Options --> QoS and/or fair queuing --> Network emulator

1 / 12
2018 - Telecomunicaciones - FI-UNRC

Netem es controlado por el comando "TC" que forma parte de la herramienta de iproute2. El
comando TC utiliza bibliotecas compartidas y archivos de datos en el directorio /usr/lib/tc.

Advertencia! netem aplica las reglas al tráfico saliente de la interface.

Modo de empleo:

$ tc qdisc add dev <interfaz> root netem <parámetro> <valor>



Donde <parámetro> y <valor> están relacionados de la
siguiente forma. <parámetro> puede ser:
delay -> especifica en <valor> un retardo
loss -> específica en <valor> un porcentaje de pérdidas
corrupt -> específica en <valor> un porcentaje de paquetes
dañados
duplicate -> específica en <valor> un porcentaje de paquetes
duplicados.
reorder -> específica en <valor> un porcentaje de paquetes
desordenados

nota: si queremos cambiar una regla asociada con una interfaz debemos utilizar change
en ves de add. Con del borramos las reglas tc qdisc del dev borra las reglas asociadas
a la interfaz seleccionada.

Con el siguiente comando vemos las configuraciones cargadas.

$ tc qdisc show

Emulando delay en un enlace

Podemos añadir una cantidad fija de retardo a cada paquete que salga de la placa de red.

$ tc qdisc add dev eth0 root netem delay 100ms

Ahora, una simple prueba de ping al host en la red local debe mostrar un incremento de 100
milisegundos.

El retraso está limitada por la resolución de reloj del núcleo (HZ). En la mayoría de los sistemas
de 2.4, el sistema de reloj funciona a 100 Hz, que permite a los retrasos en incrementos de 10
ms. En 2.6, el valor es una configuración que puede ir de 1000 a 100 hz.

Con netem podemos añadir variaciones aleatorias como las que se presentan en redes reles.

2 / 12
2018 - Telecomunicaciones - FI-UNRC

$ tc qdisc change dev eth0 root netem delay 100ms 10ms

Esto hace que el retraso sea de 100 ms ± 10 ms.

La variación de retardo no es puramente aleatoria, de forma que para emular se puede agregar
un valor de correlación.

$ tc qdisc change dev eth0 root netem delay 100ms 10ms 25%

Esto hace que al retraso del próximo elemento aleatorio (100ms ± 10ms) tenga una variación del
25% respecto del ultimos. Esta correlación estadística no es del todo cierta, sino una
aproximación.

Normalmente, el retraso en una red no es uniforme. Es más común utilizar una distribución
normal para describir la variación de delay. Netem puede tomar datos de una tabla para
especificar una distribución no uniforme.

$ tc qdisc change dev eth0 root netem delay 100ms 20ms


distribution normal

Las tablas reales (Normal, Pareto, paretonormal) se generan como parte de la compilación de la
iproute2 y se coloca en /usr/lib/tc; Se puede construir y usar una tabla propia con datos
obtenidos experimentalmente.

Pérdida de paquetes (Packet loss)

La pérdida de paquetes es especificada con el comando 'tc' en porcentaje. El valor mas chico
que puede usarse es: 232 = 0.0000000232%

$ tc qdisc change dev eth0 root netem loss 0.1%

Esto causa que 1 de 1000 paquetes se descarten en forma aleatoria. Una correlación opcional
también puede ser agregada. This causes the random number generator to be less random and
can be used to emulate packet burst losses. Esto hace que el generador de números aleatorios
para ser menos aleatoria y puede ser utilizado para emular las pérdidas de ráfagas de paquetes.

$ tc qdisc change dev eth0 root netem loss 0.3% 25%

3 / 12
2018 - Telecomunicaciones - FI-UNRC

Esto hará que el 0,3% de los paquetes se pierda, y cada probabilidad sucesiva dependa de un
cuarto de la última.

Probn = .25 * Probn-1 + .75 * Random

Advertencias Cuando se utiliza netem con pérdida de paquetes localmente (no en


un puente o router), la pérdida se informa a los protocolos de nivel superior. Esto
puede causar que TCP reenvíe el paquete y no se vea que se perdió un paquete.
Cuando se desea ver la respuesta a la pérdida de un protocolo de pruebas es
mejor utilizar netem en un puente o router.

Duplicación de paquetes

La duplicación de paquetes se especifica de la misma manera que la pérdida de paquetes.

$ tc qdisc change dev eth0 root netem duplicate 1%

Paquetes corruptos

Ruido aleatorio puede ser emulado (en kernel 2.6.16 o posterior) con la opción de paquetes
corruptos. Esto introduce error en un bit en una posición aleatoria del paquete.

$ tc qdisc change dev eth0 root netem corrupt 0.1%

Reordenamiento de paquetes

Se puede pensar en que los paquetes del buffer de salida se reacomodan antes de ser enviados,
causando que salgan fuera de orden. Esto es previsible y útil para las pruebas de protocolo que
reensamblan.

Hay dos formas diferentes de especificar la reordenación. El primer método utiliza una secuencia
fija y reordena cada n paquete.

$ tc qdisc change dev eth0 root netem gap 5 delay 10ms

Esto hace que 5 (10, 15, ...) paquetes sean enviados inmediatamente y todos los otros paquetes
se retrase por 10 ms.

La segunda forma de reordenar el cambio de orden es más parecido a la vida real.

$ tc qdisc change dev eth0 root netem delay 10ms reorder 25% 50%

4 / 12
2018 - Telecomunicaciones - FI-UNRC

En este ejemplo, el 25% de los paquetes (con una correlación de 50%) son enviadas de
inmediato, los otros se retrasará por 10ms. Las versiones más recientes de netem también
podran reordenar paquetes si los valores de retardo aleatorio estan fuera de orden.

$ tc qdisc change dev eth0 root netem delay 100ms 75ms

Si el primer paquete recibe un retraso aleatorio de 100 ms (100 ms base - 0ms jitter) y el
segundo paquete se envía 1 ms mas tarde y consigue un retraso de 50 ms (100 ms base - 50ms
jitter), el segundo paquete será enviado en primer lugar. Esto es porque la disciplina de cola tfifo
dentro de netem, guarda los paquetes en orden de tiempo para ser enviados.

Advertencias La Mezcla de formas de reordenación puede conducir a resultados


inesperados Con cualquier método de reordenación que se trabaje, es necesario
un cierto retraso. Si el retraso es menor que los tiempos de arribo entre paquetes
entonces no se podra ver la reordenación.

Netem y Token Bucket

sudo tc qdisc change dev eth0 root handle 1: tbf rate 512kbit buffer 1600 limit 3000

sudo tc qdisc add dev eth0 parent 1: handle 10: netem delay 150ms loss 1%

Asignar nuestra propia distribución a Netem

$ git clone https://github.com/shemminger/iproute2.git

$ cd iproute2
$ cd netem

$ sudo apt install build-essential


$ gcc stats.c -o stat -lm
$ gcc maketable.c -o maketable -lm

sudo ping -f 8.8.8.8 -c 2000 > mydata.txt

$ cat mydata.txt | grep icmp_seq | cut -d'=' -f4 | cut -d' ' -f1 >
myrtt.txt

$ ./maketable myrtt.txt > mydist.dist

$ sudo cp mydist.dist /usr/lib/tc

$ ./stats myrtt.txt

5 / 12
2018 - Telecomunicaciones - FI-UNRC

Usando netem con distribución propia

tc qdisc change dev eth0 root netem delay 100ms 20ms distribution mydist

IPERF3
https://iperf.fr/

Herramienta que permite medir el rendimiento de la red con protocolos como TCP, UDP y SCTP.
Es útil para probar y monitorizar el ancho de banda máximo alcanzable en redes IP (admite tanto
IPv4 como IPv6). Requiere un servidor y un cliente para realizar pruebas. En ellas se nos
informará sobre el ancho de banda, la pérdida y otros parámetros útiles para evaluar el
rendimiento de la red.

Instalación

Desde los repositorios

$ sudo apt install iperf3

Compilando la última versión

$ git clone https://github.com/esnet/iperf

#Building

$ ./configure; make; make install

# (Note: If configure fails, try running first:

$ ./bootstrap.sh)

Lista de servidores Iperf públicos

https://iperf.cc/es/

Utilización

Para ver ayuda completa del comando

$ man iperf3
$ iperf3 -h

6 / 12
2018 - Telecomunicaciones - FI-UNRC

En el receptor abrimos un socket con iperf

$ iperf3 -S # Por defecto usa el puerto 5201

En el transmisor iniciamos el envio de paquetes

$ iperf3 -c <ip_dst> -t <tiempo en seg> -i <intervalo en seg>

TCPPROBE
Instalación

$ git clone https://github.com/fengidri/tcpprobe

$ vi Makefile

#
# Makefile for kernel test - cambiar KERNEL_DIR segun su sistema
#
PWD := $(shell pwd)
KVERSION := $(shell uname -r)
KERNEL_DIR = /usr/src/linux-headers-$(KVERSION)/
#KERNEL_DIR = /usr/lib/modules/$(KVERSION)/build
MODULE_NAME = tcpprobe
obj-m += tcpprobe.o
tcpprobe-objs := tcp_probe.o tcp_probe_filter.o
all:
make -C $(KERNEL_DIR) M=$(PWD) modules
clean:
make -C $(KERNEL_DIR) M=$(PWD) clean

install:
insmod $(MODULE_NAME).ko

remove:
rmmod $(MODULE_NAME)

$ make

7 / 12
2018 - Telecomunicaciones - FI-UNRC

Utilización

$ python2.7 tp.py -h

usage: tp.py [-h] [--saddr SADDR] [--daddr DADDR] [--sport SPORT]


[--dport DPORT] [-o O] [-r R]

optional arguments:
-h, --help show this help message and exit
--saddr SADDR local ip
--daddr DADDR remote ip
--sport SPORT local port
--dport DPORT remote port
-o O remote port
-r R reload module

$ sudo python2.7 tp.py --saddr 192.168.5.65 --daddr 192.168.5.11 -


-dport 5201 --sport 45000

$ sudo python2.7 tp.py --saddr 192.168.5.65 --daddr 192.168.5.11 -


-dport 5201 --sport 45000 > salida.txt

$ sed -i 's/2147483647/0/g' salida.txt


$ sed -i '1,10d' salida.txt
$ sed -i '$d' salida.txt
$ sed -i '$d' salida.txt

$ ./iperf3 -c 192.168.5.11 -B 192.168.5.65 --cport 45000

$ python2.7 tcprobe_draw.py -i salida.txt -o salida2 -s 0

Nota: El Umbral Inicial es 2³¹ − 1 = 2147483647 el cual corresponde al máximo valor para
un entero de 32 bits con signo

8 / 12
2018 - Telecomunicaciones - FI-UNRC

Interactuando con el KERNEL, Comando sysctl


Ver valor de la variable

$ sudo sysctl -n net.ipv4.tcp_no_metrics_save

Ver todos los valores

sudo sysctl -a

Escribir valor en una variable

sudo sysctl -w [variable]=[valor]

Opciones para tcp desde el kernel de Linux

Ver algoritmos tcp disponibles

$ sysctl net.ipv4.tcp_available_congestion_control

Ver otros algoritmos tcp para usar

$ ls -l /lib/modules/`uname -r`/kernel/net/ipv4/ | grep "\<tcp"

Cargar otro algoritmo tcp

$ sudo modprobe tcp_htcp

Window Scaling [activar/desactivar]

$ sudo sysctl -w net.ipv4.tcp_window_scaling=[1, 0]

Sack [activar = 1 / desactivar =0]

9 / 12
2018 - Telecomunicaciones - FI-UNRC

$ sudo sysctl -w net.ipv4.tcp_sack=0


$ sudo sysctl -w net.ipv4.tcp_dsack=0

Cambiar Algoritmo tcp

ejemplo: reno

$ sudo sysctl -w net.ipv4.tcp_congestion_control=reno

No guardar métricas de variables

sudo sysctl -w net.ipv4.tcp_no_metrics_save=1

CAPTCP
http://research.protocollabs.com/captcp/

Captcp es un programa gratuito y de código abierto para el análisis de protocolo TCP a partir de
archivos PCAP. Normalmente grabado a través de Tcpdump o Wireshark. Captcp es un intento
de volver a escribir y agrupar todas las herramientas de análisis TCP comunes en un programa
fácil de usar, que proporciona una sintaxis de línea de comandos limpia y consistente. Captcp
está escrito en Python y es fácil de extender. Captcp no es un sustituto de Tcpdump o Wireshark,
sino que complementa estas herramientas.

Instalación

Dependencias

```bash
$ sudo apt install make gnuplot mupdf iperf3 git python-dpkt
python-geoip python-cairo python-numpy texlive-font-utils
imagemagick
```

Descarga e instalación

```bash
$ git clone https://github.com/hgn/captcp.git
$ cd captcp

10 / 12
2018 - Telecomunicaciones - FI-UNRC

$ sudo make install


```

Módulos de Análisis

Statistic Module

Statistic Module

Throughput Module

Throughput Module

Ejemplo de uso

Ejemplo cambiando la unidad de salida:

```bash
$ captcp throughput -i -p -u megabit -f 1.2 -o outth file.pcap
```

Socket Statistic Module

Socket Statistic Module

Time Sequence Module

Time Sequence Module

Posibles errores

FIX make PNG

In file /etc/ImageMagick-6/policy.xml (or /etc/ImageMagick/policy.xml)

1. comment line <!-- <policy domain="coder" rights="none" pattern="MVG" /> -->


2. change line <policy domain="coder" rights="none" pattern="PDF" /> to <policy
domain="coder" rights="read|write" pattern="PDF" />
3. add line <policy domain="coder" rights="read|write" pattern="LABEL" />

TCPDUMP
http://www.tcpdump.org/

Ejemplo:

11 / 12
2018 - Telecomunicaciones - FI-UNRC

Capturar el trafico de la insterface enp2s0 con puerto destino y orgen 5201 y guardar la salida en
un archivo trace.pcap

$ tcpdump -i enp2s0 port 5201 -w trace.pcap

12 / 12