Práctica 6 - Capa de transporte I

Contenido

Práctica 6 - Capa de transporte I#

El objetivo de esta práctica es estudiar las diferencias entre los protocolos de transporte UDP y TCP, tanto en los aspectos de rendimiento como de confiabilidad. Para ello se utilizará la herramienta nc para la transferencia de algunos ficheros, así como la herramienta wireshark para realizar las capturas correspondientes a las transmisiones.

Más específicamente, durante esta sesión vas a enviar varios ficheros entre dos procesos de tu equipo a través de la interfaz de loopback (lo). Se utilizarán diferentes ficheros de texto y de sonido, utilizando los protocolos de transporte TCP y UDP.

Evaluación#

Esta práctica es evaluable (0.5 puntos sobre los 3.0 puntos totales de las prácticas), por lo que deberás acceder al cuestionario correspondiente en Campus Virtual. El cuestionario se cerrará al acabar la sesión. Cada respuesta errónea se penalizará con un 1/3 del valor asignado a cada pregunta.

Preparación#

Para la realización de la práctica es necesario que la conexión de red esté configurada correctamente:

Se suponen conocidos aspectos ya vistos en prácticas anteriores, por ejemplo, el comando para conocer la propia IP y el manejo de Wireshark y Tshark.
Prepara tu directorio de trabajo:
- En /home/alumno crea un directorio llamado p6. Asumiendo que tu directorio actual es /home/alumno, el comando sería:
```
mkdir p6
```
- Si ya existe, bórralo y créalo de nuevo:
```
rm -rf p6
mkdir p6
```
- Ve al directorio y realiza la práctica desde allí:
```
cd p6
```
- Comprueba que estás en el directorio adecuado con:
```
pwd
```
  Debe devolver:
```
/home/alumno/p6
```
Crea un directorio para ejecutar desde allí los clientes y otro para los servidores:
```
mkdir cliente servidor
```
Ten preparadas dos terminales diferentes; en una de ellas, sitúate en el directorio del cliente y en la otra, en el del servidor:
```
cd ~/p6/cliente
pwd
```
```
cd ~/p6/servidor
pwd
```

UDP#

Para el análisis del funcionamiento del protocolo UDP se va a transmitir un fichero de texto entre 2 programas dentro del mismo equipo a través de la interfaz de red local o loopback. De manera simultánea ejecutarás el servidor, el cliente y realizarás la captura de los paquetes UDP con la herramienta que desees, Wireshark o Tshark.

`udp-uuid.pcapng`#

En primer lugar, prepara el fichero que enviará el cliente hacia el servidor. Dicho fichero debe contener un «identificador único universal» (UUID). Este tipo de identificador son 32 caracteres hexadecimales agrupados en 5 grupos de diferente tamaño, utilizando el guión como separador. Para generarlo, ejecuta lo siguiente en el terminal del cliente:
```
cat /proc/sys/kernel/random/uuid > uuid.txt
```
El fichero debe tener un tamaño de 37 bytes (36 bytes del UUID y el carácter de nueva línea). Puedes comprobarlo con:
```
$ ls -l uuid.txt
-rw-rw-r--. 1 alumno alumno 37 Mar 20 16:58 uuid.txt
```
Lanza la captura con wireshark. Si lo deseas, guárdalo con el nombre de udp-uuid.pcapng para poderlo analizar posteriormente.

Nota

Puedes indicar que se escuche sólo en la interaz «lo» (loopback) y utilizar un filtro de captura «udp», de modo que sólo se capture tráfico que viaje usando UDP como protocolo de transporte.
En el terminal del servidor, ejecuta el siguiente comando:
```
nc -l -u -p 8888 > received-uuid.txt
```
Los datos que reciba nc se redirigirán al fichero received-uuid.txt.
En el terminal del cliente, ejecuta el siguiente comando:
```
nc -q 2 -u 127.0.0.1 8888 < uuid.txt
```
En este ejemplo utilizamos 127.0.0.1, que es la dirección IP asignada a la interfaz local o loopback. De ese modo nos comunicaremos con otro proceso dentro de nuestra máquina a través de la pila de protocolos de red.
Termina la ejecución del servidor pulsando Ctrl c en la ventana correspondiente.
Detén la captura. Comprueba que en ella aparece tráfico.
Responde a las preguntas asociadas a esta captura.

`udp-quijote.pcapng`#

En este ejercicio vamos a utilizar una captura preexistente: descarga la captura udp-quijote.pcapng. En ella, el cliente envía el fichero de texto quijote.txt mediante la interfaz local o loopback, utilizando el protocolo de transporte UDP.
Abre la captura con wireshark.
Responde a las preguntas asociadas a esta captura.

TCP#

En esta parte vamos a realizar el trabajo equivalente de la sección anterior, pero en esta ocasión utilizando TCP como protocolo de transporte y utilizando un fichero de texto y otro de sonido en lugar de los ficheros de texto.

`tcp-quijote.pcapng`#

Para este ejercicio vamos a utilizar una captura preexistente: descarga la captura tcp-quijote.pcapng. En ella se replica la transmisión del ejercicio anterior, pero utilizando el protocolo de transporte TCP.
Abre la captura con wireshark.
Responde a las preguntas asociadas a esta captura.

`tcp-mp3.pcapng`#

Descarga el audio MP3 en la carpeta del cliente. El fichero se debe llamar p6audio.mp3:
```
wget https://uclm-esi.github.io/redes1-lab/assets/p6audio.mp3
```
Lanza la captura con wireshark. Si lo deseas, guárdalo con el nombre de tcp-mp3.pcapng para poderlo analizar posteriormente.

Nota

Puedes indicar que se escuche sólo en la interaz «lo» (loopback) y utilizar un filtro de captura «tcp», de modo que sólo se capture tráfico que viaje usando TCP como protocolo de transporte.
En el terminal del servidor, ejecuta el siguiente comando:
```
nc -l -p 8888 > audio_tcp_received.mp3
```
En el terminal del cliente, ejecuta el siguiente comando:
```
nc -q 2 127.0.0.1 8888 < p6audio.mp3
```
En este ejemplo utilizamos de nuevo 127.0.0.1 para que se utilice la interfaz local o loopback.
Detén la captura. Comprueba que en ella aparecen tanto los paquetes que envía el cliente como los que envía el servidor

Nota

Fíjate en el puerto origen y destino para saber qué paquetes pertenecen a cada proceso.
Responde a las preguntas asociadas a esta captura utilizando como filtro de visualización tcp.port == 8888.

Finalización#

Finalmente, borra el directorio generado /home/alumno/p6 con:

rm -rf /home/alumno/p6