construcción-de-redirector-c2

Construcción de Infraestructura de Redirector C2

Solo para uso autorizado: Esta habilidad está destinada únicamente a ejercicios de equipo rojo autorizados, simulaciones de adversarios e investigación defensiva. La infraestructura de comando y control es de doble uso; implementar redirectores para controlar malware en sistemas que no está explícitamente autorizado a probar es ilegal. Opere solo dentro de un alcance acordado con un documento de reglas de enfrentamiento firmado y desmantelar la infraestructura cuando finalice el ejercicio.

Descripción General

Un redirector C2 es un host intermediario que se sitúa entre los implants de las víctimas y el servidor real del equipo. Los beacons se conectan al dominio/IP público del redirector; el redirector inspecciona cada solicitud y, o bien envía el tráfico C2 legítimo de vuelta al servidor del equipo oculto, o desvía todo lo demás (escáneres, analistas de equipo azul, sandboxes) a un sitio señuelo benigno. Esto protege al servidor del equipo del descubrimiento, la eliminación y la atribución, y permite a los operadores rotar el borde público sin reconstruir el backend. La técnica se asigna a T1090.002 (Proxy: Proxy Externo) de MITRE ATT&CK: los adversarios enrutan el C2 a través de un nodo intermediario para ocultar el origen real.

Los redirectores vienen en dos sabores. Las tuberías simples (socat, iptables NAT) reenvían un puerto ciegamente y proporcionan separación pero ningún filtrado. Los redirectores inteligentes/con filtrado (nginx proxy_pass, Apache mod_rewrite con [P], o herramientas especializadas como RedWarden) analizan las solicitudes HTTP y solo reenvían el tráfico que coincide con el perfil Malleable C2 del implant: URI correcto, User-Agent, cabeceras, mientras envían todo lo demás una 302 a un sitio web real. La lógica de filtrado se deriva directamente del perfil de tráfico del framework C2, por lo que ambos deben permanecer sincronizados. Herramientas como cs2modrewrite automatizan la generación de reglas de Apache/nginx a partir de un perfil Malleable C2 de Cobalt Strike.

Esta habilidad cubre la construcción de redirectores simples y con filtrado con nginx y Apache, la derivación de reglas de filtrado a partir de un perfil malleable, la adición de TLS con Let's Encrypt y la aplicación de controles OPSEC (dominios categorizados, domain fronting/CDN fronting, validación de cabeceras, filtrado geo/UA) para una infraestructura resiliente y de baja atribución.

Cuándo Usarlo

• Levantar un C2 de equipo rojo que deba sobrevivir al triaje del equipo azul y a las solicitudes de eliminación de dominio.
• Separar un servidor de equipo oculto de cualquier host con conexión a Internet durante un ejercicio.
• Filtrar el tráfico del implant para que solo las solicitudes que coinciden con el perfil lleguen al backend, desviando a los escáneres.
• Añadir terminación TLS, categorización de dominios y domain fronting/CDN fronting a un listener HTTP(S).
• Enseñar a los defensores cómo se construye el C2 con proxy externo (T1090.002) para que puedan detectarlo.

Prerrequisitos

• Una o más instancias VPS desechables en la nube (el borde del redirector) y un host de servidor de equipo separado y con cortafuegos.
• Un dominio registrado con DNS controlable, idealmente añejo/categorizado.
• Acceso root en el host del redirector. Instalar el servidor web y las herramientas TLS:

  # Redirector Debian/Ubuntu
  sudo apt update
  sudo apt install -y nginx apache2 socat certbot python3-certbot-nginx git
  # Habilitar módulos proxy de Apache si se usa redirector mod_rewrite
  sudo a2enmod rewrite proxy proxy_http ssl headers
  

• El perfil Malleable C2 del framework C2 (.profile de Cobalt Strike, perfil HTTP de Sliver/Havoc) que define URIs, User-Agent y cabeceras.
• cs2modrewrite para generar automáticamente reglas a partir de un perfil de Cobalt Strike:

  git clone https://github.com/threatexpress/cs2modrewrite
  

• Configurar el cortafuegos del servidor del equipo para que solo acepte la IP de origen del redirector en el puerto C2.

Objetivos

