Uso de Tshark para el Análisis del Tráfico de Red

Introducción

En este laboratorio, aprenderás cómo utilizar tshark, la interfaz de línea de comandos del potente analizador de protocolos de red Wireshark. Dominar tshark te permite optimizar los flujos de trabajo de análisis de red, automatizar tareas y obtener una comprensión más profunda del tráfico de red.

Este laboratorio te guiará a través de diferentes opciones de línea de comandos y escenarios prácticos. Te proporcionará las habilidades necesarias para analizar eficientemente capturas de red y solucionar problemas relacionados con la red. El enfoque de línea de comandos tiene ventajas significativas sobre la interfaz gráfica, especialmente para archivos de captura grandes o análisis automatizados.

Skills Graph

Comprender y capturar tráfico de red con Tshark

En este paso, nos sumergiremos en el mundo del análisis de tráfico de red utilizando Tshark. Primero, aprenderás qué es Tshark y por qué es una herramienta valiosa para el análisis de red. Luego, descubriremos cómo identificar las interfaces de red en tu sistema, lo cual es crucial porque necesitas saber de dónde capturar el tráfico. Finalmente, veremos cómo capturar tráfico de red utilizando la interfaz de línea de comandos de Wireshark, que es Tshark.

¿Qué es tshark?

Tshark es esencialmente la versión de línea de comandos de Wireshark. Mientras que Wireshark tiene una interfaz gráfica ideal para la inspección visual, Tshark ofrece la misma funcionalidad básica sin necesidad de una pantalla gráfica. Con Tshark, puedes capturar paquetes de una red. Los paquetes son como pequeños sobres que transportan datos a través de una red. También te permite mostrar información detallada sobre estos paquetes, como de dónde vienen, a dónde van y qué tipo de datos están transportando. Puedes guardar los datos capturados en un archivo para su posterior análisis. Esta herramienta es especialmente útil en varios escenarios:

• Monitoreo automático de red: Puedes configurar scripts para ejecutar Tshark regularmente y comprobar si hay alguna actividad de red inusual.
• Análisis eficiente de archivos de captura grandes: Dado que es una herramienta de línea de comandos, puede manejar grandes cantidades de datos más rápidamente que algunas alternativas gráficas.
• Ejecución en servidores sin interfaz gráfica: Los servidores a menudo no tienen una pantalla gráfica, y Tshark se puede ejecutar directamente desde la línea de comandos.
• Integración del análisis de red en scripts: Puedes utilizar comandos de Tshark dentro de tus propios scripts para realizar tareas personalizadas de análisis de red.

Instalación de tshark

Antes de poder comenzar a utilizar Tshark, debemos asegurarnos de que esté instalado en tu sistema. Para instalar Tshark en un sistema que utiliza el gestor de paquetes apt (como Ubuntu), ejecuta el siguiente comando en tu terminal. La parte sudo te otorga privilegios de administrador, apt install se utiliza para instalar paquetes, -y responde automáticamente "sí" a cualquier solicitud, y tshark es el paquete que queremos instalar.

sudo apt install -y tshark

Identificación de tus interfaces de red

Antes de poder comenzar a capturar tráfico de red, necesitas saber qué interfaz de red monitorear. Una interfaz de red es como una puerta a través de la cual tu computadora se conecta a una red. Para enumerar todas las interfaces de red disponibles en tu sistema, ejecuta el siguiente comando:

tshark -D

Este comando mostrará una lista de todas las interfaces de red en tu sistema. La salida se verá algo así:

1. eth0
2. eth1
3. lo (Loopback)
4. any (Dispositivo pseudo que captura en todas las interfaces)

En nuestro laboratorio, utilizaremos la interfaz any. Este es un dispositivo pseudo especial que nos permite capturar tráfico de todas las interfaces de red disponibles al mismo tiempo.

Captura de tráfico de red

Ahora que sabemos qué interfaz utilizar, comencemos a capturar algún tráfico de red. La sintaxis básica para capturar tráfico con Tshark es la siguiente:

tshark -i <interface> -w <output_file>

A continuación, se explica lo que significa cada parte:

• -i <interface>: Esta opción especifica qué interfaz de red deseas capturar tráfico. Puedes reemplazar <interface> con el nombre de la interfaz real, como eth0 o any.
• -w <output_file>: Esta opción especifica la ubicación y el nombre del archivo donde deseas guardar los paquetes capturados.

