Analyse du Comportement des Malwares avec Cuckoo Sandbox

Que fait Analyse du Comportement des Malwares avec Cuckoo Sandbox ?

Quand l'Utiliser

• Un échantillon suspect a passé l'analyse statique de triage et nécessite une observation comportementale dans un environnement contrôlé
• Vous devez capturer le trafic réseau, les fichiers déposés, les modifications du registre et les appels API d'une exécution de malware
• Déterminer la chaîne d'infection complète, y compris les téléchargements de payload de deuxième étage et les mécanismes de persistance
• Générer des signatures comportementales et des règles YARA basées sur l'activité runtime observée
• Analyse automatisée d'échantillons de malwares en vrac nécessitant des rapports cohérents

Ne pas utiliser lorsque l'échantillon est une variante de ransomware connue qui pourrait se propager via les partages réseau dans un sandbox mal configuré ; vérifiez d'abord l'isolation réseau.

Prérequis

• Cuckoo Sandbox 3.x installé sur un serveur d'analyse dédié (Ubuntu 22.04 recommandé)
• Machines virtuelles invitées configurées avec des snapshots Windows 10/11 (agent Cuckoo installé, snapshots pris à l'état propre)
• VirtualBox, KVM ou VMware configuré comme backend de virtualisation Cuckoo
• Réseau isolé avec InetSim ou FakeNet-NG pour simuler des services internet
• Suricata ou Snort intégré pour la correspondance de signatures réseau pendant l'analyse
• Espace disque suffisant pour les captures PCAP et les dumps mémoire (500 Go minimum recommandé)

Workflow

Étape 1 : Soumettre l'Échantillon à Cuckoo

Soumettre l'échantillon de malware pour analyse automatisée :

# Soumission via ligne de commande
cuckoo submit /chemin/vers/suspect.exe

# Soumission avec un délai d'analyse spécifique (300 secondes)
cuckoo submit --timeout 300 /chemin/vers/suspect.exe

# Soumission avec une VM et un package d'analyse spécifiques
cuckoo submit --machine win10_x64 --package exe --timeout 300 /chemin/vers/suspect.exe

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

# Soumission d'une URL pour analyse
curl -F "url=http://site-malveillant.com/payload" -F "timeout=300" \
  http://localhost:8090/tasks/create/url

# Vérifier l'état de la tâche
curl http://localhost:8090/tasks/view/1 | jq '.task.status'

Étape 2 : Surveiller l'Exécution en Temps Réel

Suivez la progression de l'analyse et observez le comportement en direct :

# Surveiller le journal d'analyse Cuckoo
tail -f /opt/cuckoo/log/cuckoo.log

# Surveiller l'état de la tâche d'analyse
cuckoo status

# Accéder à l'interface web Cuckoo pour les captures d'écran en direct et l'arbre des processus
# Naviguer vers http://localhost:8080/analysis/<task_id>/

Événements comportementaux clés à surveiller pendant l'exécution :

• Chaîne de création de processus (relations parent-enfant)
• Tentatives de connexion réseau vers des IP externes
• Dépôts de fichiers dans les répertoires temporaires ou système
• Modifications du registre des clés Run ou des entrées de services
• Appels API liés au chiffrement (CryptEncrypt), à l'injection (WriteProcessMemory) ou à l'évasion

Étape 3 : Analyser l'Activité des Processus

Examinez l'arbre des processus et la trace des appels API à partir du rapport Cuckoo :

# Analyser le rapport JSON Cuckoo par programmation
import json

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

# Analyse de l'arbre des processus
for process in report["behavior"]["processes"]:
    pid = process["pid"]
    ppid = process["ppid"]
    name = process["process_name"]
    print(f"PID: {pid} PPID: {ppid} Nom: {name}")

    # Extraire les appels API suspects
    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})")

Étape 4 : Examiner l'Activité Réseau

Examinez les connexions réseau, les requêtes DNS et les requêtes HTTP :

