Filtros de Exibição no Tshark

Introdução

Neste laboratório, aprenderá a utilizar filtros de exibição na ferramenta de linha de comando do Wireshark, tshark, para análise eficiente do tráfego de rede. Você praticará a leitura de arquivos de captura de pacotes (capture.pcap) e a aplicação de filtros para isolar padrões de tráfego específicos, como pacotes de endereços IP ou portas TCP particulares.

Através de exercícios práticos, dominará comandos-chave do tshark, incluindo -r para leitura de arquivos e -Y para aplicação de filtros. O laboratório enfatiza a comparação dos resultados filtrados e não filtrados para aprimorar suas habilidades de solução de problemas de rede.

Este é um Lab Guiado, que fornece instruções passo a passo para ajudá-lo a aprender e praticar. Siga as instruções cuidadosamente para completar cada etapa e ganhar experiência prática. Dados históricos mostram que este é um laboratório de nível iniciante com uma taxa de conclusão de 92%. Recebeu uma taxa de avaliações positivas de 100% dos estudantes.

Verificar a Instalação do Tshark e o Ficheiro de Amostra

Neste passo inicial, você verificará se a ferramenta de linha de comando tshark está instalada e se o arquivo de captura de pacotes de amostra está disponível no seu diretório de trabalho. Isso garante que seu ambiente esteja pronto para as tarefas subsequentes de análise de rede.

Primeiro, verifique a instalação do tshark verificando sua versão. Abra um terminal e execute:
```
tshark -v
```
Você deve ver uma saída semelhante a esta, indicando que o tshark está instalado:
```
TShark (Wireshark) X.Y.Z (Git vX.Y.Z-gXXXXXXXXXXXX)
...
```
Os números de versão (X.Y.Z) podem variar, mas a presença da saída confirma que o tshark está pronto.
Em seguida, navegue até o diretório do projeto onde o arquivo de captura de pacotes de amostra está localizado. Este é o diretório de trabalho padrão para este laboratório:
```
cd ~/project
```
Verifique se o arquivo de captura de pacotes de amostra, capture.pcap, existe neste diretório. Este arquivo será usado em todos os passos de análise subsequentes:
```
ls -l capture.pcap
```
Você deve ver uma saída semelhante a esta:
```
-rw-r--r-- 1 labex labex 123456 Jan 1 00:00 capture.pcap
```
Esta saída confirma as permissões do arquivo, proprietário, tamanho e data de modificação, indicando que ele está presente e acessível.

Ler Ficheiro de Captura de Pacotes com -r

Neste passo, aprenderá a ler e exibir o conteúdo de um arquivo de captura de pacotes usando tshark. A opção -r é fundamental para especificar um arquivo de entrada, permitindo que o tshark analise o tráfego de rede pré-gravado em vez de capturar dados em tempo real.

Certifique-se de que está no diretório ~/project, pois é onde o nosso arquivo capture.pcap está localizado:
```
cd ~/project
```
Agora, use tshark para ler e exibir todos os pacotes do arquivo capture.pcap:
```
tshark -r capture.pcap
```
O sinal -r instrui o tshark a ler a partir do arquivo especificado. Este comando exibirá um resumo de cada pacote diretamente no seu terminal.
A saída mostrará informações básicas para cada pacote em colunas. Você verá detalhes como o número do pacote, timestamp, endereços IP de origem e destino, protocolo e uma breve descrição. Por exemplo:
```
1   0.000000 10.0.2.15 → 10.0.0.2 TCP 74 80 → 49234 [SYN] Seq=0 Win=64240 Len=0
2   0.000123 10.0.0.2 → 10.0.2.15 TCP 74 49234 → 80 [SYN, ACK] Seq=0 Ack=1 Win=29200 Len=0
...
```
Cada linha representa um pacote de rede, fornecendo uma visão geral rápida do tráfego.
Como capture.pcap contém muitos pacotes, a saída irá rolar continuamente. Para parar a exibição e retornar ao seu prompt de comando, pressione Ctrl+C. Este atalho de teclado encerra o processo tshark de forma segura.

Filtrar por IP de Origem com -Y "ip.src==10.0.2.15"

Neste passo, aprenderá a aplicar um filtro de exibição para mostrar apenas os pacotes originários de um endereço IP de origem específico. A opção -Y no tshark permite usar a poderosa sintaxe de filtro de exibição do Wireshark para restringir sua análise ao tráfego relevante.

Certifique-se de que está no diretório ~/project:
```
cd ~/project
```
Agora, filtre o arquivo capture.pcap para exibir apenas os pacotes onde o endereço IP de origem é 10.0.2.15. O filtro ip.src==10.0.2.15 especifica essa condição:
```
tshark -r capture.pcap -Y "ip.src==10.0.2.15"
```
O sinal -Y aplica o filtro de exibição fornecido entre aspas.
O comando exibirá apenas os pacotes que correspondem aos critérios do filtro. Notará que cada pacote exibido tem 10.0.2.15 como seu endereço IP de origem:
```
1   0.000000 10.0.2.15 → 10.0.0.2 TCP 74 80 → 49234 [SYN] Seq=0 Win=64240 Len=0
3   0.000456 10.0.2.15 → 10.0.0.2 TCP 66 80 → 49234 [ACK] Seq=1 Ack=1 Win=64240 Len=0
...
```
Compare esta saída com os resultados não filtrados do passo anterior. Isso demonstra como os filtros de exibição ajudam a focar em padrões de tráfego específicos dentro de um arquivo de captura grande.
Quando terminar de examinar a saída filtrada, pressione Ctrl+C para parar a exibição e retornar ao seu prompt de comando.

