Análisis de Comportamiento de Malware con Cuckoo Sandbox

¿Qué hace Análisis de Comportamiento de Malware con Cuckoo Sandbox?

Cuándo Usar

• Una muestra sospechosa ha pasado el análisis estático de triaje y requiere observación conductual en un entorno controlado
• Necesitas capturar tráfico de red, archivos creados, modificaciones al registro y llamadas API de una ejecución de malware
• Determinar la cadena completa de infección, incluyendo descargas de cargas secundarias y mecanismos de persistencia
• Generar firmas de comportamiento y reglas YARA basadas en la actividad observada en tiempo de ejecución
• Análisis automatizado de lotes de muestras de malware que requieren informes consistentes

No usar cuando la muestra es una variante de ransomware conocida que podría propagarse a través de recursos compartidos de red en un sandbox mal configurado; verificar primero el aislamiento de red.

Prerrequisitos

• Cuckoo Sandbox 3.x instalado en un servidor de análisis dedicado (Ubuntu 22.04 recomendado)
• Máquinas virtuales invitadas configuradas con instantáneas de Windows 10/11 (agente de Cuckoo instalado, instantáneas tomadas en estado limpio)
• VirtualBox, KVM o VMware configurados como backend de virtualización de Cuckoo
• Red aislada con InetSim o FakeNet-NG para simular servicios de internet
• Suricata o Snort integrados para la coincidencia de firmas a nivel de red durante el análisis
• Suficiente espacio en disco para capturas PCAP y volcados de memoria (mínimo 500 GB recomendados)

Flujo de Trabajo

Paso 1: Enviar Muestra a Cuckoo

Envía la muestra de malware para análisis automatizado:

# Enviar mediante línea de comandos
cuckoo submit /ruta/a/sospechoso.exe

# Enviar con tiempo de espera de análisis específico (300 segundos)
cuckoo submit --timeout 300 /ruta/a/sospechoso.exe

# Enviar con máquina virtual y paquete de análisis específicos
cuckoo submit --machine win10_x64 --package exe --timeout 300 /ruta/a/sospechoso.exe

# Enviar mediante API REST
curl -F "[email protected]" -F "timeout=300" -F "machine=win10_x64" \
  http://localhost:8090/tasks/create/file

# Enviar URL para análisis
curl -F "url=http://sitio-malicioso.com/carga" -F "timeout=300" \
  http://localhost:8090/tasks/create/url

# Verificar estado de la tarea
curl http://localhost:8090/tasks/view/1 | jq '.task.status'

Paso 2: Monitorear la Ejecución en Tiempo Real

Sigue el progreso del análisis y observa el comportamiento en vivo:

# Ver el registro de análisis de Cuckoo
tail -f /opt/cuckoo/log/cuckoo.log

# Monitorear el estado de las tareas de análisis
cuckoo status

# Acceder a la interfaz web de Cuckoo para capturas de pantalla en vivo y árbol de procesos
# Navegar a http://localhost:8080/analysis/<id_de_tarea>/

Eventos de comportamiento clave a observar durante la ejecución:

• Cadena de creación de procesos (relaciones padre-hijo)
• Intentos de conexión de red a IPs externas
• Archivos creados en directorios temporales o del sistema
• Modificaciones al registro en claves Run o entradas de servicio
• Llamadas API relacionadas con cifrado (CryptEncrypt), inyección (WriteProcessMemory) o evasión

Paso 3: Analizar la Actividad de Procesos

Revisa el árbol de procesos y el rastro de llamadas API del informe de Cuckoo:

# Parsear el informe JSON de Cuckoo mediante programación
import json

with open("/opt/cuckoo/storage/analyses/1/reports/report.json") as f:
    report = json.load(f)

# Análisis del árbol de procesos
for process in report["behavior"]["processes"]:
    pid = process["pid"]
    ppid = process["ppid"]
    name = process["process_name"]
    print(f"PID: {pid} PPID: {ppid} Nombre: {name}")

    # Extraer llamadas API sospechosas
    for call in process["calls"]:
        api = call["api"]
        if api in ["CreateRemoteThread", "VirtualAllocEx", "WriteProcessMemory",
                    "NtCreateThreadEx", "RegSetValueExA", "URLDownloadToFileA"]:
            args = {arg["name"]: arg["value"] for arg in call["arguments"]}
            print(f"  [!] {api}({args})")

Paso 4: Revisar la Actividad de Red