• Implementar un redirector de tubería simple (socat/iptables) para una separación rápida de puertos.
• Implementar un redirector de proxy inverso con filtrado nginx basado en un perfil malleable.
• Implementar un redirector Apache mod_rewrite con proxy [P] y señuelo de respaldo 302.
• Generar automáticamente reglas de redirector a partir de un perfil de Cobalt Strike con cs2modrewrite.
• Terminar TLS con Let's Encrypt y endurecer el borde público.
• Aplicar OPSEC: validación de cabeceras/UA, filtrado geográfico, desvío a señuelo y rotación de infraestructura.

Mapeo MITRE ATT&CK

ID de Técnica	Nombre Oficial	Relevancia
T1090.002	Proxy: Proxy Externo	El redirector es un intermediario externo que utiliza proxy para C2 con el fin de ocultar el servidor del equipo
T1090.004	Proxy: Domain Fronting	El CDN fronting enruta el tráfico del beacon a través de un dominio de confianza y alta reputación
T1071.001	Protocolo de Capa de Aplicación: Protocolos Web	El C2 se tuneliza a través de HTTP/HTTPS moldeado por el perfil malleable
T1573.002	Canal Cifrado: Criptografía Asimétrica	La terminación TLS en el redirector cifra el canal del beacon
T1583.006	Adquirir Infraestructura: Servicios Web	Se adquieren bordes VPS/CDN desechables para un C2 resiliente

Flujo de Trabajo

1. Laboratorio y cortafuegos del servidor del equipo

Colocar el servidor del equipo en un host privado. Restringir su puerto C2 solo a la IP del redirector.

# En el servidor del equipo: solo el redirector (203.0.113.10) puede acceder al puerto 443/tcp
sudo ufw default deny incoming
sudo ufw allow from 203.0.113.10 to any port 443 proto tcp
sudo ufw allow OpenSSH
sudo ufw enable

2. Redirector de tubería simple (socat / iptables)

Para una separación rápida sin filtrado, reenviar el puerto C2 al servidor del equipo.

# Reenvío en primer plano con socat del puerto 443 al servidor del equipo
socat TCP4-LISTEN:443,fork,reuseaddr TCP4:10.0.0.2:443

# O DNAT con iptables (persistente)
sysctl -w net.ipv4.ip_forward=1
iptables -t nat -A PREROUTING -p tcp --dport 443 -j DNAT --to-destination 10.0.0.2:443
iptables -t nat -A POSTROUTING -p tcp -d 10.0.0.2 --dport 443 -j MASQUERADE

3. Redirector de proxy inverso con filtrado nginx

Solo enviar mediante proxy las solicitudes cuya URI coincida con el perfil malleable; enviar todo lo demás una 302 a un señuelo. Reemplazar la regex de ubicación y el User-Agent con los valores de su perfil.

# /etc/nginx/sites-available/redirector.conf
server {
    listen 443 ssl;
    server_name cdn.example.com;

    ssl_certificate     /etc/letsencrypt/live/cdn.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/cdn.example.com/privkey.pem;

    # Enviar mediante proxy SOLO las URIs C2 que coinciden con el perfil al servidor del equipo oculto
    location ~ ^/(api/v2/jobs|cm/[a-z0-9]+|push) {
        # Exigir el User-Agent exacto del implant
        if ($http_user_agent != "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36") {
            return 302 https://www.legitimate-decoy.com/;
        }
        proxy_pass https://10.0.0.2;
        proxy_ssl_verify off;
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-For $remote_addr;
    }

    # Todo lo demás -> señuelo benigno
    location / {
        return 302 https://www.legitimate-decoy.com/;
    }
}

sudo ln -s /etc/nginx/sites-available/redirector.conf /etc/nginx/sites-enabled/
sudo nginx -t && sudo systemctl reload nginx

4. Redirector Apache mod_rewrite

La bandera [P] de Apache envía mediante proxy las solicitudes coincidentes al servidor del equipo; las no coincidentes obtienen una redirección 302. Este es el formato que produce cs2modrewrite.