Primero, creemos un directorio para almacenar nuestros archivos capturados. El comando mkdir -p crea un directorio si no existe, y lo estamos creando en /home/labex/project/captures.

mkdir -p /home/labex/project/captures

Ahora, comencemos la captura. Utilizaremos la interfaz any y guardaremos los paquetes capturados en un archivo llamado capture.pcapng en el directorio /home/labex/project.

tshark -i any -w /home/labex/project/capture.pcapng

Una vez que ejecutes este comando, verás una salida que indica que Tshark ha comenzado a capturar paquetes. La salida se verá así:

Capturing on 'any'

Para capturar realmente algún tráfico significativo, necesitamos generarlo. Abre una nueva pestaña de terminal y ejecuta el siguiente comando. El comando curl se utiliza para transferir datos desde un servidor. Aquí, estamos intentando acceder al sitio web https://www.example.com.

curl https://www.example.com

Después de generar el tráfico, regresa a la terminal donde se está ejecutando Tshark y presiona Ctrl + C para detener la captura. Verás un mensaje que indica cuántos paquetes se capturaron. Puede verse así:

Capturing on 'any'
164 packets captured

Examen del archivo capturado

Para asegurarnos de que el archivo de captura se creó correctamente, podemos utilizar el comando ls -l. Este comando enumera los archivos en un directorio y muestra información detallada sobre ellos. Ejecuta el siguiente comando para verificar el archivo de captura:

ls -l /home/labex/project/capture.pcapng

Deberías ver una salida similar a esta:

-rw-r--r-- 1 labex labex 24680 Jan 27 12:34 /home/labex/project/capture.pcapng

Ahora, echemos un vistazo rápido a lo que capturamos. Utilizaremos Tshark nuevamente, pero esta vez con la opción -r. La opción -r se utiliza para leer un archivo de captura. Enviaremos la salida al comando head - 10, que nos mostrará los primeros 10 paquetes del archivo.

tshark -r /home/labex/project/capture.pcapng | head -10

Este comando mostrará información detallada de los paquetes, incluyendo marcas de tiempo (cuándo se capturó el paquete), direcciones de origen y destino (de dónde vino el paquete y a dónde iba), y los protocolos utilizados.

Filtrado de tráfico de red con Tshark

En este paso, exploraremos cómo aplicar filtros a las capturas de tráfico de red. Cuando se trata de tráfico de red, los archivos de captura pueden ser bastante grandes y llenos de una gran cantidad de datos. El filtrado nos ayuda a centrarnos en tipos específicos de paquetes que nos interesan. Esto es crucial porque nos permite analizar archivos de captura grandes de manera más eficiente e identificar patrones de tráfico relevantes.

Comprender los filtros de visualización

Tshark utiliza filtros de visualización para seleccionar qué paquetes mostrar o procesar de un archivo de captura. Puedes pensar en estos filtros como una forma de decirle a Tshark qué paquetes quieres ver. Utilizan una sintaxis específica para definir criterios de coincidencia basados en campos de protocolo. Por ejemplo, puedes decirle a Tshark que solo muestre paquetes que pertenezcan a un cierto protocolo o que tengan una dirección IP específica. La sintaxis básica para aplicar un filtro de visualización es:

tshark -r "<filter_expression>" < input_file > -Y

Desglosemos los componentes de este comando:

• -r <input_file>: Esta parte del comando especifica el archivo de captura que Tshark debe leer. Es como decirle a Tshark dónde encontrar los datos de tráfico de red.
• -Y "<filter_expression>": Esto especifica el filtro de visualización que deseas aplicar. La expresión de filtro es un conjunto de reglas que definen qué paquetes deben seleccionarse.

Ejemplos comunes de filtros de visualización

A continuación, se presentan algunas expresiones de filtro útiles que puedes utilizar. Estos ejemplos cubren diferentes aspectos del filtrado de paquetes, como filtrar por protocolo, dirección IP, puerto, método HTTP, consulta DNS y combinar múltiples filtros.

