Perfilar el Rendimiento de Tshark

Introducción

En este laboratorio, aprenderá cómo perfilar y analizar el rendimiento de la herramienta de línea de comandos tshark de Wireshark utilizando mediciones de tiempo y técnicas de procesamiento de paquetes. Explorará cómo habilitar estadísticas detalladas de tiempo con --print-timers, procesar archivos de captura e interpretar la salida JSON para comprender las diferentes fases de procesamiento.

A través de ejercicios prácticos, practicarás la medición de tiempos de procesamiento, el filtrado de tipos de tráfico específicos y el análisis de métricas de rendimiento. El laboratorio ofrece experiencia práctica con comandos de tshark para contar paquetes y examinar el tráfico DHCP mientras se perfila el rendimiento de Wireshark.

Habilitar temporizadores con --print-timers

En este paso, exploraremos cómo medir el rendimiento del procesamiento de paquetes de Wireshark utilizando la opción --print-timers. Esto es especialmente útil cuando se desea entender en qué tareas Tshark gasta la mayor parte de su tiempo al analizar el tráfico de red.

Antes de comenzar, asegúrate de estar en el directorio de trabajo correcto. Esto garantiza que todos nuestros comandos funcionen con las rutas de archivo esperadas:

cd ~/project

La opción --print-timers le indica a Tshark que realice un seguimiento y informe cuánto tiempo gasta en diferentes tareas al procesar paquetes. Probémoslo con una captura de tráfico DHCP de muestra que viene con Wireshark:

tshark --print-timers -r /usr/share/wireshark/example_captures/dhcp.pcap

Después de ejecutar este comando, verás una salida similar a la siguiente:

Timer 1: 0.000000 seconds
Timer 2: 0.000123 seconds
...

Estos temporizadores representan diferentes etapas del procesamiento de paquetes. Para centrarse en un solo temporizador específico, podemos usar grep para filtrar la salida. Por ejemplo, para ver solo los resultados del Temporizador 1:

tshark --print-timers -r /usr/share/wireshark/example_captures/dhcp.pcap | grep "Timer 1"

A continuación, se muestra lo que suele medir cada temporizador principal:

Temporizador 1: Tiempo empleado en leer el archivo de captura desde el disco
Temporizador 2: Tiempo empleado en procesar y decodificar paquetes
Temporizador 3: Tiempo empleado en aplicar filtros de visualización (si se utilizan)

Comprender estos temporizadores ayuda a identificar cuellos de botella de rendimiento cuando se trabaja con archivos de captura grandes o escenarios de filtrado complejos.

Procesar archivo con -r capture.pcap

En este paso, aprenderás cómo procesar archivos de captura de paquetes utilizando la herramienta de línea de comandos tshark de Wireshark con la opción -r. Esto es esencial para analizar el tráfico de red grabado previamente almacenado en archivos .pcap, que son archivos binarios que contienen paquetes de red capturados.

Primero, asegúrate de estar en el directorio de trabajo correcto. Esto es importante porque algunos comandos pueden esperar que los archivos estén en ubicaciones específicas:
```
cd ~/project
```
Examinemos un archivo de captura DHCP de muestra que viene con la instalación de Wireshark. DHCP (Protocolo de Configuración Dinámica de Host) es un protocolo de red utilizado para asignar automáticamente direcciones IP a dispositivos. La bandera -r le indica a tshark que lea desde el archivo especificado:
```
tshark -r /usr/share/wireshark/example_captures/dhcp.pcap
```
La salida muestra cada paquete con información básica en columnas:
- Número de paquete
- Marca de tiempo (segundos desde que comenzó la captura)
- Direcciones IP de origen → destino
- Protocolo (DHCP en este caso)
- Longitud del paquete
- Información específica del protocolo
```
1 0.000000 192.168.0.1 → 192.168.0.10 DHCP 342 DHCP Discover - Transaction ID 0x7c3e0c29
2 0.023512 192.168.0.10 → 192.168.0.1 DHCP 342 DHCP Offer - Transaction ID 0x7c3e0c29
...
```
Para contar el número total de paquetes en el archivo de captura, redirigimos (|) la salida de tshark a wc -l, que cuenta líneas. Cada paquete se muestra en una línea:
```
tshark -r /usr/share/wireshark/example_captures/dhcp.pcap | wc -l
```
Para un análisis más profundo, podemos usar la bandera -V (detallada) para mostrar todos los detalles disponibles del paquete. Dado que esto produce mucha salida, usamos head -20 para mostrar solo las primeras 20 líneas:
```
tshark -r /usr/share/wireshark/example_captures/dhcp.pcap -V | head -20
```

Filtrar TCP con -Y "tcp"

