Como Ler Dados de Pacotes no Tshark: Guia Prático

Introdução

Neste laboratório, você aprenderá como usar a ferramenta de linha de comando tshark do Wireshark para analisar capturas de pacotes de rede. Você praticará comandos essenciais como -r para ler arquivos de captura, -V para saída verbose (detalhada) e -c para limitação da contagem de pacotes, enquanto trabalha com um arquivo PCAP de exemplo.

Através de exercícios práticos, você examinará os cabeçalhos dos pacotes, identificará detalhes importantes da rede, incluindo endereços IP e protocolos, e interpretará diferentes formatos de saída. Este laboratório oferece experiência prática com as funcionalidades principais do tshark para uma análise eficaz do tráfego de rede.

Abrir Arquivo com -r capture.pcap

Nesta etapa, exploraremos como analisar o tráfego de rede pré-gravado usando a poderosa ferramenta de linha de comando tshark do Wireshark. Ao trabalhar com análise de rede, frequentemente precisamos examinar dados capturados anteriormente, em vez de capturar tráfego ao vivo. A flag -r (que significa "read" - ler) nos permite fazer exatamente isso, especificando um arquivo de captura de pacotes para analisar.

Antes de começarmos, vamos garantir que estamos trabalhando no local correto. Em trabalhos baseados em terminal, é crucial estar no diretório correto onde nossos arquivos estão armazenados:

cd ~/project

O ambiente LabEx vem com o tshark pré-instalado, que é a versão de linha de comando do Wireshark. Para confirmar que está disponível e verificar qual versão estamos usando (boa prática ao trabalhar com qualquer ferramenta), execute:

tshark --version

Você deve ver informações detalhadas da versão aparecerem, confirmando que o tshark está devidamente instalado e pronto para uso.

Para esta demonstração, trabalharemos com um arquivo de captura de rede de exemplo. Ele já está baixado para /home/labex/project/capture.pcap.

Agora estamos prontos para examinar o tráfego de rede capturado. O comando básico para ler e exibir o conteúdo do nosso arquivo de captura é:

tshark -r capture.pcap

Este comando processa o arquivo e exibe uma visão resumida de todos os pacotes capturados. Cada linha na saída representa um pacote de rede e inclui várias informações importantes que nos ajudam a entender a atividade da rede:

Número do pacote: O identificador sequencial de cada pacote
Timestamp (Carimbo de tempo): Quando o pacote foi capturado (relativo ao início da captura)
IP de origem: De onde o pacote veio
IP de destino: Para onde o pacote estava indo
Protocolo: O protocolo de rede que está sendo usado (TCP, UDP, etc.)
Length (Comprimento): O tamanho do pacote em bytes
Info (Informações): Uma breve descrição do propósito ou conteúdo do pacote

Aqui está como uma saída típica pode se parecer, mostrando uma conexão TCP sendo estabelecida:

1 0.000000 192.168.1.1 → 192.168.1.2 TCP 66 443 → 49234 [SYN] Seq=0 Win=64240 Len=0
2 0.000123 192.168.1.2 → 192.168.1.1 TCP 66 49234 → 443 [SYN, ACK] Seq=0 Ack=1 Win=65535 Len=0

Esta visualização inicial nos dá uma visão geral de alto nível da comunicação de rede contida em nosso arquivo de captura, que construiremos nas etapas subsequentes.

Exibir Resumo de Pacotes com Saída Padrão

Nesta etapa, exploraremos como ler e entender o resumo básico de pacotes que o tshark exibe por padrão. Este é o seu ponto de partida para analisar o tráfego de rede, mostrando informações essenciais sobre cada pacote em um formato estruturado.

Antes de começarmos, vamos garantir que estamos no diretório de trabalho correto onde nosso arquivo de captura está armazenado:

cd ~/project

A saída padrão do tshark apresenta o tráfego de rede em colunas que nos informam algo importante sobre a comunicação:

Número do pacote: O identificador sequencial de cada pacote na captura
Timestamp (Carimbo de tempo): Quando o pacote foi capturado, em relação ao primeiro pacote
Endereço de origem: De onde o pacote veio (endereço IP)
Endereço de destino: Para onde o pacote está indo (endereço IP)
Protocolo: O protocolo de rede que está sendo usado (TCP, UDP, etc.)
Length (Comprimento): Quão grande é o pacote em bytes
Info (Informações): Detalhes adicionais específicos do protocolo

Vamos analisar os primeiros 5 pacotes para ver isso em ação:

tshark -r capture.pcap -c 5

Exemplo de saída:

    1 0.000000 192.168.1.1 → 192.168.1.2 TCP 66 443 → 49234 [SYN] Seq=0 Win=64240 Len=0
    2 0.000123 192.168.1.2 → 192.168.1.1 TCP 66 49234 → 443 [SYN, ACK] Seq=0 Ack=1 Win=65535 Len=0
    3 0.000145 192.168.1.1 → 192.168.1.2 TCP 54 443 → 49234 [ACK] Seq=1 Ack=1 Win=64240 Len=0
    4 0.000567 192.168.1.1 → 192.168.1.2 TLSv1 583 Client Hello
    5 0.000789 192.168.1.2 → 192.168.1.1 TCP 54 49234 → 443 [ACK] Seq=1 Ack=530 Win=65535 Len=0

