emp3r0r v4.7.1

emp3r0r

Malla de chismes (Gossip Mesh) C2 auto-reparable con descubrimiento asistido de pares, ejecución de BOF multiplataforma y agentes programables.

¿Qué es emp3r0r?

emp3r0r es un framework avanzado de post-explotación y sistema de comando y control (C2) de confianza cero, diseñado para entornos objetivo Linux y Windows. Construido desde cero para operar en entornos de alta seguridad, emp3r0r combina redes de malla de chismes autónomas, ejecución sin archivos solo en memoria, carga de BOF multiplataforma, transferencia de archivos entre agentes y agentes programables en memoria para ofrecer sigilo, control operativo y seguridad operativa (OPSEC) superiores.

Características Clave y Únicas

🐍 Agentes Programables (Motor Starlark Integrado y Proxy de API Win32)

Los agentes de emp3r0r cuentan con un motor de scripting Starlark integrado (un dialecto de Python implementado puramente en Go). Los scripts se ejecutan sin archivos en memoria sin requerir Python, Bash o PowerShell instalados en el objetivo.

• Cero Dependencias del Host: Ejecuta scripts independientes sin lanzar intérpretes de comandos (/bin/sh, powershell.exe) ni depender de runtimes instalados.
• APIs Go del Agente Integradas: Funciones expuestas para operaciones del sistema de archivos (read_file, write_file, list_dir, mkdir, remove, exists), redes HTTP (http_get, http_post), ejecución de comandos (exec_cmd) y hash (crypto_hash).
• Proxy Dinámico de API Win32: En objetivos Windows, los scripts Starlark pueden cargar dinámicamente DLLs del sistema y ejecutar APIs Win32 nativas (win_call, win_alloc, win_free, win_read_mem) directamente desde el código del script sin compilar código C nativo.
• Integración Modular: Los scripts Starlark se definen mediante manifiestos JSON (config.json) para un análisis y distribución de parámetros CLI sin interrupciones.

Por qué esto importa: Los módulos de script C2 tradicionales requieren intérpretes del host o el lanzamiento de procesos, dejando rastros pesados en disco o en la ejecución de línea de comandos. Los agentes programables de emp3r0r ejecutan lógica compleja enteramente en memoria con interacción nativa del sistema.

🔐 Fijación de Identidad Criptográfica TOFU

emp3r0r aplica Confianza en el Primer Uso (TOFU) con fijación estricta de UUID y clave pública al momento del registro del agente.

• Vinculación Inmutable: Una vez registrado, el UUID de un agente se fija a su clave pública criptográfica. El re-registro con credenciales alteradas se rechaza como un intento de suplantación.
• Restablecimiento Controlado: La baja de registro requiere autorización explícita del operador mediante forget_agent.

Por qué esto importa: Previene el secuestro de sesiones, la clonación de agentes y la deriva silenciosa de identidad en entornos operativos.

🔒 Secreto Perfecto hacia Adelante (PFS)

Todas las comunicaciones C2 y entre pares aplican intercambio de claves ECDH con claves de sesión derivadas de HKDF.

• Claves Efímeras: Cada sesión genera claves de cifrado únicas.
• Seguridad Desacoplada: Comprometer claves a largo plazo o un agente individual no puede comprometer comunicaciones pasadas o paralelas.

Por qué esto importa: Previene el descifrado retrospectivo de capturas de red interceptadas.

🕸️ Red de Malla de Chismes P2P Autónoma

Los agentes en segmentos de red con restricciones de salida o aislados descubren pares de forma autónoma y tunelizan el tráfico mediante una red de malla basada en chismes (Memberlist).

• Transportes de Pares Conectables: Soporte para mTLS 1.3 de camuflaje (usando certificados efímeros) y KCP (UDP confiable).
• Cifrado de Extremo a Extremo: Todos los saltos de malla entre agentes están envueltos en cifrado AES-GCM.
• Baja Huella de Red: El retransmisión directa agente a agente elimina el ruido de difusión innecesario y los puntos de estrangulamiento centralizados de conexión C2.

Por qué esto importa: El pivoteo a través de redes segmentadas ocurre de forma autónoma sin requerir intervención constante del operador o configuraciones de proxy estáticas.

📂 Sistema de Archivos P2P

Intercambio directo de archivos agente a agente mediante transporte de retransmisión P2P (mTLS/KCP) para acelerar la entrega de archivos en redes internas.

