Anti-Rétro-Ingénierie APT - Techniques d'Évasion Avancées

Au-delà de la détection de VM pure, les malwares APT profilent l'environnement pour identifier les caractéristiques d'une sandbox automatisée : peu de fichiers utilisateur, pas d'historique de navigation, résolution d'écran par défaut, etc.

"""
Techniques de fingerprinting anti-sandbox
Implémentées en Python pour l'analyse et la reproduction
"""
import os
import subprocess
import ctypes
import time

class SandboxDetector:
 def __init__(self):
 self.checks = []

 def check_disk_size(self, min_gb=60):
 """Sandboxes utilisent souvent des disques < 60 GB"""
 import shutil
 total, _, _ = shutil.disk_usage("C:\\")
 total_gb = total / (1024**3)
 return total_gb < min_gb

 def check_ram(self, min_gb=4):
 """Sandboxes avec RAM limitée"""
 import psutil
 ram_gb = psutil.virtual_memory().total / (1024**3)
 return ram_gb < min_gb

 def check_cpu_count(self, min_cores=2):
 """VMs de sandbox souvent mono-coeur"""
 return os.cpu_count() < min_cores

 def check_uptime(self, min_minutes=30):
 """Sandbox uptime est souvent très court"""
 uptime_ms = ctypes.windll.kernel32.GetTickCount64()
 uptime_min = uptime_ms / 60000
 return uptime_min < min_minutes

 def check_recent_files(self, min_files=20):
 """Vrais PC ont un historique de fichiers récents"""
 recent = os.path.expandvars(
 r"%APPDATA%\Microsoft\Windows\Recent")
 if not os.path.exists(recent):
 return True
 count = len(os.listdir(recent))
 return count < min_files

 def check_mouse_movement(self, duration_sec=10):
 """Sandboxes n'ont pas de mouvement de souris humain"""
 import ctypes

 class POINT(ctypes.Structure):
 _fields_ = [("x", ctypes.c_long), ("y", ctypes.c_long)]

 positions = set()
 for _ in range(duration_sec * 10):
 pt = POINT()
 ctypes.windll.user32.GetCursorPos(ctypes.byref(pt))
 positions.add((pt.x, pt.y))
 time.sleep(0.1)

 # Moins de 3 positions uniques = pas d'humain
 return len(positions) < 3

 def check_mac_vendors(self):
 """Détection des OUI VMware/VBox/QEMU"""
 vm_macs = [
 "00:0C:29", # VMware
 "00:50:56", # VMware
 "08:00:27", # VirtualBox
 "52:54:00", # QEMU/KVM
 "00:1C:42", # Parallels
 ]
 result = subprocess.run(
 ["getmac", "/fo", "csv", "/nh"],
 capture_output=True, text=True)
 for mac_prefix in vm_macs:
 if mac_prefix.lower() in result.stdout.lower():
 return True
 return False

 def check_username(self):
 """Sandboxes utilisent des noms communs"""
 sandbox_names = [
 "sandbox", "malware", "virus", "sample",
 "test", "john", "user", "admin", "analyst",
 "cuckoo", "vmuser", "computername"
 ]
 username = os.environ.get("USERNAME", "").lower()
 hostname = os.environ.get("COMPUTERNAME", "").lower()
 for name in sandbox_names:
 if name in username or name in hostname:
 return True
 return False

 def run_all(self):
 """Exécute toutes les vérifications"""
 results = {
 "disk_small": self.check_disk_size(),
 "ram_low": self.check_ram(),
 "cpu_low": self.check_cpu_count(),
 "uptime_short": self.check_uptime(),
 "few_recent": self.check_recent_files(),
 "vm_mac": self.check_mac_vendors(),
 "sandbox_name": self.check_username(),
 }
 # Seuil : 3+ indicateurs = sandbox probable
 score = sum(results.values())
 return score >= 3, results, score

Savez-vous identifier les techniques d'anti-analyse utilisées par les malwares modernes ?

// API hashing CRC32 - technique Equation Group
#define HASH_KERNEL32_LOADLIBRARY 0xEC0E4E8E
#define HASH_KERNEL32_GETPROCADDR 0x7C0DFCAA
#define HASH_NTDLL_NTWRITEFILE 0x95A28A3B

