Wireshark: Guia de Análise de Protocolos de Rede

16 de dezembro de 2025

16 min de leitura

Este ano

TL;DR — Resumo Rápido

Análise de rede com Wireshark permite capturar pacotes, filtrar por protocolo e diagnosticar problemas. Domine capture filters e display filters para uso em produção.

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

Aspecto	Capture Filters	Display Filters
Sintaxe	BPF (`host`, `port`, `net`)	Wireshark (`ip.addr`, `tcp.port`)
Quando aplicado	Antes de iniciar a captura	Após a captura, em tempo real
Efeito no arquivo	Reduz o tamanho do arquivo	Sem efeito (oculta pacotes da visualização)
Profundidade de protocolo	Apenas camadas 2-4	Todas as camadas de protocolo
Pode ser alterado	Apenas reiniciando a captura	A qualquer momento durante a análise
Desempenho	Filtra no kernel (rápido)	Filtra em userspace (mais lento)
Use quando	Souber exatamente o que capturar	Explorando 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:

Localize um pacote pertencente à conversa desejada
Clique com botão direito → Follow → TCP Stream
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.

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

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

Abra no Wireshark e aplique filtros:

tcp.analysis.retransmission or tcp.analysis.duplicate_ack

Verifique o tempo do handshake TCP — se o SYN-SYN/ACK levar mais de 200ms, há um problema de roteamento ou distância.
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.
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

Recurso	Wireshark (GUI)	tshark (CLI)	tcpdump	ngrep
Decodificadores de protocolo	3000+	3000+	Básico	Básico
Visualização gráfica	Sim	Não	Não	Não
Display filters	Sintaxe completa Wireshark	Sintaxe completa Wireshark	Apenas BPF	Regex no payload
Seguir streams	Sim (TCP, UDP, TLS)	Sim	Não	Parcial
Roda em servidores	Requer X11/VNC	Sim	Sim	Sim
Captura em tempo real	Sim	Sim	Sim	Sim
Leitura de arquivos pcap	Sim	Sim	Sim	Sim
Melhor para	Análise interativa detalhada	Análise por script, remota	Captura rápida, instalação mínima	Busca 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

Captura descarta pacotes em links de alta velocidade

# 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

Guide & Instructions

Estimated Time: 30m

Tools Needed:

Wireshark
tshark
tcpdump

Instalar o Wireshark no sistema operacional

Instale o Wireshark pelo gerenciador de pacotes ou pelo download oficial. Configure permissões de captura sem root no Linux.

Capturar tráfego de rede ao vivo em uma interface

Selecione uma interface de rede no Wireshark e inicie a captura de pacotes para ver todo o tráfego em tempo real.

Aplicar capture filters para limitar o tráfego registrado

Defina capture filters com sintaxe BPF antes de iniciar para reduzir o tamanho do arquivo e focar em hosts, portas ou protocolos específicos.

Usar display filters para localizar pacotes específicos

Aplique expressões de display filter do Wireshark para isolar requisições HTTP, consultas DNS, erros TCP ou tráfego entre endpoints específicos.

Seguir streams TCP para reconstruir conversas

Clique com o botão direito em um pacote e selecione Follow TCP Stream para ver a conversa completa entre cliente e servidor.

Analisar o tempo dos pacotes para diagnosticar problemas de desempenho

Use a coluna Time e os IO Graphs para identificar picos de latência, retransmissões e gargalos de throughput.

Frequently Asked Questions

Qual é a diferença entre capture filters e display filters no Wireshark?

Capture filters (sintaxe BPF) limitam quais pacotes o Wireshark grava em disco, reduzindo o tamanho do arquivo. Display filters (sintaxe Wireshark) ocultam pacotes da visualização sem apagá-los. Use capture filters quando souber antecipadamente qual tráfego precisa. Use display filters para análise interativa após a captura.

Como capturar pacotes em um servidor remoto com Wireshark?

Use o tcpdump no servidor remoto para capturar em um arquivo, depois transfira-o para sua estação e abra no Wireshark. Exemplo: ssh user@server 'sudo tcpdump -i eth0 -w -' | wireshark -k -i - transmite pacotes diretamente ao Wireshark via SSH em tempo real.

O Wireshark consegue capturar tráfego HTTPS criptografado?

O Wireshark captura os pacotes criptografados, mas não consegue ler o payload sem as chaves de sessão. Defina a variável de ambiente SSLKEYLOGFILE no seu navegador para exportar as chaves de sessão e configure o Wireshark para usá-las em Preferences > Protocols > TLS. Isso funciona apenas para suas próprias sessões de navegador.

Por que o Wireshark exibe retransmissões TCP e o que elas significam?

Retransmissões TCP aparecem quando o remetente não recebe um ACK dentro do timeout esperado. Causas comuns incluem congestionamento de rede, perda de pacotes ou um receptor lento. Uma pequena porcentagem é normal. Retransmissões sustentadas acima de 1-2% indicam um problema no caminho de rede que precisa ser investigado.