Limitar o Tamanho da Captura no Tshark

Introdução

Neste laboratório, você aprenderá a controlar o tamanho da captura de pacotes no Wireshark usando comandos do Tshark. Você explorará duas técnicas essenciais: limitar o total de pacotes com -c 500 e restringir o comprimento dos pacotes com -s 128 para capturar apenas os cabeçalhos, economizando espaço de armazenamento.

Através de exercícios práticos na interface eth1, você capturará o tráfego em limited.pcap e observará como diferentes configurações afetam suas capturas. Esta experiência prática ajudará você a otimizar a coleta de pacotes para diversos cenários de análise.

Definir a Contagem de Pacotes com -c 500

Neste passo, você aprenderá como controlar a duração da captura de pacotes limitando o número de pacotes que o Tshark coleta. O Tshark é a versão de linha de comando do Wireshark, ideal para capturas automatizadas. A opção -c é particularmente valiosa quando você precisa de uma amostra representativa do tráfego de rede sem sobrecarregar seu sistema com uma captura contínua.

Comece abrindo o terminal em sua máquina virtual LabEx. O sistema automaticamente o coloca no diretório de trabalho correto (~/project), permitindo que você comece imediatamente.
A estrutura do comando utiliza este padrão básico:
```
tshark -c [número] [outras opções]
```
Aqui, [número] determina exatamente quando a captura para, especificando o número máximo de pacotes a serem coletados. Isso impede execuções indefinidas que poderiam preencher seu armazenamento.
Primeiro, vamos identificar as interfaces de rede disponíveis. Execute o seguinte comando:
```
tshark -D
```
Você verá uma lista de interfaces, semelhante a esta:
```
1. eth0
2. eth1 (Interface Dummy)
3. any
4. lo (Loopback)
...
```
Usaremos eth1 para nossas capturas, pois é uma interface dummy criada para este laboratório, garantindo a geração consistente de tráfego.
Vamos capturar 500 pacotes como nosso exercício principal. Execute este comando:
```
tshark -c 500 -i eth1
```
O comando sudo é necessário porque a captura de pacotes requer privilégios administrativos. Isso instrui o tshark a monitorar a conexão de rede eth1.
Para gerar algum tráfego para o tshark capturar, abra um novo terminal (ou divida o terminal atual) e execute o seguinte comando:
```
ping -c 10 google.com
```
Isso enviará 10 pacotes ICMP para google.com, criando atividade de rede em eth1 que o tshark pode capturar.

Conforme os pacotes fluem, você verá a saída em tempo real no terminal tshark. Após exatamente 500 pacotes, o tshark termina automaticamente. A saída será semelhante a esta (embora seja muito mais longa para 500 pacotes):

Capturando em 'eth1'
    1 0.000000000 192.168.X.X -> 142.250.X.X ICMP 84 Echo (ping) request  id=0xXXXX, seq=1/256, ttl=64 (resposta em 2)
    2 0.000000000 142.250.X.X -> 192.168.X.X ICMP 84 Echo (ping) reply    id=0xXXXX, seq=1/256, ttl=117 (pedido em 1)
... (muitas mais linhas)
500 pacotes capturados

Antes da captura completa de 500 pacotes, teste com uma amostra menor para entender o mecanismo. Este teste de 10 pacotes ajuda a verificar sua configuração:
```
tshark -c 10 -i eth1
```
Lembre-se de gerar tráfego em outro terminal enquanto este comando estiver em execução.

Definir o Comprimento do Instantâneo com -s 128

Neste passo, você aprenderá a definir o comprimento do snapshot (snaplen) ao capturar pacotes usando a opção -s no Tshark. Isso determina quantos bytes de cada pacote são capturados, sendo 128 bytes um valor comum que captura os cabeçalhos dos pacotes, conservando espaço de armazenamento. O comprimento do snapshot é particularmente útil quando você precisa apenas dos cabeçalhos dos pacotes para análise, em vez do conteúdo completo do pacote.

Primeiro, certifique-se de que você está no diretório de trabalho padrão ~/project em seu terminal. É aqui que executaremos todos os nossos comandos de captura para manter as coisas organizadas.
A opção de comprimento do snapshot (-s) limita quantos bytes de cada pacote são capturados, especificando o número de bytes a serem gravados. Valores menores economizam espaço em disco, mas podem perder dados importantes da carga útil. A sintaxe básica é:
```
tshark -s [comprimento] [outras opções]
```
Vamos capturar pacotes com um comprimento de snapshot de 128 bytes combinado com a contagem de pacotes do passo anterior. Este comando capturará os primeiros 128 bytes de cada pacote até atingir 500 pacotes:
```
tshark -c 500 -s 128 -i eth1
```
Lembre-se de gerar tráfego em um terminal separado (por exemplo, ping -c 10 google.com) enquanto o tshark estiver em execução.
Você verá a saída mostrando os primeiros 128 bytes de cada pacote. A captura será automaticamente interrompida após 500 pacotes, conforme especificado pela opção -c. Esta combinação ajuda a gerenciar tanto o tamanho quanto a duração da captura. A saída será semelhante ao passo anterior, mas os detalhes do pacote podem ser truncados se excederem 128 bytes.
```
Capturando em 'eth1'
    1 0.000000000 192.168.X.X -> 142.250.X.X ICMP 84 Echo (ping) request  id=0xXXXX, seq=1/256, ttl=64 (reply in 2)
... (muitas mais linhas)
500 packets captured
```
Para entender melhor como o comprimento do snapshot afeta as capturas, experimente estes comandos de comparação. Observe como a quantidade de dados exibidos muda com diferentes valores de -s. Lembre-se de gerar tráfego para cada comando.
```
tshark -c 5 -s 64 -i eth1 ## Captura apenas 64 bytes por pacote
tshark -c 5 -s 0 -i eth1  ## Captura pacotes inteiros (padrão)
```
A configuração -s 0 instrui o tshark a capturar o pacote completo, o que é útil quando você precisa do conteúdo completo do pacote, mas consome mais espaço de armazenamento.

