Analisar Desempenho do Tshark - Guia Prático

Introdução

Neste laboratório, você aprenderá como perfilar e analisar o desempenho da ferramenta de linha de comando tshark do Wireshark usando medições de tempo e técnicas de processamento de pacotes. Você explorará a ativação de estatísticas de tempo detalhadas com --print-timers, o processamento de arquivos de captura e a interpretação da saída JSON para entender as diferentes fases de processamento.

Através de exercícios práticos, você praticará a medição de tempos de processamento, a filtragem de tipos específicos de tráfego e a análise de métricas de desempenho. O laboratório oferece experiência prática com comandos tshark para contar pacotes e examinar o tráfego DHCP, enquanto perfila o desempenho do Wireshark.

Habilitar Temporizadores com --print-timers

Nesta etapa, exploraremos como medir o desempenho do processamento de pacotes do Wireshark usando a opção --print-timers. Isso é particularmente útil quando você deseja entender onde o Tshark gasta a maior parte do seu tempo ao analisar o tráfego de rede.

Antes de começarmos, vamos garantir que estamos no diretório de trabalho correto. Isso garante que todos os nossos comandos funcionarão com os caminhos de arquivo esperados:

cd ~/project

A opção --print-timers instrui o Tshark a rastrear e relatar quanto tempo ele gasta em diferentes tarefas ao processar pacotes. Vamos experimentá-la com uma captura de tráfego DHCP de exemplo que acompanha o Wireshark:

tshark --print-timers -r /usr/share/wireshark/example_captures/dhcp.pcap

Após executar este comando, você verá uma saída semelhante a:

Timer 1: 0.000000 seconds
Timer 2: 0.000123 seconds
...

Esses timers representam diferentes estágios do processamento de pacotes. Para focar em apenas um timer específico, podemos usar o grep para filtrar a saída. Por exemplo, para ver apenas os resultados do Timer 1:

tshark --print-timers -r /usr/share/wireshark/example_captures/dhcp.pcap | grep "Timer 1"

Aqui está o que cada timer principal normalmente mede:

Timer 1: Tempo gasto lendo o arquivo de captura do disco
Timer 2: Tempo gasto processando e decodificando pacotes
Timer 3: Tempo gasto aplicando filtros de exibição (se algum for usado)

Compreender esses timers ajuda a identificar gargalos de desempenho ao trabalhar com arquivos de captura grandes ou cenários de filtragem complexos.

Processar Arquivo com -r capture.pcap

Nesta etapa, você aprenderá como processar arquivos de captura de pacotes usando a ferramenta de linha de comando tshark do Wireshark com a opção -r. Isso é essencial para analisar o tráfego de rede pré-gravado armazenado em arquivos .pcap, que são arquivos binários contendo pacotes de rede capturados.

Primeiro, certifique-se de estar no diretório de trabalho correto. Isso é importante porque alguns comandos podem esperar que os arquivos estejam em locais específicos:
```
cd ~/project
```
Vamos examinar um arquivo de captura DHCP de exemplo que acompanha a instalação do Wireshark. DHCP (Dynamic Host Configuration Protocol) é um protocolo de rede usado para atribuir automaticamente endereços IP a dispositivos. A flag -r diz ao tshark para ler do arquivo especificado:
```
tshark -r /usr/share/wireshark/example_captures/dhcp.pcap
```
A saída mostra cada pacote com informações básicas em colunas:
- Número do pacote
- Timestamp (segundos desde o início da captura)
- Endereços IP de Origem → Destino
- Protocolo (DHCP neste caso)
- Comprimento do pacote
- Informações específicas do protocolo
```
1 0.000000 192.168.0.1 → 192.168.0.10 DHCP 342 DHCP Discover - Transaction ID 0x7c3e0c29
2 0.023512 192.168.0.10 → 192.168.0.1 DHCP 342 DHCP Offer - Transaction ID 0x7c3e0c29
...
```
Para contar o número total de pacotes no arquivo de captura, canalizamos (|) a saída do tshark para wc -l, que conta as linhas. Cada pacote é exibido em uma linha:
```
tshark -r /usr/share/wireshark/example_captures/dhcp.pcap | wc -l
```
Para uma análise mais aprofundada, podemos usar a flag -V (verbose) para mostrar todos os detalhes disponíveis do pacote. Como isso produz muita saída, usamos head -20 para mostrar apenas as primeiras 20 linhas:
```
tshark -r /usr/share/wireshark/example_captures/dhcp.pcap -V | head -20
```

Filtrar TCP com -Y "tcp"

