análise-de-tráfego-de-rede-de-malware

Análise de Tráfego de Rede de Malware

Quando Usar

• A execução em sandbox capturou um arquivo PCAP e o comportamento da rede precisa de análise detalhada
• Identificar a estrutura do protocolo C2 para escrever assinaturas de detecção de rede
• Determinar quais dados o malware exfiltra e para qual infraestrutura externa
• Analisar tunelamento DNS, algoritmos de geração de domínio (DGA) ou comportamento fast-flux
• Criar assinaturas Suricata/Snort com base em padrões de rede de malware observados

Não use para análise baseada em host do comportamento do malware; use relatórios da sandbox Cuckoo ou análise de memória Volatility para atividade em nível de processo.

Pré-requisitos

• Wireshark 4.x instalado para análise interativa de PCAP
• tshark (CLI do Wireshark) para extração de pacotes por script
• Zeek instalado para geração automatizada de metadados a partir de PCAPs
• Suricata com regras ET Open/ET Pro para correspondência de assinaturas
• NetworkMiner para extração de arquivos e detecção de credenciais de PCAPs
• Python 3.8+ com scapy e dpkt para análise programática de pacotes

Fluxo de Trabalho

Passo 1: Visão Geral Inicial do PCAP

Obtenha uma compreensão de alto nível do tráfego de rede:

# Estatísticas de captura
capinfos malware.pcap

# Hierarquia de protocolos
tshark -r malware.pcap -q -z io,phs

# Estatísticas de endpoints (maiores comunicadores)
tshark -r malware.pcap -q -z endpoints,ip

# Estatísticas de conversas
tshark -r malware.pcap -q -z conv,tcp

# Resumo de consultas DNS
tshark -r malware.pcap -q -z dns,tree

Passo 2: Analisar Atividade DNS

Examine consultas DNS para detectar DGA, tunelamento ou resolução de domínios C2:

# Extrair todas as consultas DNS
tshark -r malware.pcap -T fields -e frame.time -e dns.qry.name -e dns.a \
  -Y "dns.flags.response == 1" | sort

# Detectar padrões DGA (nomes de domínio com alta entropia)
python3 << 'PYEOF'
import math
from collections import Counter

def entropy(s):
    p = [n/len(s) for n in Counter(s).values()]
    return -sum(pi * math.log2(pi) for pi in p if pi > 0)

# Analisar consultas DNS a partir da saída do tshark
import subprocess
result = subprocess.run(
    ["tshark", "-r", "malware.pcap", "-T", "fields", "-e", "dns.qry.name",
     "-Y", "dns.flags.response == 0"],
    capture_output=True, text=True
)

domains = set(result.stdout.strip().split('\n'))
print("Consultas DNS suspeitas (alta entropia):")
for domain in domains:
    if domain:
        subdomain = domain.split('.')[0]
        ent = entropy(subdomain)
        if ent > 3.5 and len(subdomain) > 10:
            print(f"  {domain} (entropia: {ent:.2f})")
PYEOF

# Detectar tunelamento DNS (respostas TXT grandes)
tshark -r malware.pcap -T fields -e dns.qry.name -e dns.txt \
  -Y "dns.resp.type == 16 and dns.resp.len > 100"

Passo 3: Analisar Comunicação C2 HTTP/HTTPS

Examine o tráfego de comando e controle baseado na web:

# Extrair requisições HTTP
tshark -r malware.pcap -T fields \
  -e frame.time -e ip.src -e ip.dst -e http.host \
  -e http.request.method -e http.request.uri -e http.user_agent \
  -Y "http.request"

# Extrair corpos de respostas HTTP (possíveis downloads de payload)
tshark -r malware.pcap -T fields \
  -e http.host -e http.request.uri -e http.content_type -e tcp.len \
  -Y "http.response and tcp.len > 1000"

# Extrair dados POST (possível exfiltração)
tshark -r malware.pcap -T fields \
  -e http.host -e http.request.uri -e http.file_data \
  -Y "http.request.method == POST"

# Análise TLS (SNI, impressões digitais JA3)
tshark -r malware.pcap -T fields \
  -e tls.handshake.extensions_server_name \
  -e tls.handshake.ja3 \
  -Y "tls.handshake.type == 1"

# Extrair detalhes do certificado TLS
tshark -r malware.pcap -T fields \
  -e x509ce.dNSName -e x509af.serialNumber \
  -e x509sat.utf8String \
  -Y "tls.handshake.type == 11"

# Exportar objetos HTTP (arquivos baixados)
tshark -r malware.pcap --export-objects http,exported_files/