• Túneles P2P Cifrados: Transfiere archivos a través de pares usando mTLS/KCP para eludir restricciones de salida y reducir los cuellos de botella de ancho de banda central del C2.
• Caché Inteligente de Archivos en Memoria: Los archivos se almacenan en caché en la memoria del agente como blobs cifrados; pueden servirse sin problemas para que otros agentes los descarguen bajo demanda. Al solicitar un archivo, los agentes consultan su memfs local, luego otros pares y finalmente el C2.
• Retroceso Automático de Retransmisión C2: Si un par objetivo carece del archivo solicitado, lo obtiene y transmite dinámicamente desde el servidor C2 bajo demanda.

Por qué esto importa: El intercambio directo de archivos agente a agente maximiza las velocidades de transferencia, elude los puntos de estrangulamiento de red y reduce la visibilidad del tráfico C2 directo.

📡 Listeners Multiprotocolo y Stagers Conectables

Stagers descargadores de Etapa 0 flexibles y listeners de protocolo para acceso inicial y entrega de payloads.

• Listeners Multiprotocolo: Listeners HTTP, TCP y UDP integrados e independientes con enmarcado confiable de confirmación de secuencia y perfiles HTTP personalizables. El listener independiente soporta TLS opcional (-tls), generando automáticamente un certificado autofirmado cuando no se proporciona un par cert/clave.
• Stager Descargador C Independiente: Construido con syscalls Linux directas e independientes de libc para compatibilidad entre distribuciones sin errores de símbolos.
• Entrega de Etapa Cifrada: El listener cifra el payload en etapas con RC4 usando una clave derivada de un secreto proporcionado por el operador; el stager lo descifra en memoria antes de la carga reflectiva.
• Transportes de Stager Conectables: Sistema de transporte modular que permite a los operadores insertar módulos de transporte C personalizados (transport_<name>.c). Las opciones independientes integradas incluyen HTTP, TCP y UDP mediante syscalls crudas, así como transportes de bibliotecas dinámicas (p. ej., libcurl mediante resolución de símbolos en tiempo de ejecución).
  • Beneficios: Elude el filtrado de salida y la detección de red al mezclar sin problemas el tráfico en canales legítimos del sistema (p. ej., libcurl nativo o implementaciones de protocolo personalizadas) sin alterar la lógica central del stager.
• Empaquetadores Autoextraíbles Conectables: Interfaz extensible de stub y módulo empaquetador (pack_<name>.py + unpack_stub_<name>.c). Los operadores pueden escribir algoritmos personalizados de empaquetado/ofuscación (las opciones integradas incluyen cifrado de flujo RC4 y compresión LZSS codiciosa) con parcheo automático de encabezados en tiempo de ejecución.
  • Beneficios: Rompe las reglas YARA estáticas de AV/EDR y la coincidencia de firmas al cifrar/comprimir el payload de Etapa 0 con claves o algoritmos únicos, autoextraíbles en memoria de lectura/escritura que luego se cambia a lectura/ejecución antes de la ejecución.
• Tamaño de Payload Mínimo: Mientras que los binarios de agente emp3r0r son ~20MB sin compresión, este stager es de 2KB; el payload similar a sRDI que obtiene del listener emp3r0r es de ~8MB (comprimido del binario del agente en formato de objeto compartido ELF).
• Formatos Flexibles: Se compila en shellcode independiente de posición crudo (.bin), shellcode empaquetado autoextraíble (packed), ejecutables ELF independientes u objetos compartidos (.so).
• Endurecimiento en Memoria: Asigna memoria de etapa lectura/escritura, desofusca payloads y luego aplica lectura/ejecución antes de la carga reflectiva. El autoextraedor nunca mapea RWX (lectura/escritura → desempacar → lectura/ejecución), y el estado mutable del stager reside en una página dedicada de lectura/escritura en lugar de código escribible.

🧩 Soporte Nativo Multiplataforma de BOF y PICO (COFF, ELF y PICO)

Ejecuta módulos binarios en memoria en objetivos Windows y Linux:

• Cargadores COFF de Windows: Ejecuta binarios BOF de Windows sin archivos con empaquetado de parámetros tipados (int, short, cstr, wstr, binary).
• Cargadores de Objetos ELF de Linux: Carga archivos de objetos reubicables ELF (.o) directamente en la memoria del agente en Linux.
• Módulos PICO de Crystal-Kit y Suplantación de Pila: Cargadores y empaquetadores PICO (Objeto de Código Independiente de Posición) integrados con el suplantador de desincronización de pila SilentMoonwalk para evasión avanzada.
• Suites BOF Incluidas: Soporte integrado para colecciones de módulos Kerbeus-BOF, Remote-OPs y Conciencia Situacional (SA).

Por qué esto importa: Elimina la sobrecarga de creación de procesos y elude el monitoreo de línea de comandos y pila al ejecutar módulos C compilados en el proceso con suplantación de pila.