Examina las conexiones de red, consultas DNS y solicitudes HTTP:

# Análisis de red desde el informe de Cuckoo
network = report["network"]

# Resoluciones DNS
print("Consultas DNS:")
for dns in network.get("dns", []):
    print(f"  {dns['request']} -> {dns.get('answers', [])}")

# Solicitudes HTTP
print("\nSolicitudes HTTP:")
for http in network.get("http", []):
    print(f"  {http['method']} {http['uri']} (Host: {http['host']})")
    if http.get("body"):
        print(f"    Cuerpo: {http['body'][:200]}")

# Conexiones TCP
print("\nConexiones TCP:")
for tcp in network.get("tcp", []):
    print(f"  {tcp['src']}:{tcp['sport']} -> {tcp['dst']}:{tcp['dport']}")

# Extraer PCAP para análisis más profundo con Wireshark
# Ubicación del PCAP: /opt/cuckoo/storage/analyses/1/dump.pcap

Paso 5: Examinar Cambios en el Sistema de Archivos y Registro

Documenta los mecanismos de persistencia y archivos creados:

# Operaciones con archivos
print("Archivos Creados/Modificados:")
for f in report["behavior"].get("summary", {}).get("files", []):
    print(f"  {f}")

# Archivos creados con hashes
print("\nArchivos Creados:")
for dropped in report.get("dropped", []):
    print(f"  Ruta: {dropped['filepath']}")
    print(f"  SHA-256: {dropped['sha256']}")
    print(f"  Tamaño: {dropped['size']} bytes")
    print(f"  Tipo: {dropped['type']}")

# Modificaciones al registro
print("\nClaves del Registro Modificadas:")
for key in report["behavior"].get("summary", {}).get("keys", []):
    print(f"  {key}")

Paso 6: Revisar Firmas y Puntuación

Verifica las firmas de comportamiento y la puntuación de amenaza de Cuckoo:

# Firmas de comportamiento activadas
print("Firmas Activadas:")
for sig in report.get("signatures", []):
    severity = sig["severity"]
    name = sig["name"]
    description = sig["description"]
    marker = "[!]" if severity >= 3 else "[*]"
    print(f"  {marker} [{severity}/5] {name}: {description}")
    for mark in sig.get("marks", []):
        if mark.get("call"):
            print(f"      API: {mark['call']['api']}")
        if mark.get("ioc"):
            print(f"      IOC: {mark['ioc']}")

# Puntuación general
score = report.get("info", {}).get("score", 0)
print(f"\nPuntuación de Amenaza General: {score}/10")

Paso 7: Extraer Artefactos del Volcado de Memoria

Analiza el volcado de memoria completo capturado durante la ejecución:

# El volcado de memoria se guarda en:
# /opt/cuckoo/storage/analyses/1/memory.dmp

# Usar Volatility para analizar el volcado de memoria
vol3 -f /opt/cuckoo/storage/analyses/1/memory.dmp windows.pslist
vol3 -f /opt/cuckoo/storage/analyses/1/memory.dmp windows.malfind
vol3 -f /opt/cuckoo/storage/analyses/1/memory.dmp windows.netscan

Conceptos Clave

Término	Definición
Análisis Dinámico	Ejecutar malware en un entorno controlado para observar el comportamiento en tiempo de ejecución, incluyendo llamadas al sistema, actividad de red y operaciones con archivos
Evasión de Sandbox	Técnicas que usa el malware para detectar entornos virtuales/de sandbox y alterar su comportamiento para evitar el análisis (temporizadores de espera, comprobaciones de VM, comprobaciones de interacción del usuario)
Hookeo de API	Método de Cuckoo para interceptar las llamadas API de Windows realizadas por el malware, registrando nombres de funciones, parámetros y valores de retorno
InetSim	Herramienta de simulación de servicios de internet que responde a solicitudes de red del malware (HTTP, DNS, SMTP) dentro de la red de análisis aislada
Inyección de Procesos	Técnica de malware que inyecta código en procesos legítimos; detectada monitoreando secuencias de API como VirtualAllocEx y WriteProcessMemory
Firma de Comportamiento	Detección basada en reglas que coincide secuencias específicas de llamadas API, operaciones con archivos o actividad de red con comportamientos de malware conocidos
Paquete de Análisis	Módulo de Cuckoo que define cómo ejecutar un tipo de archivo específico (exe, dll, pdf, doc) dentro de la máquina virtual invitada para una captura de comportamiento adecuada

