Analyse de Malware

L’analyse de malware consiste à étudier un logiciel malveillant pour comprendre son fonctionnement, ses capacités, son infrastructure et ses indicateurs de compromission (IOCs). Elle est essentielle pour la réponse sur incident, la Threat Intelligence et la détection.

Classification des malwares§

Sous-types de Trojans§

Mécanismes de propagation§

Environnement d’analyse§

Isolation impérative§

Ne jamais analyser un malware sur une machine de production. L’environnement doit être :

• Isolé réseau : VM sans accès internet, ou avec internet simulé (FakeNet-NG, INetSim)
• Snapshottable : restaurer l’état propre après chaque analyse
• Surveillé : capturer toutes les activités système et réseau

VMs spécialisées§

Installation FlareVM :

# Dans une VM Windows isolée
IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/mandiant/flare-vm/main/install.ps1')

INetSim — Simulation réseau§

Simule DNS, HTTP, HTTPS, SMTP, FTP pour observer les communications malware sans accès réel à internet :

# Installation
sudo apt install inetsim

# Configuration (/etc/inetsim/inetsim.conf)
dns_default_ip    192.168.1.100   # IP de la machine INetSim

# Démarrer
sudo inetsim

FakeNet-NG (Windows)§

Même objectif sur Windows :

fakenet.exe

Analyse Statique§

L’analyse statique examine le fichier sans l’exécuter.

Triage initial§

# Identifier le type de fichier
file malware.exe
file malware.bin

# Hash (pour recherche sur VirusTotal/MalwareBazaar)
sha256sum malware.exe
md5sum malware.exe

# Vérifier sur VirusTotal (si l'échantillon n'est pas sensible)
# curl -s --request GET \
#   --url "https://www.virustotal.com/api/v3/files/{sha256}" \
#   --header "x-apikey: $VT_API_KEY"

# Entropy (>7.0 = probable chiffrement ou packing)
python3 -c "
import math, sys
data = open(sys.argv[1], 'rb').read()
freq = [0]*256
for b in data:
    freq[b] += 1
entropy = -sum(f/len(data)*math.log2(f/len(data)) for f in freq if f > 0)
print(f'Entropy: {entropy:.4f}')
" malware.exe

# Ou avec die / exeinfope
die malware.exe         # Detect-It-Easy

Strings§

# Strings ASCII (min 4 chars)
strings malware.exe

# Strings Unicode
strings -el malware.exe

# Filtrer les intéressantes
strings malware.exe | grep -Ei "(http|https|ftp|cmd|powershell|registry|CREATE|CONNECT)"
strings malware.exe | grep -E "(\d{1,3}\.){3}\d{1,3}"  # IPs
strings malware.exe | grep -E "[a-zA-Z0-9+/]{20,}={0,2}"  # Base64 potential

# PEstudio (Windows, GUI)
# Floss (FLARE Obfuscated String Solver) — décode les strings obfusquées
floss malware.exe

Analyse du format PE (Windows)§

import pefile

pe = pefile.PE("malware.exe")

# Informations générales
print(f"Machine: {hex(pe.FILE_HEADER.Machine)}")
print(f"TimeDateStamp: {pe.FILE_HEADER.TimeDateStamp}")
print(f"EntryPoint: {hex(pe.OPTIONAL_HEADER.AddressOfEntryPoint)}")
print(f"ImageBase: {hex(pe.OPTIONAL_HEADER.ImageBase)}")

# Sections
for section in pe.sections:
    print(f"Section: {section.Name.decode().strip(chr(0))}")
    print(f"  VirtualAddress: {hex(section.VirtualAddress)}")
    print(f"  SizeOfRawData: {section.SizeOfRawData}")
    print(f"  Entropy: {section.get_entropy():.4f}")

# Imports
if hasattr(pe, 'DIRECTORY_ENTRY_IMPORT'):
    for entry in pe.DIRECTORY_ENTRY_IMPORT:
        print(f"\nDLL: {entry.dll.decode()}")
        for imp in entry.imports:
            if imp.name:
                print(f"  {imp.name.decode()}")

# Exports
if hasattr(pe, 'DIRECTORY_ENTRY_EXPORT'):
    for exp in pe.DIRECTORY_ENTRY_EXPORT.symbols:
        if exp.name:
            print(f"Export: {exp.name.decode()}")

Imports suspects§

CAPA — Capacités automatiques§

# Identifier automatiquement les capacités
capa malware.exe

# Avec mapping ATT&CK
capa malware.exe -j | python3 -m json.tool | grep -A5 "attack"

# Sur un répertoire
capa samples/ -o results.json

Détection de packers§

# Detect-It-Easy
die malware.exe

# Exemples de résultats :
# "UPX 3.96 (Win32/64)" → dépackable facilement
# "Custom packer" → nécessite analyse dynamique
# Entropy élevée (> 6.8) → suspect

# Dépackage UPX
upx -d malware_packed.exe -o malware_unpacked.exe

Analyse Dynamique§

L’analyse dynamique exécute le malware dans l’environnement contrôlé.

Sandbox automatisée§

Avant toute analyse manuelle, soumettre à un sandbox pour obtenir un rapport rapide :