🔑 Manipulación de Tokens de Windows Bajo Demanda

Los agentes en Windows pueden robar, almacenar en caché y suplantar tokens de acceso de procesos en ejecución — enteramente en el proceso usando syscalls NT indirectas.

• Robar y Almacenar en Caché: steal_token --pid <PID> duplica un token de proceso mediante NtOpenProcess + NtDuplicateToken y lo almacena en memoria por SID. Opcionalmente, encadena la suplantación con --token <sid> para escalar de una identidad robada a otra.
• Enumerar: list_tokens muestra todos los tokens almacenados en caché con nombres DOMAIN\User (SID).
• Suplantación Universal: Referencia un token almacenado en caché por SID (--token <sid>) en cualquier módulo — Go, Starlark, COFF/BOF. La suplantación a nivel de hilo (NtSetInformationThread) se aplica alrededor de operaciones sensibles.
• Starlark Consciente de Tokens: Los builtins (read_file, write_file, exec_cmd, proxy de API Win32, etc.) suplantan automáticamente por syscall cuando se establece un token, y exec_cmd puede lanzar procesos hijos bajo la identidad robada mediante CreateProcessWithTokenW.

Por qué esto importa: Sin herramientas externas, sin artefactos en disco, sin ruido de creación de procesos. El robo y reutilización de tokens ocurren enteramente en el proceso usando syscalls indirectas, con tokens robados inmediatamente consumibles por cada módulo integrado.

🎭 Transporte C2 Conectable, Evasión JA3 con uTLS y Protocolo CBOR

• Modos C2 Conectables: Beaconing flexible (http_poll) con perfiles HTTP maleables y streaming (h2conn) sobre HTTP/2.
• Aleatorización de Firma JA3: Utiliza uTLS para aleatorizar las huellas dactilares de Client Hello TLS, derrotando firmas de red estáticas.
• Protocolo de Cable Binario: Usa CBOR (Representación Binaria Concisa de Objetos) para todos los datos de control y serialización de cable, reduciendo los tamaños de payload de red en 30-40% en comparación con JSON.

💾 Almacenamiento Cifrado Primero en Memoria

• Sistema de Archivos Virtual Cifrado en Memoria: Todas las operaciones de archivos del agente usan un sistema de archivos virtual AES-GCM en memoria. Los datos grandes se desbordan automáticamente a almacenamiento en disco cifrado sin encabezados o extensiones identificables.
• Caché Inteligente Impulsada por P2P: Cada agente habilitado para P2P almacena en caché los archivos que obtiene del C2 en memfs; luego los pone a disposición de otros pares, minimizando la huella de tráfico C2 mientras aprovecha conexiones rápidas entre agentes.

Inicio Rápido

1. Instalación del Servidor C2

La construcción de emp3r0r requiere Docker o Podman en el host. No se requiere cadena de herramientas Go local.

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

# Construir dentro de un contenedor e instalar localmente
./install.py

El instalador compila los binarios principales dentro de un contenedor desechable, genera el emp3r0r-operator-kit.tar.zst precompilado, configura las capacidades Linux requeridas (setcap) y establece los directorios de runtime del sistema.

Opciones:

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

Use --lightweight para construir solo objetivos exe/dll linux/amd64 y windows/amd64 (más rápido, para implementaciones solo x86-64), o --targets OS/ARCH,... para compilar un conjunto específico de tipos de payload.

Lance el servidor C2:

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

Nota: Si se instala con el usuario root en lugar de sudo estándar, su usuario actual podría no poder lanzar emp3r0r ya que los permisos no pueden establecerse correctamente por el instalador. Lo mismo aplica a sus máquinas de operador.

2. Configuración de la Máquina del Operador

Transfiera el emp3r0r-operator-kit.tar.zst generado a su máquina de operador y ejecute el instalador:

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

Conecte el cliente del operador al servidor C2 usando las credenciales del túnel WireGuard impresas por el 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. Generar Payloads de Agente

Use el comando generate dentro de la interfaz del operador emp3r0r para crear payloads.

Agente C2 Directo:

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

Agente Gateway de Malla:

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

Par Intermedio de Malla:

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

Documentación y Recursos

• 📝 Política de Seguridad: SECURITY.md
• 📜 Registro de Cambios: CHANGELOG.md
• 🛠️ Guía de Desarrollo de Módulos: core/modules/module_development_guide.md

Apoyo al Desarrollo

Si emp3r0r ha demostrado ser valioso en su investigación y pruebas de seguridad, considere apoyar su desarrollo continuo mediante GitHub Sponsors.