Analisar Conversas TCP no Tshark: Guia Prático

Introdução

Neste laboratório, você aprenderá a analisar conversas TCP usando a ferramenta de linha de comando do Wireshark, tshark. Você praticará a captura de tráfego TCP com filtros, listando conversas e examinando portas específicas como HTTP (porta 80), enquanto interpreta informações detalhadas dos pacotes.

Através de exercícios práticos, incluindo a geração de tráfego com curl e a análise de arquivos de captura, você dominará o isolamento de fluxos TCP e a identificação de métricas-chave de conversação. Essas habilidades aprimorarão suas capacidades de solução de problemas de rede e análise de tráfego usando o Wireshark.

Capturar Tráfego TCP com -f "tcp"

Nesta etapa, você aprenderá a capturar tráfego de rede TCP usando a ferramenta de linha de comando do Wireshark, tshark. TCP (Transmission Control Protocol) é um dos protocolos centrais da Internet, responsável pela transmissão confiável de dados entre aplicativos. Ao usar o filtro -f "tcp", podemos nos concentrar especificamente em pacotes TCP, o que ajuda na análise de navegação na web, transferências de arquivos ou comunicações por e-mail.

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 executaremos todos os nossos comandos para esta análise de rede.
Navegue até o diretório de trabalho padrão onde armazenaremos nossos arquivos de captura:
```
cd ~/project
```
Isso garante que todos os nossos dados capturados sejam salvos em um local consistente, fácil de encontrar mais tarde.
Comece a capturar tráfego TCP com o seguinte comando:
```
sudo tshark -f "tcp" -w tcp_capture.pcap
```
Vamos detalhar o que cada parte deste comando faz:
- sudo nos dá privilégios de administrador necessários para a captura de pacotes
- tshark é a versão de linha de comando do Wireshark
- -f "tcp" atua como um filtro de captura, dizendo ao tshark para registrar apenas pacotes TCP
- -w tcp_capture.pcap salva os pacotes capturados em um arquivo chamado "tcp_capture.pcap"
Enquanto o tshark está em execução, precisamos gerar algum tráfego TCP de amostra. Abra outra janela do terminal e execute:
```
curl https://www.example.com
```
Este comando faz uma solicitação web simples para example.com, que usa TCP para sua comunicação. O comando curl mostrará o conteúdo HTML retornado do site.
Depois de esperar alguns segundos para capturar dados suficientes, pare a captura pressionando Ctrl+C no primeiro terminal onde o tshark está em execução. Isso encerra com segurança o processo de captura de pacotes.
Agora, vamos verificar o que capturamos examinando as primeiras linhas do nosso arquivo de captura:
```
tshark -r tcp_capture.pcap | head -n 5
```
Este comando lê (-r) nosso arquivo de captura e exibe os primeiros 5 pacotes. Você deve ver a saída mostrando o processo de handshake TCP, que inclui:
- Pacotes SYN (synchronize) que iniciam a conexão
- Respostas SYN-ACK (synchronize-acknowledge)
- Endereços IP de origem e destino
- Números de porta sendo usados para a comunicação

Listar Conversas com -z conv,tcp

Nesta etapa, você aprenderá a analisar conversas TCP do seu tráfego capturado usando a opção -z conv,tcp do Wireshark. Uma conversa TCP representa uma sessão de comunicação completa entre dois endpoints, identificados por seus endereços IP e números de porta. Este recurso fornece um resumo de todas as conversas TCP em sua captura, mostrando IPs de origem/destino, portas e estatísticas de pacotes, o que é essencial para entender os padrões de comunicação de rede.

Primeiro, certifique-se de estar no diretório correto onde seu arquivo de captura está armazenado. Isso é importante porque o Tshark precisa saber onde encontrar o arquivo de captura de pacotes:
```
cd ~/project
```
O comando básico para listar conversas TCP analisa os pacotes capturados e exibe uma tabela de resumo. A flag -r especifica o arquivo de entrada, enquanto -z conv,tcp habilita o recurso de estatísticas de conversação:
```
tshark -r tcp_capture.pcap -z conv,tcp
```

A saída exibirá uma tabela mostrando todas as conversas TCP, semelhante a este exemplo. Cada linha representa uma conversa entre dois endpoints, mostrando o número de quadros (pacotes) e bytes transferidos em cada direção:

=========================================================================
TCP Conversations
Filter:<No Filter>
                                                 |       <-      | |       ->      | |     Total     |
                                                 | Frames  Bytes | | Frames  Bytes | | Frames  Bytes |
192.168.1.2:49152   <-> 93.184.216.34:80     |      3    180 | |      3    216 | |      6    396 |
=========================================================================

Para obter uma visão mais detalhada com timestamps absolutos mostrando quando cada conversa ocorreu, use a opção -t ad. Isso ajuda a entender o tempo e a sequência dos eventos de rede:
```
tshark -r tcp_capture.pcap -z conv,tcp -t ad
```
Você pode filtrar conversas por critérios específicos usando filtros de exibição com a opção -Y. Este exemplo filtra conversas envolvendo a porta 80 (tráfego HTTP), o que é útil quando você deseja analisar apenas o tráfego da web:
```
tshark -r tcp_capture.pcap -z conv,tcp -Y "tcp.port==80"
```
Para salvar as estatísticas de conversação para análise ou relatório posterior, redirecione a saída para um arquivo de texto. Isso cria um registro permanente de sua análise que você pode revisar ou compartilhar com outras pessoas:
```
tshark -r tcp_capture.pcap -z conv,tcp > tcp_conversations.txt
```

Filtrar Porta Específica com -Y "tcp.port==80"