• Filtrar por protocolo: tcp, udp, icmp, http, dns. Por ejemplo, si utilizas tcp, Tshark solo mostrará paquetes que utilicen el protocolo TCP.
• Filtrar por dirección IP: ip.addr == 192.168.1.1. Este filtro mostrará solo los paquetes que tengan la dirección IP 192.168.1.1 como origen o destino.
• Filtrar por puerto: tcp.port == 80 o tcp.port == 443. Estos filtros mostrarán paquetes que utilicen los puertos TCP 80 o 443. El puerto 80 se utiliza comúnmente para tráfico HTTP, y el puerto 443 se utiliza para tráfico HTTPS.
• Filtrar por método HTTP: http.request.method == "GET". Este filtro mostrará solo las solicitudes HTTP que utilicen el método GET.
• Filtrar por consulta DNS: dns.qry.name contains "example.com". Este filtro mostrará paquetes DNS donde el nombre de la consulta contenga la cadena "example.com".
• Combinar filtros: tcp.port == 80 and http.request.method == "POST". Este filtro combina dos condiciones. Mostrará solo los paquetes que utilicen el puerto TCP 80 y tengan una solicitud HTTP POST.

Aplicar filtros a nuestra captura

Comencemos filtrando el tráfico HTTPS (puerto TCP 443) de nuestro archivo de captura. Utilizaremos el siguiente comando:

tshark -r /home/labex/project/capture.pcapng -Y "tcp.port == 443"

Cuando ejecutes este comando, Tshark leerá el archivo de captura /home/labex/project/capture.pcapng y aplicará el filtro tcp.port == 443. Como resultado, solo deberías ver paquetes que utilicen el puerto TCP 443, que se utiliza típicamente para tráfico HTTPS. La salida incluirá detalles sobre estos paquetes, como las direcciones IP de origen y destino, números de puerto y banderas de paquete. Aquí tienes un ejemplo de cómo podría verse la salida:

  1   0.000000 192.168.1.100 → 93.184.216.34 TCP 74 43210 → 443 [SYN] Seq=0 Win=64240 Len=0 MSS=1460 WS=256 SACK_PERM=1
  2   0.023456 93.184.216.34 → 192.168.1.100 TCP 74 443 → 43210 [SYN, ACK] Seq=0 Ack=1 Win=65535 Len=0 MSS=1460 WS=128 SACK_PERM=1
  3   0.023789 192.168.1.100 → 93.184.216.34 TCP 66 43210 → 443 [ACK] Seq=1 Ack=1 Win=64240 Len=0
  ...

Intentemos otro filtro para buscar tráfico DNS. Utilizaremos el siguiente comando:

tshark -r /home/labex/project/capture.pcapng -Y "dns"

Este comando mostrará solo los paquetes DNS en la captura. La salida mostrará consultas y respuestas DNS, incluyendo detalles como el nombre de la consulta y la dirección IP de respuesta. Aquí tienes un ejemplo de cómo podría verse la salida:

  8   0.034567 192.168.1.100 → 8.8.8.8 DNS 82 Standard query 0x1234 A example.com
  9   0.056789 8.8.8.8 → 192.168.1.100 DNS 98 Standard query response 0x1234 A example.com A 93.184.216.34

Contar paquetes por tipo

También puedes utilizar filtros para contar tipos específicos de paquetes. Esto puede ser útil para obtener una visión general del tráfico en un archivo de captura. Por ejemplo, para contar el número de paquetes TCP, podemos utilizar el siguiente comando:

tshark -r /home/labex/project/capture.pcapng -Y "tcp" | wc -l

En este comando, tshark lee el archivo de captura y aplica el filtro tcp. La salida de tshark se canaliza (|) al comando wc -l, que cuenta el número de líneas en la salida. Dado que cada línea representa un paquete, esto nos da el número de paquetes TCP en el archivo de captura.

Contemos el número de paquetes HTTPS y guardemos el resultado en un archivo. Utilizaremos el siguiente comando:

tshark -r /home/labex/project/capture.pcapng -Y "tcp.port == 443" | wc -l > /home/labex/project/filtered_packet_count.txt

Este comando es similar al anterior, pero en lugar de solo mostrar el recuento, redirigimos (>) la salida a un archivo llamado filtered_packet_count.txt. Puedes ver el resultado con el siguiente comando:

cat /home/labex/project/filtered_packet_count.txt

La salida mostrará el número de paquetes que coinciden con el filtro. Por ejemplo:

42

Extraer campos específicos

Tshark puede extraer campos específicos de los paquetes utilizando las opciones -T fields y -e. Esto es útil cuando solo estás interesado en cierta información de los paquetes, como el host, el método y la URI de una solicitud HTTP. Aquí tienes un ejemplo de comando:

tshark -r /home/labex/project/capture.pcapng -Y "http" -T fields -e http.host -e http.request.method -e http.request.uri