# Analyse réseau depuis le rapport Cuckoo
network = report["network"]

# Résolutions DNS
print("Requêtes DNS :")
for dns in network.get("dns", []):
    print(f"  {dns['request']} -> {dns.get('answers', [])}")

# Requêtes HTTP
print("\nRequêtes HTTP :")
for http in network.get("http", []):
    print(f"  {http['method']} {http['uri']} (Hôte: {http['host']})")
    if http.get("body"):
        print(f"    Corps: {http['body'][:200]}")

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

# Extraire la PCAP pour une analyse Wireshark plus approfondie
# Emplacement PCAP : /opt/cuckoo/storage/analyses/1/dump.pcap

Étape 5 : Examiner les Modifications du Système de Fichiers et du Registre

Documentez les mécanismes de persistance et les fichiers déposés :

# Opérations sur les fichiers
print("Fichiers Créés/Modifiés :")
for f in report["behavior"].get("summary", {}).get("files", []):
    print(f"  {f}")

# Fichiers déposés avec empreintes
print("\nFichiers Déposés :")
for dropped in report.get("dropped", []):
    print(f"  Chemin: {dropped['filepath']}")
    print(f"  SHA-256: {dropped['sha256']}")
    print(f"  Taille: {dropped['size']} octets")
    print(f"  Type: {dropped['type']}")

# Modifications du registre
print("\nClés de Registre Modifiées :")
for key in report["behavior"].get("summary", {}).get("keys", []):
    print(f"  {key}")

Étape 6 : Examiner les Signatures et le Score

Vérifiez les signatures comportementales de Cuckoo et le score de menace :

# Signatures comportementales déclenchées
print("Signatures Déclenchées :")
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']}")

# Score global
score = report.get("info", {}).get("score", 0)
print(f"\nScore de Menace Global : {score}/10")

Étape 7 : Extraire les Artefacts du Dump Mémoire

Analysez le dump mémoire complet capturé pendant l'exécution :

# Le dump mémoire est enregistré à :
# /opt/cuckoo/storage/analyses/1/memory.dmp

# Utiliser Volatility pour analyser le dump mémoire
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

Concepts Clés

Terme	Définition
Analyse Dynamique	Exécution d'un malware dans un environnement contrôlé pour observer le comportement runtime, y compris les appels système, l'activité réseau et les opérations sur les fichiers
Évasion du Sandbox	Techniques utilisées par les malwares pour détecter les environnements virtuels/sandbox et altérer leur comportement pour éviter l'analyse (timers de sommeil, vérifications de VM, vérifications d'interaction utilisateur)
API Hooking	Méthode de Cuckoo pour intercepter les appels API Windows effectués par le malware afin de journaliser les noms de fonctions, paramètres et valeurs de retour
InetSim	Outil de simulation de services internet qui répond aux requêtes réseau du malware (HTTP, DNS, SMTP) dans le réseau d'analyse isolé
Injection de Processus	Technique de malware consistant à injecter du code dans des processus légitimes ; détectée en surveillant les séquences d'API VirtualAllocEx et WriteProcessMemory
Signature Comportementale	Détection basée sur des règles correspondant à des séquences spécifiques d'appels API, d'opérations sur les fichiers ou d'activité réseau à des comportements de malwares connus
Package d'Analyse	Module Cuckoo définissant comment exécuter un type de fichier spécifique (exe, dll, pdf, doc) dans la VM invitée pour une capture comportementale appropriée

Outils et Systèmes

• Cuckoo Sandbox : Système open-source d'analyse automatisée de malwares fournissant des rapports comportementaux, des captures réseau et des dumps mémoire
• InetSim : Suite de simulation de services internet fournissant des faux services HTTP, DNS, SMTP, etc. pour les réseaux d'analyse de malwares isolés
• FakeNet-NG : Outil de simulation réseau de l'équipe FLARE qui intercepte et redirige tout le trafic réseau pour analyse
• Suricata : IDS/IPS réseau intégré à Cuckoo pour la détection en temps réel basée sur des signatures de trafic réseau malveillant
• Volatility : Framework de forensique mémoire utilisé pour analyser les dumps mémoire capturés pendant l'analyse Cuckoo

