emp3r0r v4.7.1

emp3r0r

Malha Gossip Mesh C2 com Autocura, Descoberta de Pares Assistida, Execução de BOF Multiplataforma e Agentes com Scripts.

O que é o emp3r0r?

O emp3r0r é um framework avançado de pós-exploração e sistema de comando e controle (C2) com zero confiança, projetado para ambientes Linux e Windows. Construído do zero para operar em ambientes de alta segurança, o emp3r0r combina rede mesh gossip autônoma, execução somente em memória sem arquivos, carregamento de BOF multiplataforma, transferência de arquivos entre agentes e agentes com scripts em memória para oferecer furtividade superior, controle operacional e segurança operacional (OPSEC).

Principais Destaques e Recursos Exclusivos

🐍 Agentes com Scripts (Mecanismo Starlark Embutido e Proxy de API Win32)

Os agentes do emp3r0r possuem um mecanismo de scripting Starlark embutido (um dialeto de Python implementado puramente em Go). Os scripts são executados sem arquivos, diretamente em memória, sem exigir Python, Bash ou PowerShell instalados no alvo.

• Zero Dependências do Host: Executa scripts autônomos sem iniciar interpretadores de comando (/bin/sh, powershell.exe) ou depender de runtimes instalados.
• APIs Go do Agente Embutidas: Funções expostas para operações de sistema de arquivos (read_file, write_file, list_dir, mkdir, remove, exists), rede HTTP (http_get, http_post), execução de comandos (exec_cmd) e hash (crypto_hash).
• Proxy Dinâmico de API Win32: Em alvos Windows, scripts Starlark podem carregar dinamicamente DLLs do sistema e executar APIs Win32 nativas (win_call, win_alloc, win_free, win_read_mem) diretamente do código do script, sem compilar código C nativo.
• Integração Modular: Scripts Starlark são definidos usando manifestos JSON (config.json) para análise de parâmetros CLI e distribuição sem interrupções.

Por que isso importa: Módulos de script C2 tradicionais exigem interpretadores do host ou criação de processos, deixando rastros pesados em disco ou na execução de linha de comando. Os agentes com scripts do emp3r0r executam lógica complexa inteiramente em memória, com interação nativa com o sistema.

🔐 Fixação de Identidade Criptográfica TOFU

O emp3r0r aplica Trust-On-First-Use (TOFU) com fixação estrita de UUID e chave pública no registro do agente.

• Vínculo Imutável: Após o registro, o UUID de um agente é fixado à sua chave pública criptográfica. O re-registro com credenciais alteradas é rejeitado como tentativa de personificação.
• Redefinição Controlada: O cancelamento do registro exige autorização explícita do operador via forget_agent.

Por que isso importa: Previne sequestro de sessão, clonagem de agentes e deriva silenciosa de identidade em ambientes operacionais.

🔒 Sigilo Perfeito de Encaminhamento (PFS)

Todas as comunicações C2 e entre pares aplicam troca de chaves ECDH com chaves de sessão derivadas de HKDF.

• Chaves Efêmeras: Cada sessão gera chaves de criptografia exclusivas.
• Segurança Desacoplada: Comprometer chaves de longo prazo ou um agente individual não pode comprometer comunicações passadas ou paralelas.

Por que isso importa: Previne descriptografia retrospectiva de capturas de rede interceptadas.

🕸️ Rede Mesh Gossip P2P Autônoma

Agentes em segmentos de rede com restrição de egresso ou isolados descobrem pares autonomamente e fazem túnel de tráfego via uma rede mesh baseada em gossip (Memberlist).

• Transportes de Pares Plugáveis: Suporte a mTLS 1.3 de camuflagem (usando certificados efêmeros) e KCP (UDP confiável).
• Criptografia Ponto a Ponto: Todos os saltos de mesh entre agentes são envolvidos em criptografia AES-GCM.
• Baixa Pegada de Rede: O retransmissão direta entre agentes elimina ruído de broadcast desnecessário e gargalos centralizados de conexão C2.

Por que isso importa: O pivoteamento entre redes segmentadas ocorre autonomamente, sem exigir intervenção constante do operador ou configurações de proxy estáticas.

📂 Sistema de Arquivos P2P

Compartilhamento de arquivos direto entre agentes via transporte de retransmissão P2P (mTLS/KCP) para acelerar a entrega de arquivos em redes internas.

• Túneis P2P Criptografados: Transfere arquivos entre pares usando mTLS/KCP para contornar restrições de egresso e reduzir gargalos de largura de banda do C2 central.
• Cache Inteligente de Arquivos em Memória: Arquivos são armazenados em cache na memória do agente como blobs criptografados; podem ser servidos perfeitamente para outros agentes baixarem sob demanda. Ao solicitar um arquivo, os agentes verificam seu memfs local, depois outros pares e, finalmente, o C2.
• Fallback Automático de Retransmissão C2: Se um par alvo não tiver o arquivo solicitado, ele busca e transmite dinamicamente do servidor C2 sob demanda.

