Limitar el Tamaño de la Captura con Tshark

Introducción

En este laboratorio, aprenderás a controlar el tamaño de la captura de paquetes en Wireshark utilizando comandos de Tshark. Explorarás dos técnicas esenciales: limitar el número total de paquetes con -c 500 y restringir la longitud de los paquetes con -s 128 para capturar solo los encabezados y ahorrar espacio de almacenamiento.

A través de ejercicios prácticos en la interfaz eth1, capturarás el tráfico en limited.pcap y observarás cómo diferentes configuraciones afectan tus capturas. Esta experiencia práctica te ayudará a optimizar la recolección de paquetes para diversos escenarios de análisis.

Establecer el Conteo de Paquetes con -c 500

En este paso, aprenderás a controlar la duración de la captura de paquetes limitando el número de paquetes que Tshark recopila. Tshark es la versión de línea de comandos de Wireshark, ideal para capturas automatizadas. La opción -c es particularmente valiosa cuando necesitas una muestra representativa del tráfico de red sin sobrecargar tu sistema con una captura continua.

Comienza abriendo el terminal en tu máquina virtual LabEx. El sistema te coloca automáticamente en el directorio de trabajo correcto (~/project), por lo que puedes comenzar inmediatamente.
La estructura del comando utiliza este patrón básico:
```
tshark -c [número] [otras opciones]
```
Aquí, [número] determina exactamente cuándo la captura se detiene especificando el número máximo de paquetes a recopilar. Esto evita ejecuciones indefinidas que podrían llenar tu almacenamiento.
Primero, identifiquemos las interfaces de red disponibles. Ejecuta el siguiente comando:
```
tshark -D
```
Verás una lista de interfaces, similar a esta:
```
1. eth0
2. eth1 (Interfaz ficticia)
3. any
4. lo (Loopback)
...
```
Usaremos eth1 para nuestras capturas, ya que es una interfaz ficticia creada para este laboratorio para asegurar una generación de tráfico consistente.
Capturemos 500 paquetes como ejercicio principal. Ejecuta este comando:
```
tshark -c 500 -i eth1
```
El comando sudo es necesario porque la captura de paquetes requiere privilegios administrativos. Esto le indica a tshark que supervise la conexión de red eth1.
Para generar algo de tráfico que tshark pueda capturar, abre una nueva pestaña de terminal (o divide la terminal actual) y ejecuta el siguiente comando:
```
ping -c 10 google.com
```
Esto enviará 10 paquetes ICMP a google.com, creando actividad de red en eth1 que tshark puede capturar.

A medida que los paquetes fluyen, verás la salida en tiempo real en el terminal de tshark. Después de exactamente 500 paquetes, tshark se termina automáticamente. La salida se verá similar a esto (aunque será mucho más larga para 500 paquetes):

Capturando en 'eth1'
    1 0.000000000 192.168.X.X -> 142.250.X.X ICMP 84 Echo (ping) request  id=0xXXXX, seq=1/256, ttl=64 (reply in 2)
    2 0.000000000 142.250.X.X -> 192.168.X.X ICMP 84 Echo (ping) reply    id=0xXXXX, seq=1/256, ttl=117 (request in 1)
... (muchas más líneas)
500 paquetes capturados

Antes de la captura completa de 500 paquetes, prueba con una muestra más pequeña para comprender el mecanismo. Esta prueba de 10 paquetes ayuda a verificar tu configuración:
```
tshark -c 10 -i eth1
```
Recuerda generar tráfico en otra terminal mientras este comando se ejecuta.

Definir la Longitud de la Instantánea con -s 128

En este paso, aprenderás a configurar la longitud de la instantánea (snaplen) al capturar paquetes utilizando la opción -s en Tshark. Esto determina cuántos bytes de cada paquete se capturan, siendo 128 bytes un valor común que captura los encabezados del paquete mientras se conserva el espacio de almacenamiento. La longitud de la instantánea es particularmente útil cuando solo necesitas los encabezados del paquete para el análisis en lugar del contenido completo del paquete.

Primero, asegúrate de estar en el directorio de trabajo predeterminado ~/project en tu terminal. Aquí es donde ejecutaremos todos nuestros comandos de captura para mantener las cosas organizadas.
La opción de longitud de la instantánea (-s) limita la cantidad de cada paquete capturado especificando el número de bytes a registrar. Los valores más pequeños ahorran espacio en el disco, pero pueden perder datos importantes de la carga útil. La sintaxis básica es:
```
tshark -s [longitud] [otras opciones]
```
Capturemos paquetes con una longitud de instantánea de 128 bytes combinada con el conteo de paquetes del paso anterior. Este comando capturará los primeros 128 bytes de cada paquete hasta alcanzar 500 paquetes:
```
tshark -c 500 -s 128 -i eth1
```
Recuerda generar tráfico en una terminal separada (por ejemplo, ping -c 10 google.com) mientras tshark se está ejecutando.
Verás la salida mostrando los primeros 128 bytes de cada paquete. La captura se detendrá automáticamente después de 500 paquetes, como lo especifica la opción -c. Esta combinación ayuda a gestionar tanto el tamaño como la duración de la captura. La salida será similar al paso anterior, pero los detalles del paquete podrían estar truncados si exceden los 128 bytes.
```
Capturando en 'eth1'
    1 0.000000000 192.168.X.X -> 142.250.X.X ICMP 84 Echo (ping) request  id=0xXXXX, seq=1/256, ttl=64 (reply in 2)
... (muchas más líneas)
500 paquetes capturados
```
Para comprender mejor cómo la longitud de la instantánea afecta las capturas, prueba estos comandos de comparación. Observa cómo la cantidad de datos mostrados cambia con diferentes valores de -s. Recuerda generar tráfico para cada comando.
```
tshark -c 5 -s 64 -i eth1 ## Captura solo 64 bytes por paquete
tshark -c 5 -s 0 -i eth1  ## Captura paquetes completos (predeterminado)
```
La configuración -s 0 le indica a tshark que capture el paquete completo, lo cual es útil cuando necesitas el contenido completo del paquete pero consume más espacio de almacenamiento.

