análise-de-comunicação-command-and-control

Análise de Comunicação Command-and-Control

Quando Usar

• Engenharia reversa de uma amostra de malware revelou comunicação de rede que precisa de análise de protocolo
• Construção de assinaturas de detecção em nível de rede para um framework C2 específico (Cobalt Strike, Metasploit, Sliver)
• Mapeamento de infraestrutura C2 incluindo servidores primários, domínios de fallback e dead drops
• Análise de tráfego C2 criptografado ou codificado para entender o conjunto de comandos e o formato dos dados
• Atribuição de malware a um ator de ameaça com base em padrões de infraestrutura C2 e ferramentas

Não use para detecção geral de anomalias de rede; isso é especificamente para entender protocolos C2 conhecidos ou suspeitos a partir da análise de malware.

Pré-requisitos

• Captura PCAP do tráfego de rede do malware (de sandbox, espelho de rede ou captura completa de pacotes)
• Wireshark/tshark para análise em nível de pacote
• Ferramentas de engenharia reversa (Ghidra, dnSpy) para entender o código C2 no binário do malware
• Python 3.8+ com scapy, dpkt e requests para análise e reprodução de protocolo
• Bases de dados de inteligência de ameaças para correlação de infraestrutura C2 (VirusTotal, Shodan, Censys)
• Bancos de dados de impressões digitais JA3/JA3S para identificação de C2 baseado em TLS

Fluxo de Trabalho

Passo 1: Identificar o Canal C2

Determine o protocolo e o transporte usados para a comunicação C2:

Canais de Comunicação C2:
━━━━━━━━━━━━━━━━━━━━━━━━━
HTTP/HTTPS:     Mais comum; usa tráfego web padrão para se misturar
                Indicadores: Requisições POST/GET regulares, padrões de URI específicos, cabeçalhos personalizados

DNS:            Tunelamento de dados através de consultas e respostas DNS
                Indicadores: Consultas TXT de alto volume, nomes de subdomínio longos, alta entropia

TCP/UDP Personalizado: Protocolo binário proprietário em porta não padrão
                Indicadores: Tráfego não-HTTP em portas altas, protocolo desconhecido

ICMP:           Dados codificados em payloads de echo/reply ICMP
                Indicadores: Pacotes ICMP com payloads grandes ou não padrão

WebSocket:      Conexão bidirecional persistente para C2 em tempo real
                Indicadores: Upgrade WebSocket seguido por frames binários

Serviços Cloud: Usando APIs legítimas (Telegram, Discord, Slack, GitHub)
                Indicadores: Chamadas de API para serviços cloud a partir de processos inesperados

Email:          SMTP/IMAP para comandos C2 e exfiltração de dados
                Indicadores: Operações automatizadas de email a partir de processos não relacionados a email

Passo 2: Analisar o Padrão de Beacon

Caracterize o padrão de comunicação periódico:

from scapy.all import rdpcap, IP, TCP
from collections import defaultdict
import statistics
import json

packets = rdpcap("c2_traffic.pcap")

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

# Analisar cada destino para beaconing
for dst, times in sorted(connections.items()):
    if len(times) < 3:
        continue

    intervals = [times[i+1] - times[i] for i in range(len(times)-1)]
    avg_interval = statistics.mean(intervals)
    stdev = statistics.stdev(intervals) if len(intervals) > 1 else 0
    jitter_pct = (stdev / avg_interval * 100) if avg_interval > 0 else 0
    duration = times[-1] - times[0]

    beacon_data = {
        "destination": dst,
        "connections": len(times),
        "duration_seconds": round(duration, 1),
        "avg_interval_seconds": round(avg_interval, 1),
        "stdev_seconds": round(stdev, 1),
        "jitter_percent": round(jitter_pct, 1),
        "is_beacon": 5 < avg_interval < 7200 and jitter_pct < 25,
    }

    if beacon_data["is_beacon"]:
        print(f"[!] BEACON DETECTADO: {dst}")
        print(f"    Intervalo: {avg_interval:.0f}s +/- {stdev:.0f}s ({jitter_pct:.0f}% jitter)")
        print(f"    Sessões: {len(times)} em {duration:.0f}s")

