Lidando com PCAPs gigantes: do script lento ao processamento eficiente com Tshark, Editcap e Zeek

Quem analisa tráfego de rede ou investiga incidentes de segurança conhece a dor de cabeça clássica: abrir um arquivo .pcap com vários gigabytes e ver o computador congelar.

A tentação inicial de muita gente é escrever um script rápido para ler os pacotes, extrair campos e salvar em CSV. Quando o tamanho do arquivo cresce, no entanto, o script consome toda a memória RAM, arrasta a máquina e parece que nunca vai terminar.

Abaixo, compartilho os gargalos dessas abordagens e as ferramentas nativas mais eficientes para extrair dados sem sofrimento.

1. O gargalo das abordagens puras em Python (scapy)#

Bibliotecas como o Scapy são excelentes para manipular pacotes individualmente e prototipar ferramentas. Porém, elas não foram projetadas para fazer parsing de arquivos com gigabytes de dados.

Ao tentar processar um arquivo volumoso em Python puro:

• O consumo de memória RAM dispara porque a biblioteca tenta manter estruturas complexas em memória.
• O interpretador pesa na CPU para decodificar cada camada de rede, transformando uma conversão simples em um processo que leva horas.

Quando preciso de velocidade no terminal, o caminho mais inteligente é usar ferramentas compiladas em C.

2. A regra de ouro: Tshark para extração direta em CSV#

A melhor alternativa para converter arquivos .pcap em tabelas estruturadas de forma ultrarrápida é o Tshark, a interface de linha de comando oficial do Wireshark.

Por ser escrito em C, o ganho de velocidade e economia de memória em relação a scripts interpretados é enorme. O comando padrão para gerar um CSV limpo:

tshark -r trafego.pcap -T fields \
  -e frame.number \
  -e ip.src \
  -e ip.dst \
  -e _ws.col.Protocol \
  -e frame.len \
  -E header=y -E separator=, -E quote=d > resultado.csv

Dica de ouro: Especifique apenas os campos (-e) estritamente necessários para o que você vai analisar. Quanto menos campos o Tshark precisar extrair e formatar, mais rápida será a execução.

3. Arquivos massivos na casa dos gigabytes: dividir para conquistar#

Mesmo com o Tshark, tentar ler um único arquivo gigantesco pode esbarrar em gargalos de leitura de disco ou travar a CPU em uma única thread.

A melhor saída é fatiar o arquivo antes de processar usando o Editcap (que já vem instalado junto com o pacote do Wireshark/Tshark):

# Divide o pcap original em pedaços de 100.000 pacotes cada
editcap -c 100000 entrada.pcap pequeno.pcap

Com o arquivo dividido em blocos menores, você pode processar todos os pedaços em paralelo aproveitando todos os núcleos da CPU via xargs. Como o Tshark lê dados em streaming e não carrega o arquivo inteiro na RAM, a divisão serve justamente para distribuir a decodificação entre múltiplos núcleos:

# 1. Converte cada pedaço em um CSV próprio em paralelo (4 threads simultâneas)
ls pequeno_*.pcap | xargs -P 4 -I {} sh -c 'tshark -r "{}" -T fields -E header=n -E separator=, -e ip.src -e ip.dst > "{}.csv"'

# 2. Une todos os pedaços em um único CSV com cabeçalho limpo
echo "ip.src,ip.dst" > dados_unificados.csv
cat pequeno_*.pcap.csv >> dados_unificados.csv
rm -f pequeno_*.pcap.csv

4. Alternativas de alto desempenho: Zeek e arkime#

Se o seu objetivo for além de uma simples tabela estática e envolver monitoramento e consultas frequentes, ficar convertendo .pcap para CSV deixa de fazer sentido:

• Zeek (antigo Bro): Em vez de despejar pacotes brutos, o Zeek analisa o tráfego e gera logs de eventos especializados e muito mais leves (conn.log, http.log, dns.log). Esses arquivos de texto são perfeitos para buscas rápidas com grep, awk ou envio para um SIEM.
• Arkime (antigo Moloch): Ideal para buscas visuais e análises profundas em terabytes de tráfego. Ele indexa os metadados dos pacotes no OpenSearch (ex-Elasticsearch), permitindo filtrar conexões e extrair fluxos em segundos via interface web ou API.

Resumo prático da estratégia#

• Arquivos médios (centenas de MB): Use o tshark com campos delimitados para gerar CSVs rápidos sem overhead.
• Arquivos gigantes (vários GB): Fatie com o editcap -c e converta em paralelo usando múltiplos núcleos.
• Análise contínua e investigações profundas: Migre o fluxo para logs estruturados com o Zeek ou indexação em larga escala com o Arkime.

Conclusão#

Neste artigo compartilhei a escada que uso para PCAPs grandes: tshark com campos mínimos para CSVs rápidos, editcap -c com paralelismo por pedaço para arquivos gigantes, e Zeek ou Arkime quando a análise vira rotina — sempre priorizando ferramentas nativas em C em vez de scripts interpretados.

Veja também

Cibersegurança Troubleshooting real: do crash status 255 no Fail2ban ao backend systemd e modularização no Nginx

Cibersegurança Anatomia de um incidente: mitigando ataques L7 simultâneos, dos no Dovecot e gargalos de CPU

Cibersegurança Análise forense de um comprometimento no CloudLinux e cPanel: da armadilha do sshd_config à persistência no PAM e IPMI

Este post está licenciado sob CC BY-NC.