Use Tshark para Análise de Tráfego de Rede

WiresharkBeginner
Pratique Agora

Introdução

Neste laboratório, você aprenderá como usar o tshark, a interface de linha de comando do poderoso analisador de protocolos de rede Wireshark. Dominar o tshark permite otimizar fluxos de trabalho de análise de rede, automatizar tarefas e obter insights mais profundos sobre o tráfego de rede.

Este laboratório irá guiá-lo através de diferentes opções de linha de comando e cenários práticos. Ele irá equipá-lo com as habilidades para analisar capturas de rede de forma eficiente e solucionar problemas relacionados à rede. A abordagem de linha de comando tem vantagens significativas sobre a interface gráfica, especialmente para arquivos de captura grandes ou análise automatizada.

Entendendo e Capturando Tráfego de Rede com Tshark

Neste passo, mergulharemos no mundo da análise de tráfego de rede usando o Tshark. Primeiro, você aprenderá o que é o Tshark e por que ele é uma ferramenta valiosa para análise de rede. Em seguida, descobriremos como identificar as interfaces de rede em seu sistema, o que é crucial porque você precisa saber de onde capturar o tráfego. Finalmente, veremos como capturar tráfego de rede usando a interface de linha de comando do Wireshark, que é o Tshark.

O que é tshark?

Tshark é essencialmente a versão de linha de comando do Wireshark. Embora o Wireshark tenha uma interface gráfica que é ótima para inspeção visual, o Tshark oferece a mesma funcionalidade principal sem a necessidade de uma exibição gráfica. Com o Tshark, você pode capturar pacotes de uma rede. Pacotes são como pequenos envelopes que transportam dados através de uma rede. Ele também permite exibir informações detalhadas sobre esses pacotes, como de onde vieram, para onde estão indo e que tipo de dados estão transportando. Você pode salvar os dados capturados em um arquivo para análise posterior. Esta ferramenta é particularmente útil em vários cenários:

  • Monitoramento de rede automatizado: Você pode configurar scripts para executar o Tshark regularmente e verificar qualquer atividade de rede incomum.
  • Análise eficiente de arquivos de captura grandes: Como é uma ferramenta de linha de comando, ela pode lidar com grandes quantidades de dados mais rapidamente do que algumas alternativas gráficas.
  • Execução em servidores sem interface gráfica: Servidores geralmente não possuem uma exibição gráfica, e o Tshark pode ser executado diretamente da linha de comando.
  • Integração da análise de rede em scripts: Você pode usar comandos Tshark dentro de seus próprios scripts para realizar tarefas personalizadas de análise de rede.

Instalando o tshark

Antes de começarmos a usar o Tshark, precisamos garantir que ele esteja instalado em seu sistema. Para instalar o Tshark em um sistema que usa o gerenciador de pacotes apt (como o Ubuntu), execute o seguinte comando em seu terminal. A parte sudo concede a você privilégios administrativos, apt install é usado para instalar pacotes, -y responde automaticamente sim a quaisquer prompts, e tshark é o pacote que queremos instalar.

sudo apt install -y tshark

Identificando suas Interfaces de Rede

Antes de começar a capturar tráfego de rede, você precisa saber qual interface de rede monitorar. Uma interface de rede é como uma porta através da qual seu computador se conecta a uma rede. Para listar todas as interfaces de rede disponíveis em seu sistema, execute o seguinte comando:

tshark -D

Este comando exibirá uma lista de todas as interfaces de rede em seu sistema. A saída será semelhante a esta:

1. eth0
2. eth1
3. lo (Loopback)
4. any (Pseudo - device that captures on all interfaces)

Em nosso laboratório, usaremos a interface any. Este é um pseudo-dispositivo especial que nos permite capturar tráfego de todas as interfaces de rede disponíveis de uma vez.

Capturando Tráfego de Rede

Agora que sabemos qual interface usar, vamos começar a capturar algum tráfego de rede. A sintaxe básica para capturar tráfego com o Tshark é a seguinte:

tshark -i <interface> -w <output_file>

Aqui está o que cada parte significa:

  • -i <interface>: Esta opção especifica de qual interface de rede você deseja capturar o tráfego. Você pode substituir <interface> pelo nome da interface real, como eth0 ou any.
  • -w <output_file>: Esta opção especifica o local e o nome do arquivo onde você deseja salvar os pacotes capturados.

