Malware-Verhalten mit Cuckoo Sandbox analysieren

Analysieren von Malware-Verhalten mit Cuckoo Sandbox

Wann verwenden

• Eine verdächtige Probe hat die statische Analyse bestanden und benötigt eine Verhaltensbeobachtung in einer kontrollierten Umgebung
• Sie müssen Netzwerkverkehr, Datei-Drops, Registry-Änderungen und API-Aufrufe einer Malware-Ausführung erfassen
• Sie möchten die vollständige Infektionskette einschließlich Second-Stage-Payload-Downloads und Persistenzmechanismen ermitteln
• Sie möchten Verhaltenssignaturen und YARA-Regeln basierend auf beobachteter Laufzeitaktivität generieren
• Automatisierte Analyse von Bulk-Malware-Proben mit konsistenter Berichterstattung

Nicht verwenden, wenn es sich bei der Probe um eine bekannte Ransomware-Variante handelt, die sich über Netzwerkfreigaben in einer falsch konfigurierten Sandbox verbreiten könnte; überprüfen Sie zuerst die Netzwerkisolation.

Voraussetzungen

• Cuckoo Sandbox 3.x installiert auf einem dedizierten Analyseserver (Ubuntu 22.04 empfohlen)
• Gast-VMs mit Windows 10/11 Snapshots konfiguriert (Cuckoo-Agent installiert, Snapshots im sauberen Zustand erstellt)
• VirtualBox, KVM oder VMware als Cuckoo-Virtualisierungs-Backend konfiguriert
• Isoliertes Netzwerk mit InetSim oder FakeNet-NG zur Simulation von Internetdiensten
• Suricata oder Snort für netzwerkbasierte Signaturerkennung während der Analyse integriert
• Ausreichend Speicherplatz für PCAP-Aufzeichnungen und Speicher-Dumps (mindestens 500 GB empfohlen)

Workflow

Schritt 1: Probe an Cuckoo übermitteln

Übermitteln Sie die Malware-Probe zur automatisierten Analyse:

# Über die Kommandozeile einreichen
cuckoo submit /pfad/zur/verdaechtige.exe

# Mit spezifischem Analyse-Timeout (300 Sekunden)
cuckoo submit --timeout 300 /pfad/zur/verdaechtige.exe

# Mit spezifischer VM und Analyse-Paket
cuckoo submit --machine win10_x64 --package exe --timeout 300 /pfad/zur/verdaechtige.exe

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

# URL zur Analyse einreichen
curl -F "url=http://malicious-site.com/payload" -F "timeout=300" \
  http://localhost:8090/tasks/create/url

# Aufgabenstatus überprüfen
curl http://localhost:8090/tasks/view/1 | jq '.task.status'

Schritt 2: Ausführung in Echtzeit überwachen

Verfolgen Sie den Analysefortschritt und beobachten Sie das Live-Verhalten:

# Cuckoo-Analyse-Log beobachten
tail -f /opt/cuckoo/log/cuckoo.log

# Aufgabenstatus überwachen
cuckoo status

# Auf Cuckoo-Weboberfläche zugreifen für Live-Screenshots und Prozessbaum
# Navigieren Sie zu http://localhost:8080/analysis/<task_id>/

Wichtige Verhaltensereignisse während der Ausführung:

• Prozesserstellungskette (Eltern-Kind-Beziehungen)
• Netzwerkverbindungsversuche zu externen IPs
• Datei-Drops in temporären Verzeichnissen oder Systemordnern
• Registry-Änderungen an Run-Keys oder Dienst-Einträgen
• API-Aufrufe im Zusammenhang mit Verschlüsselung (CryptEncrypt), Injection (WriteProcessMemory) oder Umgehung

Schritt 3: Prozessaktivität analysieren

Überprüfen Sie den Prozessbaum und die API-Call-Traces aus dem Cuckoo-Bericht:

# Cuckoo JSON-Bericht programmatisch parsen
import json

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

# Prozessbaum-Analyse
for process in report["behavior"]["processes"]:
    pid = process["pid"]
    ppid = process["ppid"]
    name = process["process_name"]
    print(f"PID: {pid} PPID: {ppid} Name: {name}")

    # Verdächtige API-Aufrufe extrahieren
    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})")