Para obter uma compreensão mais ampla do que está acontecendo em nossa captura de rede, podemos contar quantos pacotes pertencem a cada tipo de protocolo. Isso ajuda a identificar quais protocolos são mais ativos em nosso tráfego de rede:

tshark -r capture.pcap -qz io,phs

Este comando gera uma tabela de hierarquia de protocolos, mostrando a distribuição de diferentes protocolos em seu arquivo de captura, o que é particularmente útil ao analisar padrões complexos de tráfego de rede.

Mostrar Campos Detalhados com -V

Nesta etapa, exploraremos como visualizar detalhes abrangentes de pacotes usando a flag -V (verbose - detalhado) do Wireshark. Isso é particularmente útil quando você precisa examinar todas as camadas de protocolo e seus campos dentro de um pacote de rede.

Antes de começarmos, vamos garantir que estamos no diretório de trabalho correto onde nosso arquivo de captura de pacotes está armazenado:

cd ~/project

A flag -V revela a estrutura completa de cada pacote, mostrando todas as camadas de protocolo, desde o quadro físico até os dados da aplicação. Esta visão hierárquica ajuda você a entender como diferentes protocolos trabalham juntos na comunicação de rede. Vamos analisar o primeiro pacote em nosso arquivo de captura:

tshark -r capture.pcap -V -c 1

A saída exibirá informações detalhadas sobre cada camada de protocolo. Aqui está um exemplo do que você pode ver (abreviado para clareza):

Frame 1: 66 bytes on wire (528 bits), 66 bytes captured (528 bits)
    Encapsulation type: Ethernet (1)
    Arrival Time: Jun  8, 2023 10:15:32.000000000 UTC
    [Time shift for this packet: 0.000000000 seconds]
    Epoch Time: 1686219332.000000000 seconds
    [Time delta from previous captured frame: 0.000000000 seconds]
    [Time delta from previous displayed frame: 0.000000000 seconds]
    [Time since reference or first frame: 0.000000000 seconds]
    Frame Number: 1
    Frame Length: 66 bytes (528 bits)
    Capture Length: 66 bytes (528 bits)
    [Frame is marked: False]
    [Frame is ignored: False]
    [Protocols in frame: eth:ethertype:ip:tcp]
Ethernet II, Src: 00:11:22:33:44:55, Dst: aa:bb:cc:dd:ee:ff
    Destination: aa:bb:cc:dd:ee:ff
    Source: 00:11:22:33:44:55
    Type: IPv4 (0x0800)
Internet Protocol Version 4, Src: 192.168.1.1, Dst: 192.168.1.2
    Version: 4
    Header length: 20 bytes
    ...

Se você deseja ver detalhes apenas para pacotes contendo um protocolo específico (como TCP), pode combinar -V com o filtro de exibição -Y. Isso ajuda a concentrar sua análise em um tráfego de rede específico:

tshark -r capture.pcap -V -Y "tcp" -c 1

Contar Pacotes com -c 100

Nesta etapa, exploraremos como controlar a exibição de pacotes no Tshark usando a flag -c. Isso é particularmente útil ao trabalhar com arquivos de captura grandes, onde você só precisa analisar uma amostra de pacotes.

Primeiro, vamos navegar para o nosso diretório de trabalho onde o arquivo de captura de pacotes está armazenado. Isso garante que todos os comandos funcionarão com o arquivo correto:

cd ~/project

A flag -c (abreviação de "count" - contar) limita quantos pacotes o Tshark processará e exibirá. Por exemplo, para examinar apenas os primeiros 100 pacotes do nosso arquivo de captura:

tshark -r capture.pcap -c 100

Ao analisar tipos específicos de tráfego, podemos combinar a flag -c com um filtro de exibição usando -Y. Este comando mostra os primeiros 100 pacotes HTTP:

tshark -r capture.pcap -Y "http" -c 100

Se você precisar saber o número total de pacotes no arquivo (não apenas os primeiros 100), este pipeline conta todas as linhas na saída:

tshark -r capture.pcap | wc -l

Para uma análise mais detalhada dos protocolos em sua captura, este comando fornece um resumo da hierarquia de protocolos, mostrando as contagens para cada tipo de protocolo:

tshark -r capture.pcap -qz io,phs

Resumo

Neste laboratório, você aprendeu a utilizar a ferramenta de linha de comando tshark do Wireshark para analisar capturas de pacotes de rede. Os exercícios cobriram a abertura de arquivos PCAP com a flag -r, a verificação da instalação via --version e a análise dos campos de saída padrão, incluindo metadados de pacotes e informações de protocolo.

Você também praticou a interpretação do formato de resumo de pacotes estruturado e o uso da flag -c para controlar o volume de saída. Essas habilidades fornecem uma base sólida para a análise eficiente do tráfego de rede e a investigação de protocolos usando arquivos de captura salvos.