Primeiro, vamos criar um diretório para armazenar nossos arquivos capturados. O comando mkdir -p cria um diretório se ele não existir, e estamos criando-o em /home/labex/project/captures.

mkdir -p /home/labex/project/captures

Agora, vamos iniciar a captura. Usaremos a interface any e salvaremos os pacotes capturados em um arquivo chamado capture.pcapng no diretório /home/labex/project.

tshark -i any -w /home/labex/project/capture.pcapng

Depois de executar este comando, você verá uma saída indicando que o Tshark começou a capturar pacotes. A saída será assim:

Capturing on 'any'

Para realmente capturar algum tráfego significativo, precisamos gerá-lo. Abra uma nova aba do terminal e execute o seguinte comando. O comando curl é usado para transferir dados de um servidor. Aqui, estamos tentando acessar o site https://www.example.com.

curl https://www.example.com

Depois de gerar o tráfego, volte para o terminal onde o Tshark está sendo executado e pressione Ctrl + C para parar a captura. Você verá uma mensagem indicando quantos pacotes foram capturados. Pode ser assim:

Capturing on 'any'
164 packets captured

Examinando o Arquivo Capturado

Para garantir que o arquivo de captura foi criado com sucesso, podemos usar o comando ls -l. Este comando lista os arquivos em um diretório e mostra informações detalhadas sobre eles. Execute o seguinte comando para verificar o arquivo de captura:

ls -l /home/labex/project/capture.pcapng

Você deve ver uma saída semelhante a esta:

-rw-r--r-- 1 labex labex 24680 Jan 27 12:34 /home/labex/project/capture.pcapng

Agora, vamos dar uma olhada rápida no que capturamos. Usaremos o Tshark novamente, mas desta vez com a opção -r. A opção -r é usada para ler um arquivo de captura. Vamos canalizar a saída para o comando head - 10, que nos mostrará os primeiros 10 pacotes no arquivo.

tshark -r /home/labex/project/capture.pcapng | head -10

Este comando exibirá informações detalhadas do pacote, incluindo timestamps (quando o pacote foi capturado), endereços de origem e destino (de onde o pacote veio e para onde estava indo) e os protocolos usados.

Filtrando Tráfego de Rede com Tshark

Nesta etapa, exploraremos como aplicar filtros a capturas de tráfego de rede. Ao lidar com tráfego de rede, os arquivos de captura podem ser bastante grandes e conter uma vasta quantidade de dados. A filtragem nos ajuda a focar em tipos específicos de pacotes que nos interessam. Isso é crucial porque nos permite analisar arquivos de captura grandes de forma mais eficiente e identificar padrões de tráfego relevantes.

Entendendo os Filtros de Exibição (Display Filters)

O Tshark usa filtros de exibição (display filters) para selecionar quais pacotes exibir ou processar a partir de um arquivo de captura. Pense nesses filtros como uma maneira de dizer ao Tshark quais pacotes você deseja visualizar. Eles usam uma sintaxe específica para definir critérios de correspondência com base nos campos do protocolo. Por exemplo, você pode instruir o Tshark a mostrar apenas pacotes que pertencem a um determinado protocolo ou que possuem um endereço IP específico. A sintaxe básica para aplicar um filtro de exibição é:

tshark -r "<input_file>" -Y "<filter_expression>"

Vamos detalhar os componentes deste comando:

  • -r <input_file>: Esta parte do comando especifica o arquivo de captura que o Tshark deve ler. É como dizer ao Tshark onde encontrar os dados do tráfego de rede.
  • -Y "<filter_expression>": Isso especifica o filtro de exibição que você deseja aplicar. A expressão do filtro é um conjunto de regras que definem quais pacotes devem ser selecionados.

Exemplos Comuns de Filtros de Exibição

Aqui estão algumas expressões de filtro úteis que você pode usar. Estes exemplos cobrem diferentes aspectos da filtragem de pacotes, como filtrar por protocolo, endereço IP, porta, método HTTP, consulta DNS e combinação de múltiplos filtros.

  • Filtrar por protocolo: tcp, udp, icmp, http, dns. Por exemplo, se você usar tcp, o Tshark mostrará apenas pacotes que utilizam o protocolo TCP.
  • Filtrar por endereço IP: ip.addr == 192.168.1.1. Este filtro mostrará apenas pacotes que têm o endereço IP 192.168.1.1 como origem ou destino.
  • Filtrar por porta: tcp.port == 80 ou tcp.port == 443. Estes filtros mostrarão pacotes que usam as portas TCP 80 ou 443. A porta 80 é comumente usada para tráfego HTTP, e a porta 443 é usada para tráfego HTTPS.
  • Filtrar por método HTTP: http.request.method == "GET". Este filtro mostrará apenas requisições HTTP que utilizam o método GET.
  • Filtrar por consulta DNS: dns.qry.name contains "example.com". Este filtro mostrará pacotes DNS onde o nome da consulta contém a string "example.com".
  • Combinando filtros: tcp.port == 80 and http.request.method == "POST". Este filtro combina duas condições. Ele mostrará apenas pacotes que usam a porta TCP 80 e possuem uma requisição HTTP POST.

