Analizar la pérdida de paquetes en Tshark

Introducción

En este laboratorio, aprenderá a analizar la pérdida de paquetes TCP utilizando la herramienta de línea de comandos de Wireshark, Tshark. Practicará la captura de tráfico de red, la identificación de retransmisiones y la interpretación de estadísticas de pérdida a través de comandos prácticos en la terminal.

Los ejercicios lo guiarán a través de la detección de patrones de pérdida de paquetes y la comprensión de las métricas de rendimiento de la red. Obtendrá experiencia práctica tanto en transmisiones normales como en escenarios de pérdida simulados para solucionar problemas de conexión TCP en el mundo real.

Capturar tráfico TCP con -f "tcp"

En este paso, aprenderá cómo capturar tráfico TCP utilizando la opción de filtro de captura -f "tcp" de Wireshark. TCP (Protocolo de Control de Transmisión) es uno de los protocolos fundamentales de Internet, responsable de la entrega confiable de datos. Este filtro asegura que solo se capturen paquetes TCP, lo cual es especialmente útil cuando desea centrarse en comportamientos específicos de TCP, como el establecimiento de conexiones (handshake de tres vías), retransmisiones y control de flujo, sin distraerse con otro tráfico de red.

Primero, abra una terminal en su máquina virtual LabEx haciendo clic en el icono de la terminal en el escritorio Xfce o utilizando el atajo Ctrl+Alt+T. La terminal es donde ejecutará todos los comandos para este análisis de red.
Navegue al directorio de trabajo predeterminado donde almacenaremos nuestros archivos de captura:
```
cd ~/project
```
Este directorio se crea específicamente para su trabajo en el laboratorio, manteniendo sus archivos organizados y separados de los archivos del sistema.
Comience a capturar paquetes TCP ejecutando este comando:
```
sudo tshark -f "tcp" -w tcp_capture.pcap
```
Analicemos qué hace cada parte:
- sudo le otorga los privilegios de administrador necesarios para la captura de paquetes.
- tshark es la versión de línea de comandos de Wireshark.
- -f "tcp" le indica a tshark que solo capture paquetes TCP.
- -w tcp_capture.pcap guarda los paquetes capturados en un archivo llamado tcp_capture.pcap.
Mientras tshark está en ejecución, abra otra pestaña/ventana de terminal (Ctrl+Shift+T) y genere algo de tráfico TCP. Utilizaremos curl para realizar una solicitud web simple:
```
curl -I https://www.labex.io
```
La opción -I le indica a curl que solo obtenga los encabezados HTTP, lo cual genera suficiente tráfico para nuestro análisis sin descargar datos innecesarios.
Después de esperar alrededor de 5 - 10 segundos para capturar suficientes paquetes, detenga la captura presionando Ctrl+C en la terminal donde tshark está en ejecución. Debería ver una salida similar a:
```
Capturing on 'eth1'
10 packets captured
```
Esto confirma cuántos paquetes TCP se capturaron durante su sesión.
Verifique que su archivo de captura se haya creado correctamente listando los archivos en el directorio:
```
ls -lh tcp_capture.pcap
```
Las opciones -lh muestran el tamaño del archivo en un formato legible por humanos (como KB o MB) junto con otros detalles. Esto ayuda a confirmar que su captura se guardó correctamente antes de pasar al siguiente paso.

Verificar retransmisiones con -Y "tcp.analysis.retransmission"

En este paso, examinaremos las retransmisiones TCP que ocurren cuando el emisor no recibe confirmación (acknowledgment) de los paquetes enviados y necesita reenviarlos. Esta es una técnica crucial para solucionar problemas de red, ya que las retransmisiones frecuentes a menudo indican congestión de red, pérdida de paquetes u otros problemas de conectividad.

Antes de comenzar, entendamos lo que estamos buscando:

Una retransmisión ocurre cuando TCP no recibe un ACK (confirmación) dentro del tiempo esperado.
Wireshark/tshark pueden identificar estas retransmisiones utilizando el filtro especial "tcp.analysis.retransmission".
Primero verificaremos una captura existente y luego crearemos una nueva con problemas de red simulados.

Primero, asegúrese de estar en el directorio del proyecto donde se almacenan nuestros archivos de captura:
```
cd ~/project
```
Analicemos el archivo de captura que creamos anteriormente en busca de retransmisiones. El comando se desglosa de la siguiente manera:
- -r lee desde un archivo de captura guardado.
- -Y aplica un filtro de visualización para mostrar solo las retransmisiones.
```
tshark -r tcp_capture.pcap -Y "tcp.analysis.retransmission"
```
Si su conexión a la red fue estable durante la primera captura, probablemente verá:
```
0 packets captured
```
Esto es normal e indica que no se necesitó retransmitir ningún paquete durante ese período de captura.
Para entender mejor las retransmisiones, ahora crearemos una nueva captura mientras provocamos intencionalmente congestión de red. Abra dos ventanas de terminal:

