Depuración con Registros en Tshark

Introducción

En este laboratorio, aprenderá técnicas esenciales de depuración utilizando la herramienta de línea de comandos Tshark de Wireshark. Explorará cómo establecer niveles de depuración con --log-level, capturar tráfico en tiempo real en eth1 utilizando -i y guardar registros en archivos con --log-file para su análisis.

A través de ejercicios prácticos, practicarás la configuración de modos de depuración, el monitoreo del tráfico de red y la interpretación de las salidas de los registros. Este laboratorio brinda experiencia práctica con las características principales de depuración de Tshark en un entorno controlado de máquina virtual (VM).

Establecer el nivel de depuración con --log-level debug

En este paso, aprenderá cómo ajustar el nivel de detalle de los mensajes de registro cuando utilice la herramienta de línea de comandos tshark de Wireshark. La opción --log-level ayuda a controlar cuánta información muestra tshark, lo cual es especialmente útil cuando necesita entender lo que está sucediendo detrás de escena o solucionar problemas.

Primero, preparemos nuestro entorno de trabajo. Abra una terminal en su máquina virtual (VM) de LabEx. Trabajaremos en el directorio del proyecto predeterminado para mantener todo organizado:
```
cd ~/project
```
La estructura básica del comando para establecer niveles de registro es sencilla. Simplemente especifique el nivel deseado después de la opción:
```
tshark --log-level <level>
```
Estos son los niveles de registro más comúnmente utilizados, ordenados de menos a más detallados:
- critical - Solo muestra errores graves que podrían impedir que tshark funcione
- warning - Muestra posibles problemas que no son críticos pero que vale la pena tener en cuenta
- message - El nivel predeterminado que muestra mensajes de funcionamiento normal
- info - Proporciona mensajes informativos adicionales sobre las actividades de tshark
- debug - Muestra la información técnica más detallada para la solución profunda de problemas
Para este ejercicio, utilizaremos el nivel debug para ver la máxima cantidad de información. Esto nos ayudará a entender todas las operaciones detrás de escena de tshark. Ejecute este comando:
```
tshark --log-level debug
```
Después de ejecutar el comando, notará mucha más salida que de costumbre. Esta salida de depuración incluye detalles de inicialización, mensajes de procesamiento interno e información técnica sobre cómo tshark está manejando el tráfico de red.
Cuando esté listo para detener tshark, simplemente presione Ctrl+C en la terminal. Este atajo de teclado envía una señal de interrupción para detener el comando que se está ejecutando actualmente.

Capturar tráfico con -i eth1

En este paso, exploraremos cómo capturar tráfico de red en tiempo real utilizando la poderosa herramienta de línea de comandos tshark de Wireshark. Las interfaces de red son los puntos físicos o virtuales donde su computadora se conecta a una red, y eth1 suele ser la primera interfaz Ethernet en los sistemas Linux.

Primero, identifiquemos qué interfaces de red están disponibles en su máquina virtual (VM) de LabEx. Esto ayuda a asegurarnos de que estemos monitoreando la correcta:
```
tshark -D
```
Este comando lista todas las interfaces de red a las que tshark puede acceder. Busque eth1 en la salida; esta suele ser su conexión Ethernet principal.
Ahora comenzaremos a capturar el tráfico de red real. La opción -i le dice a tshark qué interfaz debe monitorear:
```
tshark -i eth1
```
A medida que los paquetes fluyen a través de su red, los verá mostrados en tiempo real. Cada línea representa un paquete de red y muestra:
- La hora exacta en que se capturó (marca de tiempo)
- De dónde viene y hacia dónde va (direcciones IP)
- Qué tipo de comunicación de red contiene (protocolo)
- Cuántos datos transporta (longitud del paquete)
Deje que la captura se ejecute durante aproximadamente 10 segundos para recopilar una muestra representativa del tráfico. Cuando esté listo, presione Ctrl+C para detener la captura. Esto le brinda experiencia práctica en la captura de paquetes en tiempo real.
A veces, es posible que desee capturar un número específico de paquetes. La opción -c le permite establecer este límite:
```
tshark -i eth1 -c 10
```
Este comando se detendrá automáticamente después de capturar exactamente 10 paquetes, lo cual es útil para pruebas rápidas.
Puede combinar esto con la depuración para obtener información más detallada sobre el proceso de captura:
```
tshark -i eth1 --log-level debug
```
Esto muestra no solo los paquetes, sino también las operaciones internas de tshark, lo que le ayuda a entender lo que está sucediendo detrás de escena.

Registrar en archivo con --log-file tshark.log