Aplicando Filtros à Nossa Captura

Vamos começar filtrando o tráfego HTTPS (porta TCP 443) do nosso arquivo de captura. Usaremos o seguinte comando:

tshark -r /home/labex/project/capture.pcapng -Y "tcp.port == 443"

Ao executar este comando, o Tshark lerá o arquivo de captura /home/labex/project/capture.pcapng e aplicará o filtro tcp.port == 443. Como resultado, você deverá ver apenas pacotes que utilizam a porta TCP 443, que é tipicamente usada para tráfego HTTPS. A saída incluirá detalhes sobre esses pacotes, como endereços IP de origem e destino, números de porta e flags do pacote. Aqui está um exemplo de como a saída pode ser:

  1   0.000000 192.168.1.100 → 93.184.216.34 TCP 74 43210 → 443 [SYN] Seq=0 Win=64240 Len=0 MSS=1460 WS=256 SACK_PERM=1
  2   0.023456 93.184.216.34 → 192.168.1.100 TCP 74 443 → 43210 [SYN, ACK] Seq=0 Ack=1 Win=65535 Len=0 MSS=1460 WS=128 SACK_PERM=1
  3   0.023789 192.168.1.100 → 93.184.216.34 TCP 66 43210 → 443 [ACK] Seq=1 Ack=1 Win=64240 Len=0
  ...

Vamos tentar outro filtro para procurar tráfego DNS. Usaremos o seguinte comando:

tshark -r /home/labex/project/capture.pcapng -Y "dns"

Este comando exibirá apenas os pacotes DNS na captura. A saída mostrará consultas e respostas DNS, incluindo detalhes como o nome da consulta e o endereço IP da resposta. Aqui está um exemplo de como a saída pode ser:

  8   0.034567 192.168.1.100 → 8.8.8.8 DNS 82 Standard query 0x1234 A example.com
  9   0.056789 8.8.8.8 → 192.168.1.100 DNS 98 Standard query response 0x1234 A example.com A 93.184.216.34

Contando Pacotes por Tipo

Você também pode usar filtros para contar tipos específicos de pacotes. Isso pode ser útil para obter uma visão geral do tráfego em um arquivo de captura. Por exemplo, para contar o número de pacotes TCP, podemos usar o seguinte comando:

tshark -r /home/labex/project/capture.pcapng -Y "tcp" | wc -l

Neste comando, tshark lê o arquivo de captura e aplica o filtro tcp. A saída do tshark é então canalizada (|) para o comando wc -l, que conta o número de linhas na saída. Como cada linha representa um pacote, isso nos dá o número de pacotes TCP no arquivo de captura.

Vamos contar o número de pacotes HTTPS e salvar o resultado em um arquivo. Usaremos o seguinte comando:

tshark -r /home/labex/project/capture.pcapng -Y "tcp.port == 443" | wc -l > /home/labex/project/filtered_packet_count.txt

Este comando é semelhante ao anterior, mas em vez de apenas exibir a contagem, redirecionamos (>) a saída para um arquivo chamado filtered_packet_count.txt. Você pode visualizar o resultado com o seguinte comando:

cat /home/labex/project/filtered_packet_count.txt

A saída mostrará o número de pacotes que correspondem ao filtro. Por exemplo:

42

Extraindo Campos Específicos

O Tshark pode extrair campos específicos dos pacotes usando as opções -T fields e -e. Isso é útil quando você está interessado apenas em certas informações dos pacotes, como o host, o método e a URI de uma requisição HTTP. Aqui está um exemplo de comando:

tshark -r /home/labex/project/capture.pcapng -Y "http" -T fields -e http.host -e http.request.method -e http.request.uri

