Comprimir Capturas de Rede com Tshark: Guia Prático

Introdução

Neste laboratório, você aprenderá a capturar, comprimir e analisar o tráfego de rede usando a ferramenta de linha de comando tshark do Wireshark. Você praticará comandos essenciais para seleção de interface, salvamento de arquivos comprimidos e leitura de pacotes, verificando a integridade dos dados.

Os exercícios cobrem a listagem de interfaces, a captura de tráfego ao vivo e a inspeção de arquivos comprimidos. Ao concluir este laboratório, você adquirirá habilidades para gerenciar com eficiência capturas de pacotes em formatos comprimidos, otimizando o espaço de armazenamento sem comprometer a qualidade dos dados.

Capturar Tráfego com -i eth1

Nesta etapa, você aprenderá a usar o tshark, a versão de linha de comando do Wireshark, para capturar tráfego de rede ao vivo. A opção -i permite que você especifique qual interface de rede monitorar - crucial quando sua máquina tem múltiplas conexões de rede.

Primeiro, vamos preparar nosso espaço de trabalho. Abra o terminal em sua VM LabEx e navegue até o diretório do projeto onde armazenaremos nossas capturas:
```
cd ~/project
```
Antes de capturar, precisamos identificar as interfaces de rede disponíveis. Execute este comando para listá-las:
```
tshark -D
```
Você verá uma saída listando suas interfaces de rede, tipicamente incluindo:
```
1. eth1 (sua interface Ethernet principal)
2. any (todas as interfaces)
3. lo (loopback para comunicação interna)
```
Para começar a capturar pacotes em sua interface de rede principal (geralmente eth1), use:
```
tshark -i eth1
```
Isso mostra o tráfego de rede em tempo real rolando em seu terminal - cada linha representa um pacote com endereços de origem/destino e informações de protocolo.
Para parar a captura contínua (que, caso contrário, seria executada indefinidamente), pressione Ctrl+C. O terminal exibirá então estatísticas de captura, incluindo o total de pacotes capturados.
Para praticar, vamos capturar exatamente 5 pacotes. A flag -c limita a contagem de captura:
```
tshark -i eth1 -c 5
```
Este comando para automaticamente após capturar 5 pacotes, dando a você uma amostra gerenciável para examinar.

Salvar com Gzip usando -w capture.pcap.gz

Nesta etapa, exploraremos como armazenar capturas de tráfego de rede de forma eficiente, salvando-as diretamente em formato comprimido usando o Tshark. A compressão ajuda a reduzir o espaço de armazenamento, mantendo todos os dados originais dos pacotes. A opção -w no Tshark lida automaticamente com a compressão quando usamos a extensão de arquivo .gz.

Primeiro, vamos navegar para o nosso diretório de trabalho onde armazenaremos os arquivos de captura. Isso garante que todos os nossos arquivos permaneçam organizados em um só lugar:
```
cd ~/project
```
Agora, capturaremos o tráfego de rede ao vivo e o salvaremos comprimido. O seguinte comando faz três coisas importantes de uma vez:
- Especifica qual interface de rede monitorar (eth1)
- Comprime automaticamente o arquivo de saída (observe a extensão .gz)
- Limita a captura a 10 pacotes para fins de demonstração
```
tshark -i eth1 -w capture.pcap.gz -c 10
```
Conforme o comando é executado, você verá o Tshark contando cada pacote capturado até atingir 10.
Após a conclusão da captura, vamos verificar se nosso arquivo comprimido foi criado corretamente. As opções -lh mostram o tamanho do arquivo em formato legível por humanos:
```
ls -lh capture.pcap.gz
```
A saída mostra os detalhes do arquivo comprimido, incluindo seu tamanho (muito menor do que uma captura não comprimida seria):
```
-rw-r--r-- 1 labex labex 1.2K Mar 1 10:00 capture.pcap.gz
```
Finalmente, podemos ler diretamente do arquivo comprimido sem descompactá-lo manualmente. Este comando exibe apenas os primeiros 3 pacotes para confirmar que nossa captura funcionou:
```
tshark -r capture.pcap.gz -c 3
```
O Tshark lida com a descompressão automaticamente, mostrando os detalhes do pacote exatamente como se você tivesse usado um arquivo não comprimido.

Ler Arquivo Comprimido com -r capture.pcap.gz

Nesta etapa, você trabalhará com o arquivo de captura de pacotes comprimido (capture.pcap.gz) que você criou anteriormente. Usaremos a ferramenta de linha de comando do Wireshark, tshark, para ler e analisar este arquivo sem precisar descompactá-lo manualmente primeiro. Isso é particularmente útil ao lidar com arquivos de captura grandes que ocupariam um espaço significativo em disco se não fossem descompactados.