# Soumettre via API VirusTotal
curl -s --request POST \
  --url "https://www.virustotal.com/api/v3/files" \
  --header "x-apikey: $VT_API_KEY" \
  --form "[email protected]"

Procmon (Process Monitor) — Windows§

Capture tous les accès fichiers, registre, réseau et processus en temps réel.

Filtres utiles dans Procmon :

Process Name → malware.exe       (isoler le processus)
Operation   → RegSetValue        (écritures registre)
Operation   → WriteFile          (créations fichiers)
Operation   → TCP Connect        (connexions réseau)
Result      → SUCCESS            (opérations réussies)
Path        → *Startup*          (persistence)
Path        → *\Run*             (registry run keys)

API Monitor§

Capture les appels API Windows avec leurs arguments et valeurs de retour. Utile pour comprendre les interactions avec l’OS.

x64dbg — Débogueur Windows§

Workflow d'analyse :
1. Ouvrir le binaire (File → Open)
2. F9 : Run jusqu'au point d'entrée
3. F2 : Breakpoint sur une fonction cible
4. F7 : Step Into (rentre dans les appels)
5. F8 : Step Over (exécute sans rentrer)
6. Ctrl+G : Aller à une adresse

Breakpoints utiles :
- VirtualAlloc   → allocation de shellcode
- CreateProcess  → spawn de processus
- WriteFile      → création de fichiers
- connect / WSAConnect → connexions réseau
- RegSetValueEx  → persistence registre
- CryptEncrypt   → chiffrement (ransomware)

Analyse réseau (Wireshark)§

Capturer le trafic pendant l’exécution :

# Commencer la capture avant l'exécution
wireshark -i eth0 -w capture.pcap

# Filtres Wireshark utiles
http                              # Trafic HTTP
dns                               # Requêtes DNS
tcp.flags.syn == 1                # Connexions TCP
ip.addr == 192.168.1.100          # IP spécifique
http.request.method == "POST"     # POSTs (exfiltration)
frame contains "password"         # Strings sensibles
ssl.handshake                     # Connexions TLS

Techniques malware courantes§

Process Injection§

Persistence§

Obfuscation et évasion§

# XOR string decoding (commun dans les malwares)
def decode_xor(data, key):
    return bytes(b ^ key for b in data)

# Exemple : strings XOR encodées avec clé 0x41
encoded = b'\x26\x34\x3b\x3b\x30'  # "hello" XOR 0x41
decoded = decode_xor(encoded, 0x41)
print(decoded.decode())

# Base64 decode
import base64
encoded = "aHR0cHM6Ly9tYWx3YXJlLmNvbS9jMg=="
print(base64.b64decode(encoded).decode())

IOCs à extraire§

Lors de l’analyse, documenter systématiquement :

Fichiers :
- Hashes (MD5, SHA1, SHA256) du binaire original
- Fichiers créés (chemins complets)
- Noms de fichiers droppés

Réseau :
- IPs de C2 contactées
- Domaines (inclure les DGA si applicable)
- URLs complètes
- User-Agents inhabituels
- Ports utilisés

Registre :
- Clés de persistance créées/modifiées
- Valeurs associées

Processus :
- Processus créés
- Process injection (source → cible)
- Arguments de ligne de commande

YARA rules :
- Strings caractéristiques
- Séquences de bytes uniques
- Patterns de comportement

Écrire une règle YARA§

rule Ransomware_GenericExtensionChange {
    meta:
        description = "Détecte un ransomware ajoutant une extension aux fichiers"
        author = "SOC Team"
        date = "2024-01-15"
        severity = "critical"

    strings:
        $s1 = "Your files have been encrypted" nocase
        $s2 = "bitcoin" nocase
        $s3 = ".locked" nocase
        $hex1 = { 48 65 6C 6C 6F 57 6F 72 6C 64 }  // "HelloWorld" hex
        $re1 = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/  // UUID (ransom note ID)

    condition:
        uint16(0) == 0x5A4D and  // MZ header
        filesize < 5MB and
        2 of ($s*)
}

# Scanner avec YARA
yara rule.yar malware.exe
yara -r rule.yar /directory/

# Scanner la mémoire (Volatility)
vol -f memory.dmp windows.yarascan.YaraScan --yara-file rule.yar

Workflow d’analyse complet§

1. TRIAGE
   └─ Hash → VirusTotal lookup
   └─ die/exeinfope → type et packer
   └─ strings → strings lisibles
   └─ capa → capacités automatiques

2. ANALYSE STATIQUE
   └─ pefile → imports, exports, sections, entropy
   └─ Ghidra/IDA → décompilation, compréhension code
   └─ FLOSS → strings obfusquées
   └─ Documenter les APIs suspectes

3. ANALYSE DYNAMIQUE (VM isolée + snapshot)
   └─ INetSim/FakeNet → simuler internet
   └─ Procmon → activité fichiers/registre/réseau
   └─ Wireshark → capture trafic
   └─ x64dbg → debug interactif si nécessaire
   └─ Sandbox → rapport automatisé

4. RAPPORT
   └─ Description comportement
   └─ IOCs (hashes, IPs, domaines, fichiers, clés registre)
   └─ ATT&CK TTPs identifiées
   └─ Recommandations de détection et remediation
   └─ Règles YARA/Sigma si applicable