Passo 4: Detectar Padrões de Beaconing

Identifique comunicação periódica regular indicando beaconing C2:

# Detecção de beacon a partir do PCAP
from scapy.all import rdpcap, IP, TCP
from collections import defaultdict
import statistics

packets = rdpcap("malware.pcap")

# Agrupar conexões por IP:porta de destino
connections = defaultdict(list)
for pkt in packets:
    if IP in pkt and TCP in pkt:
        if pkt[TCP].flags & 0x02:  # Flag SYN
            dst = f"{pkt[IP].dst}:{pkt[TCP].dport}"
            connections[dst].append(float(pkt.time))

# Analisar intervalos de tempo para beaconing
print("Análise de Beacon:")
for dst, times in connections.items():
    if len(times) >= 5:
        intervals = [times[i+1] - times[i] for i in range(len(times)-1)]
        avg = statistics.mean(intervals)
        stdev = statistics.stdev(intervals) if len(intervals) > 1 else 0
        jitter = (stdev / avg * 100) if avg > 0 else 0

        if 10 < avg < 3600 and jitter < 30:  # Intervalo regular com < 30% de jitter
            print(f"  [!] {dst}: {len(times)} conexões")
            print(f"      Intervalo: {avg:.1f}s ± {stdev:.1f}s (jitter: {jitter:.1f}%)")
            print(f"      Padrão: PROVÁVEL BEACONING")

Passo 5: Gerar Assinaturas de Detecção de Rede

Crie regras Suricata/Snort a partir de padrões de tráfego observados:

# Executar Suricata contra o PCAP para correspondências de assinaturas existentes
suricata -r malware.pcap -l suricata_output/ -c /etc/suricata/suricata.yaml

# Revisar alertas
cat suricata_output/fast.log

# Criar regra Suricata personalizada a partir de padrões observados
cat << 'EOF' > custom_malware.rules
# Detecção de beacon C2 com base no padrão de URI observado
alert http $HOME_NET any -> $EXTERNAL_NET any (
    msg:"MALWARE MalwareX C2 Beacon";
    flow:established,to_server;
    http.method; content:"POST";
    http.uri; content:"/gate.php?id=";
    http.user_agent; content:"Mozilla/5.0 (compatible; MSIE 10.0)";
    sid:9000001; rev:1;
)

# Consulta DNS para domínio C2 conhecido
alert dns $HOME_NET any -> any any (
    msg:"MALWARE MalwareX C2 DNS Query";
    dns.query; content:"update.malicious.com";
    sid:9000002; rev:1;
)

# Correspondência de hash JA3 para cliente TLS de malware
alert tls $HOME_NET any -> $EXTERNAL_NET any (
    msg:"MALWARE MalwareX JA3 Match";
    ja3.hash; content:"a0e9f5d64349fb13191bc781f81f42e1";
    sid:9000003; rev:1;
)
EOF

Passo 6: Extrair Arquivos e Artefatos do Tráfego

Recupere arquivos transferidos e dados incorporados:

# Extrair arquivos usando Zeek
zeek -r malware.pcap /opt/zeek/share/zeek/policy/frameworks/files/extract-all-files.zeek
ls extract_files/

# Extrair arquivos usando NetworkMiner (GUI)
# Ou usar tshark para exportações de protocolo específicas
tshark -r malware.pcap --export-objects http,http_objects/
tshark -r malware.pcap --export-objects smb,smb_objects/
tshark -r malware.pcap --export-objects tftp,tftp_objects/