Passo 3: Decodificar a Estrutura do Protocolo C2

Faça engenharia reversa do formato da mensagem a partir do tráfego capturado:

# Análise de protocolo C2 baseado em HTTP
import dpkt
import base64

with open("c2_traffic.pcap", "rb") as f:
    pcap = dpkt.pcap.Reader(f)

for ts, buf in pcap:
    eth = dpkt.ethernet.Ethernet(buf)
    if not isinstance(eth.data, dpkt.ip.IP):
        continue
    ip = eth.data
    if not isinstance(ip.data, dpkt.tcp.TCP):
        continue
    tcp = ip.data

    if tcp.dport == 80 or tcp.dport == 443:
        if len(tcp.data) > 0:
            try:
                http = dpkt.http.Request(tcp.data)
                print(f"\n--- REQUISIÇÃO C2 ---")
                print(f"Método: {http.method}")
                print(f"URI: {http.uri}")
                print(f"Cabeçalhos: {dict(http.headers)}")
                if http.body:
                    print(f"Corpo ({len(http.body)} bytes):")
                    # Tentar decodificar Base64
                    try:
                        decoded = base64.b64decode(http.body)
                        print(f"  Decodificado: {decoded[:200]}")
                    except:
                        print(f"  Bruto: {http.body[:200]}")
            except:
                pass

Passo 4: Identificar o Framework C2

Combine os padrões observados com frameworks C2 conhecidos:

Assinaturas de Frameworks C2 Conhecidos:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Cobalt Strike:
  - URIs padrão: /pixel, /submit.php, /___utm.gif, /ca, /dpixel
  - Perfis Malleable C2 personalizam todas as características do tráfego
  - JA3: varia por perfil, catálogo em ja3er.com
  - Watermark na configuração do beacon (único por licença)
  - Extração de configuração: usar CobaltStrikeParser ou 1768.py

Metasploit/Meterpreter:
  - Padrões de URI de staging padrão: checksum aleatório de 4 caracteres
  - Padrões do handler Reverse HTTP(S)
  - Estrutura de protocolo TLV (Type-Length-Value) do Meterpreter

Sliver:
  - Opções de transporte: mTLS, HTTP, DNS, WireGuard
  - Mensagens codificadas em Protobuf
  - ID de implante único na comunicação

Covenant:
  - Framework C2 baseado em .NET
  - HTTP com perfis personalizáveis
  - Execução de comandos baseada em tarefas

PoshC2:
  - Baseado em PowerShell/C#
  - HTTP com payloads criptografados
  - Gerenciamento de sessão baseado em cookies

# Extrair configuração do beacon Cobalt Strike de PCAP ou amostra
python3 << 'PYEOF'
# Usando CobaltStrikeParser (pip install cobalt-strike-parser)
from cobalt_strike_parser import BeaconConfig

try:
    config = BeaconConfig.from_file("suspeito.exe")
    print("Configuração do Beacon Cobalt Strike:")
    for key, value in config.items():
        print(f"  {key}: {value}")
except Exception as e:
    print(f"Não é um beacon Cobalt Strike ou erro de análise: {e}")
PYEOF

Passo 5: Mapear a Infraestrutura C2

Documente toda a infraestrutura C2 e mecanismos de failover:

# Mapeamento de infraestrutura
import requests
import json

indicators_c2 = {
    "c2_primario": "185.220.101.42",
    "dominios": ["update.malicious.com", "backup.evil.net"],
    "portas": [443, 8443],
    "dns_failover": ["ns1.malicious-dns.com"],
}