Capturar Tráfego com -i eth1

Neste passo, focaremos em capturar tráfego de rede de uma interface específica usando a opção -i do Tshark. As interfaces de rede são as conexões físicas ou virtuais que seu computador utiliza para se comunicar com redes. Quando você possui várias interfaces (como Wi-Fi e Ethernet), especificar a correta é crucial para uma análise de pacotes direcionada.

Abra seu terminal e navegue para o diretório de trabalho:
```
cd ~/project
```
O sinal -i informa ao Tshark qual interface de rede monitorar. A estrutura básica do comando é:
```
tshark -i [interface] [outras opções]
```
Aqui, [interface] deve ser substituído pelo nome da sua interface real, normalmente eth1 para o nosso ambiente de laboratório.
Agora, vamos combinar isso com o que aprendemos sobre limites de pacotes (-c) e comprimento do snapshot (-s). Este comando capturará 500 pacotes da interface eth1, salvando apenas os primeiros 128 bytes de cada pacote:
```
tshark -c 500 -s 128 -i eth1
```
O sudo é necessário porque a captura de pacotes requer privilégios administrativos.
Para gerar tráfego de teste enquanto captura, abra outra aba de terminal e execute:
```
ping -c 3 google.com
```
Isso envia 3 pacotes ICMP para os servidores do Google, que devem aparecer na sua captura. Observar esses pacotes conhecidos ajuda a verificar se sua captura está funcionando corretamente.
A captura será interrompida automaticamente após 500 pacotes, mas você pode interromper manualmente a qualquer momento pressionando:
```
Ctrl+C
```
Este atalho de teclado interrompe o processo de captura de forma segura, preservando quaisquer dados capturados.

Salvar em Arquivo com -w limited.pcap

Neste passo, você aprenderá como salvar o tráfego de rede capturado em um arquivo para análise posterior. A opção -w no Tshark cria um arquivo de captura de pacotes (pcap) que preserva todos os dados de rede capturados. Isso é particularmente útil quando você precisa examinar padrões de tráfego offline ou compartilhar capturas com colegas.

Antes de começar, certifique-se de que seu terminal esteja no diretório de trabalho correto. Digite:
```
cd ~/project
```
Isso garante que todos os seus arquivos de captura serão salvos na pasta de projeto designada.
O sinalizador -w informa ao Tshark onde armazenar os pacotes capturados. A estrutura básica do comando é:
```
tshark -w [nome_do_arquivo] [outras opções]
```
O nome do arquivo deve terminar com a extensão .pcap, que é o formato padrão para arquivos de captura de pacotes.
Agora, vamos combinar todas as opções que aprendemos até agora em um exemplo prático. Este comando irá:
- Capturar exatamente 500 pacotes (-c 500)
- Limitar cada pacote a 128 bytes (-s 128)
- Ouvir na interface eth1 (-i eth1)
- Salvar tudo em um arquivo chamado limited.pcap (-w limited.pcap)
```
tshark -c 500 -s 128 -i eth1 -w limited.pcap
```
Enquanto o tshark estiver em execução, abra outra janela de terminal para gerar algum tráfego de teste. Esses comandos criarão atividades de rede típicas:
```
ping -c 3 google.com
curl http://example.com
```
Este tráfego simulado será capturado pela nossa sessão tshark em execução.
Após a captura de 500 pacotes (ou pressione Ctrl+C para parar antes), verifique se o seu arquivo de captura existe e verifique seu tamanho:
```
ls -lh limited.pcap
```
A saída mostra os detalhes do arquivo, incluindo o tamanho e a hora de criação, semelhante a isto:
```
-rw-r--r-- 1 root root 56K Ago 10 XX:XX limited.pcap
```
Para revisar seus pacotes capturados posteriormente, você tem duas opções principais:
- Usando tshark (linha de comando):
```
tshark -r limited.pcap
```
  Isso exibe o conteúdo dos pacotes exatamente como foram capturados, permitindo que você analise o tráfego conforme necessário.
- Usando wireshark (GUI):
  
  Nota: Você precisa executar este comando na Interface Desktop.
```
wireshark limited.pcap &
```
  Isso abrirá o arquivo limited.pcap na interface gráfica do usuário do Wireshark, fornecendo uma maneira mais visual e interativa de analisar os pacotes capturados. O & no final executa o comando em segundo plano, para que você possa continuar usando seu terminal.

Resumo

Neste laboratório, você aprendeu a controlar o tamanho da captura de pacotes no Tshark usando parâmetros essenciais da linha de comando. Você praticou a limitação do número de pacotes com -c 500 e a restrição do comprimento dos pacotes com -s 128, observando como essas opções afetam o comportamento da captura e a eficiência de armazenamento.

Os exercícios demonstraram a combinação dessas técnicas com a seleção de interface (-i eth1) para análise direcionada do tráfego. Através de comandos como tshark -c 500 -s 128 -i eth1 -w limited.pcap, você ganhou experiência prática na aplicação de múltiplas restrições de captura simultaneamente e na salvaguarda dos resultados para análise offline, utilizando tanto o tshark quanto o wireshark.