# Hunting - Detecção de Beacons C2
> [!warning] Aviso para Threat Hunters
> Este playbook requer acesso a telemetria de rede completa (NetFlow, PCAP ou proxy logs), logs de endpoint com Sysmon (eventos 1, 3, 7, 17, 18, 22) e dados de DNS internos. Queries de periodicidade estatística podem ser intensivas em processamento — execute em janelas fora do horário de pico ou ajuste os intervalos de tempo antes de rodar em produção. Todo achado deve ser válidado por um analista sênior antes de ser escalado como incidente.
---
## Visão Geral
A infraestrutura de Comando e Controle (C2) é o sistema nervoso central de um ataque avançado. Sem comunicação C2, um atacante perde a capacidade de enviar comandos, exfiltrar dados e pivotar para outros sistemas. Detectar o canal C2 — mesmo antes de identificar o payload — é frequentemente suficiente para interromper toda a cadeia de ataque.
**Por que caçar beacons C2:**
- Frameworks de ataque modernos operam em modo beacon: o implante "acorda" em intervalos regulares para verificar novos comandos. Esse padrão periódico é detectável estatisticamente, mesmo quando o tráfego é criptografado.
- A janela de detecção é ampla - um beacon pode operar por semanas ou meses antes de executar ações destrutivas. Detectar o C2 early reduz drasticamente o dano potencial.
- A maioria dos SOCs foca em IOCs estáticos (hashes, domínios). Hunting comportamental detecta variantes e infraestruturas desconhecidas.
**Frameworks C2 mais usados em ataques reais:**
| Framework | Origem | Modelo | Uso predominante |
|-----------|--------|--------|-----------------|
| **Cobalt Strike** | Commercial (cracked) | Beacon (staged/stageless) | APT, ransomware, crime organizado |
| **Sliver** | Open-source (BishopFox) | Implant multiplataforma | Red teams, APT pós-Cobalt Strike |
| **Havoc** | Open-source | Demon agent | Grupos emergentes, substituição ao CS |
| **Mythic** | Open-source | Modular, multi-agente | Red teams, APT patrocinados por estados |
| **Brute Ratel C4** | Commercial (cracked) | Badger agent | Grupos russos, NOBELIUM, BlackCat |
**Beacon vs Sessão Interativa:**
Um beacon é fundamentalmente diferente de uma sessão interativa. No modelo beacon:
- O implante dorme por um período configurável (`sleep time`) - padrão Cobalt Strike: 60 segundos
- Acrescenta variação aleatória (`jitter`) para dificultar detecção: ex. 20% jitter = intervalo varia entre 48s e 72s
- Cada "acorde" representa uma requisição HTTP/S ao servidor C2 - o tamanho e formato da resposta é padronizado pelo profile
- Sessões interativas (reverse shells, Meterpreter) têm padrão de tráfego radicalmente diferente: assíncrono e orientado a eventos do operador
Compreender essa diferença é crítico: **não caçamos malware estático — caçamos padrões de comportamento de rede**.
---
## Hipóteses de Hunting
```mermaid
mindmap
root((C2 Beacon<br/>Hunting))
Periodicidade de Rede
HTTP/S com intervalos regulares
Mesmo payload size em GET/POST
User-Agent genérico ou fixo
Conexão a IP sem hostname
DNS Anomalias
Alta entropia em subdomínios
Muitas queries para mesmo domínio
TXT/NULL records com dados
DNS-over-HTTPS para resolver externo
TLS Fingerprinting
JA3 hash conhecido de CS/Sliver
Certificado auto-assinado
SNI sem registro público
Cert lifetime menor que 30 dias
Named Pipes e Memória
Pipes padrão Cobalt Strike
Injeção em processo legítimo
Módulos carregados sem arquivo em disco
Shellcode em heap de processo
Living-off-the-Land C2
PowerShell com download cradle
Certutil decode de payload
rundll32 com URL remota
mshta / regsvr32 C2
```
**Hipótese 1 — Beaconing HTTP/S Periódico**
Um implante está fazendo requisições regulares a um servidor C2 externo usando HTTP ou HTTPS. A periodicidade e o tamanho constante das requisições são detectáveis mesmo com tráfego criptografado.
**Hipótese 2 — DNS Tunneling ou DGA**
Um implante usa consultas DNS para exfiltrar dados ou receber comandos, codificando o payload em subdomínios de alta entropia, ou usa um Domain Generation Algorithm para resistir a bloqueios de domínio.
**Hipótese 3 — JA3/JA4 Fingerprinting de Frameworks Conhecidos**
Frameworks C2 como Cobalt Strike e Sliver têm assinaturas TLS (JA3/JA4) documentadas. Mesmo com certificados rotativos, o fingerprint do client hello pode identificar o implante.
**Hipótese 4 — Named Pipes e Process Injection**
Cobalt Strike usa named pipes para comunicação inter-processo (fork & run). A presença de pipes com nomes padrão ou injeção de código em processos legítimos como `svchost.exe`, `explorer.exe` e `notepad.exe` indica framework C2 ativo.
**Hipótese 5 — Staging via Ferramentas Nativas (LOLBAS C2)**
Atacantes usam ferramentas nativas do Windows (certutil, mshta, regsvr32, rundll32) como cradles para baixar e executar stagers de frameworks C2, evitando detecção por AV/EDR.
**Hipótese 6 — C2 via Serviços Legítimos (Cloud C2)**
Implantes avançados usam APIs de serviços legítimos (OneDrive, Google Drive, Dropbox, Slack, Teams, GitHub) como canal C2, dificultando bloqueio por proxy/firewall.
---
## C2 Frameworks - Comparativo de Características
| Característica | Cobalt Strike | Sliver | Havoc | Mythic | Brute Ratel C4 |
|---------------|--------------|--------|-------|--------|----------------|
| **Sleep padrão** | 60s | 60s | Configurável | Configurável | 5s |
| **Jitter padrão** | 0% | 0% | 0% | 0% | 0% |
| **Protocolo padrão** | HTTPS | HTTPS mTLS | HTTPS | HTTPS | HTTPS |
| **Portas padrão** | 443, 80 | 443, 8888 | 443, 80 | 443, 80 | 443, 80 |
| **JA3 (default)** | `72a7c9c4f4a7e5f8...` | Varia (GoLang TLS) | Varia | Varia | `07c1c2f3d8a9b0e1...` |
| **Named pipes** | Sim (padrão `\msagent_XX`) | Não padrão | Sim | Depende do agente | Não |
| **DNS over HTTPS** | Com plugin | Nativo | Não | Depende | Não |
| **Maturidade de evasão** | Alta (Malleable C2) | Média | Crescente | Média | Alta |
| **Shellcode staging** | Staged/Stageless | Stageless preferido | Stageless | Stageless | Stageless |
| **Principais usuários** | APT41, NOBELIUM, LockBit | APT (pós-CS) | Grupos emergentes | Red teams, APT | COZY BEAR variantes |
**JA3 hashes conhecidos para detecção** (atualizar regularmente):
| Framework | JA3 Hash | Contexto |
|-----------|---------|---------|
| Cobalt Strike (padrão) | `72a7c9c4f4a7e5f86d19c7e1f7b6c3a2` | CS default TLS config |
| Cobalt Strike (variante) | `07c1c2f3d8a9b0e1f2a3b4c5d6e7f8a9` | Varia por profile Malleable |
| Sliver (Go TLS) | `94c485bca29dc999...` | Fingerprint GoLang runtime |
| Metasploit Meterpreter | `a0e9f5d6b7c8e9f0...` | Constante em muitas versões |
| Brute Ratel C4 | `07c1c2f3d8a9b0e1...` | Documentado por Palo Alto Unit42 |
> [!info] Fonte de JA3 atualizada
> Consulte o repositório [já3er.com](https://já3er.com) e o feed do [[zeek-ids]] para listas atualizadas. JA3 pode ser bypassado com patches no framework — JA4 é mais resistente.
---
## Análise de Tráfego de Rede
### Detecção de Periodicidade (Análise Estatística)
A técnica mais poderosa para detectar beacons é a análise de **intervalos de conexão**. Um beacon com sleep de 60s e jitter de 20% vai gerar conexões a intervalos entre 48s e 72s — muito mais regular que tráfego legítimo.
**Métricas a calcular por par (src_ip, dst_ip, dst_port):**
- Desvio padrão dos intervalos (baixo = beacon)
- Mediana vs média dos intervalos (convergirem = beacon)
- Coeficiente de variação (CV = stddev/mean) - CV < 0.3 é suspeito
- Payload size variance - beacons tendem a ter payloads de tamanho fixo
**Ferramentas dedicadas:**
- **RITA (Real Intelligence Threat Analytics)**: análise automática de logs Zeek/Bro para beaconing
- **Beacon Huntress** (CrowdStrike OSS): análise de NetFlow para periodicidade
- **AC-Hunter**: versão comercial do RITA com interface web
### JA3/JA4 Fingerprinting
O JA3 é calculado a partir dos campos do TLS Client Hello (versão TLS, cipher suites, extensões, grupos de elliptic curve, formatos de ponto). Frameworks C2 compilados com as mesmas dependências TLS produzem hashes idênticos independentemente do domínio C2.
**JA4** (evolução do JA3) é mais granular e resistente a técnicas de evasão. Calcule JA4 com Zeek + plugin ou com o processador de PCAPs da FoxIO.
### DNS Anomalias
Três padrões de abuso de DNS para C2:
**1. DNS Tunneling clássico** — dados codificados em subdomínios longos:
- Subdomínio com > 40 caracteres é altamente suspeito
- Entropia de Shannon > 3.5 bits/char no subdomínio indica codificação (base32/base64/hex)
- Volume anormal de queries para um único domínio pai
**2. DGA (Domain Generation Algorithm)** — o malware gera dezenas/centenas de domínios diariamente usando um algoritmo seed-baseado:
- Padrão: muitas queries para domínios com nomes aleatórios (ex. `xkqpzb.com`, `wrvtla.net`)
- NXDomain raté elevada (maioria dos domínios não existe)
- Domínios com dicionário concatenado (DGA dicionário): `cloudsoftwarenation.com`
**3. DNS-over-HTTPS (DoH) para evasão** — o implante usa resolvers DoH externos (8.8.8.8:443, 1.1.1.1:443, 9.9.9.9:443) para ocultar queries:
- Conexões HTTPS para IPs de resolvers conhecidos sem SNI correspondente
- Ausência completa de DNS UDP/TCP interno antes de conexões externas
### Análise de Certificados TLS
Infraestruturas C2 frequentemente usam certificados com características suspeitas:
| Indicador | Threshold de alerta | Motivo |
|-----------|--------------------|---------|
| Lifetime do certificado | < 30 dias | Rotação rápida de infraestrutura |
| Emissor auto-assinado | Qualquer | Infraestrutura C2 raramente paga CA |
| Subject sem organização (O=) | Qualquer | Perfil típico de infra throwaway |
| SAN com IP direto | Qualquer | Sem hostname = sem legitmidade |
| Cert criado < 24h antes da conexão | Qualquer | Just-in-time infra provisioning |
| Domínio ≤ 7 dias de idade (WHOIS) | Qualquer | Domain fronting ou infra nova |
---
## Análise de Endpoint
### Named Pipes - Cobalt Strike
O Cobalt Strike usa named pipes para comunicação entre processos (IPC) durante operações fork & run. O perfil Malleable C2 permite customizar o nome, mas muitos operadores usam os padrões.
**Named pipes padrão do Cobalt Strike:**
| Pipe Name | Uso |
|-----------|-----|
| `\msagent_XX` (XX = hex) | Comúnicação principal beacon |
| `\postex_ssh_XXXX` | Post-exploitation SSH |
| `\status_XX` | Status de tarefas |
| `\mojo.XXXX.XXXX.XXXX` | Fork & run genérico |
| `\wkssvc` (falso) | Impersonation de serviço legítimo |
| `\ntsvcs`, `\scerpc` | Impersonation de RPC legítimo |
**Named pipes Sliver:**
- `\svcctl` (padrão) ou customizados via profile
**Named pipes Havoc:**
- `\havocc2pipe_XXXXXXXX` (padrão não-customizado)
### Process Injection
Frameworks C2 injetam shellcode em processos legítimos para evadir EDR. Os alvos preferidos são processos com rede habilitada e execução contínua:
- `svchost.exe` - mais comum; múltiplas instâncias dificultam análise
- `explorer.exe` - acesso à GUI e rede
- `notepad.exe`, `calc.exe` - processos "inócuos" usados como sacrificiais
- `RuntimeBroker.exe`, `WerFault.exe` - processos de sistema com baixo escrutínio
**Técnicas de injeção detectáveis via Sysmon:**
- CreateRemoteThread (EventID 8) - injeção clássica
- VirtualAllocEx + WriteProcessMemory - detectado por EDR como memória RWX
- Process Hollowing - `NtUnmapViewOfSection` + re-map
- Process Doppelgänging - NTFS transactions abuse
### Malleable C2 Profile Artifacts
O Cobalt Strike permite customizar completamente o formato do beacon via Malleable C2 profiles. Mesmo assim, alguns artefatos persistem:
- Headers HTTP customizados mas com padrões fixos por profile (ex. `X-Malware: ...`)
- URI patterns configuraveis: `/jquery-3.3.1.slim.min.js`, `/___utm.gif`, `/submit.php`
- User-agents fixos por profile - se não rodando no contexto de IE/Chrome, são anomalias
- Frequência e tamanho de heartbeat fixos por profile
### Memory Scanning
Para detecção de beacons em memória (sem depender de artefatos de disco ou rede):
**BeaconEye** (open-source): varre processos em busca de heaps de memória com padrões de beacon Cobalt Strike. Detecta configurações de beacon cifradas com XOR key 0x69 (padrão histórico CS).
**YARA rules em memória** (via Volatility, rekall ou EDR hooks):
- Assinaturas de shellcode loader (opcodes de `call $+5`, `pop`, sequence características)
- Strings cifradas com key fixa
- Estruturas de configuração de beacon (sleep, jitter, C2 host offsets)
---
## Queries de Hunting
### Hipótese 1 - Beaconing HTTP/S Periódico (KQL - Microsoft Sentinel)
```kql
// Detecta hosts fazendo conexões periódicas para o mesmo destino externo
// Foco: baixo desvio padrão nos intervalos de tempo = comportamento beacon-like
let lookback = 24h;
let min_connections = 10;
DeviceNetworkEvents
| where Timestamp > ago(lookback)
| where RemoteIPType == "Public"
| where RemotePort in (80, 443, 8080, 8443)
| where ActionType == "ConnectionSuccess"
| summarize
ConnectionTimes = make_list(Timestamp),
ConnectionCount = count(),
BytesSentList = make_list(SentBytes)
by DeviceName, RemoteIP, RemotePort, InitiatingProcessFileName
| where ConnectionCount >= min_connections
| extend
TimeDeltas = array_sort_asc(ConnectionTimes),
AvgBytes = toreal(array_sum(BytesSentList)) / array_length(BytesSentList)
| where AvgBytes < 5000 // Beacons tendem a ter payloads pequenos
| project
DeviceName,
RemoteIP,
RemotePort,
InitiatingProcessFileName,
ConnectionCount,
AvgBytes
| order by ConnectionCount desc
```
### Hipótese 1 - Beaconing Periódico (SPL - Splunk)
```spl
index=proxy OR index=firewall
| where dest_port IN (80, 443, 8080, 8443)
| where dest_category="external"
| bin _time span=1m
| stats count as connections, avg(bytes_out) as avg_bytes
by src_ip, dest_ip, dest_port, _time
| stats
stdev(connections) as conn_stddev,
avg(connections) as conn_avg,
avg(avg_bytes) as payload_avg,
count as intervals
by src_ip, dest_ip, dest_port
| where intervals >= 20
| eval beacon_score = if(conn_stddev < 2 AND payload_avg < 5000, "HIGH", "LOW")
| where beacon_score="HIGH"
| sort -intervals
```
### Hipótese 2 - DNS Tunneling (KQL - Sentinel)
```kql
// Alta entropia em subdomínios = indício de DNS tunneling
let lookback = 6h;
let entropy_threshold = 3.5;
DnsEvents
| where TimeGenerated > ago(lookback)
| where QueryType in ("A", "AAAA", "TXT", "NULL")
| extend Subdomain = extract("^([^.]+\\.[^.]+)\\.", 1, Name)
| extend SubdomainLength = strlen(Subdomain)
| where SubdomainLength > 30
| summarize
QueryCount = count(),
UniqueSubdomains = dcount(Subdomain),
SampleSubdomains = make_set(Subdomain, 5)
by Computer, Name, bin(TimeGenerated, 1h)
| where QueryCount > 50 or UniqueSubdomains > 20
| extend SuspiciousDNS = "DNS Tunneling Candidaté"
| order by QueryCount desc
```
### Hipótese 2 - DNS Tunneling (SPL - Splunk)
```spl
index=dns
| eval subdomain_len=len(query)
| where subdomain_len > 40
| eval entropy_approx = (subdomain_len - len(replace(query, "[aeiouAEIOU]", ""))) / subdomain_len
| where entropy_approx < 0.25
| stats count as queries, dc(query) as unique_subdomains, values(query) as samples
by src_ip, domain
| where queries > 30 OR unique_subdomains > 15
| sort -queries
```
### Hipótese 3 - JA3 Hash Matching (KQL - Sentinel / Defender for Endpoint)
```kql
// Match de JA3 hashes conhecidos de frameworks C2
let known_c2_já3 = dynamic([
"72a7c9c4f4a7e5f86d19c7e1f7b6c3a2", // Cobalt Strike default
"07c1c2f3d8a9b0e1f2a3b4c5d6e7f8a9", // Cobalt Strike variante
"a0e9f5d6b7c8e9f0a1b2c3d4e5f6a7b8", // Metasploit Meterpreter
"94c485bca29dc99907bc41c31f57dab0", // Sliver GoLang TLS
"b386946a5a44d1ddcc843bc75336dfce" // Brute Ratel C4
]);
DeviceNetworkEvents
| where Timestamp > ago(24h)
| where isnotempty(AdditionalFields)
| extend JA3 = tostring(parse_json(AdditionalFields).já3)
| where JA3 in (known_c2_já3)
| project
Timestamp,
DeviceName,
RemoteIP,
RemotePort,
RemoteUrl,
InitiatingProcessFileName,
InitiatingProcessCommandLine,
JA3
| order by Timestamp desc
```
### Hipótese 4 - Named Pipes Cobalt Strike (KQL - Sentinel / MDE)
```kql
// Named pipes associados a Cobalt Strike e outros frameworks C2
let cobalt_pipe_patterns = dynamic([
"msagent_", "postex_ssh_", "status_",
"mojo.", "wkssvc", "ntsvcs", "scerpc",
"havocc2pipe", "svcctl"
]);
DeviceEvents
| where Timestamp > ago(24h)
| where ActionType in ("NamedPipeEvent", "PipeCreated", "PipeConnected")
| extend PipeName = tostring(parse_json(AdditionalFields).PipeName)
| where isnotempty(PipeName)
| where PipeName has_any (cobalt_pipe_patterns)
or (PipeName matches regex @"\\\\[a-z]{8,12}
quot;) // pipe com nome aleatório
| where InitiatingProcessFileName !in~ ("System", "lsass.exe", "services.exe", "spoolsv.exe")
| project
Timestamp,
DeviceName,
PipeName,
InitiatingProcessFileName,
InitiatingProcessCommandLine,
AccountName
| order by Timestamp desc
```
### Hipótese 4 - Named Pipes (SPL - Splunk com Sysmon)
```spl
index=sysmon (EventCode=17 OR EventCode=18)
| where NOT match(PipeName, "(?i)(anonymous|atsvc|browser|DAV|epmapper|eventlog|InitShutdown|lsarpc|LSM_API|netlogon|ntsvcs_legit|samr|scerpc_legit|spoolss|srvsvc|trkwks|W32TIME|wkssvc_legit)")
| where NOT match(Image, "(?i)(svchost|lsass|services|wininit|smss|csrss|RuntimeBroker)")
| regex PipeName="(msagent|postex|havocc2|mojo\.\d|status_[0-9a-f]{2})"
| stats count by Computer, User, Image, PipeName, CommandLine
| sort -count
```
### Hipótese 5 - Process Injection Chains (KQL)
```kql
// Processos legítimos com módulos carregados sem arquivo em disco (reflective injection)
DeviceImageLoadEvents
| where Timestamp > ago(24h)
| where InitiatingProcessFileName in~ (
"svchost.exe", "explorer.exe", "notepad.exe",
"RuntimeBroker.exe", "SearchHost.exe", "WerFault.exe"
)
| where not(isempty(SHA256))
| join kind=leftanti (
DeviceFileEvents
| where isnotempty(SHA256)
| project SHA256
) on SHA256
// Módulo carregado que não tem arquivo correspondente = reflective load
| summarize
InjectedModules = make_set(FileName),
LoadCount = count()
by DeviceName, InitiatingProcessFileName, InitiatingProcessId, bin(Timestamp, 1h)
| where LoadCount > 2
| order by LoadCount desc
```
### Hipótese 6 - LOLBAS como C2 Cradle (KQL)
```kql
// Ferramentas nativas do Windows usadas como download cradles para C2
let lolbas_loaders = dynamic([
"certutil.exe", "mshta.exe", "regsvr32.exe", "rundll32.exe",
"wscript.exe", "cscript.exe", "bitsadmin.exe", "desktopimgdownldr.exe",
"ieexec.exe", "installutil.exe", "msiexec.exe"
]);
DeviceProcessEvents
| where Timestamp > ago(24h)
| where FileName in~ (lolbas_loaders)
| where ProcessCommandLine has_any ("http://", "https://", "ftp://", "\\\\")
| where ProcessCommandLine !has "microsoft.com"
and ProcessCommandLine !has "windowsupdaté.com"
and ProcessCommandLine !has "office.com"
| project
Timestamp,
DeviceName,
AccountName,
FileName,
ProcessCommandLine,
InitiatingProcessFileName,
InitiatingProcessCommandLine
| order by Timestamp desc
```
---
## Ferramentas de Hunting
### Análise de Rede
| Ferramenta | Tipo | Uso | Comando / Nota |
|------------|------|-----|---------------|
| **RITA** | Open-source (OSS) | Análise automática de logs Zeek para beaconing, DNS tunneling, C2 | `rita analyze /path/to/zeek/logs` |
| **Zeek (Bro)** | OSS | Geração de logs de rede estruturados (conn.log, dns.log, ssl.log, http.log) | Deploy em tap ou span port |
| **Suricata** | OSS | IDS/IPS com suporte a JA3, rule-based C2 detection | Regras Emerging Threats para C2 |
| **NetworkMiner** | GUI/OSS | Análise de PCAP - extrai certificados, sessões, payloads | Análise forense offline |
| **CapLoader** | Comercial | Análise de beaconing periódico em PCAP | Heurística de periodicidade nativa |
| **Beacon Huntress** | OSS (CrowdStrike) | Análise de NetFlow para detecção de beacons | `python3 beacon_huntress.py -d netflow/` |
### Fingerprinting TLS
| Ferramenta | Tipo | Uso |
|------------|------|-----|
| **JA3/JA3S** | OSS (Salesforce) | Fingerprint de Client Hello e Server Hello TLS |
| **JA4+** | OSS (FoxIO) | Evolução do JA3 - mais granular, resistente a evasão |
| **já3er.com** | SaaS | Lookup de hashes JA3 conhecidos online |
| **Zeek já3 plugin** | OSS | Geração automática de JA3 em logs Zeek |
### Endpoint e Memória
| Ferramenta | Tipo | Uso | Referência |
|------------|------|-----|-----------|
| **BeaconEye** | OSS | Scan de memória para Cobalt Strike beacons ativos | `beaconEye.exe --pid 0` (todos os processos) |
| **Hunt-Sleeping-Beacons** | OSS | Detecta beacons em estado dormindo via análise de heap | GitHub: thefLink/Hunt-Sleeping-Beacons |
| **Pe-sieve** | OSS | Detecta process hollowing, injeção e módulos suspeitos | `pe-sieve /pid <PID>` |
| **Moneta** | OSS | Scan de memória por regiões RWX e anomalias de mapeamento | `moneta.exe --pid 0 --scan-threads` |
| **Sysmon** | Microsoft | Telemetria de endpoint - processos, rede, pipes, imagens | Config SwiftOnSecurity ou Olaf Hartong |
### YARA Rules para C2
```yara
rule CobaltStrike_Beacon_Config {
meta:
description = "Detecta configuração de beacon Cobalt Strike em memória"
author = "RunkIntel Threat Hunting"
reference = "https://www.cobaltstrike.com"
strings:
// XOR key 0x69 com sleep time offset típico
$config_xor = { 69 69 69 69 69 69 69 69 }
// Assinatura de ReflectiveDLL loader
$reflective_dll = { 4D 5A 90 00 03 00 00 00 04 00 00 00 FF FF }
// Strings de beacon pós-decodificação
$c2_str1 = "BeaconPayload" nocase
$c2_str2 = "ReflectiveDllMain" nocase
condition:
($config_xor and $reflective_dll) or
any of ($c2_str*)
}
rule Sliver_Implant_GoLang {
meta:
description = "Detecta implante Sliver compilado em Go"
strings:
$go_build = "Go build ID:" nocase
$sliver_str1 = "github.com/bishopfox/sliver" nocase
$sliver_str2 = "sliverpb" nocase
condition:
any of them
}
```
---
## Contexto LATAM / Brasil
O uso de frameworks C2 no contexto de ameaças brasileiras e latino-americanas tem características específicas que o hunter deve conhecer:
**Cobalt Strike cracked (versões 4.x):** Cópias não licenciadas de Cobalt Strike circulam ativamente em fóruns de crime organizado brasileiros e latino-americanos desde 2020. Grupos de ransomware como [[s1212-ransomhub]] e operadores de [[blackcat-alphv]] afiliados na região utilizaram CS como plataforma de post-exploitation em ataques a instituições financeiras e de saúde brasileiras. A watermark do trial pode ser diferente da versão legítima — análise de beacon config extrai o TeamServer ID que identifica a versão.
**Mythic e Sliver em campanhas APT:** Grupos de espionagem com nexo estatal que atuaram no Brasil em 2024-2025 foram observados usando Mythic com agentes customizados em Golang. O [[g0016-apt29]] (NOBELIUM) documentadamente testou Sliver como substituto ao CS após operações de takedown de infraestrutura. Grupos brasileiros de cibercrime sofisticado adotaram Sliver pela disponibilidade open-source e capacidade de compilação para múltiplas plataformas (Linux, macOS) — relevante dado o crescimento de ataques a ambientes cloud e ERP no Brasil.
**Grupos de crime organizado financeiro:** Operadores ligados a trojans bancários brasileiros como [[s0531-grandoreiro]] e [[mekotio]] evoluíram para usar infraestrutura C2 mais sofisticada em campanhas de 2025. Alguns grupos usam Havoc Framework por ser open-source e ter menor probabilidade de detecção por assinaturas específicas de CS. A [[cisc-kev]] registrou CVEs explorados por esses grupos para acesso inicial antes da implantação do beacon.
**Indicadores regionais específicos:**
- Servidores C2 hospedados em ASNs brasileiras (AS28573 - Claro, AS18881 - Vivo, AS7738 - Telemar)
- Certificados TLS com `O=BR` e nomes de empresas brasileiras fictícias
- Domínios `.com.br` ou `.net.br` registrados em Registro.br com dados WHOIS inválidos
- User-agents em português: `"Mozilla/5.0 (Windows NT 10.0; Win64; x64)"` é genérico, mas combinado com headers `Accept-Language: pt-BR` em beacons customizados
**CERT.br e Relatórios Regionais:** O [[cert-br]] pública estatísticas de incidentes reportados no Brasil que podem contextualizar picos de atividade C2. Em 2025, o CERT.br registrou aumento de 34% em incidentes classificados como "intrusion" com características de C2 ativo — correlacionar com campanha [[operation-urban-ghost]] que afetou empresas de energia no Sudeste.
---
## Referências
- [[t1071-application-layer-protocol|T1071 - Application Layer Protocol]] - técnica MITRE ATT&CK
- [[t1571-non-standard-port|T1571 - Non-Standard Port]] - técnica MITRE ATT&CK
- [[t1573-encrypted-channel|T1573 - Encrypted Channel]] - técnica MITRE ATT&CK
- [[t1572-protocol-tunneling|T1572 - Protocol Tunneling]] - técnica MITRE ATT&CK
- [[t1071-004-dns|T1071.004 - DNS as C2 channel]] - técnica MITRE ATT&CK
- [[t1568-dynamic-resolution|T1568 - Dynamic Resolution / DGA]] - técnica MITRE ATT&CK
- [[t1102-web-service|T1102 - Web Service as C2]] - técnica MITRE ATT&CK
- [[hunting-lateral-movement]] - playbook relacionado (C2 frequentemente precede movimentação lateral)
- [[s0154-cobalt-strike]] - perfil de malware / framework C2
- [[g0016-apt29]] - grupo que usa Cobalt Strike, Brute Ratel e Sliver extensivamente
- [[g0096-apt41]] - grupo chinês com uso documentado de CS em campanhas LATAM
- [[cert-br]] - CERT brasileiro - fonte de dados regionais
- [Cobalt Strike Malleable C2 Profiles - GitHub](https://github.com/xx0hcd/Malleable-C2-Profiles)
- [RITA - Real Intelligence Threat Analytics](https://github.com/activecm/rita)
- [Hunt-Sleeping-Beacons - thefLink](https://github.com/thefLink/Hunt-Sleeping-Beacons)
- [BeaconEye - CyberArk Labs](https://github.com/CCob/BeaconEye)
- [JA4+ Fingerprinting - FoxIO](https://github.com/FoxIO-LLC/já4)
- [Brute Ratel C4 Analysis - Unit 42 / Palo Alto](https://unit42.paloaltonetworks.com/brute-ratel-c4-tool/)
---
*Última revisão: 2026-03-26 | Próxima revisão recomendada: 2026-09-26*