# Gerar hashes de todos os arquivos extraídos
sha256sum http_objects/* smb_objects/* 2>/dev/null

# Gerar logs do Zeek para metadados abrangentes
zeek -r malware.pcap
# Saída: conn.log, dns.log, http.log, ssl.log, files.log, etc.

Conceitos Chave

Termo	Definição
Beaconing	Conexões periódicas regulares de malware para servidor C2, identificáveis por intervalos de tempo e tamanhos de pacotes consistentes
JA3/JA3S	Método de impressão digital TLS que cria um hash a partir dos parâmetros ClientHello/ServerHello para identificar exclusivamente implementações TLS de malware
DGA (Algoritmo de Geração de Domínio)	Algoritmo que gera nomes de domínio pseudoaleatórios que o malware consulta para localizar servidores C2, evitando listas de bloqueio de domínios estáticas
Tunelamento DNS	Codificação de dados em consultas e respostas DNS para estabelecer um canal C2 ou exfiltrar dados através da infraestrutura DNS
Fast Flux	Técnica DNS que rotaciona rapidamente endereços IP para um domínio para evitar derrubada e distribuir C2 por muitos hosts comprometidos
SNI (Indicação de Nome do Servidor)	Extensão TLS que revela o nome do host ao qual o cliente está se conectando; visível mesmo em conexões HTTPS criptografadas
Assinatura de Rede	Regra Suricata/Snort que corresponde a padrões específicos no tráfego de rede (cabeçalhos, payloads, temporização) para detectar comunicações maliciosas

Ferramentas e Sistemas

• Wireshark: Analisador de pacotes de código aberto para inspeção interativa aprofundada do tráfego de rede no nível do protocolo
• Zeek: Framework de análise de rede que gera logs de metadados estruturados (conn, dns, http, ssl) a partir de tráfego ao vivo ou capturado
• Suricata: IDS/IPS de rede de alto desempenho para detecção baseada em assinatura com scripts Lua para lógica de detecção personalizada
• NetworkMiner: Ferramenta de análise forense de rede para extrair arquivos, imagens e credenciais de arquivos PCAP
• Scapy: Biblioteca de manipulação de pacotes Python para análise programática de pacotes, detecção de beacon e decodificação de protocolos

Cenários Comuns

Cenário: Decodificando um Protocolo C2 Binário Personalizado

Contexto: Malware se comunica com seu servidor C2 usando um protocolo binário personalizado sobre a porta TCP 8443. A análise HTTP padrão não produz resultados. A estrutura do protocolo precisa ser engenheirada reversamente a partir do PCAP.

Abordagem:

1. Filtrar o PCAP para conversas na porta TCP 8443 e seguir o fluxo TCP
2. Identificar o enquadramento da mensagem (prefixo de comprimento, delimitador, cabeçalhos de tamanho fixo)
3. Comparar múltiplas mensagens para identificar campos de cabeçalho estáticos vs. campos de dados variáveis
4. Cruzar referências com descobertas de engenharia reversa do Ghidra (se o binário foi analisado)
5. Escrever um dissecador Wireshark ou analisador Scapy para o protocolo personalizado
6. Criar regras Suricata correspondentes aos bytes do cabeçalho estático para detecção de rede
7. Documentar a especificação completa do protocolo para compartilhamento de inteligência de ameaças

Armadilhas:

• Analisar apenas os primeiros pacotes; alguns protocolos C2 mudam de comportamento após o handshake inicial
• Não descriptografar o tráfego TLS quando a sandbox tem capacidades MITM
• Confundir tráfego legítimo de CDN ou nuvem com C2 (validar IPs de destino)
• Perder tráfego C2 que usa DNS ou ICMP em vez de TCP/UDP

Formato de Saída

ANÁLISE DE TRÁFEGO DE REDE DE MALWARE
============================================
Arquivo PCAP:        malware_sandbox.pcap
Duração:             300 segundos
Total de Pacotes:    12.847
Total de Bytes:      4.2 MB

ATIVIDADE DNS
Total de Consultas:     47
DGA Detectado:          Sim (23 consultas de alta entropia para TLD .com)
Tunelamento:            Não
C2 Resolvido:           update.malicious[.]com -> 185.220.101[.]42

COMUNICAÇÃO C2
Protocolo:              HTTPS (TLS 1.2)
Servidor:               185.220.101[.]42:443
SNI:                    update.malicious[.]com
Hash JA3:               a0e9f5d64349fb13191bc781f81f42e1
Intervalo de Beacon:    60.2s ± 6.8s (11.3% de jitter)
Total de Sessões:       237
Dados Enviados:         147 MB
Dados Recebidos:        2.3 MB
Certificado:            CN=update.malicious[.]com (autoassinado, expirado)

DOWLOADS DE PAYLOAD
GET /payload.dll de compromised-site[.]com
  Tamanho: 98.304 bytes
  SHA-256: abc123def456...
  Content-Type: application/octet-stream

EXFILTRAÇÃO
Método:           HTTPS POST para /gate.php
Content-Type:     application/octet-stream
Tamanho Médio:    15.432 bytes por requisição
Volume Total:     147 MB em 4 horas

ALERTAS SURICATA
[1:2028401] ET MALWARE Padrão Genérico de Beacon C2
[1:2028500] ET POLICY Certificado Autoassinado

ASSINATURAS GERADAS
SID 9000001: Padrão de beacon HTTP MalwareX
SID 9000002: Domínio C2 DNS MalwareX
SID 9000003: Impressão digital TLS JA3 MalwareX