En este comando, tshark lee el archivo de captura, aplica el filtro http para seleccionar solo paquetes HTTP y luego utiliza la opción -T fields para especificar que queremos extraer campos. La opción -e se utiliza para especificar qué campos extraer. En este caso, estamos extrayendo los campos http.host, http.request.method y http.request.uri. La salida podría verse así:

example.com	GET	/index.html
example.com	GET	/images/logo.png

Analizar y exportar tráfico de red con Tshark

En este paso, nos centraremos en cómo exportar tráfico de red en diferentes formatos y realizar un análisis básico del tráfico utilizando tshark. Estas habilidades son cruciales porque te permiten compartir los datos capturados con tus colegas o utilizarlos en otras herramientas. Al final de esta sección, serás capaz de manejar diferentes formatos de archivos y extraer información valiosa del tráfico de red.

Comprender los formatos de archivos de captura

Wireshark, un conocido analizador de protocolos de red, admite varios formatos de archivos de captura. Cada formato tiene sus propias características únicas, que es importante entender ya que determinan cómo se pueden utilizar los datos más adelante.

• pcapng: Este es el formato predeterminado utilizado por Wireshark. Admite múltiples interfaces y tiene características avanzadas. Es una excelente opción cuando necesitas capturar escenarios de red complejos.
• pcap: El formato clásico. Es compatible con herramientas antiguas, pero tiene menos características en comparación con pcapng. Si necesitas trabajar con sistemas heredados, este formato podría ser tu mejor opción.
• csv: Valores separados por comas. Este formato es muy útil cuando quieres importar los datos a hojas de cálculo para un análisis posterior.
• json: Notación de Objeto JavaScript. Es ideal para el análisis programático, ya que puede ser fácilmente analizado por lenguajes de programación.
• text: Un formato de texto plano legible por humanos. Es útil cuando quieres ver rápidamente los datos sin herramientas especiales.

Exportar a diferentes formatos de archivos

Para cambiar el formato de un archivo de captura, puedes utilizar la opción -F en tshark. La estructura general del comando es la siguiente:

tshark -r <input_file> -F <format> -w <output_file>

Aquí, -r especifica el archivo de entrada, -F establece el formato de salida y -w define el archivo de salida.

Tomemos un ejemplo y exportemos nuestra captura al formato pcap:

tshark -r /home/labex/project/capture.pcapng -F pcap -w /home/labex/project/export.pcap

Cuando este comando se ejecuta correctamente, no verás ninguna salida en la pantalla. Para confirmar que la exportación fue exitosa, puedes utilizar el comando ls para listar los detalles del archivo exportado:

ls -l /home/labex/project/export.pcap

Deberías ver una salida similar a esta:

-rw-r--r-- 1 labex labex 22468 Jan 27 12:45 /home/labex/project/export.pcap

Analizar estadísticas de protocolos

Tshark no solo es útil para exportar archivos, sino también para generar diversas estadísticas sobre el tráfico capturado. Exploremos algunas de estas opciones de análisis estadístico.

Estadísticas de jerarquía de protocolos

Si quieres ver cómo se distribuyen diferentes protocolos en tu captura, puedes utilizar el siguiente comando:

tshark -r /home/labex/project/capture.pcapng -z io,phs

La opción -z se utiliza para especificar el tipo de estadísticas. En este caso, io,phs significa estadísticas de jerarquía de protocolos. La salida mostrará la jerarquía de protocolos y el porcentaje de paquetes para cada protocolo.

Protocol Hierarchy Statistics
|
+ Ethernet
  + Internet Protocol Version 4
    + Transmission Control Protocol
      + Transport Layer Security
        + Hypertext Transfer Protocol Secure
    + User Datagram Protocol
      + Domain Name System

Estadísticas de conversaciones

Para analizar las conversaciones entre puntos finales en la red, puedes utilizar el siguiente comando:

tshark -r /home/labex/project/capture.pcapng -z conv,tcp

Este comando se centra en las conversaciones TCP. Muestra estadísticas como los puntos finales involucrados, el número de paquetes intercambiados y el total de bytes transferidos.

TCP Conversations
                                               |       <-      | |       ->      | |     Total     |    Relative    |   Duration   |
                                               | Frames  Bytes | | Frames  Bytes | | Frames  Bytes |      Start     |              |
192.168.1.100:43210 <-> 93.184.216.34:443          24   18765      18    4532      42    23297       0.000000000        8.2345

Estadísticas de solicitudes HTTP

