A análise de rede com Wireshark oferece visibilidade completa sobre o que acontece na sua rede no nível de pacotes. Quando aplicações falham ao conectar, o desempenho cai de forma inexplicável, ou você precisa verificar se o tráfego está fluindo conforme esperado, o Wireshark captura cada pacote e permite que você examine detalhes de protocolo que nenhuma outra ferramenta expõe. Este guia aborda o uso prático do Wireshark desde a instalação até filtros avançados e cenários reais de troubleshooting que engenheiros de rede e sysadmins enfrentam no dia a dia.

Pré-requisitos

  • Uma estação de trabalho rodando Linux, macOS ou Windows (Wireshark funciona nos três)
  • Acesso administrativo ou root para captura de pacotes (ou associação ao grupo wireshark no Linux)
  • Conhecimento básico de redes TCP/IP (endereços IP, portas, protocolos)
  • Uma interface de rede para capturar (Ethernet, Wi-Fi ou loopback)

Instalando o Wireshark

Linux

# Debian / Ubuntu
sudo apt install wireshark
# Durante a instalação, selecione "Yes" para permitir captura por usuários não-root

# Se perdeu o prompt, reconfigure:
sudo dpkg-reconfigure wireshark-common
sudo usermod -aG wireshark $USER
# Faça logout e login novamente para que a associação ao grupo tenha efeito

# RHEL / Fedora
sudo dnf install wireshark wireshark-cli

# Arch Linux
sudo pacman -S wireshark-qt

No Linux, o grupo wireshark concede acesso à interface de captura. Sem ele, você precisa executar o Wireshark como root — o que representa um risco de segurança e não é recomendado.

macOS

# Usando Homebrew
brew install --cask wireshark

Ou faça o download pelo site oficial. O macOS exige o helper ChmodBPF para capturar sem root.

Windows

Baixe o instalador no site do Wireshark. O instalador inclui o Npcap (o driver de captura de pacotes para Windows). Aceite os padrões do Npcap durante a instalação.

Alternativa via Linha de Comando: tshark

O Wireshark inclui o tshark, sua versão de linha de comando, útil para servidores remotos e scripts:

# Capturar 100 pacotes na eth0
tshark -i eth0 -c 100

# Capturar com um display filter
tshark -i eth0 -Y "http.request" -c 50

# Ler um arquivo de captura
tshark -r capture.pcapng -Y "dns"

Capturando Tráfego de Rede

Iniciando uma Captura Básica

Ao abrir o Wireshark, você vê uma lista de interfaces de rede disponíveis com gráficos sparkline mostrando a atividade. Dê um duplo clique em uma interface para iniciar a captura imediatamente.

Pela linha de comando:

# Listar interfaces disponíveis
tshark -D

# Iniciar captura em uma interface específica
tshark -i eth0

# Capturar para um arquivo
tshark -i eth0 -w /tmp/capture.pcapng

# Capturar com ring buffer (5 arquivos, 100MB cada)
tshark -i eth0 -b filesize:102400 -b files:5 -w /tmp/rolling.pcapng

O ring buffer é essencial para capturas de longa duração em sistemas de produção. Ele evita o esgotamento do espaço em disco sobrescrevendo o arquivo mais antigo quando o limite é atingido.

Capture Filters (Sintaxe BPF)

Capture filters usam a sintaxe Berkeley Packet Filter (BPF) — a mesma do tcpdump. Eles são aplicados antes que os pacotes cheguem ao Wireshark, reduzindo o tamanho do arquivo de captura.

# Capturar apenas tráfego de/para um host específico
host 192.168.1.100

# Capturar apenas tráfego HTTP e HTTPS
port 80 or port 443

# Capturar tráfego entre dois hosts específicos
host 10.0.0.1 and host 10.0.0.2

# Capturar apenas pacotes TCP SYN (novas conexões)
tcp[tcpflags] & (tcp-syn) != 0 and tcp[tcpflags] & (tcp-ack) == 0

# Capturar apenas tráfego DNS
port 53

# Capturar tráfego de uma subnet específica
net 192.168.1.0/24

# Excluir tráfego SSH (útil ao capturar em servidor remoto)
not port 22

Defina capture filters no diálogo de opções de captura do Wireshark (Ctrl+K) ou com a flag -f do tshark:

tshark -i eth0 -f "host 192.168.1.100 and port 443" -w /tmp/https_traffic.pcapng

