Análise de Perda de Pacotes Tshark: Guia Prático

Introdução

Neste laboratório, você aprenderá a analisar a perda de pacotes TCP usando a ferramenta de linha de comando Tshark do Wireshark. Você praticará a captura de tráfego de rede, a identificação de retransmissões e a interpretação de estatísticas de perda por meio de comandos práticos no terminal.

Os exercícios o guiarão na detecção de padrões de perda de pacotes e na compreensão de métricas de desempenho de rede. Você obterá experiência prática com transmissões normais e cenários de perda simulada para solucionar problemas de conexão TCP do mundo real.

Capturar TCP com -f "tcp"

Nesta etapa, você aprenderá a capturar tráfego TCP usando a opção de filtro de captura do Wireshark -f "tcp". TCP (Transmission Control Protocol) é um dos protocolos centrais da Internet, responsável pela entrega confiável de dados. Este filtro garante que apenas pacotes TCP sejam capturados, o que é particularmente útil quando você deseja se concentrar em comportamentos específicos do TCP, como estabelecimento de conexão (three-way handshake), retransmissões e controle de fluxo, sem se distrair com outro tráfego de rede.

Primeiro, abra um terminal em sua VM LabEx clicando no ícone do terminal na área de trabalho Xfce ou usando o atalho Ctrl+Alt+T. O terminal é onde você executará todos os comandos para esta análise de rede.
Navegue até o diretório de trabalho padrão onde armazenaremos nossos arquivos de captura:
```
cd ~/project
```
Este diretório é criado especificamente para o seu trabalho de laboratório, mantendo seus arquivos organizados e separados dos arquivos do sistema.
Comece a capturar pacotes TCP executando este comando:
```
sudo tshark -f "tcp" -w tcp_capture.pcap
```
Vamos detalhar o que cada parte faz:
- sudo concede a você privilégios de administrador necessários para a captura de pacotes
- tshark é a versão de linha de comando do Wireshark
- -f "tcp" diz ao tshark para capturar apenas pacotes TCP
- -w tcp_capture.pcap salva os pacotes capturados em um arquivo chamado tcp_capture.pcap
Enquanto o tshark estiver em execução, abra outra aba/janela do terminal (Ctrl+Shift+T) e gere algum tráfego TCP. Usaremos o curl para fazer uma solicitação web simples:
```
curl -I https://www.labex.io
```
A flag -I diz ao curl para buscar apenas os cabeçalhos HTTP, o que gera tráfego suficiente para nossa análise sem baixar dados desnecessários.
Depois de esperar cerca de 5 a 10 segundos para capturar pacotes suficientes, pare a captura pressionando Ctrl+C no terminal onde o tshark está em execução. Você deve ver uma saída semelhante a:
```
Capturing on 'eth1'
10 packets captured
```
Isso confirma quantos pacotes TCP foram capturados durante sua sessão.
Verifique se o seu arquivo de captura foi criado com sucesso listando os arquivos no diretório:
```
ls -lh tcp_capture.pcap
```
As opções -lh mostram o tamanho do arquivo em formato legível por humanos (como KB ou MB) junto com outros detalhes. Isso ajuda a confirmar se sua captura foi salva corretamente antes de passar para a próxima etapa.

Verificar Retransmissões com -Y "tcp.analysis.retransmission"

Nesta etapa, examinaremos as retransmissões TCP, que ocorrem quando o remetente não recebe o reconhecimento (ACK) dos pacotes enviados e precisa reenviá-los. Esta é uma técnica crucial de solução de problemas de rede, pois retransmissões frequentes geralmente indicam congestionamento de rede, perda de pacotes ou outros problemas de conectividade.

Antes de começarmos, vamos entender o que estamos procurando:

Uma retransmissão acontece quando o TCP não recebe um ACK (acknowledgment) dentro do tempo esperado
Wireshark/tshark pode identificar isso usando o filtro especial "tcp.analysis.retransmission"
Primeiro, verificaremos uma captura existente e, em seguida, criaremos uma nova com problemas de rede simulados

Primeiro, certifique-se de estar no diretório do projeto onde nossos arquivos de captura são armazenados:
```
cd ~/project
```
Vamos analisar o arquivo de captura que criamos anteriormente em busca de quaisquer retransmissões. O comando se divide em:
- -r lê de um arquivo de captura salvo
- -Y aplica um filtro de exibição para mostrar apenas retransmissões
```
tshark -r tcp_capture.pcap -Y "tcp.analysis.retransmission"
```
Se sua conexão de rede estava estável durante a primeira captura, você provavelmente verá:
```
0 packets captured
```
Isso é normal e indica que nenhum pacote precisou ser retransmitido durante esse período de captura.
Para entender melhor as retransmissões, agora criaremos uma nova captura enquanto intencionalmente causamos congestionamento de rede. Abra duas janelas de terminal:

No primeiro terminal, comece a capturar o tráfego TCP:
```
sudo tshark -f "tcp" -w retransmission_capture.pcap
```
No segundo terminal, execute um download lento que pode acionar retransmissões:
```
curl --limit-rate 10k https://www.labex.io
```
Após alguns segundos, pare ambos os processos com Ctrl+C
Agora, examine o novo arquivo de captura em busca de retransmissões:
```
tshark -r retransmission_capture.pcap -Y "tcp.analysis.retransmission"
```
Desta vez, você deve ver os pacotes retransmitidos listados, mostrando números de sequência e detalhes de tempo que ajudam a diagnosticar problemas de desempenho da rede.

Resumir Estatísticas de Perda com -z tcp,tree

Nesta etapa, você aprenderá a usar o recurso de estatísticas poderoso do Wireshark com a opção -z tcp,tree. Este comando ajuda a analisar conversas TCP e identificar padrões de perda de pacotes, fornecendo uma visão geral estruturada de todos os fluxos TCP em seus dados capturados.

Antes de começar, vamos entender o que as estatísticas de conversação TCP mostram:

A visualização em árvore exibe a comunicação entre pares de hosts
Ele conta quadros (pacotes) e bytes transferidos em cada direção
Ajuda a identificar tráfego desequilibrado, o que pode indicar problemas

Primeiro, certifique-se de estar no diretório do projeto onde seus arquivos de captura são armazenados:
```
cd ~/project
```
Agora, vamos analisar as estatísticas TCP básicas da nossa captura inicial. Este comando lê o arquivo de captura e gera uma árvore de conversação:
```
tshark -r tcp_capture.pcap -z tcp,tree
```

A saída mostrará uma tabela estruturada de todas as conversas TCP. Preste atenção nestas colunas:

<- mostra o tráfego chegando à sua máquina
-> mostra o tráfego saindo da sua máquina
Total resume ambas as direções

======================================================
TCP Conversations
Filter:<No Filter>
|       <-      | |       ->      | |     Total     |
| Frames  Bytes | | Frames  Bytes | | Frames  Bytes |
======================================================

Agora, vamos examinar especificamente a captura de retransmissão. As retransmissões ocorrem quando os pacotes são perdidos e precisam ser reenviados:
```
tshark -r retransmission_capture.pcap -z tcp,tree
```
Procure conversas onde a contagem de quadros seja significativamente maior do que outras - isso geralmente indica problemas de retransmissão.
Para a análise mais precisa, podemos combinar isso com nosso filtro de retransmissão anterior. Isso mostra apenas os pacotes retransmitidos na árvore de conversação:
```
tshark -r retransmission_capture.pcap -Y "tcp.analysis.retransmission" -z tcp,tree
```
Isso ajuda a identificar exatamente quais conversas estão sofrendo perda de pacotes.

Saída Silenciosa com -q

Nesta etapa, exploraremos como usar a opção -q do Wireshark para simplificar sua análise de pacotes. Ao trabalhar com grandes capturas de rede, você geralmente não precisa ver cada pacote individualmente - você só quer as estatísticas importantes. A opção -q (quiet - silencioso) ajuda a ocultar as listagens detalhadas de pacotes e mostrar apenas os dados de resumo.

Primeiro, vamos navegar para o nosso diretório de trabalho onde os arquivos de captura são armazenados:
```
cd ~/project
```
Agora, analisaremos nosso arquivo de captura TCP em modo silencioso. Este comando lê o arquivo, mas mostra apenas as estatísticas de conversação TCP:
```
tshark -r tcp_capture.pcap -q -z tcp,tree
```
Para entender o que a opção -q faz, vamos executar o mesmo comando sem ela. Observe como esta versão mostra todos os pacotes individuais antes das estatísticas:
```
tshark -r tcp_capture.pcap -z tcp,tree
```
Podemos combinar a opção silenciosa com nosso filtro de retransmissão anterior. Isso nos dá uma visão limpa apenas das estatísticas de retransmissão:
```
tshark -r retransmission_capture.pcap -Y "tcp.analysis.retransmission" -q -z tcp,tree
```

O formato de saída será assim, mostrando apenas as estatísticas de conversação sem detalhes do pacote:

======================================================
TCP Conversations
Filter:tcp.analysis.retransmission
|       <-      | |       ->      | |     Total     |
| Frames  Bytes | | Frames  Bytes | | Frames  Bytes |
======================================================

Resumo

Neste laboratório, você aprendeu a analisar a perda de pacotes TCP usando o Tshark por meio de técnicas práticas de solução de problemas de rede. Você capturou tráfego TCP com filtros específicos, identificou retransmissões e gerou estatísticas de conexão para avaliar o desempenho da rede.

Os exercícios demonstraram como usar os recursos avançados do Tshark, como -z tcp,tree para análise abrangente de fluxos TCP e -q para relatórios estatísticos eficientes. Essas habilidades permitem que você diagnostique e solucione rapidamente problemas de perda de pacotes em ambientes de rede do mundo real.

Analisar Perda de Pacotes no Tshark