Neste comando, o tshark lê o arquivo de captura, aplica o filtro http para selecionar apenas pacotes HTTP e, em seguida, usa a opção -T fields para especificar que queremos extrair campos. A opção -e é usada para especificar quais campos extrair. Neste caso, estamos extraindo os campos http.host, http.request.method e http.request.uri. A saída pode ser algo como:

example.com GET /index.html
example.com GET /images/logo.png

Analisando e Exportando Tráfego de Rede com Tshark

Neste passo, focaremos em como exportar tráfego de rede em diferentes formatos e realizar análises básicas de tráfego usando o tshark. Essas habilidades são cruciais porque permitem que você compartilhe os dados capturados com seus colegas ou os use em outras ferramentas. Ao final desta seção, você será capaz de lidar com diferentes formatos de arquivo e extrair informações valiosas do tráfego de rede.

Compreendendo os Formatos de Arquivo de Captura

O Wireshark, um conhecido analisador de protocolo de rede, suporta vários formatos de arquivo de captura. Cada formato tem suas próprias características únicas, que são importantes de entender, pois determinam como os dados podem ser usados ​​posteriormente.

  • pcapng: Este é o formato padrão usado pelo Wireshark. Ele suporta múltiplas interfaces e possui recursos avançados. É uma ótima opção quando você precisa capturar cenários de rede complexos.
  • pcap: O formato clássico. É compatível com ferramentas mais antigas, mas possui menos recursos em comparação com o pcapng. Se você precisar trabalhar com sistemas legados, este formato pode ser o seu preferido.
  • csv: Valores separados por vírgula (Comma-separated values). Este formato é muito útil quando você deseja importar os dados para planilhas para análise posterior.
  • json: Notação de Objeto JavaScript (JavaScript Object Notation). É ideal para análise programática, pois pode ser facilmente analisado por linguagens de programação.
  • text: Um formato de texto simples que é legível por humanos. É útil quando você deseja visualizar rapidamente os dados sem nenhuma ferramenta especial.

Exportando para Diferentes Formatos de Arquivo

Para alterar o formato de um arquivo de captura, você pode usar a opção -F no tshark. A estrutura geral do comando é a seguinte:

tshark -r <input_file> -F <format> -w <output_file>

Aqui, -r especifica o arquivo de entrada, -F define o formato de saída e -w define o arquivo de saída.

Vamos pegar um exemplo e exportar nossa captura para o formato pcap:

tshark -r /home/labex/project/capture.pcapng -F pcap -w /home/labex/project/export.pcap

Quando este comando é executado com sucesso, você não verá nenhuma saída na tela. Para confirmar que a exportação foi bem-sucedida, você pode usar o comando ls para listar os detalhes do arquivo exportado:

ls -l /home/labex/project/export.pcap

Você deve ver uma saída semelhante a esta:

-rw-r--r-- 1 labex labex 22468 Jan 27 12:45 /home/labex/project/export.pcap

Analisando Estatísticas de Protocolo

O Tshark não é útil apenas para exportar arquivos, mas também para gerar várias estatísticas sobre o tráfego capturado. Vamos explorar algumas dessas opções de análise estatística.

Estatísticas da Hierarquia de Protocolos

Se você deseja ver como diferentes protocolos são distribuídos em sua captura, pode usar o seguinte comando:

tshark -r /home/labex/project/capture.pcapng -z io,phs

A opção -z é usada para especificar o tipo de estatística. Neste caso, io,phs significa estatísticas da hierarquia de protocolos (protocol hierarchy statistics). A saída mostrará a hierarquia de protocolos e a porcentagem de pacotes para cada protocolo.

Protocol Hierarchy Statistics
|
+ Ethernet
  + Internet Protocol Version 4
    + Transmission Control Protocol
      + Transport Layer Security
        + Hypertext Transfer Protocol Secure
    + User Datagram Protocol
      + Domain Name System

Estatísticas de Conversa

Para analisar as conversas entre os endpoints na rede, você pode usar o seguinte comando:

tshark -r /home/labex/project/capture.pcapng -z conv,tcp

Este comando se concentra em conversas TCP. Ele mostra estatísticas como os endpoints envolvidos, o número de pacotes trocados e o total de bytes transferidos.

TCP Conversations
                                               |       <-      | |       ->      | |     Total     |    Relative    |   Duration   |
                                               | Frames  Bytes | | Frames  Bytes | | Frames  Bytes |      Start     |              |
192.168.1.100:43210 <-> 93.184.216.34:443          24   18765      18    4532      42    23297       0.000000000        8.2345

Estatísticas de Solicitação HTTP