Primeiro, vamos verificar se estamos no local certo e se nosso arquivo de captura comprimido existe. Os seguintes comandos navegarão para o diretório do projeto e listarão o arquivo com detalhes:
```
cd ~/project
ls -l capture.pcap.gz
```
Você deve ver o arquivo comprimido listado com seu tamanho e permissões. Isso confirma que estamos prontos para prosseguir.
O comando básico para ler o arquivo de captura comprimido exibe resumos de pacotes. Cada linha representa um pacote de rede com informações essenciais como carimbo de data/hora, endereços de origem/destino e protocolo:
```
tshark -r capture.pcap.gz
```
Observe que o tshark lida automaticamente com a compressão gzip - não precisamos de etapas de descompressão separadas.
Ao trabalhar com arquivos grandes, muitas vezes é útil limitar a saída. Este comando mostra apenas os primeiros 5 pacotes, o que é útil para uma verificação rápida:
```
tshark -r capture.pcap.gz -c 5
```
A flag -c significa "contagem" e controla quantos pacotes exibir.
Para mergulhar mais fundo no conteúdo dos pacotes, usamos o modo verbose com -V. Este exemplo mostra detalhes completos dos primeiros 3 pacotes, incluindo todos os cabeçalhos de protocolo e dados de payload:
```
tshark -r capture.pcap.gz -V -c 3
```
A saída verbose é inestimável quando você precisa examinar campos específicos de pacotes ou solucionar problemas de rede.
Para análise direcionada, podemos filtrar pacotes por protocolo. Este comando exibe os primeiros 2 pacotes HTTP encontrados na captura:
```
tshark -r capture.pcap.gz -Y "http" -c 2
```
A flag -Y aplica um filtro de exibição (semelhante à sintaxe principal de filtro do Wireshark).
Finalmente, para obter estatísticas sobre todo o arquivo de captura sem exibir pacotes individuais, usamos este comando de contagem:
```
tshark -r capture.pcap.gz -q -z io,stat,0
```
O -q torna a saída silenciosa (suprimindo a exibição de pacotes), enquanto -z fornece várias opções de estatísticas. Isso fornece uma visão geral rápida do tamanho e conteúdo da captura.

Verificar com -V

Nesta etapa, você explorará o poderoso modo verbose do Wireshark usando a flag -V. Este modo revela a dissecação completa do protocolo dos pacotes, mostrando exatamente o que está acontecendo em cada camada da comunicação de rede. É particularmente útil quando você precisa examinar o conteúdo dos pacotes além dos cabeçalhos básicos.

Primeiro, vamos navegar para o nosso diretório de trabalho e verificar se nosso arquivo de captura comprimido existe. O comando cd altera o diretório, enquanto ls -l mostra informações detalhadas do arquivo:
```
cd ~/project
ls -l capture.pcap.gz
```
Agora usaremos -V para ver detalhes abrangentes do protocolo. A flag -c 3 limita a saída aos primeiros 3 pacotes, tornando mais fácil a análise:
```
tshark -r capture.pcap.gz -V -c 3
```
A saída de cada pacote mostrará informações camada por camada, incluindo cabeçalhos Ethernet, IP e da camada de transporte, seguidos por quaisquer dados da camada de aplicação.
Ao focar no tráfego HTTP, combinamos -V com um filtro de exibição (-Y). Isso mostra apenas os pacotes HTTP com seus detalhes completos do protocolo:
```
tshark -r capture.pcap.gz -Y "http" -V -c 2
```
Para análise TCP, este comando exibe um pacote TCP com todos os seus campos de protocolo. Você verá números de sequência, flags, tamanho da janela e outras informações específicas do TCP:
```
tshark -r capture.pcap.gz -V -Y "tcp" -c 1
```
Consultas DNS revelam detalhes interessantes no modo verbose. Isso mostra um único pacote DNS, incluindo o tipo de consulta, classe e a seção de pergunta completa:
```
tshark -r capture.pcap.gz -V -Y "dns" -c 1
```
Finalmente, podemos verificar se há pacotes com checksums ruins. Isso ajuda a identificar possíveis problemas de corrupção de rede ou captura:
```
tshark -r capture.pcap.gz -V -Y "tcp.checksum_bad==1" -c 1
```

Resumo

Neste laboratório, você aprendeu a capturar, comprimir e analisar o tráfego de rede de forma eficiente usando a ferramenta de linha de comando tshark do Wireshark. Você praticou a captura de tráfego ao vivo na interface eth1 com -i eth1 e salvou arquivos comprimidos diretamente no formato gzip usando -w capture.pcap.gz.

Os exercícios demonstraram como gerenciar capturas de pacotes de forma eficaz, combinando compressão com análise. Você verificou a capacidade de ler arquivos comprimidos sem descompressão manual usando -r capture.pcap.gz, enquanto dominava flags essenciais como -i, -w, -r e -c.

Comprimir Arquivos de Captura no Tshark