En este paso, aprenderás cómo filtrar el tráfico TCP utilizando la opción de filtro de visualización -Y de Wireshark. TCP (Protocolo de Control de Transmisión) es uno de los protocolos fundamentales en la comunicación de red, responsable de la entrega confiable de datos. El filtro -Y ayuda a aislar los paquetes TCP del resto del tráfico de red, lo cual es esencial cuando se analizan navegaciones web, transferencias de archivos u otras aplicaciones basadas en TCP.

Primero, asegúrate de estar en el directorio de trabajo correcto. Esto es importante porque algunos comandos pueden depender de rutas de archivos relativas:
```
cd ~/project
```
Ahora, apliquemos un filtro básico de TCP a nuestro archivo de captura de muestra. La bandera -r especifica el archivo de entrada, mientras que -Y "tcp" le indica a tshark que muestre solo los paquetes TCP:
```
tshark -r /usr/share/wireshark/example_captures/http.pcap -Y "tcp"
```
La salida mostrará solo los paquetes TCP, mostrando el handshake TCP (SYN, SYN-ACK) y las transferencias de datos posteriores. Cada línea representa un paquete TCP con su número de secuencia, tamaño de ventana y banderas:
```
1 0.000000 192.168.1.100 → 192.168.1.1 TCP 74 49278 → 80 [SYN] Seq=0 Win=64240 Len=0
2 0.000042 192.168.1.1 → 192.168.1.100 TCP 74 80 → 49278 [SYN, ACK] Seq=0 Ack=1 Win=65535 Len=0
...
```
Si solo quieres contar cuántos paquetes TCP hay en la captura, puedes redirigir la salida a wc -l. Esto es útil para obtener estadísticas rápidas:
```
tshark -r /usr/share/wireshark/example_captures/http.pcap -Y "tcp" | wc -l
```
Para un análisis más específico, puedes filtrar el tráfico TCP en puertos específicos. Este ejemplo muestra solo el tráfico en el puerto 80 (HTTP). Observa cómo usamos tcp.port en lugar de solo tcp para especificar el número de puerto:
```
tshark -r /usr/share/wireshark/example_captures/http.pcap -Y "tcp.port == 80"
```

Analizar la salida de tiempo en formato JSON

En este paso, examinaremos cómo Wireshark registra información de tiempos en formato JSON. JSON (JavaScript Object Notation) es un formato de datos ligero que es fácil de leer para los humanos y de analizar para las máquinas. Combinaremos las habilidades de captura y filtrado de paquetes de los pasos anteriores para generar estadísticas de tiempos significativas.

Antes de comenzar, asegúremos de estar en el directorio correcto. La carpeta del proyecto contiene todos los archivos necesarios y mantendrá nuestro trabajo organizado:

cd ~/project

Ahora generaremos datos de tiempos específicamente para los paquetes TCP. La bandera --print-timers le indica a Tshark que incluya información de tiempos en su salida, mientras que -T json lo formatea como JSON. Estamos guardando esto en un archivo para su posterior análisis:

tshark -r /usr/share/wireshark/example_captures/http.pcap -Y "tcp" --print-timers -T json > tcp_timings.json

Echemos un vistazo rápido a la estructura de nuestra salida JSON. El comando head nos muestra las primeras 20 líneas, lo que nos ayuda a entender cómo está organizada la data antes de procesarla más:

head -20 tcp_timings.json

Para trabajar de manera efectiva con datos JSON, usaremos jq, un potente procesador de JSON de línea de comandos. Si aún no lo tienes instalado, este comando lo configurará:

sudo apt-get install -y jq

Ahora podemos extraer métricas de tiempo específicas. Este comando filtra el JSON para mostrar solo la información de los temporizadores de cada paquete, dándonos una vista más clara de los datos de tiempo:

jq '.[].timers' tcp_timings.json | head -10

Finalmente, creemos un resumen más enfocado que muestre solo los números de paquete y sus tiempos de procesamiento correspondientes. Esto nos da una vista clara de cuánto tiempo tardó en procesarse cada paquete:

jq '.[].timers | {packet_number: .packet_num, processing_time: .processing_time}' tcp_timings.json | head -5

Resumen

En este laboratorio, has aprendido a evaluar el rendimiento de Tshark utilizando la opción --print-timers para analizar fases de procesamiento como la lectura de archivos y el procesamiento de paquetes. Los ejercicios demostraron cómo interpretar las estadísticas de tiempo para optimizar los flujos de trabajo de análisis de red.

También practicaste técnicas esenciales de análisis de paquetes, incluyendo el procesamiento de archivos de captura con -r, el examen del contenido de los paquetes y el uso del modo detallado (verbose mode). El laboratorio proporcionó experiencia práctica con los archivos de muestra de Wireshark para desarrollar habilidades fundamentales en el análisis del tráfico de red.