# Enriquecer com Shodan
def consulta_shodan(ip, api_key):
    resp = requests.get(f"https://api.shodan.io/shodan/host/{ip}?key={api_key}")
    if resp.status_code == 200:
        data = resp.json()
        return {
            "ip": ip,
            "portas": data.get("ports", []),
            "os": data.get("os"),
            "org": data.get("org"),
            "asn": data.get("asn"),
            "pais": data.get("country_code"),
            "hostnames": data.get("hostnames", []),
            "ultima_atualizacao": data.get("last_update"),
        }
    return None

# Enriquecer com DNS passivo
def consulta_pdns(dominio):
    # Usando DNS passivo do VirusTotal
    resp = requests.get(
        f"https://www.virustotal.com/api/v3/domains/{dominio}/resolutions",
        headers={"x-apikey": VT_API_KEY}
    )
    if resp.status_code == 200:
        data = resp.json()
        resolucoes = []
        for r in data.get("data", []):
            resolucoes.append({
                "ip": r["attributes"]["ip_address"],
                "data": r["attributes"]["date"],
            })
        return resolucoes
    return []

Passo 6: Criar Assinaturas de Detecção de Rede

Construa regras de detecção com base nas características C2 analisadas:

# Regras Suricata para o C2 analisado
cat << 'EOF' > regras_deteccao_c2.rules
# Padrão de beacon HTTP
alert http $HOME_NET any -> $EXTERNAL_NET any (
    msg:"MALWARE Beacon HTTP MalwareX C2";
    flow:established,to_server;
    http.method; content:"POST";
    http.uri; content:"/gate.php"; startswith;
    http.header; content:"User-Agent: Mozilla/5.0 (compatible; MSIE 10.0)";
    threshold:type threshold, track by_src, count 5, seconds 600;
    sid:9000010; rev:1;
)

# Correspondência de impressão digital JA3
alert tls $HOME_NET any -> $EXTERNAL_NET any (
    msg:"MALWARE Impressão Digital JA3 TLS MalwareX";
    ja3.hash; content:"a0e9f5d64349fb13191bc781f81f42e1";
    sid:9000011; rev:1;
)

# Detecção de beacon DNS (subdomínio de alta entropia)
alert dns $HOME_NET any -> any any (
    msg:"MALWARE Suspeita de Tunelamento C2 DNS";
    dns.query; pcre:"/^[a-z0-9]{20,}\./";
    threshold:type threshold, track by_src, count 10, seconds 60;
    sid:9000012; rev:1;
)

# Detecção baseada em certificado
alert tls $HOME_NET any -> $EXTERNAL_NET any (
    msg:"MALWARE Certificado C2 Autoassinado MalwareX";
    tls.cert_subject; content:"CN=update.malicious.com";
    sid:9000013; rev:1;
)
EOF

Conceitos Chave

Termo	Definição
Beaconing	Comunicação periódica de check-in do malware para o servidor C2 em intervalos regulares, muitas vezes com jitter para evitar detecção de padrão
Jitter	Randomização aplicada ao intervalo do beacon (ex.: 60s +/- 15%) para tornar o padrão de temporização menos previsível e mais difícil de detectar
Malleable C2	Recurso do Cobalt Strike que permite aos operadores personalizar todos os aspectos do tráfego C2 (URIs, cabeçalhos, codificação) para imitar serviços legítimos
Dead Drop	Localização intermediária (site de paste, armazenamento cloud, mídia social) onde comandos C2 são publicados para o malware recuperar
Domain Fronting	Usar um domínio CDN confiável no SNI TLS enquanto roteia para um backend diferente, fazendo o tráfego C2 parecer ir para um serviço legítimo
Fast Flux	Alteração rápida de registros DNS para domínios C2 para distribuir por muitos IPs e resistir a esforços de derrubada
Framework C2	Conjunto de ferramentas de software que fornece servidor C2, gerador de implante e interface do operador (Cobalt Strike, Metasploit, Sliver, Covenant)

Ferramentas e Sistemas