Capturar Tráfico con -i eth1

En este paso, nos centraremos en capturar el tráfico de red desde una interfaz específica utilizando la opción -i de Tshark. Las interfaces de red son las conexiones físicas o virtuales que tu computadora utiliza para comunicarse con las redes. Cuando tienes múltiples interfaces (como Wi-Fi y Ethernet), especificar la correcta es crucial para un análisis de paquetes dirigido.

Abre tu terminal y navega al directorio de trabajo:
```
cd ~/project
```
La bandera -i le indica a Tshark qué interfaz de red monitorear. La estructura básica del comando es:
```
tshark -i [interfaz] [otras opciones]
```
Aquí, [interfaz] debe ser reemplazado con el nombre de tu interfaz real, típicamente eth1 para nuestro entorno de laboratorio.
Ahora combinemos esto con lo que hemos aprendido sobre los límites de paquetes (-c) y la longitud de la instantánea (-s). Este comando capturará 500 paquetes de la interfaz eth1, guardando solo los primeros 128 bytes de cada paquete:
```
tshark -c 500 -s 128 -i eth1
```
El comando sudo es necesario porque la captura de paquetes requiere privilegios administrativos.
Para generar tráfico de prueba mientras se captura, abre otra pestaña de terminal y ejecuta:
```
ping -c 3 google.com
```
Esto envía 3 paquetes ICMP a los servidores de Google, los cuales deberían aparecer en tu captura. Observar estos paquetes conocidos ayuda a verificar que tu captura está funcionando correctamente.
La captura se detendrá automáticamente después de 500 paquetes, pero puedes detenerla manualmente en cualquier momento presionando:
```
Ctrl+C
```
Esta interrupción de teclado termina el proceso de captura de forma segura preservando cualquier dato capturado.

Guardar en Archivo con -w limited.pcap

En este paso, aprenderás cómo guardar el tráfico de red capturado en un archivo para su análisis posterior. La opción -w en Tshark crea un archivo de captura de paquetes (pcap) que preserva todos los datos de red capturados. Esto es especialmente útil cuando necesitas examinar patrones de tráfico sin conexión o compartir capturas con colegas.

Antes de comenzar, asegúrate de que tu terminal se encuentra en el directorio de trabajo correcto. Escribe:
```
cd ~/project
```
Esto asegura que todos tus archivos de captura se guardarán en la carpeta de proyecto designada.
La bandera -w indica a Tshark dónde almacenar los paquetes capturados. La estructura básica del comando es:
```
tshark -w [nombre_de_archivo] [otras opciones]
```
El nombre de archivo debe terminar con la extensión .pcap, que es el formato estándar para los archivos de captura de paquetes.
Ahora combinemos todas las opciones que hemos aprendido hasta ahora en un ejemplo práctico. Este comando:
- Capturará exactamente 500 paquetes (-c 500)
- Limitará cada paquete a 128 bytes (-s 128)
- Escuchará en la interfaz eth1 (-i eth1)
- Guardará todo en un archivo llamado limited.pcap (-w limited.pcap)
```
tshark -c 500 -s 128 -i eth1 -w limited.pcap
```
Mientras tshark esté ejecutándose, abre otra ventana de terminal para generar algo de tráfico de prueba. Estos comandos crearán actividad de red típica:
```
ping -c 3 google.com
curl http://example.com
```
Este tráfico simulado será capturado por nuestra sesión tshark en ejecución.
Después de capturar 500 paquetes (o presiona Ctrl+C para detenerlo antes), verifica que tu archivo de captura exista y comprueba su tamaño:
```
ls -lh limited.pcap
```
La salida muestra los detalles del archivo, incluyendo el tamaño y la hora de creación, similar a esto:
```
-rw-r--r-- 1 root root 56K 10 ago XX:XX limited.pcap
```
Para revisar tus paquetes capturados más tarde, tienes dos opciones principales:
- Usando tshark (línea de comandos):
```
tshark -r limited.pcap
```
  Esto muestra el contenido de los paquetes exactamente como fueron capturados, permitiéndote analizar el tráfico a tu conveniencia.
- Usando wireshark (GUI):
  
  Nota: Debes ejecutar este comando en la interfaz de escritorio.
```
wireshark limited.pcap &
```
  Esto abrirá el archivo limited.pcap en la interfaz gráfica de usuario de Wireshark, proporcionando una forma más visual e interactiva de analizar los paquetes capturados. El & al final ejecuta el comando en segundo plano, para que puedas seguir usando tu terminal.

Resumen

En este laboratorio, has aprendido a controlar el tamaño de la captura de paquetes en Tshark utilizando parámetros esenciales de línea de comandos. Practicaste la limitación del número de paquetes con -c 500 y la restricción de la longitud de los paquetes con -s 128, observando cómo estas opciones afectan el comportamiento de la captura y la eficiencia del almacenamiento.

Los ejercicios demostraron la combinación de estas técnicas con la selección de interfaz (-i eth1) para un análisis de tráfico específico. A través de comandos como tshark -c 500 -s 128 -i eth1 -w limited.pcap, adquiriste experiencia práctica en la aplicación de múltiples restricciones de captura simultáneamente y en guardar los resultados para su análisis fuera de línea utilizando tanto tshark como wireshark.

Limitar el Tamaño de la Captura en Tshark