Regra fundamental: sempre defina um capture filter ao capturar em redes movimentadas. Uma captura sem filtro em um link gigabit pode gerar centenas de megabytes por minuto.

Permissões de Captura e Segurança

# Verificar se seu usuário está no grupo wireshark (Linux)
groups $USER | grep wireshark

# Verificar capacidades de captura
getcap /usr/bin/dumpcap
# Deve exibir: /usr/bin/dumpcap cap_net_admin,cap_net_raw=eip

Nunca execute o Wireshark como root. A interface gráfica analisa dados de protocolo complexos e qualquer vulnerabilidade no parser se torna um exploit de root. Em vez disso, o dumpcap (o binário de captura propriamente dito) é executado com capacidades elevadas enquanto a interface gráfica roda como seu usuário normal.

Display Filters — Encontrando o Que Importa

Display filters são o recurso mais poderoso do Wireshark. Ao contrário dos capture filters, eles funcionam após a captura e podem filtrar qualquer campo de protocolo que o Wireshark entende — centenas de protocolos com milhares de campos.

Display Filters Essenciais

# Filtrar por endereço IP
ip.addr == 192.168.1.100
ip.src == 10.0.0.1
ip.dst == 10.0.0.2

# Filtrar por porta
tcp.port == 443
udp.port == 53

# Filtrar por protocolo
http
dns
tls
tcp
arp
icmp

# Apenas requisições HTTP
http.request

# Respostas HTTP com códigos de status específicos
http.response.code == 404
http.response.code >= 500

# Consultas DNS para um domínio específico
dns.qry.name contains "example.com"

# Problemas de conexão TCP
tcp.analysis.retransmission
tcp.analysis.duplicate_ack
tcp.analysis.zero_window
tcp.analysis.reset

# Pacotes de handshake TLS
tls.handshake.type == 1    # Client Hello
tls.handshake.type == 2    # Server Hello

# Filtrar por tamanho de pacote
frame.len > 1400
frame.len < 64

# Combinar filtros com operadores lógicos
ip.addr == 192.168.1.100 and tcp.port == 80
dns or http
not arp and not icmp
(ip.src == 10.0.0.1 or ip.src == 10.0.0.2) and tcp.port == 443

Display Filters vs Capture Filters

AspectoCapture FiltersDisplay Filters
SintaxeBPF (host, port, net)Wireshark (ip.addr, tcp.port)
Quando aplicadoAntes de iniciar a capturaApós a captura, em tempo real
Efeito no arquivoReduz o tamanho do arquivoSem efeito (oculta pacotes da visualização)
Profundidade de protocoloApenas camadas 2-4Todas as camadas de protocolo
Pode ser alteradoApenas reiniciando a capturaA qualquer momento durante a análise
DesempenhoFiltra no kernel (rápido)Filtra em userspace (mais lento)
Use quandoSouber exatamente o que capturarExplorando ou analisando uma captura

Conselho prático: use um capture filter amplo (ex.: host 192.168.1.100) para manter o tamanho do arquivo gerenciável, depois use display filters para analisar protocolos específicos.

Analisando Protocolos Comuns

Seguindo Streams TCP

Um dos recursos mais úteis do Wireshark é a reconstrução de conversas TCP:

  1. Localize um pacote pertencente à conversa desejada
  2. Clique com botão direito → Follow → TCP Stream
  3. O Wireshark exibe a conversa completa com dados do cliente em uma cor e dados do servidor em outra

Isso é indispensável para depurar APIs HTTP, sessões SMTP, queries de banco de dados e qualquer protocolo baseado em texto. Para tráfego criptografado (TLS), você vê o handshake, mas o payload fica cifrado a menos que forneça as chaves de sessão.

# Exportar um stream TCP específico com tshark
tshark -r capture.pcapng -q -z follow,tcp,ascii,0

Analisando Tráfego DNS

Problemas de DNS causam alguns dos problemas de rede mais confusos. Filtre e examine o DNS:

# Todo o tráfego DNS
dns

# Apenas consultas DNS (sem respostas)
dns.flags.response == 0

# Respostas DNS com erros
dns.flags.rcode != 0

# Consultas para um domínio específico
dns.qry.name == "api.example.com"

# Localizar respostas NXDOMAIN (domínio não existe)
dns.flags.rcode == 3

Cenário Real: Diagnosticando Lentidão em Aplicação