# /etc/apache2/sites-available/redirector.conf  (dentro de <VirtualHost *:443>)
RewriteEngine On
SSLProxyEngine On
# Exigir el User-Agent del implant
RewriteCond %{HTTP_USER_AGENT} "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36" [NC]
# Coincidir con URIs C2 válidas (GET/POST/stager) del perfil malleable
RewriteCond %{REQUEST_URI} ^/(api/v2/jobs|cm/[a-z0-9]+|push)/?$
# Enviar mediante proxy al servidor del equipo oculto, preservando la URI
RewriteRule ^.*$ https://10.0.0.2%{REQUEST_URI} [P,L]
# Todo lo demás -> sitio señuelo
RewriteRule ^.*$ https://www.legitimate-decoy.com/ [R=302,L]

sudo a2ensite redirector && sudo apache2ctl configtest && sudo systemctl reload apache2

5. Generar reglas a partir de un perfil malleable

Permitir que cs2modrewrite construya las reglas de Apache o nginx directamente desde su perfil de Cobalt Strike para que el filtro coincida exactamente con el tráfico del beacon.

cd cs2modrewrite
# Reglas Apache mod_rewrite
python3 cs2modrewrite.py -i havex.profile -c https://10.0.0.2 \
  -r https://www.legitimate-decoy.com -o /etc/apache2/redirect.rules
# Configuración de nginx
python3 cs2nginx.py -i havex.profile -c https://10.0.0.2 \
  -r https://www.legitimate-decoy.com -H cdn.example.com > /etc/nginx/sites-available/c2.conf

6. Terminar TLS con Let's Encrypt

Emitir un certificado válido para que el HTTPS del beacon no genere advertencias TLS y el borde parezca legítimo.

sudo certbot --nginx -d cdn.example.com --agree-tos -m [email protected] --redirect
# Verificar la renovación automática
sudo certbot renew --dry-run

7. Aplicar controles OPSEC

Añadir capas de defensa contra el análisis del equipo azul: validar cabeceras, geofencing al país objetivo, desviar sandboxes y rotar los bordes. Considerar CDN/domain fronting (T1090.004) donde sea compatible.

# Ejemplo: descartar geografías no objetivo en el cortafuegos con ipset/GeoIP,
# exigir una cabecera de autenticación personalizada en el perfil y rotar el dominio/IP
# del redirector según un cronograma. Verificar que el redirector solo reenvía tráfico coincidente:
curl -k https://cdn.example.com/                       # esperar 302 al señuelo
curl -k -A "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36" \
  https://cdn.example.com/api/v2/jobs                  # esperar respuesta proxy

Herramientas y Recursos

Herramienta	Propósito	Fuente
nginx	Redirector de proxy inverso con filtrado	https://nginx.org/
Apache mod_rewrite	Proxy [P] + redirector señuelo 302	https://httpd.apache.org/docs/current/mod/mod_rewrite.html
cs2modrewrite	Generar reglas de Apache/nginx desde perfil CS	https://github.com/threatexpress/cs2modrewrite
RedWarden	Proxy inverso C2 con filtrado consciente de Malleable	https://github.com/mgeeky/RedWarden
redi	Redirector CS automatizado con nginx + Let's Encrypt	https://github.com/taherio/redi
socat	Reenviador TCP de tubería simple	http://www.dest-unreach.org/socat/
Let's Encrypt / certbot	Certificados TLS gratuitos	https://certbot.eff.org/
ired.team	Referencia de infraestructura de equipo rojo	https://www.ired.team/offensive-security/red-team-infrastructure

Criterios de Validación

• El servidor del equipo está protegido por cortafuegos para aceptar solo la IP de origen del redirector en el puerto C2.
• Redirector implementado (tubería simple y/o proxy inverso con filtrado).
• Reglas de filtrado derivadas del perfil Malleable C2 real (URI + User-Agent + cabeceras).
• Las solicitudes no coincidentes devuelven una 302 a un sitio señuelo benigno (verificado con curl).
• Las solicitudes de beacon coincidentes se envían mediante proxy al servidor del equipo oculto (verificado con curl).
• Certificado TLS válido emitido y renovación automática confirmada.
• Controles OPSEC aplicados (validación de UA/cabeceras, geofencing, desvío a señuelo).
• Se ha considerado la categorización de dominios / CDN fronting cuando corresponda.
• Plan de rotación y desmantelamiento de infraestructura documentado.
• Toda la actividad confinada al alcance del ejercicio autorizado.