Analisando o Tráfego de Rede de Malware

Quando Usar

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

Não use para análise baseada em host do comportamento de malware; use relatórios de 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 conjuntos de 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

Etapa 1: Visão Geral Inicial do PCAP

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

# Capture statistics
capinfos malware.pcap

# Protocol hierarchy
tshark -r malware.pcap -q -z io,phs

# Endpoint statistics (top talkers)
tshark -r malware.pcap -q -z endpoints,ip

# Conversation statistics
tshark -r malware.pcap -q -z conv,tcp

# DNS query summary
tshark -r malware.pcap -q -z dns,tree

Etapa 2: Analisar Atividade DNS

Examine as consultas DNS para DGA, tunneling ou resolução de domínio C2:

# Extract all DNS queries
tshark -r malware.pcap -T fields -e frame.time -e dns.qry.name -e dns.a \
  -Y "dns.flags.response == 1" | sort

# Detect DGA patterns (high entropy domain names)
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)

# Parse DNS queries from tshark output
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("Suspicious DNS queries (high entropy):")
for domain in domains:
    if domain:
        subdomain = domain.split('.')[0]
        ent = entropy(subdomain)
        if ent > 3.5 and len(subdomain) > 10:
            print(f"  {domain} (entropy: {ent:.2f})")
PYEOF

# Detect DNS tunneling (large TXT responses)
tshark -r malware.pcap -T fields -e dns.qry.name -e dns.txt \
  -Y "dns.resp.type == 16 and dns.resp.len > 100"

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

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

# Extract HTTP requests
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"

# Extract HTTP response bodies (potential payload downloads)
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"

# Extract POST data (potential exfiltration)
tshark -r malware.pcap -T fields \
  -e http.host -e http.request.uri -e http.file_data \
  -Y "http.request.method == POST"

# TLS analysis (SNI, JA3 fingerprints)
tshark -r malware.pcap -T fields \
  -e tls.handshake.extensions_server_name \
  -e tls.handshake.ja3 \
  -Y "tls.handshake.type == 1"

# Extract TLS certificate details
tshark -r malware.pcap -T fields \
  -e x509ce.dNSName -e x509af.serialNumber \
  -e x509sat.utf8String \
  -Y "tls.handshake.type == 11"

# Export HTTP objects (downloaded files)
tshark -r malware.pcap --export-objects http,exported_files/

Etapa 4: Detectar Padrões de Beaconing

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

# Análise de beaconing a partir de PCAP
from scapy.all import rdpcap, IP, TCP
from collections import defaultdict
import statistics

packets = rdpcap("malware.pcap")

# Agrupar conexões por IP de destino:porta
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 Beaconing:")
for dst, times in connections.items():
    if len(times) >= 5:

…