Schritt 4: Netzwerkaktivität überprüfen

Untersuchen Sie Netzwerkverbindungen, DNS-Abfragen und HTTP-Anfragen:

# Netzwerkanalyse aus Cuckoo-Bericht
network = report["network"]

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

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

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

# PCAP für tiefere Wireshark-Analyse extrahieren
# PCAP-Speicherort: /opt/cuckoo/storage/analyses/1/dump.pcap

Schritt 5: Dateisystem- und Registry-Änderungen untersuchen

Dokumentieren Sie Persistenzmechanismen und abgelegte Dateien:

# Dateioperationen
print("Erstellte/Geänderte Dateien:")
for f in report["behavior"].get("summary", {}).get("files", []):
    print(f"  {f}")

# Abgelegte Dateien mit Hashes
print("\nAbgelegte Dateien:")
for dropped in report.get("dropped", []):
    print(f"  Pfad: {dropped['filepath']}")
    print(f"  SHA-256: {dropped['sha256']}")
    print(f"  Größe: {dropped['size']} Bytes")
    print(f"  Typ: {dropped['type']}")

# Registry-Änderungen
print("\nGeänderte Registry-Keys:")
for key in report["behavior"].get("summary", {}).get("keys", []):
    print(f"  {key}")

Schritt 6: Signaturen und Bewertung überprüfen

Prüfen Sie Cuckoos Verhaltenssignaturen und die Bedrohungsbewertung:

# Ausgelöste Verhaltenssignaturen
print("Ausgelöste Signaturen:")
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']}")

# Gesamtbewertung
score = report.get("info", {}).get("score", 0)
print(f"\nGesamtbedrohungsbewertung: {score}/10")

Schritt 7: Speicher-Dump-Artefakte extrahieren

Analysieren Sie den während der Ausführung erfassten vollständigen Speicher-Dump:

# Speicher-Dump gespeichert unter:
# /opt/cuckoo/storage/analyses/1/memory.dmp

# Volatility zur Analyse des Speicher-Dumps verwenden
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

Schlüsselkonzepte

Begriff	Definition
Dynamische Analyse	Ausführen von Malware in einer kontrollierten Umgebung, um das Laufzeitverhalten einschließlich Systemaufrufen, Netzwerkaktivität und Dateioperationen zu beobachten
Sandbox-Umgehung	Techniken, mit denen Malware virtuelle Umgebungen/Sandboxen erkennt und ihr Verhalten ändert, um der Analyse zu entgehen (Schlaftimer, VM-Prüfungen, Benutzerinteraktionsprüfungen)
API-Hooking	Cuckoos Methode zum Abfangen von Windows-API-Aufrufen der Malware, um Funktionsnamen, Parameter und Rückgabewerte zu protokollieren
InetSim	Internetservice-Simulationstool, das auf Netzwerkanfragen von Malware (HTTP, DNS, SMTP) im isolierten Analysenetzwerk antwortet
Process Injection	Malware-Technik zum Injizieren von Code in legitime Prozesse; erkannt durch Überwachung von VirtualAllocEx- und WriteProcessMemory-API-Sequenzen
Verhaltenssignatur	Regelbasierte Erkennung, die bestimmte Sequenzen von API-Aufrufen, Dateioperationen oder Netzwerkaktivitäten mit bekannten Malware-Verhaltensweisen abgleicht
Analyse-Paket	Cuckoo-Modul, das definiert, wie ein bestimmter Dateityp (exe, dll, pdf, doc) in der Gast-VM ausgeführt wird, um das Verhalten korrekt zu erfassen

Tools & Systeme

• Cuckoo Sandbox: Open-Source, automatisiertes Malware-Analysesystem, das Verhaltensberichte, Netzwerkaufzeichnungen und Speicher-Dumps liefert
• InetSim: Suite zur Simulation von Internetdiensten, die gefälschte HTTP-, DNS-, SMTP- und andere Dienste für isolierte Malware-Analyse-Netzwerke bereitstellt
• FakeNet-NG: Netzwerksimulationstool des FLARE-Teams, das den gesamten Netzwerkverkehr abfängt und zur Analyse umleitet
• Suricata: Netzwerk-IDS/IPS, das in Cuckoo integriert ist, für die Echtzeit-Signaturerkennung von bösartigem Netzwerkverkehr
• Volatility: Memory-Forensik-Framework zur Analyse von Speicher-Dumps, die während der Cuckoo-Analyse erfasst wurden