En la primera terminal, comience a capturar tráfico TCP:
```
sudo tshark -f "tcp" -w retransmission_capture.pcap
```
En la segunda terminal, ejecute una descarga lenta que puede desencadenar retransmisiones:
```
curl --limit-rate 10k https://www.labex.io
```
Después de unos segundos, detenga ambos procesos con Ctrl+C.
Ahora examine el nuevo archivo de captura en busca de retransmisiones:
```
tshark -r retransmission_capture.pcap -Y "tcp.analysis.retransmission"
```
Esta vez debería ver una lista de paquetes retransmitidos, que muestra números de secuencia y detalles de tiempo que ayudan a diagnosticar problemas de rendimiento de la red.

Resumir estadísticas de pérdida con -z tcp,tree

En este paso, aprenderá cómo utilizar la potente función de estadísticas de Wireshark con la opción -z tcp,tree. Este comando le ayuda a analizar las conversaciones TCP e identificar patrones de pérdida de paquetes al proporcionar una visión general estructurada de todos los flujos TCP en los datos capturados.

Antes de comenzar, entendamos lo que muestran las estadísticas de las conversaciones TCP:

La vista en árbol muestra la comunicación entre pares de hosts.
Cuenta los marcos (paquetes) y los bytes transferidos en cada dirección.
Ayuda a identificar el tráfico desequilibrado, que puede indicar problemas.

Primero, asegúrese de estar en el directorio del proyecto donde se almacenan sus archivos de captura:
```
cd ~/project
```
Ahora analicemos las estadísticas básicas de TCP de nuestra captura inicial. Este comando lee el archivo de captura y genera un árbol de conversaciones:
```
tshark -r tcp_capture.pcap -z tcp,tree
```

La salida mostrará una tabla estructurada de todas las conversaciones TCP. Presta atención a estas columnas:

<- muestra el tráfico que llega a su máquina.
-> muestra el tráfico que sale de su máquina.
Total resume ambos sentidos.

======================================================
TCP Conversations
Filter:<No Filter>
|       <-      | |       ->      | |     Total     |
| Frames  Bytes | | Frames  Bytes | | Frames  Bytes |
======================================================

Ahora examinemos específicamente la captura de retransmisiones. Las retransmisiones ocurren cuando se pierden paquetes y es necesario reenviarlos:
```
tshark -r retransmission_capture.pcap -z tcp,tree
```
Busque conversaciones donde el recuento de marcos sea significativamente más alto que en otras: esto a menudo indica problemas de retransmisión.
Para un análisis más preciso, podemos combinar esto con nuestro filtro de retransmisiones anterior. Esto muestra solo los paquetes retransmitidos en el árbol de conversaciones:
```
tshark -r retransmission_capture.pcap -Y "tcp.analysis.retransmission" -z tcp,tree
```
Esto ayuda a identificar exactamente qué conversaciones están experimentando pérdida de paquetes.

Salida silenciosa con -q

En este paso, exploraremos cómo utilizar la opción -q de Wireshark para simplificar el análisis de paquetes. Cuando se trabaja con capturas de red grandes, a menudo no es necesario ver cada paquete individual; solo se desean las estadísticas importantes. La opción -q (quiet, silenciosa) ayuda ocultando las listas detalladas de paquetes y mostrando solo los datos resumidos.

Primero, naveguemos hasta nuestro directorio de trabajo donde se almacenan los archivos de captura:
```
cd ~/project
```
Ahora analizaremos nuestro archivo de captura TCP en modo silencioso. Este comando lee el archivo pero solo muestra las estadísticas de las conversaciones TCP:
```
tshark -r tcp_capture.pcap -q -z tcp,tree
```
Para entender lo que hace la opción -q, ejecutemos el mismo comando sin ella. Observe cómo esta versión muestra todos los paquetes individuales antes de las estadísticas:
```
tshark -r tcp_capture.pcap -z tcp,tree
```
Podemos combinar la opción silenciosa con nuestro filtro de retransmisiones anterior. Esto nos da una vista clara solo de las estadísticas de retransmisión:
```
tshark -r retransmission_capture.pcap -Y "tcp.analysis.retransmission" -q -z tcp,tree
```

El formato de salida se verá así, mostrando solo las estadísticas de las conversaciones sin detalles de los paquetes:

======================================================
TCP Conversations
Filter:tcp.analysis.retransmission
|       <-      | |       ->      | |     Total     |
| Frames  Bytes | | Frames  Bytes | | Frames  Bytes |
======================================================

Resumen

En este laboratorio, has aprendido a analizar la pérdida de paquetes TCP utilizando Tshark a través de técnicas prácticas de resolución de problemas de red. Has capturado tráfico TCP con filtros específicos, identificado retransmisiones y generado estadísticas de conexión para evaluar el rendimiento de la red.

Los ejercicios demostraron cómo utilizar las características avanzadas de Tshark, como -z tcp,tree para un análisis completo de flujos TCP y -q para un informe estadístico eficiente. Estas habilidades te permiten diagnosticar y resolver rápidamente problemas de pérdida de paquetes en entornos de red del mundo real.