Você tem uma aplicação web que demora intermitentemente mais de 5 segundos para responder. As métricas do servidor mostram tempos de processamento rápidos. O problema está na rede.

  1. Capture o tráfego entre o cliente e o servidor:

    tshark -i eth0 -f "host 10.0.0.50 and port 443" -w /tmp/slow_app.pcapng

  2. Reproduza a requisição lenta a partir do cliente.

  3. Abra no Wireshark e aplique filtros:

    tcp.analysis.retransmission or tcp.analysis.duplicate_ack

  4. Verifique o tempo do handshake TCP — se o SYN-SYN/ACK levar mais de 200ms, há um problema de roteamento ou distância.

  5. Observe o intervalo entre pacotes — se o servidor envia dados rapidamente, mas há longos intervalos entre os ACKs do cliente, a rede do cliente está congestionada.

  6. Verifique problemas de TCP window scaling:

    tcp.analysis.zero_window

    Eventos de zero window significam que o buffer do receptor está cheio — a aplicação não está lendo os dados rápido o suficiente.

A causa costuma ser: retransmissões em uma conexão Wi-Fi com perda de pacotes, atrasos na resolução DNS ou um handshake TLS que inclui uma verificação OCSP lenta.

Recursos Avançados do Wireshark

IO Graphs

Os IO Graphs do Wireshark (Statistics → IO Graphs) visualizam padrões de tráfego ao longo do tempo. Crie múltiplas linhas de gráfico com filtros diferentes:

  • Linha 1: todo o tráfego (frame)
  • Linha 2: retransmissões (tcp.analysis.retransmission)
  • Linha 3: erros HTTP (http.response.code >= 400)

Picos de retransmissões que coincidem com picos de tráfego revelam congestionamento. Um fluxo constante de retransmissões sugere um problema na camada física (cabo ruim, interferência).

Expert Information

Acesse Analyze → Expert Information para o diagnóstico automatizado do Wireshark. Ele categoriza os problemas em:

  • Errors (vermelho): pacotes malformados, falhas de checksum
  • Warnings (amarelo): retransmissões, segmentos fora de ordem, zero windows
  • Notes (ciano): ACKs duplicados, keep-alives
  • Chats (azul): eventos normais de protocolo (estabelecimento de conexão, requisições HTTP)

Comece sua análise por aqui. Se o Expert Information mostrar centenas de warnings, foque neles antes de examinar pacotes individuais.

Decriptando Tráfego TLS

Para inspecionar conteúdo HTTPS no Wireshark:

# Defina a variável de ambiente antes de abrir o navegador
export SSLKEYLOGFILE=~/sslkeys.log
google-chrome &
# ou
firefox &

No Wireshark: Edit → Preferences → Protocols → TLS → (Pre)-Master-Secret log filename → selecione ~/sslkeys.log.

Agora o Wireshark decripta o tráfego TLS daquela sessão do navegador. Você vê requisições HTTP/2 completas, cabeçalhos e corpos de resposta. Isso funciona apenas para tráfego do seu próprio navegador usando aquele log de chaves — não é possível decriptar o tráfego de terceiros.

Estatísticas e Conversas

O Wireshark oferece diversas visualizações estatísticas:

  • Statistics → Conversations: exibe todos os pares de comunicação com contagens de pacotes e bytes
  • Statistics → Protocol Hierarchy: distribuição do tráfego por percentual de protocolo
  • Statistics → Endpoints: lista todos os endereços IP com volume de tráfego
  • Statistics → HTTP → Requests: todas as requisições HTTP ordenadas por URI

Essas visualizações ajudam a entender rapidamente o perfil de uma captura sem precisar rolar manualmente por todos os pacotes.

Comparando Wireshark com Alternativas de Análise de Rede

RecursoWireshark (GUI)tshark (CLI)tcpdumpngrep
Decodificadores de protocolo3000+3000+BásicoBásico
Visualização gráficaSimNãoNãoNão
Display filtersSintaxe completa WiresharkSintaxe completa WiresharkApenas BPFRegex no payload
Seguir streamsSim (TCP, UDP, TLS)SimNãoParcial
Roda em servidoresRequer X11/VNCSimSimSim
Captura em tempo realSimSimSimSim
Leitura de arquivos pcapSimSimSimSim
Melhor paraAnálise interativa detalhadaAnálise por script, remotaCaptura rápida, instalação mínimaBusca de pacotes estilo grep

Use o Wireshark para análise interativa e detalhada de protocolos na sua estação de trabalho. Use o tshark para análise por script e capturas remotas. Use o tcpdump quando o Wireshark não estiver instalado e você precisar de uma captura rápida. As três ferramentas compartilham o mesmo formato de arquivo pcap, então capture com uma e analise com outra.