Häufige Szenarien

Szenario: Analyse eines mehrstufigen Droppers

Kontext: Die statische Analyse zeigt eine gepackte ausführbare Datei mit minimalen Importen und hoher Entropie. Die Probe muss in der Sandbox ausgeführt werden, um das Entpacken, die Payload-Bereitstellung und den C2-Aufbau zu beobachten.

Vorgehen:

1. Probe mit erweitertem Timeout (600 Sekunden) an Cuckoo übermitteln, um langsames Verhalten zu erfassen
2. Prozessbaum auf Erstellung von Kindprozessen überprüfen (Dropper, der Payload-Prozesse startet)
3. Abgelegte Dateien in %TEMP%, %APPDATA% oder Systemverzeichnissen identifizieren
4. Abgelegte Dateien extrahieren und Hashes für separate Analysen berechnen
5. Netzwerkverbindungen zuordnen, um die nach der ersten Ausführung kontaktierten C2-Infrastrukturen zu identifizieren
6. Auf Persistenzmechanismen (Run-Keys, geplante Aufgaben, Dienste) in Registry-Änderungen prüfen
7. Verhaltenssignaturen mit bekannten Malware-Familien vergleichen

Fallstricke:

• Verwendung eines unzureichenden Analyse-Timeouts, sodass die Sandbox terminiert, bevor die Second-Stage-Payload ausgeführt wird
• Fehlende Konfiguration von InetSim, um auf DNS- und HTTP-Anfragen zu antworten, wodurch die Malware nicht über den C2-Check-in hinauskommt
• Ignorieren von Sandbox-Umgehungserkennungen; wenn die Probe sofort beendet wird, könnte sie die virtuelle Umgebung erkennen
• Fehlende separate Analyse abgelegter Dateien; der ursprüngliche Dropper könnte weniger interessant sein als die endgültige Payload

Ausgabeformat

DYNAMIC ANALYSIS REPORT - CUCKOO SANDBOX
==========================================
Task ID:          1547
Sample:           suspect.exe (SHA-256: e3b0c44298fc1c149afbf4c8996fb924...)
Analysis Time:    300 Sekunden
VM:               win10_x64 (Windows 10 21H2)
Score:            8.5/10

PROCESS TREE
suspect.exe (PID: 2184)
  └── cmd.exe (PID: 3456)
      └── powershell.exe (PID: 4012)
          └── svchost_fake.exe (PID: 4568)

FILE SYSTEM ACTIVITY
[CREATED]  C:\Users\Admin\AppData\Local\Temp\payload.dll
[CREATED]  C:\Windows\System32\svchost_fake.exe
[MODIFIED] C:\Windows\System32\drivers\etc\hosts

REGISTRY MODIFICATIONS
[SET] HKCU\Software\Microsoft\Windows\CurrentVersion\Run\WindowsUpdate = "C:\Windows\System32\svchost_fake.exe"
[SET] HKLM\SYSTEM\CurrentControlSet\Services\FakeService\ImagePath = "C:\Windows\System32\svchost_fake.exe"

NETWORK ACTIVITY
DNS:    update.malicious[.]com -> 185.220.101.42
HTTP:   POST hxxps://185.220.101[.]42/gate.php (beacon)
TCP:    10.0.2.15:49152 -> 185.220.101.42:443 (237 Verbindungen)

BEHAVIORAL SIGNATURES
[!] [4/5] injection_createremotethread: Injiziert Code in entfernten Prozess
[!] [4/5] persistence_autorun: Ändert Run-Registry-Key für Persistenz
[!] [3/5] network_cnc_http: Führt HTTP-C2-Kommunikation durch
[*] [2/5] antiav_detectfile: Prüft auf Antiviren-Produktdateien

DROPPED FILES
payload.dll    SHA-256: abc123... Größe: 98304  Typ: PE32 DLL
svchost_fake.exe SHA-256: def456... Größe: 184320 Typ: PE32 EXE