Si tu captura contiene tráfico HTTP, puedes analizar las solicitudes HTTP utilizando el siguiente comando:

tshark -r /home/labex/project/capture.pcapng -z http,tree

Este comando organiza las solicitudes HTTP por URI y muestra el número de solicitudes para cada URI.

HTTP/Requests:
 /index.html                                    1 requests
 /images/logo.png                               2 requests

Exportar a diferentes formatos de texto

Además de los formatos binarios, tshark también puede exportar datos a formatos de texto, que a menudo son más fáciles de analizar.

Exportar a CSV

Para exportar campos específicos de la captura a un archivo CSV, puedes utilizar el siguiente comando:

tshark -r /home/labex/project/capture.pcapng -T fields -e frame.number -e ip.src -e ip.dst -e tcp.srcport -e tcp.dstport -E header=y -E separator=, > /home/labex/project/tcp_summary.csv

Aquí, -T fields especifica que queremos exportar campos específicos. La opción -e se utiliza para definir los campos que queremos exportar, como el número de trama, las direcciones IP de origen y destino y los puertos TCP de origen y destino. -E header=y agrega un encabezado al archivo CSV y -E separator=, establece el separador como una coma.

Examinar la exportación CSV

Después de exportar los datos a un archivo CSV, puedes ver rápidamente las primeras líneas del archivo utilizando el comando head:

head -5 /home/labex/project/tcp_summary.csv

La salida podría verse así:

frame.number,ip.src,ip.dst,tcp.srcport,tcp.dstport
1,192.168.1.100,93.184.216.34,43210,443
2,93.184.216.34,192.168.1.100,443,43210
3,192.168.1.100,93.184.216.34,43210,443
...

Técnicas avanzadas de Tshark y tuberías (pipes)

En este paso, aprenderás técnicas avanzadas de tshark. Estas técnicas son cruciales para el análisis de redes, ya que te permiten realizar operaciones complejas en los datos de tráfico de red. En concreto, aprenderás cómo leer tráfico de red desde la entrada estándar (stdin) y cómo combinar tshark con otras herramientas de línea de comandos utilizando tuberías (pipes). Dominar estas habilidades te permitirá crear flujos de trabajo de análisis de redes potentes, lo que te ahorrará tiempo y esfuerzo al trabajar con grandes cantidades de datos de red.

Comprender las tuberías (pipes) y la entrada estándar en Linux

En el sistema operativo Linux, las tuberías (|) son una característica muy útil. Actúan como un puente entre dos comandos, lo que te permite enviar la salida de un comando como entrada a otro comando. De esta manera, puedes encadenar múltiples comandos para realizar tareas más complejas. La entrada estándar (stdin) es una secuencia de datos que un programa lee como entrada. Cuando se utiliza el símbolo - con muchas herramientas de línea de comandos, es una señal para la herramienta de que la entrada debe provenir de stdin en lugar de un archivo. Esto te da más flexibilidad en cómo procesas los datos.

Leer tráfico de red desde la entrada estándar

Tshark tiene la capacidad de leer datos de captura desde la entrada estándar utilizando la opción -r -. Esta característica es extremadamente útil en escenarios en los que deseas procesar datos de otro comando o cuando necesitas filtrar una captura en tiempo real. En lugar de leer directamente desde un archivo, puedes canalizar datos a tshark.

La sintaxis básica para leer tráfico de red desde la entrada estándar es:

cat <input_file> | tshark -r -

Intentemos esto con nuestro archivo de captura. El siguiente comando lee el archivo de captura y muestra todos los paquetes, similar a ejecutar tshark -r capture.pcapng.

cat /home/labex/project/capture.pcapng | tshark -r -

La salida mostrará todos los paquetes de la captura, como esta:

  1   0.000000 192.168.1.100 → 93.184.216.34 TCP 74 43210 → 443 [SYN] Seq=0 Win=64240 Len=0 MSS=1460 WS=256 SACK_PERM=1
  2   0.023456 93.184.216.34 → 192.168.1.100 TCP 74 443 → 43210 [SYN, ACK] Seq=0 Ack=1 Win=65535 Len=0 MSS=1460 WS=128 SACK_PERM=1
  ...

Filtrar en la entrada estándar

También puedes aplicar filtros cuando lees desde stdin. Esto te permite centrarte en tipos específicos de tráfico de red.

cat /home/labex/project/capture.pcapng | tshark -r - -Y "tcp.port == 80"