Por que isso importa: O compartilhamento direto de arquivos entre agentes maximiza as velocidades de transferência, contorna gargalos de rede e reduz a visibilidade do tráfego C2 direto.

📡 Listeners Multiprotocolo e Stagers Plugáveis

Stagers de downloader Stage 0 flexíveis e listeners de protocolo para acesso inicial e entrega de payloads.

• Listeners Multiprotocolo: Listeners HTTP, TCP e UDP embutidos e autônomos com enquadramento confiável de confirmação de sequência e perfis HTTP personalizáveis. O listener autônomo suporta TLS opcional (-tls), gerando automaticamente um certificado autoassinado quando nenhum par cert/chave é fornecido.
• Stager Downloader C Autônomo: Construído com syscalls Linux diretos e independentes de libc para compatibilidade entre distribuições sem erros de símbolo.
• Entrega de Stage Criptografado: O listener criptografa o payload encenado com RC4 usando uma chave derivada de um segredo fornecido pelo operador; o stager o descriptografa em memória antes do carregamento reflexivo.
• Transportes de Stager Plugáveis: Sistema de transporte modular que permite aos operadores inserir módulos de transporte C personalizados (transport_<name>.c). Opções autônomas integradas incluem HTTP, TCP e UDP via syscalls brutos, bem como transportes de bibliotecas dinâmicas (ex.: libcurl via resolução de símbolos em tempo de execução).
  • Benefícios: Contorna filtragem de egresso e detecção de rede ao misturar perfeitamente o tráfego em canais legítimos do sistema (ex.: libcurl nativo ou implementações de protocolo personalizadas) sem alterar a lógica central do stager.
• Packers Auto-Descompactáveis Plugáveis: Interface extensível de stub e módulo de empacotamento (pack_<name>.py + unpack_stub_<name>.c). Operadores podem escrever algoritmos de empacotamento/obfuscação personalizados (opções integradas incluem criptografia de fluxo RC4 e compressão LZSS gananciosa) com correção automática de cabeçalho em tempo de execução.
  • Benefícios: Quebra regras YARA estáticas de AV/EDR e correspondência de assinaturas ao criptografar/compactar o payload Stage 0 com chaves ou algoritmos exclusivos, auto-descompactando em memória de leitura/escrita que é então alternada para leitura/execução antes da execução.
• Tamanho Minúsculo de Payload: Enquanto os binários do agente emp3r0r têm ~20MB sem compressão, este stager tem 2KB; o payload semelhante a sRDI que ele busca do listener emp3r0r tem ~8MB (comprimido do binário do agente em formato ELF shared object).
• Formatos Flexíveis: Compila em shellcode bruto independente de posição (.bin), shellcode empacotado auto-descompactável (packed), executáveis ELF autônomos ou shared objects (.so).
• Endurecimento em Memória: Aloca memória de stage como leitura/escrita, desobfusca payloads e, em seguida, aplica leitura/execução antes do carregamento reflexivo. O auto-descompactador nunca mapeia RWX (leitura/escrita → descompactação → leitura/execução), e o estado mutável do stager reside em uma página dedicada de leitura/escrita, em vez de código gravável.

🧩 Suporte Nativo Multiplataforma a BOF e PICO (COFF, ELF e PICO)

Execute módulos binários em memória em alvos Windows e Linux:

• Carregadores COFF Windows: Execute binários BOF Windows sem arquivos com empacotamento de parâmetros tipados (int, short, cstr, wstr, binary).
• Carregadores de Objetos ELF Linux: Carregue arquivos de objeto relocáveis ELF (.o) diretamente na memória do agente no Linux.
• Módulos PICO Crystal-Kit e Spoofing de Pilha: Carregadores e packers PICO (Position-Independent Code Object) integrados com spoofer de dessincronização de callstack SilentMoonwalk para evasão avançada.
• Suites BOF Incluídas: Suporte integrado para coleções de módulos Kerbeus-BOF, Remote-OPs e Situational Awareness (SA).

Por que isso importa: Elimina a sobrecarga de criação de processos e contorna o monitoramento de linha de comando e callstack ao executar módulos C compilados no processo com spoofing de callstack.

🔑 Manipulação de Tokens Windows Sob Demanda

Agentes no Windows podem roubar, armazenar em cache e personificar tokens de acesso de processos em execução — inteiramente no processo usando syscalls NT indiretos.

• Roubar e Armazenar em Cache: steal_token --pid <PID> duplica um token de processo via NtOpenProcess + NtDuplicateToken e o armazena em memória por SID. Opcionalmente, encadeie a personificação com --token <sid> para escalar de uma identidade roubada para outra.
• Enumerar: list_tokens exibe todos os tokens em cache com nomes DOMAIN\User (SID).
• Personificação Universal: Referencie um token em cache por SID (--token <sid>) em qualquer módulo — Go, Starlark, COFF/BOF. A personificação em nível de thread (NtSetInformationThread) é aplicada em torno de operações sensíveis.
• Starlark Ciente de Tokens: Builtins (read_file, write_file, exec_cmd, proxy de API Win32, etc.) personificam automaticamente por syscall quando um token é definido, e exec_cmd pode iniciar processos filhos sob a identidade roubada via CreateProcessWithTokenW.