En este paso, aprenderá cómo guardar los registros de captura de tshark en un archivo para su posterior análisis utilizando la opción --log-file. Esto es especialmente útil cuando necesita documentar patrones de tráfico de red o solucionar problemas de conectividad, ya que le permite revisar los datos a su conveniencia en lugar de ver la salida en tiempo real.

Primero, asegúrese de estar en el directorio de trabajo predeterminado. Esto es importante porque el archivo de registro se creará en su directorio actual:
```
cd ~/project
```
Para comenzar a capturar tráfico de red y, al mismo tiempo, guardar todos los registros en un archivo llamado tshark.log, ejecute este comando. La opción -i eth1 especifica que estamos capturando desde la interfaz Ethernet:
```
tshark -i eth1 --log-file tshark.log
```
Deje que la captura se ejecute durante aproximadamente 10 segundos para recopilar suficientes datos, luego presione Ctrl+C para detener el proceso de captura correctamente. Esta interrupción de teclado asegura que el archivo de registro se cierre adecuadamente.
Verifique que el archivo de registro se haya creado correctamente listando el contenido del directorio. La opción -l muestra información detallada del archivo, incluyendo el tamaño y la marca de tiempo:
```
ls -l tshark.log
```
Debería ver el archivo enumerado con su tamaño y hora de creación, lo que confirma que la captura funcionó como se esperaba.
Vea el contenido del archivo de registro para examinar los paquetes capturados. El comando cat muestra todo el contenido del archivo en su terminal:
```
cat tshark.log
```
La salida mostrará los paquetes capturados en un formato legible, incluyendo marcas de tiempo, direcciones de origen/destino y información de protocolo.
Para un ejemplo más completo que combine pasos anteriores, pruebe este comando mejorado que incluye múltiples parámetros útiles:
```
tshark -i eth1 --log-level debug --log-file tshark.log -c 20
```
Este comando completo hará lo siguiente:
- Capturará paquetes específicamente de la interfaz de red eth1
- Establecerá el nivel de registro en depuración (debug) para obtener el máximo detalle
- Guardará toda la salida en el archivo tshark.log
- Se detendrá automáticamente después de capturar exactamente 20 paquetes

Revisar registros en busca de errores

En este paso, analizará el archivo de registro de tshark creado en el paso anterior para identificar posibles problemas y errores de red. Esta es una habilidad crucial para la resolución de problemas de red, ya que los registros proporcionan registros detallados de la actividad de red y de los posibles problemas.

Primero, navegue hasta el directorio de su proyecto si no está ya allí. Esto asegura que esté trabajando con el archivo de registro correcto:
```
cd ~/project
```
Vea el contenido completo del archivo de registro para obtener una imagen general del tráfico de red capturado. El comando cat muestra todo el contenido del archivo en su terminal:
```
cat tshark.log
```
Para buscar específicamente mensajes de error en el registro, use grep con coincidencia insensible a mayúsculas y minúsculas (opción -i). Esto ayuda a encontrar todas las entradas de error independientemente de la capitalización:
```
grep -i "error" tshark.log
```
Para un análisis más completo, busque varios tipos de problemas, incluyendo advertencias y fallos. La opción -E habilita expresiones regulares extendidas:
```
grep -E -i "error|warning|fail" tshark.log
```
Para cuantificar el número de ocurrencias de errores, envíe la salida de grep a la cuenta de palabras (wc) con la cuenta de líneas (-l). Esto le da una idea rápida de cuántos errores se registraron:
```
grep -i "error" tshark.log | wc -l
```
Para una vista más estructurada de los errores a nivel de paquete, use el filtro de visualización (-Y) de tshark para mostrar solo los marcos con banderas de error. Esto ayuda a identificar los paquetes problemáticos en su captura:
```
tshark -r tshark.log -Y "frame.error_flag == 1"
```
Para guardar solo los mensajes de error para un análisis o informe posterior, redirija la salida de grep a un nuevo archivo. Esto crea un registro limpio solo de errores:
```
grep -i "error" tshark.log > errors.txt
```

Resumen

En este laboratorio, has aprendido técnicas prácticas para el análisis de tráfico de red utilizando la herramienta de línea de comandos tshark de Wireshark. Has explorado cómo establecer niveles de depuración con --log-level debug para obtener mensajes operativos detallados, lo cual es crucial para solucionar problemas complejos de red.

Además, has practicado la captura de tráfico en vivo en la interfaz eth1 identificando las interfaces disponibles y analizando datos de paquetes en tiempo real. Estas habilidades fundamentales permiten un monitoreo eficiente de la red y el diagnóstico de problemas en entornos de línea de comandos.