Se sua captura contiver tráfego HTTP, você pode analisar as solicitações HTTP usando o seguinte comando:

tshark -r /home/labex/project/capture.pcapng -z http,tree

Este comando organiza as solicitações HTTP por URI e mostra o número de solicitações para cada URI.

HTTP/Requests:
 /index.html                                    1 requests
 /images/logo.png                               2 requests

Exportando para Diferentes Formatos de Texto

Além dos formatos binários, o tshark também pode exportar dados para formatos de texto, que geralmente são mais fáceis de analisar.

Exportando para CSV

Para exportar campos específicos da captura para um arquivo CSV, você pode usar o seguinte comando:

tshark -r /home/labex/project/capture.pcapng -T fields -e frame.number -e ip.src -e ip.dst -e tcp.srcport -e tcp.dstport -E header=y -E separator=, > /home/labex/project/tcp_summary.csv

Aqui, -T fields especifica que queremos exportar campos específicos. A opção -e é usada para definir os campos que queremos exportar, como número do quadro, IPs de origem e destino e portas TCP de origem e destino. -E header=y adiciona um cabeçalho ao arquivo CSV e -E separator=, define o separador como uma vírgula.

Examinando a Exportação CSV

Depois de exportar os dados para um arquivo CSV, você pode visualizar rapidamente as primeiras linhas do arquivo usando o comando head:

head -5 /home/labex/project/tcp_summary.csv

A saída pode ser assim:

frame.number,ip.src,ip.dst,tcp.srcport,tcp.dstport
1,192.168.1.100,93.184.216.34,43210,443
2,93.184.216.34,192.168.1.100,443,43210
3,192.168.1.100,93.184.216.34,43210,443
...

Técnicas Avançadas do Tshark e Piping

Neste passo, você aprenderá técnicas avançadas do tshark. Essas técnicas são cruciais para a análise de rede, pois permitem que você execute operações complexas nos dados de tráfego de rede. Especificamente, você aprenderá como ler o tráfego de rede da entrada padrão (stdin) e como combinar o tshark com outras ferramentas de linha de comando usando pipes. Dominar essas habilidades permitirá que você crie fluxos de trabalho de análise de rede poderosos, o que pode economizar tempo e esforço ao lidar com grandes quantidades de dados de rede.

Compreendendo os Pipes do Linux e a Entrada Padrão

No sistema operacional Linux, os pipes (|) são um recurso muito útil. Eles atuam como uma ponte entre dois comandos, permitindo que você envie a saída de um comando como entrada para outro comando. Dessa forma, você pode encadear vários comandos para executar tarefas mais complexas. A entrada padrão (stdin) é um fluxo de dados que um programa lê para entrada. Quando você usa o símbolo - com muitas ferramentas de linha de comando, é um sinal para a ferramenta de que a entrada deve vir de stdin em vez de um arquivo. Isso oferece mais flexibilidade na forma como você processa os dados.

Lendo o Tráfego de Rede da Entrada Padrão

O Tshark tem a capacidade de ler dados de captura da entrada padrão usando a opção -r -. Esse recurso é extremamente útil em cenários em que você deseja processar dados de outro comando ou quando precisa filtrar uma captura em tempo real. Em vez de ler diretamente de um arquivo, você pode canalizar dados para o tshark.

A sintaxe básica para ler o tráfego de rede da entrada padrão é:

cat <input_file> | tshark -r -

Vamos tentar isso com nosso arquivo de captura. O seguinte comando lê o arquivo de captura e exibe todos os pacotes, semelhante à execução de tshark -r capture.pcapng.

cat /home/labex/project/capture.pcapng | tshark -r -

A saída mostrará todos os pacotes na captura, assim:

  1   0.000000 192.168.1.100 → 93.184.216.34 TCP 74 43210 → 443 [SYN] Seq=0 Win=64240 Len=0 MSS=1460 WS=256 SACK_PERM=1
  2   0.023456 93.184.216.34 → 192.168.1.100 TCP 74 443 → 43210 [SYN, ACK] Seq=0 Ack=1 Win=65535 Len=0 MSS=1460 WS=128 SACK_PERM=1
  ...

Filtrando na Entrada Padrão

Você também pode aplicar filtros ao ler de stdin. Isso permite que você se concentre em tipos específicos de tráfego de rede.

cat /home/labex/project/capture.pcapng | tshark -r - -Y "tcp.port == 80"