DWORD crc32_hash(const char* str) {
 DWORD hash = 0xFFFFFFFF;
 while (*str) {
 hash ^= (unsigned char)(*str++);
 for (int i = 0; i < 8; i++) {
 if (hash & 1)
 hash = (hash >> 1) ^ 0xEDB88320;
 else
 hash >>= 1;
 }
 }
 return hash ^ 0xFFFFFFFF;
}

// Résolution d'API par hash via PEB walking
FARPROC resolve_api_by_hash(DWORD target_hash) {
 // Accès au PEB
 PPEB peb = (PPEB)__readgsqword(0x60);
 PPEB_LDR_DATA ldr = peb->Ldr;

 // Parcours de la liste des modules chargés
 PLIST_ENTRY head = &ldr->InMemoryOrderModuleList;
 PLIST_ENTRY curr = head->Flink;

 while (curr != head) {
 PLDR_DATA_TABLE_ENTRY entry = CONTAINING_RECORD(
 curr, LDR_DATA_TABLE_ENTRY, InMemoryOrderLinks);

 // Parse la table d'exports du module
 PIMAGE_DOS_HEADER dos = (PIMAGE_DOS_HEADER)entry->DllBase;
 PIMAGE_NT_HEADERS nt = (PIMAGE_NT_HEADERS)(
 (BYTE*)dos + dos->e_lfanew);

 DWORD exportRVA = nt->OptionalHeader.DataDirectory[0]
 .VirtualAddress;
 if (exportRVA == 0) { curr = curr->Flink; continue; }

 PIMAGE_EXPORT_DIRECTORY exports = (PIMAGE_EXPORT_DIRECTORY)(
 (BYTE*)dos + exportRVA);

 DWORD* names = (DWORD*)((BYTE*)dos + exports->AddressOfNames);
 WORD* ords = (WORD*)((BYTE*)dos + exports->AddressOfNameOrdinals);
 DWORD* funcs = (DWORD*)((BYTE*)dos + exports->AddressOfFunctions);

 for (DWORD i = 0; i < exports->NumberOfNames; i++) {
 char* name = (char*)((BYTE*)dos + names[i]);
 if (crc32_hash(name) == target_hash) {
 return (FARPROC)((BYTE*)dos + funcs[ords[i]]);
 }
 }
 curr = curr->Flink;
 }
 return NULL;
}

// Script Frida pour bypass des anti-RE en temps réel
// Usage : frida -l bypass_anti_re.js -f malware.exe

console.log("[*] Anti-RE Bypass Script loaded");

// 1. Hook IsDebuggerPresent
Interceptor.attach(Module.findExportByName("kernel32.dll",
 "IsDebuggerPresent"), {
 onLeave: function(retval) {
 retval.replace(0); // Toujours retourner FALSE
 console.log("[+] IsDebuggerPresent -> FALSE");
 }
});

// 2. Hook NtQueryInformationProcess
var ntdll = Module.findBaseAddress("ntdll.dll");
var pNtQIP = Module.findExportByName("ntdll.dll",
 "NtQueryInformationProcess");

Interceptor.attach(pNtQIP, {
 onEnter: function(args) {
 this.infoClass = args[1].toInt32();
 this.outBuffer = args[2];
 },
 onLeave: function(retval) {
 // ProcessDebugPort (7) ou ProcessDebugObjectHandle (0x1E)
 if (this.infoClass === 7 || this.infoClass === 0x1E) {
 this.outBuffer.writeU64(0);
 console.log("[+] NtQueryInformationProcess(" +
 this.infoClass + ") -> 0");
 }
 }
});

// 3. Hook GetTickCount64 (anti-timing)
var originalTick = null;
Interceptor.attach(Module.findExportByName("kernel32.dll",
 "GetTickCount64"), {
 onEnter: function() {
 if (!originalTick) {
 originalTick = Date.now();
 }
 },
 onLeave: function(retval) {
 // Simuler un uptime de 3 heures (éviter détection sandbox)
 var fakeUptime = 10800000 + (Date.now() - originalTick);
 retval.replace(ptr(fakeUptime));
 }
});