Herramientas y Sistemas

• Cuckoo Sandbox: Sistema automatizado de análisis de malware de código abierto que proporciona informes de comportamiento, capturas de red y volcados de memoria
• InetSim: Suite de simulación de servicios de internet que proporciona servicios falsos de HTTP, DNS, SMTP y otros para redes de análisis de malware aisladas
• FakeNet-NG: Herramienta de simulación de red del equipo FLARE que intercepta y redirige todo el tráfico de red para análisis
• Suricata: IDS/IPS de red integrado con Cuckoo para detección en tiempo real basada en firmas de tráfico de red malicioso
• Volatility: Marco de análisis forense de memoria utilizado para analizar volcados de memoria capturados durante el análisis de Cuckoo

Escenarios Comunes

Escenario: Analizando un Dropper Multicapa

Contexto: El análisis estático revela un ejecutable empaquetado con importaciones mínimas y alta entropía. La muestra necesita ejecución en sandbox para observar el desempaquetado, la entrega de la carga y el establecimiento de C2.

Enfoque:

1. Enviar la muestra a Cuckoo con un tiempo de espera extendido (600 segundos) para capturar comportamiento lento
2. Revisar el árbol de procesos para la creación de procesos hijos (dropper que genera procesos de carga)
3. Identificar archivos creados en %TEMP%, %APPDATA% o directorios del sistema
4. Extraer los archivos creados y calcular sus hashes para análisis por separado
5. Mapear las conexiones de red para identificar la infraestructura C2 contactada después de la ejecución inicial
6. Verificar los mecanismos de persistencia (claves Run, tareas programadas, servicios) en las modificaciones al registro
7. Comparar las firmas de comportamiento con familias de malware conocidas

Errores Comunes:

• Usar un tiempo de espera de análisis insuficiente, causando que el sandbox termine antes de que se ejecute la carga de segunda etapa
• No configurar InetSim para responder a solicitudes DNS y HTTP, impidiendo que el malware progrese más allá de la conexión C2
• Ignorar las detecciones de evasión de sandbox; si la muestra sale inmediatamente, puede estar detectando el entorno virtual
• No analizar los archivos creados por separado; el dropper inicial puede ser menos interesante que la carga final

Formato de Salida

INFORME DE ANÁLISIS DINÁMICO - CUCKOO SANDBOX
==============================================
ID de Tarea:      1547
Muestra:          sospechoso.exe (SHA-256: e3b0c44298fc1c149afbf4c8996fb924...)
Tiempo de Análisis: 300 segundos
MV:               win10_x64 (Windows 10 21H2)
Puntuación:       8.5/10

ÁRBOL DE PROCESOS
sospechoso.exe (PID: 2184)
  └── cmd.exe (PID: 3456)
      └── powershell.exe (PID: 4012)
          └── svchost_fake.exe (PID: 4568)

ACTIVIDAD DEL SISTEMA DE ARCHIVOS
[CREADO]  C:\Users\Admin\AppData\Local\Temp\payload.dll
[CREADO]  C:\Windows\System32\svchost_fake.exe
[MODIFICADO] C:\Windows\System32\drivers\etc\hosts

MODIFICACIONES AL REGISTRO
[ESTABLECIDO] HKCU\Software\Microsoft\Windows\CurrentVersion\Run\WindowsUpdate = "C:\Windows\System32\svchost_fake.exe"
[ESTABLECIDO] HKLM\SYSTEM\CurrentControlSet\Services\FakeService\ImagePath = "C:\Windows\System32\svchost_fake.exe"

ACTIVIDAD DE RED
DNS:    update.malicious[.]com -> 185.220.101.42
HTTP:   POST hxxps://185.220.101[.]42/gate.php (baliza)
TCP:    10.0.2.15:49152 -> 185.220.101.42:443 (237 conexiones)

FIRMAS DE COMPORTAMIENTO
[!] [4/5] injection_createremotethread: Inyecta código en un proceso remoto
[!] [4/5] persistence_autorun: Modifica la clave de registro Run para persistencia
[!] [3/5] network_cnc_http: Realiza comunicación HTTP C2
[*] [2/5] antiav_detectfile: Busca archivos de productos antivirus

ARCHIVOS CREADOS
payload.dll    SHA-256: abc123... Tamaño: 98304  Tipo: PE32 DLL
svchost_fake.exe SHA-256: def456... Tamaño: 184320 Tipo: PE32 EXE