Este comando exibirá apenas o tráfego HTTP (porta TCP 80) da captura. Ao usar o filtro, você pode isolar rapidamente os dados nos quais está interessado.

Criando um Pipeline para Análise de Rede

Vamos criar um pipeline mais complexo que executa várias operações nos dados de captura de rede. Este pipeline irá:

  1. Ler o arquivo de captura
  2. Filtrar o tráfego DNS
  3. Extrair apenas os nomes de consulta DNS
  4. Classificá-los alfabeticamente
  5. Remover duplicatas
  6. Salvar o resultado em um arquivo
cat /home/labex/project/capture.pcapng | tshark -r - -Y "dns" -T fields -e dns.qry.name | sort | uniq > /home/labex/project/dns_queries.txt

Vamos examinar o resultado executando o seguinte comando:

cat /home/labex/project/dns_queries.txt

A saída mostrará uma lista classificada de nomes de consulta DNS exclusivos da sua captura, assim:

example.com
www.example.com

Combinando Tshark com Outras Ferramentas

O Tshark pode ser combinado com outras ferramentas de linha de comando para uma análise mais poderosa.

Contando Tipos de Pacotes com grep

cat /home/labex/project/capture.pcapng | tshark -r - | grep TCP | wc -l > /home/labex/project/tcp_count.txt

Este pipeline conta o número de pacotes TCP na captura. Ao usar grep para encontrar pacotes TCP e wc -l para contá-los, você pode obter rapidamente uma ideia da quantidade de tráfego TCP em sua captura.

Extraindo Agentes de Usuário HTTP com sed

cat /home/labex/project/capture.pcapng | tshark -r - -Y "http.user_agent" -T fields -e http.user_agent | sed 's/,/\n/g' > /home/labex/project/user_agents.txt

Isso extrai todas as strings de agente de usuário HTTP, substituindo vírgulas por novas linhas. Isso torna a saída mais legível e fácil de analisar.

Salvando a Saída de Stdin em um Arquivo

Vamos salvar a saída completa de uma análise tshark stdin em um arquivo. Dessa forma, você pode revisar os dados mais tarde.

cat /home/labex/project/capture.pcapng | tshark -r - > /home/labex/project/stdin_output.txt

Vamos verificar o conteúdo executando o seguinte comando:

head -5 /home/labex/project/stdin_output.txt

Isso deve mostrar as primeiras 5 linhas da análise, semelhante a:

  1   0.000000 192.168.1.100 → 93.184.216.34 TCP 74 43210 → 443 [SYN] Seq=0 Win=64240 Len=0 MSS=1460 WS=256 SACK_PERM=1
  2   0.023456 93.184.216.34 → 192.168.1.100 TCP 74 443 → 43210 [SYN, ACK] Seq=0 Ack=1 Win=65535 Len=0 MSS=1460 WS=128 SACK_PERM=1
  3   0.023789 192.168.1.100 → 93.184.216.34 TCP 66 43210 → 443 [ACK] Seq=1 Ack=1 Win=64240 Len=0
  4   0.024012 192.168.1.100 → 93.184.216.34 TLSv1.2 192 Client Hello
  5   0.045678 93.184.216.34 → 192.168.1.100 TLSv1.2 1023 Server Hello, Certificate, Server Key Exchange, Server Hello Done

Resumo

Neste laboratório, você aprendeu a usar efetivamente a interface de linha de comando (CLI - command-line interface) do Wireshark (tshark) para análise de tráfego de rede. Primeiro, você compreendeu os conceitos básicos do tshark e aprendeu a capturar tráfego de rede de interfaces de rede. Em seguida, você explorou a aplicação de filtros para se concentrar em tipos específicos de tráfego, o que é crucial ao lidar com arquivos de captura grandes.

Você também aprendeu a exportar o tráfego de rede em diferentes formatos para compartilhamento ou análise posterior. Além disso, você explorou os recursos de análise estatística do tshark para entender a composição do tráfego de rede. Finalmente, você avançou para técnicas mais complexas, como ler o tráfego da entrada padrão e criar pipelines de análise combinando o tshark com outras ferramentas de linha de comando. Essas habilidades oferecem vantagens sobre a interface gráfica do Wireshark em cenários como o manuseio de arquivos grandes, a execução de análises automatizadas, a análise em servidores remotos e a criação de fluxos de trabalho repetíveis. Ao dominar essas técnicas, você aprimorou suas capacidades de solução de problemas de rede e análise de segurança para um trabalho mais eficiente em vários contextos de rede.