Nesta etapa, você aprenderá a filtrar o tráfego de rede para uma porta TCP específica (porta 80) usando a sintaxe de filtro de exibição do Wireshark com a opção -Y "tcp.port==80". A porta 80 é a porta padrão para tráfego web HTTP, então este filtro ajuda a isolar as comunicações relacionadas à web em sua captura de rede.

Antes de começarmos, vamos entender o que este filtro faz: ele mostra todos os pacotes TCP onde a porta de origem OU destino é 80. Isso é diferente de filtrar especificamente por portas de origem ou destino, o que abordaremos mais tarde.

Primeiro, certifique-se de estar no diretório correto onde seu arquivo de captura está armazenado:
```
cd ~/project
```
Para filtrar seu tráfego capturado anteriormente para a porta 80 (HTTP), execute:
```
tshark -r tcp_capture.pcap -Y "tcp.port==80"
```
A flag -r especifica o arquivo de entrada, enquanto -Y aplica o filtro de exibição. Este comando lê pacotes de tcp_capture.pcap, mas mostra apenas aqueles que envolvem a porta 80.

A saída mostrará apenas pacotes envolvendo a porta 80, seja como origem ou destino:

 1 0.000000000    192.168.1.2 → 93.184.216.34 TCP 74 49152 → 80 [SYN] Seq=0 Win=64240 Len=0 MSS=1460
 2 0.028763000  93.184.216.34 → 192.168.1.2 TCP 74 80 → 49152 [SYN, ACK] Seq=0 Ack=1 Win=65535 Len=0
 3 0.028852000    192.168.1.2 → 93.184.216.34 TCP 66 49152 → 80 [ACK] Seq=1 Ack=1 Win=64240 Len=0

Esta saída mostra um handshake TCP de três vias completo (SYN, SYN-ACK, ACK) entre um cliente (192.168.1.2) e um servidor web (93.184.216.34).

Para filtrar especificamente o tráfego que vai para a porta 80 (porta de destino), que mostra as solicitações aos servidores web:
```
tshark -r tcp_capture.pcap -Y "tcp.dstport==80"
```
Para filtrar o tráfego vindo da porta 80 (porta de origem), que normalmente mostra as respostas do servidor web:
```
tshark -r tcp_capture.pcap -Y "tcp.srcport==80"
```
Você pode combinar isso com outros filtros para uma análise mais precisa. Por exemplo, para ver apenas as solicitações HTTP GET (o tipo mais comum de solicitação web):
```
tshark -r tcp_capture.pcap -Y "tcp.port==80 && http.request.method==GET"
```
Isso combina um filtro de porta com um filtro de protocolo HTTP para mostrar especificamente quando os navegadores web solicitam páginas dos servidores.

Exibir Resultados com -V

Nesta etapa, exploraremos como visualizar detalhes abrangentes de pacotes usando a opção -V (verbose) do Wireshark. Ao solucionar problemas de rede, ver a análise completa do protocolo é crucial. A flag -V revela cada camada da pilha de rede, desde os quadros Ethernet até os protocolos da camada de aplicação, ajudando você a entender exatamente o que está acontecendo em seu tráfego de rede.

Primeiro, certifique-se de estar no diretório correto onde seu arquivo de captura está armazenado. Isso é importante porque o Tshark precisa acessar o arquivo que você deseja analisar:
```
cd ~/project
```
O comando básico para exibir todos os detalhes do pacote mostra tudo o que o Tshark pode decodificar. Isso é útil quando você precisa examinar a estrutura completa das comunicações de rede:
```
tshark -r tcp_capture.pcap -V
```
A saída verbose exibe detalhes técnicos em um formato estruturado. Aqui está o que cada parte significa:
- Frame (Quadro): Informações da camada física sobre o tamanho do pacote
- Ethernet II: Endereços MAC da camada de enlace de dados
- IP: Endereçamento da camada de rede
- TCP: Portas e números de sequência da camada de transporte
```
Frame 1: 74 bytes on wire (592 bits), 74 bytes captured (592 bits)
Ethernet II, Src: 00:11:22:33:44:55, Dst: 66:77:88:99:aa:bb
Internet Protocol Version 4, Src: 192.168.1.2, Dst: 93.184.216.34
Transmission Control Protocol, Src Port: 49152, Dst Port: 80, Seq: 0, Ack: 0, Len: 0
```
Ao trabalhar com capturas grandes, combinar filtros com saída verbose ajuda a focar no tráfego relevante. Este exemplo mostra apenas o tráfego HTTP (porta 80) e limita a saída às primeiras 20 linhas:
```
tshark -r tcp_capture.pcap -Y "tcp.port==80" -V | head -n 20
```
Para documentação ou análise posterior, você pode salvar a saída detalhada em um arquivo de texto. Isso cria um registro permanente de sua inspeção de pacotes:
```
tshark -r tcp_capture.pcap -V > verbose_output.txt
```
Para examinar elementos específicos do protocolo, como cabeçalhos HTTP, combine filtros de protocolo com o modo verbose. Isso ajuda ao depurar aplicativos web ou analisar transações HTTP:
```
tshark -r tcp_capture.pcap -Y "http" -V
```

Resumo

Neste laboratório, você aprendeu a analisar conversas TCP usando a ferramenta de linha de comando tshark do Wireshark. Você capturou tráfego TCP com filtros específicos, examinou os detalhes do handshake TCP e gerou tráfego de amostra para análise.

Além disso, você explorou técnicas para listar conversas TCP entre endpoints e filtrar tráfego de portas específicas. O laboratório forneceu experiência prática com inspeção de pacotes usando saída verbose e estatísticas de conversas para uma análise de rede eficaz.