Scénarios Courants

Scénario : Analyse d'un Dropper Multi-Étapes

Contexte : L'analyse statique révèle un exécutable packé avec des imports minimaux et une entropie élevée. L'échantillon nécessite une exécution en sandbox pour observer le dépaquetage, la livraison du payload et l'établissement du C2.

Approche :

1. Soumettre l'échantillon à Cuckoo avec un délai prolongé (600 secondes) pour capturer un comportement lent
2. Examiner l'arbre des processus pour la création de processus enfants (dropper générant des processus payload)
3. Identifier les fichiers déposés dans %TEMP%, %APPDATA% ou les répertoires système
4. Extraire les fichiers déposés et calculer leurs empreintes pour une analyse séparée
5. Cartographier les connexions réseau pour identifier l'infrastructure C2 contactée après l'exécution initiale
6. Vérifier les mécanismes de persistance (clés Run, tâches planifiées, services) dans les modifications du registre
7. Comparer les signatures comportementales avec les familles de malwares connues

Pièges :

• Utilisation d'un délai d'analyse insuffisant, entraînant l'arrêt du sandbox avant l'exécution du payload de deuxième étage
• Non-configuration d'InetSim pour répondre aux requêtes DNS et HTTP, empêchant le malware de progresser au-delà du check-in C2
• Ignorer les détections d'évasion du sandbox ; si l'échantillon se ferme immédiatement, il peut détecter l'environnement virtuel
• Ne pas analyser les fichiers déposés séparément ; le dropper initial peut être moins intéressant que le payload final

Format de Sortie

RAPPORT D'ANALYSE DYNAMIQUE - CUCKOO SANDBOX
==============================================
ID de Tâche :     1547
Échantillon :      suspect.exe (SHA-256: e3b0c44298fc1c149afbf4c8996fb924...)
Temps d'Analyse : 300 secondes
VM :               win10_x64 (Windows 10 21H2)
Score :            8.5/10

ARBRE DES PROCESSUS
suspect.exe (PID: 2184)
  └── cmd.exe (PID: 3456)
      └── powershell.exe (PID: 4012)
          └── svchost_fake.exe (PID: 4568)

ACTIVITÉ SYSTÈME DE FICHIERS
[CRÉÉ]  C:\Users\Admin\AppData\Local\Temp\payload.dll
[CRÉÉ]  C:\Windows\System32\svchost_fake.exe
[MODIFIÉ] C:\Windows\System32\drivers\etc\hosts

MODIFICATIONS DU REGISTRE
[DÉFINI] HKCU\Software\Microsoft\Windows\CurrentVersion\Run\WindowsUpdate = "C:\Windows\System32\svchost_fake.exe"
[DÉFINI] HKLM\SYSTEM\CurrentControlSet\Services\FakeService\ImagePath = "C:\Windows\System32\svchost_fake.exe"

ACTIVITÉ RÉSEAU
DNS :    update.malicious[.]com -> 185.220.101.42
HTTP :   POST hxxps://185.220.101[.]42/gate.php (balise)
TCP :    10.0.2.15:49152 -> 185.220.101.42:443 (237 connexions)

SIGNATURES COMPORTEMENTALES
[!] [4/5] injection_createremotethread : Injecte du code dans un processus distant
[!] [4/5] persistence_autorun : Modifie la clé de registre Run pour la persistance
[!] [3/5] network_cnc_http : Effectue une communication C2 HTTP
[*] [2/5] antiav_detectfile : Vérifie la présence de fichiers de produits antivirus

FICHIERS DÉPOSÉS
payload.dll    SHA-256: abc123... Taille: 98304  Type: DLL PE32
svchost_fake.exe SHA-256: def456... Taille: 184320 Type: EXE PE32