// 4. Hook CPUID (anti-VM)
// Note : nécessite Stalker pour intercepter CPUID
var cm = new CModule(`
#include 
extern void on_cpuid(GumCpuContext *ctx) {
 // Si leaf 0x40000000 (hypervisor vendor), retourner vide
 if (ctx->rax == 0x40000000) {
 ctx->rbx = 0;
 ctx->rcx = 0;
 ctx->rdx = 0;
 }
 // Si leaf 1, masquer le bit hypervisor (ECX bit 31)
 if (ctx->rax == 1) {
 ctx->rcx &= ~(1 << 31);
 }
}
`);

// 5. Patcher les checks de nom d'utilisateur/hostname
Interceptor.attach(Module.findExportByName("kernel32.dll",
 "GetComputerNameA"), {
 onLeave: function(retval) {
 var buf = this.context.rcx || this.context.r8;
 // Remplacer par un nom réaliste
 buf.writeAnsiString("DESKTOP-A7B3C9D");
 console.log("[+] ComputerName -> DESKTOP-A7B3C9D");
 }
});

console.log("[*] All hooks installed. Anti-RE bypassed.");

9.3 Fuzzing avec AFL++ pour découvrir les chemins cachés

#!/bin/bash
# Utilisation d'AFL++ pour fuzzer un malware et découvrir
# les chemins d'exécution cachés derrière les anti-RE

# 1. Compiler le harness avec instrumentation AFL
export AFL_CC_COMPILER=LLVM
afl-clang-lto -o harness harness.c \
 -fsanitize=address \
 -DFUZZ_MODE=1

# 2. Créer le corpus initial (inputs connus)
mkdir -p corpus/
echo -n "NORMAL_INPUT" > corpus/seed1.bin
echo -n "\x00\x00\x00\x00" > corpus/seed2.bin

# 3. Créer le dictionnaire de tokens du malware
cat > dict.txt << 'EOF'
# Tokens extraits du malware
"VMware"
"VBOX"
"Sandbox"
"cuckoo"
"\x0F\x31" # RDTSC
"\xCD\x2D" # INT 2D
"\x64\xA1\x30\x00\x00\x00" # PEB access x86
EOF

# 4. Lancer le fuzzing multi-coeur
afl-fuzz -i corpus/ -o findings/ \
 -x dict.txt \
 -m 512 \
 -t 5000 \
 -M master \
 -- ./harness @@

# En parallèle sur d'autres coeurs :
# afl-fuzz -i corpus/ -o findings/ -S slave01 -- ./harness @@
# afl-fuzz -i corpus/ -o findings/ -S slave02 -- ./harness @@

# 5. Analyser les crashes et les chemins découverts
afl-tmin -i findings/master/crashes/ -o minimized/ -- ./harness @@

echo "[*] Chemins uniques découverts :"
ls findings/master/queue/ | wc -l

echo "[*] Crashes trouvés :"
ls findings/master/crashes/ | wc -l

Pour approfondir ce sujet, consultez notre outil open-source reverse-engineering-scripts qui facilite l'assistance à la rétro-ingénierie de binaires.

Questions frequentes

Sources et références : MITRE ATT&CK · CERT-FR

10. Conclusion

L'analyse des techniques anti-RE déployées par les groupes APT révèle une industrialisation de l'évasion. Les implants modernes ne reposent plus sur une ou deux astuces, mais sur une architecture défensive multicouche où chaque protection renforce les autres.

Les tendances émergentes incluent :

• IA offensive : utilisation de modèles de langage pour générer du code polymorphe contextuel, rendant chaque sample unique et indétectable par signatures statiques
• Anti-RE basée sur l'environnement : le payload ne se déchiffre que sur la machine cible (clé dérivée du hostname, GUID machine, certificats installés), rendant l'analyse impossible sur une machine tierce
• Firmware-level evasion : implants dans le BIOS/UEFI, l'Intel ME, ou les contrôleurs BMC, invisibles à l'OS et survivant aux réinstallations
• Communication covert channel : DNS-over-HTTPS, steganographie dans les images de profil de réseaux sociaux, communications via des services cloud légitimes (OneDrive, Notion, Telegram)

Face à cette sophistication croissante, l'analyste doit maintenir une approche systématique : identifier les couches de protection, les neutraliser séquentiellement, et documenter chaque technique pour alimenter les signatures de détection. Les outils comme Frida, IDAPython et AFL++ sont les alliés essentiels de cette contre-analyse.