Aplicar Filtros de Captura en Tshark

Introducción

En este laboratorio, aprenderá cómo utilizar los filtros de captura de Tshark para capturar selectivamente paquetes de red. Explorará la sintaxis de los filtros de Wireshark y practicará la captura de tráfico TCP en interfaces específicas utilizando comandos como tshark -f "tcp".

A través de ejercicios prácticos, filtrará paquetes TCP en eth1, analizará los detalles de los paquetes y guardará los resultados en tcp.pcap. Este laboratorio brinda experiencia práctica en la aplicación de filtros de captura para aislar y examinar de manera eficiente el tráfico de red objetivo.

Aprender la sintaxis con la referencia del manual

En este paso, aprenderá la sintaxis básica de los filtros de captura de Wireshark consultando la página del manual. Comprender estos conceptos fundamentales es crucial antes de realizar capturas reales de paquetes, ya que los filtros le permiten capturar selectivamente solo el tráfico de red que le interesa.

1. Primero, abra la terminal en su máquina virtual (VM) de LabEx si aún no está abierta. El directorio de trabajo predeterminado es ~/project. Aquí es donde ejecutaremos todos nuestros comandos.

2. Para acceder a la documentación completa de los filtros de Wireshark, ejecute el siguiente comando en su terminal:

man wireshark-filter

Esta página del manual contiene toda la documentación oficial sobre la sintaxis y las capacidades de los filtros de captura. Piense en ella como su hoja de trucos para crear filtros efectivos.

3. A medida que desplace la página del manual (presione Enter para navegar), concéntrese en estas secciones clave que forman la base de los filtros de captura:

   • Estructura básica de la sintaxis del filtro: Cómo formatear adecuadamente sus expresiones de filtro
   • Filtros de protocolos comunes: Filtros predefinidos para protocolos como TCP, UDP, HTTP
   • Operadores de comparación: Cómo comparar valores en sus filtros
   • Operadores lógicos: Combinar condiciones utilizando and, or, not

4. Ahora, apliquemos lo que ha aprendido con un ejemplo práctico. Ejecute este comando para probar un filtro TCP simple:

tshark -f "tcp" -c 5

Este comando hace tres cosas:

• -f "tcp" aplica un filtro para capturar solo paquetes TCP
• -c 5 limita la captura a 5 paquetes
• Los resultados se muestran directamente en su terminal

5. Si hay tráfico de red, verá una salida similar a esta, que muestra los detalles de cada paquete TCP capturado:

1 0.000000 192.168.1.1 → 192.168.1.2 TCP 74 443 → 49234 [SYN] Seq=0 Win=64240 Len=0

Cada línea representa un paquete, mostrando su número, marca de tiempo, direcciones IP de origen y destino, puertos y banderas TCP.

6. Cuando haya terminado de examinar la salida, presione q para salir tanto de la página del manual (si aún está abierta) como de cualquier captura de tshark en ejecución. Esto lo devuelve al indicador de comando, listo para el siguiente paso.

Filtrar tráfico TCP con -f "tcp"

En este paso, practicarás la captura de tráfico de red TCP (Transmission Control Protocol) utilizando la sintaxis de filtro de Wireshark. TCP es uno de los protocolos centrales del conjunto de protocolos de Internet, que proporciona una entrega de datos confiable, ordenada y con verificación de errores entre aplicaciones. Este ejercicio se basa en las habilidades básicas de captura de paquetes que aprendiste anteriormente.

1. Primero, asegúrate de estar en el directorio de trabajo predeterminado donde almacenaremos nuestros archivos de captura:

cd ~/project

2. Para capturar tráfico TCP en vivo desde tu interfaz de red, ejecuta este comando:

sudo tshark -i eth1 -f "tcp" -c 10

Nota: Las máquinas virtuales (VM) gratuitas pueden no tener la interfaz eth1. Puedes usar otras interfaces como eth0, eth2, etc.

Analicemos qué hace cada parte de este comando:

• sudo te otorga los privilegios de administrador necesarios para la captura de paquetes
• -i eth1 especifica que estamos capturando desde la interfaz Ethernet (eth1)
• -f "tcp" aplica un filtro de captura para recopilar solo paquetes TCP
• -c 10 limita la captura a 10 paquetes para esta demostración

3. La salida mostrará los paquetes TCP con información esencial en este formato:

1 0.000000 192.168.1.1 → 192.168.1.2 TCP 74 443 → 49234 [SYN] Seq=0 Win=64240 Len=0
2 0.000123 192.168.1.2 → 192.168.1.1 TCP 74 49234 → 443 [SYN, ACK] Seq=0 Ack=1 Win=28960 Len=0

Cada línea representa un paquete TCP mostrando:

• Número de paquete y marca de tiempo (timestamp)
• Direcciones IP de origen y destino
• Puertos de origen y destino
• Banderas (flags) TCP (como SYN, ACK)
• Números de secuencia y tamaños de ventana

4. Para examinar la estructura completa del paquete TCP, incluyendo todos los campos de la cabecera (header), utiliza el modo detallado (verbose):

sudo tshark -i eth1 -f "tcp" -c 5 -V

La bandera -V proporciona una salida detallada que muestra la cabecera TCP completa con todos sus campos, como números de secuencia, números de acuse de recibo (acknowledgment numbers), banderas, tamaño de ventana, checksum y opciones.

5. Si necesitas interrumpir una captura en ejecución en cualquier momento, simplemente presiona Ctrl+C para detener el proceso. Esto es útil cuando deseas terminar una captura de larga duración o si ya has visto suficientes paquetes para tu análisis.