Nesta etapa, você aprenderá como filtrar o tráfego TCP usando a opção de filtro de exibição -Y do Wireshark. TCP (Transmission Control Protocol) é um dos protocolos principais na comunicação de rede, responsável pela entrega confiável de dados. O filtro -Y ajuda a isolar pacotes TCP de outros tráfegos de rede, o que é essencial ao analisar navegação na web, transferências de arquivos ou outras aplicações baseadas em TCP.

Primeiro, certifique-se de estar no diretório de trabalho correto. Isso é importante porque alguns comandos podem depender de caminhos de arquivo relativos:
```
cd ~/project
```
Agora, vamos aplicar um filtro TCP básico ao nosso arquivo de captura de exemplo. A flag -r especifica o arquivo de entrada, enquanto -Y "tcp" diz ao tshark para mostrar apenas pacotes TCP:
```
tshark -r /usr/share/wireshark/example_captures/http.pcap -Y "tcp"
```
A saída exibirá apenas pacotes TCP, mostrando o handshake TCP (SYN, SYN-ACK) e as transferências de dados subsequentes. Cada linha representa um pacote TCP com seu número de sequência, tamanho da janela e flags:
```
1 0.000000 192.168.1.100 → 192.168.1.1 TCP 74 49278 → 80 [SYN] Seq=0 Win=64240 Len=0
2 0.000042 192.168.1.1 → 192.168.1.100 TCP 74 80 → 49278 [SYN, ACK] Seq=0 Ack=1 Win=65535 Len=0
...
```
Se você apenas quiser contar quantos pacotes TCP estão na captura, pode canalizar a saída para wc -l. Isso é útil para estatísticas rápidas:
```
tshark -r /usr/share/wireshark/example_captures/http.pcap -Y "tcp" | wc -l
```
Para uma análise mais direcionada, você pode filtrar o tráfego TCP em portas específicas. Este exemplo mostra apenas o tráfego na porta 80 (HTTP). Observe como usamos tcp.port em vez de apenas tcp para especificar o número da porta:
```
tshark -r /usr/share/wireshark/example_captures/http.pcap -Y "tcp.port == 80"
```

Analisar Saída JSON de Timing

Nesta etapa, examinaremos como o Wireshark registra informações de tempo em formato JSON. JSON (JavaScript Object Notation) é um formato de dados leve que é fácil tanto para humanos lerem quanto para máquinas analisarem. Combinaremos as habilidades de captura e filtragem de pacotes das etapas anteriores para gerar estatísticas de tempo significativas.

Antes de começarmos, vamos garantir que estamos no diretório correto. A pasta do projeto contém todos os arquivos necessários e manterá nosso trabalho organizado:

cd ~/project

Agora, geraremos dados de tempo especificamente para pacotes TCP. A flag --print-timers diz ao Tshark para incluir informações de tempo em sua saída, enquanto -T json formata-a como JSON. Estamos salvando isso em um arquivo para análise posterior:

tshark -r /usr/share/wireshark/example_captures/http.pcap -Y "tcp" --print-timers -T json > tcp_timings.json

Vamos dar uma olhada rápida na estrutura da nossa saída JSON. O comando head nos mostra as primeiras 20 linhas, o que nos ajuda a entender como os dados são organizados antes de processá-los ainda mais:

head -20 tcp_timings.json

Para trabalhar efetivamente com dados JSON, usaremos jq, um poderoso processador JSON de linha de comando. Se você ainda não o tiver instalado, este comando o configurará:

sudo apt-get install -y jq

Agora podemos extrair métricas de tempo específicas. Este comando filtra o JSON para mostrar apenas as informações do temporizador para cada pacote, dando-nos uma visão mais clara dos dados de tempo:

jq '.[].timers' tcp_timings.json | head -10

Finalmente, vamos criar um resumo mais focado que mostra apenas os números dos pacotes e seus tempos de processamento correspondentes. Isso nos dá uma visão clara de quanto tempo cada pacote levou para ser processado:

jq '.[].timers | {packet_number: .packet_num, processing_time: .processing_time}' tcp_timings.json | head -5

Resumo

Neste laboratório, você aprendeu a analisar o desempenho do Tshark usando a opção --print-timers para analisar fases de processamento, como leitura de arquivos e processamento de pacotes. Os exercícios demonstraram como interpretar estatísticas de tempo para otimizar fluxos de trabalho de análise de rede.

Você também praticou técnicas essenciais de análise de pacotes, incluindo o processamento de arquivos de captura com -r, o exame do conteúdo dos pacotes e a utilização do modo verbose. O laboratório forneceu experiência prática com os arquivos de exemplo do Wireshark para construir habilidades fundamentais em análise de tráfego de rede.