Solução de Problemas

”No interfaces found” no Linux

# Verificar se o dumpcap tem as capabilities corretas
sudo setcap cap_net_admin,cap_net_raw=eip /usr/bin/dumpcap

# Verificar se seu usuário está no grupo wireshark
groups $USER

# Se você acabou de se adicionar, faça logout e login novamente
# Ou inicie uma nova sessão:
newgrp wireshark
# Aumentar o buffer de captura (o padrão costuma ser insuficiente)
# No Wireshark: Capture Options → Buffer size → defina 256 MB
# Com tshark:
tshark -i eth0 -B 256 -w /tmp/capture.pcapng

# Use um capture filter para reduzir o volume
tshark -i eth0 -f "port 443" -B 256 -w /tmp/https_only.pcapng

Se ainda houver descarte de pacotes, use o dumpcap diretamente (menos overhead que o tshark) ou migre para um appliance de captura dedicado para capturas sustentadas em alta velocidade.

Arquivos de captura grandes abrem lentamente

# Dividir uma captura grande em arquivos menores
editcap -c 100000 large_capture.pcapng split_capture.pcapng

# Usar tshark para pré-filtrar e criar um arquivo menor
tshark -r large_capture.pcapng -Y "http" -w http_only.pcapng

# Mesclar múltiplos arquivos de captura
mergecap -w merged.pcapng file1.pcapng file2.pcapng

O Wireshark exibe erros de checksum em todo lugar

NICs modernas delegam o cálculo de checksum ao hardware. O Wireshark captura pacotes antes que a NIC adicione os checksums, então eles aparecem como inválidos. Desative a verificação de checksum:

Edit → Preferences → Protocols → TCP → desmarque “Validate the TCP checksum if possible”

Faça o mesmo para IPv4, UDP e outros protocolos. Isso é cosmético — o tráfego real na rede tem checksums corretos.

Casos Especiais e Pegadinhas

Capturando na interface errada: em uma máquina com múltiplas NICs, você pode estar capturando na interface de gerenciamento enquanto o tráfego da aplicação flui por uma interface diferente. Use ip route get <destino> para verificar qual interface lida com o tráfego para o seu alvo.

Modo promíscuo vs modo normal: por padrão, o Wireshark ativa o modo promíscuo, capturando todos os pacotes que a NIC recebe (não apenas os endereçados à sua máquina). Em uma rede comutada (switched), você só vê seu próprio tráfego e broadcast/multicast, a menos que configure o espelhamento de porta no switch.

Limitações de captura em Wi-Fi: no Wi-Fi, você só vê o tráfego de e para sua própria máquina, a menos que use o monitor mode, que requer um adaptador compatível e desativa sua conexão Wi-Fi normal.

Timestamps de pacotes: o Wireshark usa o relógio da máquina de captura para os timestamps. Se você comparar capturas de duas máquinas, certifique-se de que os relógios estejam sincronizados (NTP). Até algumas centenas de milissegundos de defasagem tornam enganosa a correlação de eventos entre capturas.

Tags VLAN: se sua interface de captura for uma sub-interface VLAN (ex.: eth0.100), as tags VLAN são removidas antes que o Wireshark as veja. Capture na interface pai (eth0) para visualizar as tags VLAN.

Resumo

  • O Wireshark captura e decodifica 3000+ protocolos — é a ferramenta definitiva para entender o que está acontecendo na sua rede no nível de pacotes
  • Capture filters (sintaxe BPF) reduzem o tamanho do arquivo filtrando antes da gravação — sempre os use em redes movimentadas para manter as capturas gerenciáveis
  • Display filters (sintaxe Wireshark) permitem analisar interativamente qualquer campo de protocolo — domine ip.addr, tcp.port, tcp.analysis.* e dns.qry.name para os troubleshootings mais comuns
  • Follow TCP Stream reconstrói conversas completas entre endpoints — indispensável para depurar chamadas de API, fluxos de autenticação e erros de protocolo
  • Expert Information e IO Graphs fornecem diagnóstico automatizado e visualização de tráfego — comece por aqui antes de examinar pacotes individuais
  • Decriptação TLS funciona com SSLKEYLOGFILE para o tráfego do seu próprio navegador — inestimável para depurar problemas HTTPS sem um proxy

Artigos Relacionados