Capturar tráfico filtrado en eth1

En este paso, aprenderás a capturar tráfico de red en la interfaz eth1 con filtros específicos, basándote en el filtrado TCP de pasos anteriores. La interfaz eth1 generalmente representa tu conexión de red cableada principal, y la usaremos para demostrar escenarios prácticos de captura de paquetes.

1. Primero, verifica tus interfaces de red ejecutando:

ip addr show eth1

Este comando muestra información detallada sobre tu interfaz eth1. Deberías ver una salida que indique que la interfaz eth1 está activa (estado UP) y tiene una dirección IP asignada. Esta verificación es importante porque no se puede capturar tráfico en una interfaz que no existe o no está activa.

2. Para capturar tráfico HTTP específicamente en eth1, utiliza:

sudo tshark -i eth1 -f "tcp port 80" -c 15

Desglosemos lo que hace este comando:

• -i eth1 especifica en qué interfaz de red se debe escuchar
• -f "tcp port 80" crea un filtro de captura para el tráfico HTTP (el puerto 80 es el puerto estándar de HTTP)
• -c 15 limita la captura a 15 paquetes, lo cual es suficiente para la demostración sin abrumarte con demasiada información

3. Para capturar tráfico entre direcciones IP específicas, prueba:

sudo tshark -i eth1 -f "host 8.8.8.8" -c 10

Aquí estamos filtrando el tráfico hacia/desde el servidor DNS de Google (8.8.8.8). El filtro "host" coincide con el tráfico entrante y saliente hacia esta dirección IP específica. Esto es útil cuando quieres monitorear la comunicación con un servidor en particular.

4. Para un filtrado más complejo, combina condiciones:

sudo tshark -i eth1 -f "tcp port 443 and host 8.8.8.8" -c 5

Este comando demuestra cómo combinar filtros. Captura tráfico HTTPS (puerto 443) específicamente hacia/desde 8.8.8.8. El operador "and" te permite crear filtros precisos que coincidan con múltiples condiciones simultáneamente.

5. Observa la salida que muestra los paquetes filtrados con detalles como:

1 0.000000 192.168.1.100 → 8.8.8.8 TCP 74 49234 → 443 [SYN] Seq=0 Win=64240 Len=0

Esta salida de muestra muestra un paquete TCP SYN (el primer paquete en una conexión TCP) desde tu máquina local (192.168.1.100) hacia el servidor de Google. Los números representan la sincronización temporal, los puertos y la información de secuencia TCP que ayudan a analizar el comportamiento de la red.

Guardar resultados con -w tcp.pcap

En este paso, aprenderás cómo guardar el tráfico de red capturado en un archivo para su posterior análisis. Esto es especialmente útil cuando necesitas examinar paquetes de red en un momento diferente o compartirlos con colegas. Utilizaremos la herramienta de línea de comandos de Wireshark, Tshark, con la opción -w para guardar nuestra captura.

1. Primero, asegúrate de estar en el directorio de trabajo correcto. El directorio ~/project es donde almacenaremos nuestros archivos de captura para mantener todo organizado:

cd ~/project

2. Ahora capturaremos tráfico TCP real. El siguiente comando hace varias cosas importantes a la vez. Es como configurar una cámara de red que solo graba paquetes TCP y los guarda en un archivo:

sudo tshark -i eth1 -f "tcp" -w tcp.pcap -c 20

Desglosemos lo que significa cada parte de este comando:

• -i eth1 le dice a Tshark que escuche en la interfaz de red eth1
• -f "tcp" aplica un filtro de captura para grabar solo paquetes TCP
• -w tcp.pcap guarda los paquetes capturados en un archivo llamado tcp.pcap
• -c 20 limita la captura a 20 paquetes para no recopilar demasiada información

3. Después de ejecutar la captura, debemos verificar que nuestro archivo se haya creado correctamente. El comando ls con las opciones -lh muestra el tamaño del archivo en un formato legible para humanos:

ls -lh tcp.pcap

Deberías ver una salida que indique que el archivo existe y su tamaño (por lo general, unos pocos KB para 20 paquetes).

4. Ahora examinemos nuestros paquetes capturados. Este comando lee los primeros 5 paquetes de nuestro archivo guardado:

tshark -r tcp.pcap -c 5

La opción -r le dice a Tshark que lea desde un archivo en lugar de capturar tráfico en vivo, mientras que -c 5 limita la salida a 5 paquetes.

5. Para una vista más técnica de lo que capturamos, podemos usar el modo detallado. Esto muestra todos los detalles del protocolo y el contenido de los paquetes, pero limitaremos la salida a las primeras 20 líneas para que no se vuelva abrumadora:

tshark -r tcp.pcap -V | head -20

La opción -V habilita la salida detallada, y head -20 muestra solo el principio de esa salida para no abrumarnos con información.

Resumen

En este laboratorio, has aprendido a aplicar filtros de captura en tshark a través de ejercicios prácticos. Has explorado los conceptos básicos de la sintaxis de los filtros, incluyendo filtros de protocolo y expresiones lógicas, y luego has practicado la captura de tráfico TCP con comandos básicos.

El laboratorio te ha guiado además a través de técnicas avanzadas como la monitorización en vivo de interfaces, la personalización de la salida en modo detallado y el guardado de capturas filtradas en archivos. Estas habilidades permiten un análisis eficiente del tráfico de red al combinar la selección de interfaces, el filtrado y la gestión de la salida en flujos de trabajo optimizados.