Canalizar la salida de Tshark a herramientas

Introducción

En este laboratorio, aprenderá cómo capturar y analizar tráfico de red utilizando herramientas de línea de comandos, redirigiendo la salida de Tshark a otras utilidades. Practicará la captura de paquetes en la interfaz eth1 con tcpdump, filtrará mensajes de error utilizando grep y contará las coincidencias con wc -l.

El laboratorio se centra en técnicas prácticas para la resolución de problemas de red, incluyendo el guardado de capturas en formato pcap para su posterior análisis. Aprenderá a verificar interfaces, aplicar filtros y optimizar los flujos de trabajo de análisis de paquetes a través de tuberías Unix y operaciones de archivos.

Skills Graph

Capturar tráfico con -i eth1

En este paso, aprenderá cómo capturar tráfico de red en la interfaz eth1 utilizando comandos básicos de Linux. La interfaz eth1 suele ser la interfaz de red principal en los sistemas Linux, que representa la primera conexión Ethernet de su equipo.

Antes de capturar tráfico, es importante verificar que la interfaz exista y esté activa. Las interfaces de red pueden ser físicas (como puertos Ethernet) o virtuales (como conexiones VPN). Ejecute este comando para comprobar el estado de su interfaz eth1:

ip link show eth1

Debería ver una salida similar a la siguiente:

2: eth1: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP mode DEFAULT group default qlen 1000
    link/ether 00:16:3e:5e:6c:00 brd ff:ff:ff:ff:ff:ff

El estado UP indica que la interfaz está activa. Ahora usaremos tcpdump, una herramienta fundamental para el análisis de redes que le permite ver el tráfico en tiempo real. Este comando de captura básico le ayudará a entender lo que está sucediendo en su red:

sudo tcpdump -i eth1 -c 5

Desglosemos lo que hace este comando:

• -i eth1: Especifica qué interfaz de red se debe monitorear (en este caso, eth1)
• -c 5: Limita la captura a 5 paquetes, lo cual es suficiente para la demostración sin llenar su terminal

La salida mostrará detalles de los paquetes, incluyendo marcas de tiempo, direcciones IP de origen/destino y información del protocolo:

tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
listening on eth1, link-type EN10MB (Ethernet), capture size 262144 bytes
12:34:56.789012 IP 192.168.1.100.22 > 192.168.1.1.12345: Flags [P.], seq 1:21, ack 1, win 501, length 20
12:34:56.789123 IP 192.168.1.1.12345 > 192.168.1.100.22: Flags [.], ack 21, win 1024, length 0
...
5 packets captured
5 packets received by filter
0 packets dropped by kernel

Para un análisis más detallado, querrá guardar los paquetes en un archivo. Los archivos PCAP conservan todos los datos de los paquetes y se pueden abrir en herramientas gráficas como Wireshark. Este comando crea un archivo de captura:

sudo tcpdump -i eth1 -c 5 -w ~/project/eth1_capture.pcap

La opción -w escribe los paquetes en eth1_capture.pcap en su directorio de proyecto. Este formato binario mantiene toda la información original de los paquetes tal como se capturó.

Filtrar errores con | grep "ERROR"

En este paso, aprenderá cómo filtrar el tráfico de red en busca de mensajes de error utilizando el comando grep. Esto es especialmente útil cuando se analizan capturas de paquetes grandes y solo se desea ver los paquetes que contienen errores. El operador tubería (|) en Linux permite tomar la salida de un comando y utilizarla como entrada para otro comando, creando flujos de trabajo de análisis poderosos.

Primero, examinemos el archivo de captura que creamos en el paso anterior. Ejecute el siguiente comando para ver el contenido del archivo pcap en formato de texto. Esto convierte los datos binarios de los paquetes en una forma legible por humanos:

tcpdump -r ~/project/eth1_capture.pcap

Ahora, creemos un archivo de registro de muestra que contenga tanto mensajes normales como de error con fines demostrativos. Esto nos ayudará a entender cómo funciona grep antes de aplicarlo al tráfico de red real:

echo -e "INFO: Connection established\nERROR: Authentication failed\nINFO: Data transfer complete\nERROR: Connection timeout" > ~/project/network.log

Para filtrar solo los mensajes de error de este archivo de registro, usaremos grep con el patrón "ERROR". grep busca en el texto línea por línea e imprime solo las líneas que coinciden con el patrón:

grep "ERROR" ~/project/network.log

Debería ver una salida que contenga solo las líneas de error:

ERROR: Authentication failed
ERROR: Connection timeout

Ahora apliquemos esto a nuestra captura de paquetes real. Primero, necesitamos convertir el archivo pcap a formato de texto legible, ya que grep funciona con archivos de texto. Esto crea una versión de texto de nuestra captura de paquetes:

tcpdump -r ~/project/eth1_capture.pcap > ~/project/packets.txt

Luego, filtre cualquier mensaje de error en los datos de paquetes convertidos. Usamos la opción -i para hacer la búsqueda insensible a mayúsculas y minúsculas, lo que significa que coincidirá con "error", "ERROR" o cualquier otra capitalización:

grep -i "error" ~/project/packets.txt

La opción -i hace que la búsqueda sea insensible a mayúsculas y minúsculas. Si hay algún paquete que contenga "error" (en cualquier caso), se mostrará. Esto ayuda a garantizar que no se pierdan mensajes de error debido a diferentes capitalizaciones en los protocolos de red.

Contar coincidencias con | wc -l

En este paso, aprenderemos cómo cuantificar los errores de red contando las líneas coincidentes utilizando el comando wc -l. Esta técnica ayuda a los administradores de red a entender la frecuencia de los errores en el tráfico capturado.

Antes de contar, primero repasemos los mensajes de error que identificamos anteriormente. El siguiente comando muestra todas las líneas que contienen "error" (sin distinguir entre mayúsculas y minúsculas) de nuestro archivo de captura de paquetes:

grep -i "error" ~/project/packets.txt

Para contar estas ocurrencias de errores en lugar de mostrarlas, usaremos una tubería (|) para enviar la salida de grep a wc -l. El comando wc cuenta palabras, líneas o caracteres, y la opción -l cuenta específicamente las líneas:

grep -i "error" ~/project/packets.txt | wc -l

El comando devuelve un número simple que representa cuántos mensajes de error se encontraron:

2

Para tener un contexto, también contemos el número total de paquetes en nuestro archivo de captura. Esto nos ayuda a entender qué proporción del tráfico contiene errores:

wc -l ~/project/packets.txt

La salida muestra tanto el recuento como el nombre del archivo:

50 packets.txt

Para calcular la tasa de error como un porcentaje, usaremos aritmética básica de shell. Primero, almacenamos el recuento de errores y el recuento total de paquetes en variables, luego realizamos el cálculo utilizando bc (un programa de calculadora básica):

errors=$(grep -i "error" ~/project/packets.txt | wc -l)
total=$(wc -l < ~/project/packets.txt)
echo "scale=2; ($errors/$total)*100" | bc

La configuración scale=2 le dice a bc que muestre dos decimales en el resultado:

4.00

Guardar en un archivo con > output.txt

En este paso, exploraremos cómo guardar los resultados del análisis de red en archivos para su documentación y examen posterior. Cuando se trabaja con la salida de Tshark, a menudo es útil almacenar los datos filtrados por separado en lugar de simplemente verlos en la terminal.

Primero, recordemos el comando que usamos anteriormente para contar las ocurrencias de errores en nuestra captura de paquetes:

grep -i "error" ~/project/packets.txt | wc -l

El operador > en Linux nos permite redirigir la salida de un comando a un archivo en lugar de mostrarla en pantalla. Para guardar solo el recuento numérico de errores en un nuevo archivo llamado error_count.txt, modificamos nuestro comando de la siguiente manera:

grep -i "error" ~/project/packets.txt | wc -l > ~/project/error_count.txt

Después de ejecutar esto, puede verificar que el archivo contiene exactamente lo que esperamos: solo el número del recuento de errores:

cat ~/project/error_count.txt

A veces necesitamos más que solo recuentos; queremos los mensajes de error reales para su análisis. Para guardar todas las líneas de error coincidentes en un archivo, eliminamos la parte del recuento de palabras:

grep -i "error" ~/project/packets.txt > ~/project/error_messages.txt

Verifique el contenido para confirmar que se capturaron todos los mensajes de error:

cat ~/project/error_messages.txt

Para el monitoreo continuo, es posible que queramos agregar a archivos existentes en lugar de sobrescribirlos. El operador >> agrega al final de los archivos. Así es como se crea un informe de errores con marca de tiempo:

echo "Error count at $(date):" >> ~/project/error_report.txt
grep -i "error" ~/project/packets.txt | wc -l >> ~/project/error_report.txt

Vea su archivo de informe creciente para ver los datos acumulados:

cat ~/project/error_report.txt

Resumen

En este laboratorio, has aprendido técnicas prácticas para la captura y análisis del tráfico de red utilizando herramientas de línea de comandos. Los ejercicios cubrieron la captura de paquetes con tcpdump, la verificación de interfaces utilizando ip link show y la creación de archivos PCAP para análisis fuera de línea.

También has explorado métodos eficientes de procesamiento de datos a través de operaciones de tubería (piping), incluyendo el filtrado de errores con grep, el conteo de coincidencias a través de wc -l y la redirección de salida a archivos de texto. Estas habilidades permiten la extracción dirigida de información de red para la resolución efectiva de problemas.