• Wireshark: Analisador de pacotes para análise detalhada de protocolo C2 em nível de pacote
• RITA (Real Intelligence Threat Analytics): Ferramenta de código aberto que analisa logs Zeek para detecção de beacon e tunelamento DNS
• CobaltStrikeParser: Ferramenta que extrai configuração do beacon Cobalt Strike de amostras e dumps de memória
• JA3/JA3S: Método de impressão digital TLS para identificar frameworks C2 por suas características de implementação TLS
• Shodan/Censys: Plataformas de varredura da internet para mapear infraestrutura C2 e identificar servidores relacionados

Cenários Comuns

Cenário: Engenharia Reversa de um Protocolo C2 Personalizado

Contexto: Uma amostra de malware se comunica com seu servidor C2 usando um protocolo binário desconhecido sobre a porta TCP 8443. O protocolo precisa ser decodificado para entender o conjunto de comandos e construir assinaturas de detecção.

Abordagem:

1. Filtrar o PCAP para conversas na porta TCP 8443 e extrair os streams TCP
2. Analisar as primeiras trocas para identificar o mecanismo de handshake/autenticação
3. Mapear a estrutura da mensagem (prefixo de comprimento, campo de tipo, codificação do payload)
4. Cruzar referências com a desmontagem do Ghidra das funções de envio/recebimento no malware
5. Identificar o dispatcher de comandos e documentar a função de cada código de comando
6. Construir um decodificador de protocolo em Python para análise contínua de tráfego
7. Criar regras Suricata correspondentes ao handshake do protocolo ou bytes de cabeçalho estáticos

Armadilhas:

• Assumir que o protocolo é estático; alguns frameworks C2 negociam criptografia durante o handshake
• Não capturar tráfego suficiente para ver todos os tipos de comando (alguns comandos são raros)
• Perder canais C2 de fallback (DNS, ICMP) que são ativados quando o canal primário falha
• Confundir dados de payload criptografados com a estrutura de enquadramento do protocolo

Formato de Saída

RELATÓRIO DE ANÁLISE DE COMUNICAÇÃO C2
==============================================
Amostra:          malware.exe (SHA-256: e3b0c44...)
Framework C2:     Cobalt Strike 4.9

CONFIGURAÇÃO DO BEACON
Servidor C2:      hxxps://185.220.101[.]42/updates
Tipo de Beacon:   HTTPS (reverso)
Sleep:            60 segundos
Jitter:           15%
User-Agent:       Mozilla/5.0 (Windows NT 10.0; Win64; x64)
URI (GET):        /dpixel
URI (POST):       /submit.php
Watermark:        1234567890

ANÁLISE DE PROTOCOLO
Transporte:       HTTPS (TLS 1.2)
Hash JA3:         a0e9f5d64349fb13191bc781f81f42e1
Certificado:      CN=Microsoft Update (autoassinado)
Codificação:      Base64 com chave XOR 0x69
Formato do Comando: [4B comprimento][4B id_comando][payload]

CONJUNTO DE COMANDOS
0x01 - Sleep          Alterar intervalo do beacon
0x02 - Shell          Executar comando cmd.exe
0x03 - Download       Transferir arquivo do C2
0x04 - Upload         Exfiltrar arquivo para o C2
0x05 - Inject         Injeção de processo
0x06 - Keylog         Iniciar keylogger
0x07 - Screenshot     Capturar tela

INFRAESTRUTURA
Primário:         185.220.101[.]42 (AS12345, Hosting Co, NL)
Failover:         91.215.85[.]17 (AS67890, VPS Provider, RU)
DNS:              update.malicious[.]com -> 185.220.101[.]42
Registrador:      NameCheap
Registro:         2025-09-01

ASSINATURAS DE DETECÇÃO
SID 9000010:      Padrão de beacon HTTP
SID 9000011:      Impressão digital TLS JA3
SID 9000013:      Correspondência de certificado C2