emp3r0r v4.8.0

emp3r0r

C2 de malha gossip com autocura, descoberta assistida de pares, execução de BOF multiplataforma e agentes scriptáveis.

O que é o emp3r0r?

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

Principais Destaques e Recursos Exclusivos

🐍 Agentes Scriptáveis (Mecanismo Starlark Embutido e Proxy de API Win32)

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

• Zero Dependências do Host: Executa scripts autônomos sem criar interpretadores de comando (/bin/sh, powershell.exe) nem depender de runtimes instalados.
• APIs Go Embutidas do Agente: 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, os scripts Starlark podem carregar dinamicamente DLLs do sistema e executar APIs nativas Win32 (win_call, win_alloc, win_free, win_read_mem) diretamente do código do script, sem compilar código C nativo.
• Integração Modular: Os scripts Starlark são definidos usando manifestos JSON (config.json) para análise e distribuição de parâmetros de CLI sem interrupções.

Por que isso é importante: Os módulos de script de C2 tradicionais exigem interpretadores do host ou criação de processos, deixando rastros pesados de execução em disco ou na linha de comando. Os agentes scriptáveis 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 Confiança no Primeiro Uso (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. Um novo 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 é importante: Impede o sequestro de sessão, a clonagem de agentes e o desvio silencioso de identidade entre ambientes operacionais.

🔒 Sigilo de Encaminhamento Perfeito (PFS)

Todas as comunicações de 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 é importante: Impede a descriptografia retrospectiva de capturas de rede interceptadas.

🕸️ Rede de Malha Gossip P2P Autônoma

Agentes em segmentos de rede com restrição de saída ou isolados descobrem pares de forma autônoma e fazem tunelamento de tráfego por meio de uma rede de malha baseada em gossip (Memberlist).

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

Por que isso é importante: O pivô entre redes segmentadas ocorre de forma autônoma, sem exigir intervenção constante do operador ou configurações estáticas de proxy.

📂 Sistema de Arquivos P2P

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

• Túneis P2P Criptografados: Faça túnel de transferências entre pares usando mTLS/KCP para contornar restrições de saída e reduzir gargalos de largura de banda do C2 central.
• Cache Inteligente de Arquivos em Memória: Os arquivos são armazenados em cache na memória do agente como blobs criptografados; podem ser servidos de forma transparente para outros agentes baixarem sob demanda. Ao solicitar um arquivo, os agentes consultam seu memfs local, depois outros pares e, por fim, o C2.
• Fallback Automático de Retransmissão do C2: Se um par de destino não tiver o arquivo solicitado, ele o busca e transmite dinamicamente a partir do servidor C2 sob demanda.

Por que isso é importante: O compartilhamento direto de arquivos entre agentes maximiza a velocidade de transferência, contorna gargalos de rede e reduz a visibilidade do tráfego direto com o C2.

📡 Listeners e Stagers Multiprotocolo

Stagers de download flexíveis do Estágio 0 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 reconhecimento de sequência e perfis HTTP personalizados.
• Stager Downloader Autônomo em C: Construído com chamadas de sistema Linux diretas e independentes de libc para compatibilidade entre distribuições, sem erros de símbolo.
• Tamanho Minúsculo de Payload: Embora os binários do agente emp3r0r tenham ~20MB sem compressão, este stager tem menos de 1,5KB; o payload do tipo sRDI que ele busca do listener emp3r0r tem ~8MB (comprimido a partir do binário do agente no formato de objeto compartilhado ELF).
• Formatos Flexíveis: Compila em shellcode bruto independente de posição (.bin), executáveis ELF autônomos ou objetos compartilhados (.so).
• Endurecimento em Memória: Aloca a memória do estágio com permissões de leitura-escrita, desofusca payloads e aplica leitura-execução antes de executar reflexivamente o Estágio 1.

🧩 Suporte BOF Multiplataforma Nativo (COFF & ELF)

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

• Loaders COFF para Windows: Executam binários BOF do Windows sem arquivos, com empacotamento tipado de parâmetros (int, short, cstr, wstr, binary).
• Loaders de Objetos ELF para Linux: Carregam arquivos de objeto relocáveis ELF (.o) diretamente na memória do agente no Linux.
• Suítes BOF Incluídas: Suporte integrado para as coleções de módulos Kerbeus-BOF, Remote-OPs e Situational Awareness (SA).

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

🔑 Manipulação de Token do 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 indiretas.

• 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 Token: As funções embutidas (read_file, write_file, exec_cmd, proxy de API Win32, etc.) personificam automaticamente por syscall quando um token está definido, e exec_cmd pode criar processos filhos sob a identidade roubada via CreateProcessWithTokenW.

Por que isso é importante: Sem ferramentas externas, sem artefatos em disco, sem ruído de criação de processos. O roubo e a reutilização de tokens ocorrem inteiramente no processo usando syscalls indiretas, com os tokens roubados imediatamente utilizáveis por todos os módulos embutidos.

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

• Modos C2 Conectá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 do TLS Client Hello, derrotando assinaturas de rede estáticas.
• Protocolo Binário de Transporte: Usa CBOR (Representação Binária Concisa de Objetos) para todos os dados de controle e serialização de transmissão, reduzindo o tamanho dos payloads de rede em 30-40% em comparação com JSON.

💾 Armazenamento Criptografado com Prioridade em 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 transferidos para armazenamento criptografado em disco, sem cabeçalhos ou extensões identificáveis.
• Cache Inteligente com P2P: Cada agente habilitado para P2P armazena em cache no memfs os arquivos que busca do C2; depois os disponibiliza para outros pares, minimizando a pegada de tráfego do C2 e aproveitando conexões rápidas entre agentes.

Início Rápido

1. Instalação do Servidor C2

Para compilar o emp3r0r, é necessário Docker ou Podman no host. Nenhuma toolchain Go local é necessária.

# Clone repository
git clone --depth=1 https://github.com/jm33-m0/emp3r0r.git && cd emp3r0r

# Build inside a container and install locally
./install.sh

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

Opções:

./install.sh [--debug] [--disable-garble] [--prefix /usr/local] [--skip-build]

Inicie o servidor C2:

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

Observação: Se for instalado com o usuário root em vez do sudo padrão, o seu usuário atual pode não conseguir iniciar o emp3r0r, pois o instalador não consegue definir as permissões corretamente. 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 a sua máquina de operador e execute o instalador:

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

Conecte o cliente do operador ao servidor C2 usando as credenciais do túnel WireGuard exibidas 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 do emp3r0r para criar payloads.

Agente C2 Direto:

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

Agente Gateway de Malha:

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

Par Intermediário de Malha:

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
• 📜 Registro de Alterações: 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 por meio do GitHub Sponsors.