Este comando mostrará solo el tráfico HTTP (puerto TCP 80) de la captura. Al utilizar el filtro, puedes aislar rápidamente los datos que te interesan.

Crear una tubería (pipeline) para el análisis de redes

Creemos una tubería más compleja que realice múltiples operaciones en los datos de captura de red. Esta tubería hará lo siguiente:

1. Leer el archivo de captura
2. Filtrar el tráfico DNS
3. Extraer solo los nombres de consulta DNS
4. Ordenarlos alfabéticamente
5. Eliminar duplicados
6. Guardar el resultado en un archivo

cat /home/labex/project/capture.pcapng | tshark -r - -Y "dns" -T fields -e dns.qry.name | sort | uniq > /home/labex/project/dns_queries.txt

Examinemos el resultado ejecutando el siguiente comando:

cat /home/labex/project/dns_queries.txt

La salida mostrará una lista ordenada de nombres de consulta DNS únicos de tu captura, como esta:

example.com
www.example.com

Combinar Tshark con otras herramientas

Tshark se puede combinar con otras herramientas de línea de comandos para un análisis más potente.

Contar tipos de paquetes con grep

cat /home/labex/project/capture.pcapng | tshark -r - | grep TCP | wc -l > /home/labex/project/tcp_count.txt

Esta tubería cuenta el número de paquetes TCP en la captura. Al utilizar grep para encontrar paquetes TCP y wc -l para contarlos, puedes obtener rápidamente una idea de la cantidad de tráfico TCP en tu captura.

Extraer agentes de usuario HTTP con sed

cat /home/labex/project/capture.pcapng | tshark -r - -Y "http.user_agent" -T fields -e http.user_agent | sed 's/,/\n/g' > /home/labex/project/user_agents.txt

Esto extrae todas las cadenas de agentes de usuario HTTP, reemplazando las comas con saltos de línea. Esto hace que la salida sea más legible y fácil de analizar.

Guardar la salida de stdin en un archivo

Guardemos la salida completa de un análisis de tshark desde stdin en un archivo. De esta manera, puedes revisar los datos más tarde.

cat /home/labex/project/capture.pcapng | tshark -r - > /home/labex/project/stdin_output.txt

Verifiquemos el contenido ejecutando el siguiente comando:

head -5 /home/labex/project/stdin_output.txt

Esto debería mostrar las primeras 5 líneas del análisis, similar a:

  1   0.000000 192.168.1.100 → 93.184.216.34 TCP 74 43210 → 443 [SYN] Seq=0 Win=64240 Len=0 MSS=1460 WS=256 SACK_PERM=1
  2   0.023456 93.184.216.34 → 192.168.1.100 TCP 74 443 → 43210 [SYN, ACK] Seq=0 Ack=1 Win=65535 Len=0 MSS=1460 WS=128 SACK_PERM=1
  3   0.023789 192.168.1.100 → 93.184.216.34 TCP 66 43210 → 443 [ACK] Seq=1 Ack=1 Win=64240 Len=0
  4   0.024012 192.168.1.100 → 93.184.216.34 TLSv1.2 192 Client Hello
  5   0.045678 93.184.216.34 → 192.168.1.100 TLSv1.2 1023 Server Hello, Certificate, Server Key Exchange, Server Hello Done

Resumen

En este laboratorio, has aprendido cómo utilizar de manera efectiva la interfaz de línea de comandos de Wireshark (tshark) para el análisis de tráfico de red. En primer lugar, has comprendido los conceptos básicos de tshark y has aprendido a capturar tráfico de red desde interfaces de red. Luego, has explorado cómo aplicar filtros para centrarte en tipos específicos de tráfico, lo cual es crucial cuando se trabaja con archivos de captura grandes.

También has aprendido a exportar tráfico de red en diferentes formatos para compartir o realizar un análisis posterior. Además, has explorado las capacidades de análisis estadístico de tshark para entender la composición del tráfico de red. Finalmente, has avanzado hacia técnicas más complejas, como leer tráfico desde la entrada estándar y crear tuberías (pipelines) de análisis combinando tshark con otras herramientas de línea de comandos. Estas habilidades ofrecen ventajas sobre la interfaz gráfica de Wireshark en escenarios como el manejo de archivos grandes, la realización de análisis automatizados, el análisis en servidores remotos y la creación de flujos de trabajo repetibles. Al dominar estas técnicas, has mejorado tus capacidades de resolución de problemas de red y análisis de seguridad para trabajar de manera más eficiente en diversos contextos de redes.