Por que isso importa: Sem ferramentas externas, sem artefatos em disco, sem ruído de criação de processos. O roubo e reutilização de tokens acontecem inteiramente no processo usando syscalls indiretos, com tokens roubados imediatamente consumíveis por todos os módulos integrados.

🎭 Transporte C2 Plugável, Evasão JA3 com uTLS e Protocolo CBOR

• Modos C2 Plugáveis: Beaconing flexível (http_poll) com perfis HTTP maleáveis e streaming (h2conn) sobre HTTP/2.
• Randomização de Assinatura JA3: Utiliza uTLS para randomizar impressões digitais TLS Client Hello, derrotando assinaturas de rede estáticas.
• Protocolo de Fio Binário: Usa CBOR (Concise Binary Object Representation) para todos os dados de controle e serialização de fio, reduzindo os tamanhos de payload de rede em 30-40% em comparação com JSON.

💾 Armazenamento Criptografado com Prioridade de Memória

• Sistema de Arquivos Virtual Criptografado em Memória: Todas as operações de arquivo do agente usam um sistema de arquivos virtual AES-GCM em memória. Dados grandes são automaticamente despejados em armazenamento em disco criptografado, sem cabeçalhos ou extensões identificáveis.
• Cache Inteligente Alimentado por P2P: Cada agente habilitado para P2P armazena em cache os arquivos que busca do C2 no memfs; em seguida, os disponibiliza para outros pares, minimizando a pegada de tráfego C2 enquanto aproveita conexões rápidas entre agentes.

Início Rápido

1. Instalação do Servidor C2

A construção do emp3r0r requer Docker ou Podman no host. Nenhuma toolchain Go local é necessária.

# Clonar repositório
git clone --depth=1 https://github.com/jm33-m0/emp3r0r.git && cd emp3r0r

# Compilar dentro de um contêiner e instalar localmente
./install.py

O instalador compila os binários principais dentro de um contêiner descartável, gera o emp3r0r-operator-kit.tar.zst pré-compilado, configura as capacidades Linux necessárias (setcap) e define os diretórios de runtime do sistema.

Opções:

./install.py [--debug] [--disable-garble] [--prefix /usr/local] [--skip-build] \
  [--lightweight] [--targets linux/amd64,windows/amd64]

Use --lightweight para compilar apenas alvos linux/amd64 e windows/amd64 exe/dll (mais rápido, para implantações somente x86-64), ou --targets OS/ARCH,... para compilar um conjunto específico de tipos de payload.

Inicie o servidor C2:

emp3r0r server --c2-hosts 1.2.3.4 --http-port 12345 --operator-port 13377

Nota: Se instalado com o usuário root em vez de sudo padrão, seu usuário atual pode não conseguir iniciar o emp3r0r, pois as permissões não podem ser definidas corretamente pelo instalador. O mesmo se aplica às suas máquinas de operador.

2. Configuração da Máquina do Operador

Transfira o emp3r0r-operator-kit.tar.zst gerado para sua máquina de operador e execute o instalador:

tar --zstd -xpf emp3r0r-operator-kit.tar.zst
cd ./emp3r0r-operator-kit && ./install.py

Conecte o cliente do operador ao servidor C2 usando as credenciais de túnel WireGuard impressas pelo servidor:

emp3r0r client --c2-port 13377 \
  --server-wg-key '<SERVER_WG_KEY>' \
  --server-wg-ip '<SERVER_WG_IP>' \
  --operator-wg-ip '<OPERATOR_WG_IP>' \
  --operator-wg-key '<OPERATOR_WG_KEY>' \
  --c2-host 1.2.3.4

3. Gerar Payloads de Agente

Use o comando generate na interface do operador emp3r0r para criar payloads.

Agente C2 Direto:

generate --type linux_executable --arch amd64 --cc your.domain.com

Agente Gateway Mesh:

generate --type linux_executable --arch amd64 --cc your.domain.com \
  --p2p --direct-c2 --p2p-transport mtls

Par Intermediário Mesh:

generate --type linux_executable --arch amd64 --cc your.domain.com \
  --p2p --p2p-transport mtls --peers 1.2.3.4

Documentação e Recursos

• 📝 Política de Segurança: SECURITY.md
• 📜 Changelog: CHANGELOG.md
• 🛠️ Guia de Desenvolvimento de Módulos: core/modules/module_development_guide.md

Apoie o Desenvolvimento

Se o emp3r0r se mostrou valioso em sua pesquisa e testes de segurança, considere apoiar seu desenvolvimento contínuo via GitHub Sponsors.