Combinar Filtros com -Y "ip.src==10.0.2.15 e tcp.port==80"

Neste passo, aprenderá a combinar múltiplos filtros de exibição usando operadores lógicos para refinar a análise do tráfego de rede. Usando o operador and, pode especificar que os pacotes devem satisfazer todas as condições definidas para serem exibidos, permitindo investigações altamente direcionadas.

Certifique-se de que está no diretório ~/project:
```
cd ~/project
```
Agora, vamos filtrar os pacotes que satisfazem duas condições simultaneamente: devem originar do endereço IP 10.0.2.15 E usar a porta TCP 80 (comumente usada para tráfego HTTP). O operador and garante que ambas as condições devem ser verdadeiras para que um pacote seja incluído na saída:
```
tshark -r capture.pcap -Y "ip.src==10.0.2.15 and tcp.port==80"
```
Este comando exibirá apenas os pacotes que correspondem a ambos os critérios de endereço IP de origem e porta TCP.
A saída mostrará apenas os pacotes que satisfazem ambas as condições. Por exemplo, poderá ver pedidos ou respostas HTTP do endereço IP especificado:
```
1   0.000000 10.0.2.15 → 10.0.0.2 TCP 74 80 → 49234 [SYN] Seq=0 Win=64240 Len=0
5   0.001234 10.0.2.15 → 10.0.0.2 HTTP 145 GET /index.html HTTP/1.1
...
```
Observe como este filtro combinado fornece resultados mais precisos em comparação com o uso de filtros únicos. Esta técnica é crucial para isolar conversas ou tráfego de aplicativos específicos.
Quando terminar de examinar a saída, pressione Ctrl+C para retornar ao prompt de comando.

Verificar Saída com -P (Visualização Detalhada de Pacotes)

Neste passo final, aprenderá como exibir informações detalhadas dos pacotes filtrados usando a opção -P do tshark. A opção -P é particularmente útil quando deseja ver resumos de pacotes enquanto grava pacotes num ficheiro ou quando usada com outras opções que suprimem a saída.

Certifique-se de que está no diretório ~/project:
```
cd ~/project
```
Primeiro, vamos ver a diferença entre usar -P e não usá-lo ao gravar num ficheiro. Execute este comando sem -P:
```
tshark -r capture.pcap -Y "ip.src==10.0.2.15 and tcp.port==80" -w filtered.pcap
```
Note que nenhuma informação de pacote é exibida na tela, pois os pacotes estão a ser gravados num ficheiro.

Agora execute o mesmo comando com a opção -P:

tshark -r capture.pcap -Y "ip.src==10.0.2.15 and tcp.port==80" -w filtered.pcap -P

Com a opção -P, verá os resumos dos pacotes exibidos na tela enquanto os pacotes são simultaneamente gravados no ficheiro:

1   0.000000 10.0.2.15 → 10.0.0.2 TCP 74 80 → 49234 [SYN] Seq=0 Win=64240 Len=0
2   0.000123 10.0.2.15 → 10.0.0.2 TCP 74 80 → 49234 [ACK] Seq=1 Ack=1 Win=64240 Len=0
...

Outro cenário útil é combinar -P com -q (modo silencioso). Primeiro, experimente apenas com -q:
```
tshark -r capture.pcap -Y "ip.src==10.0.2.15 and tcp.port==80" -q
```
Isto suprime toda a saída de pacotes e apenas mostra uma contagem no final.
Agora combine -q com -P:
```
tshark -r capture.pcap -Y "ip.src==10.0.2.15 and tcp.port==80" -q -P
```
A opção -P anula a supressão de -q e exibe novamente os resumos dos pacotes.

A opção -P é mais valiosa quando precisa monitorizar o processamento de pacotes enquanto simultaneamente salva os resultados filtrados num ficheiro, ou quando pretende anular a supressão de saída de outras opções como -q.

Resumo

Neste laboratório, aprendeu a aplicar eficazmente filtros de exibição usando a ferramenta de linha de comandos tshark do Wireshark para análise de tráfego de rede. Pratiqueu a leitura de ficheiros PCAP com -r, a filtragem por endereços IP e portas usando -Y, e a combinação de condições com operadores lógicos como and.

Os exercícios demonstraram como isolar padrões de tráfego específicos e verificar os resultados com -P, equipando-o com competências essenciais para análise de pacotes direcionada. Estas técnicas permitem a resolução de problemas eficiente, focando-se nos dados de rede relevantes.

Utilizar Filtros de Exibição no Tshark