API communes utilisées dans les malwares

Reading time: 9 minutes

Général

Réseau

Pinning TLS et transport en morceaux

Many loaders wrap their TCP stream in SslStream and pin the server’s leaf certificate against an embedded copy (certificate pinning). Bot info/tasks are compressed (e.g., GZip). When responses exceed a threshold (~1 MB), data is fragmented into small chunks (e.g., 16 KB segments) to avoid size-based heuristics and reduce memory spikes during deserialisation.

Persistance

Chiffrement

Anti-analyse / VM

Contrôle d'exécution basé sur la locale/le clavier

Many stealers/loaders abort on certain locales to evade researchers and comply with threat-actor constraints. Typical checks:

• GetKeyboardLayout to enumerate installed layouts (per-thread/user)
• GetLocaleInfoA/W to resolve country/region codes
• GetSystemDefaultLangID / GetUserDefaultLangID

If any match a blocked list (commonly CIS countries), the loader exits immediately before network IOCs or injection.

Défense/chasse

• Signaler les processus qui interrogent plusieurs API de locale/clavier tôt dans l'exécution puis quittent sans activité observable.
• Corréler avec les vérifications anti-VM (chaînes BIOS, périphériques PnP, modèle de disque, services) réutilisées depuis des projets open-source (par ex., VMDetector) pour détecter l'exécution conditionnée.

Empreinte d'API des émulateurs et évasion du délai/sommeil

Malware often fingerprints sandbox emulators by searching for Defender’s virtualised exports (seen in the Malware Protection Emulator). If any of these symbols are present (case-insensitive scan of the process), execution is delayed for 10–30 minutes and re-checked to waste analysis time.

Examples of API names used as canaries:

• MpVmp32Entry, MpVmp32FastEnter, MpCallPreEntryPointCode, MpCallPostEntryPointCode, MpFinalize, MpReportEvent*, MpSwitchToNextThread*
• VFS_* family: VFS_Open, VFS_Read, VFS_MapViewOfFile, VFS_UnmapViewOfFile, VFS_FindFirstFile/FindNextFile, VFS_CopyFile, VFS_DeleteFile, VFS_MoveFile
• ThrdMgr_*: ThrdMgr_GetCurrentThreadHandle, ThrdMgr_SaveTEB, ThrdMgr_SwitchThreads

Primitive de temporisation typique (espace utilisateur):

cmd /c timeout /t %RANDOM_IN_[600,1800]% > nul

Argument gatekeeping

• Les opérateurs exigent parfois qu'un switch CLI à apparence bénigne soit présent avant d'exécuter le payload (par ex., /i:--type=renderer pour imiter les processus enfants de Chromium). Si le switch est absent, le loader se termine immédiatement, empêchant une exécution naïve dans un sandbox.

Stealth

Execution

Miscellaneous

• GetAsyncKeyState() -- Enregistrement des frappes (keylogging)
• SetWindowsHookEx -- Enregistrement des frappes (keylogging)
• GetForeGroundWindow -- Obtenir le nom de la fenêtre active (ou le site web depuis un navigateur)
• LoadLibrary() -- Importer une bibliothèque
• GetProcAddress() -- Obtenir l'adresse d'une fonction importée
• CreateToolhelp32Snapshot() -- Lister les processus en cours
• GetDC() -- Faire une capture d'écran
• BitBlt() -- Faire une capture d'écran
• InternetOpen(), InternetOpenUrl(), InternetReadFile(), InternetWriteFile() -- Accéder à Internet
• FindResource(), LoadResource(), LockResource() -- Accéder aux ressources de l'exécutable

Malware Techniques

DLL Injection

Execute an arbitrary DLL inside another process

1. Localiser le processus dans lequel injecter la DLL malveillante: CreateToolhelp32Snapshot, Process32First, Process32Next
2. Ouvrir le processus: GetModuleHandle, GetProcAddress, OpenProcess
3. Écrire le chemin de la DLL dans le processus: VirtualAllocEx, WriteProcessMemory
4. Créer un thread dans le processus qui chargera la DLL malveillante: CreateRemoteThread, LoadLibrary

Other functions to use: NTCreateThreadEx, RtlCreateUserThread

Reflective DLL Injection

Load a malicious DLL without calling normal Windows API calls.
La DLL est mappée dans un processus, elle résoudra les adresses d'import, corrigera les relocations et appellera la fonction DllMain.

Thread Hijacking

Find a thread from a process and make it load a malicious DLL

1. Trouver un thread cible: CreateToolhelp32Snapshot, Thread32First, Thread32Next
2. Ouvrir le thread: OpenThread
3. Suspendre le thread: SuspendThread
4. Écrire le chemin de la DLL malveillante dans le processus victime: VirtualAllocEx, WriteProcessMemory
5. Relancer le thread pour charger la bibliothèque: ResumeThread

PE Injection

Portable Execution Injection: L'exécutable sera écrit dans la mémoire du processus victime et exécuté depuis là.

Process Hollowing (a.k.a RunPE)

Process Hollowing est l'un des trucs préférés de defence-evasion / execution utilisés par les malwares Windows. L'idée est de lancer un processus légitime en état suspendu, supprimer (hollow) son image originale en mémoire et y copier un arbitrary PE à la place. Quand le thread principal est finalement repris, le point d'entrée malveillant s'exécute sous l'apparence d'un binaire de confiance (souvent signé par Microsoft).

Typical workflow:

1. Lancer un hôte bénin (par ex. RegAsm.exe, rundll32.exe, msbuild.exe) suspendu pour qu'aucune instruction ne s'exécute encore.

STARTUPINFOA  si = { sizeof(si) };
PROCESS_INFORMATION pi;
CreateProcessA("C:\\Windows\\Microsoft.NET\\Framework32\\v4.0.30319\\RegAsm.exe",
NULL, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &si, &pi);

2. Lire le payload malveillant en mémoire et parser ses en-têtes PE pour obtenir SizeOfImage, les sections et le nouveau EntryPoint.
3. NtUnmapViewOfSection / ZwUnmapViewOfSection – démapper la base d'image originale du processus suspendu.
4. VirtualAllocEx – réserver de la mémoire RWX de taille SizeOfImage dans le processus distant.
5. WriteProcessMemory – copier d'abord les Headers, puis itérer sur les sections en copiant leurs données brutes.
6. SetThreadContext – patcher la valeur de EAX/RAX (RCX sur x64) ou Rip dans la structure de contexte afin que EIP pointe vers le EntryPoint du payload.
7. ResumeThread – le thread reprend et exécute le code fourni par l'attaquant.

Minimal proof-of-concept (x86) skeleton:

void RunPE(LPCSTR host, LPVOID payload, DWORD payloadSize){
// 1. create suspended process
STARTUPINFOA si = {sizeof(si)}; PROCESS_INFORMATION pi;
CreateProcessA(host, NULL,NULL,NULL,FALSE,CREATE_SUSPENDED,NULL,NULL,&si,&pi);

// 2. read remote PEB to get ImageBaseAddress
CONTEXT ctx; ctx.ContextFlags = CONTEXT_FULL;
GetThreadContext(pi.hThread,&ctx);
PVOID baseAddr;
ReadProcessMemory(pi.hProcess,(PVOID)(ctx.Ebx+8),&baseAddr,4,NULL);

// 3. unmap original image & allocate new region at same base
NtUnmapViewOfSection(pi.hProcess,baseAddr);
PVOID newBase = VirtualAllocEx(pi.hProcess,baseAddr,pHdr->OptionalHeader.SizeOfImage,
MEM_COMMIT|MEM_RESERVE,PAGE_EXECUTE_READWRITE);
// 4-5. copy headers & sections …
// 6. write new image base into PEB and set Eip
WriteProcessMemory(pi.hProcess,(PVOID)(ctx.Ebx+8),&baseAddr,4,NULL);
ctx.Eax = (DWORD)(newBase) + pHdr->OptionalHeader.AddressOfEntryPoint;
SetThreadContext(pi.hThread,&ctx);
// 7. run!
ResumeThread(pi.hThread);
}

Notes pratiques observées dans la campagne DarkCloud Stealer :

• Le loader a choisi RegAsm.exe (part of the .NET Framework) comme hôte — un binaire signé peu susceptible d'attirer l'attention.
• Le stealer VB6 déchiffré (holographies.exe) n'est pas déposé sur le disque ; il existe uniquement à l'intérieur du processus hollowed, ce qui complique la détection statique.
• Les chaînes sensibles (regexes, paths, Telegram credentials) sont RC4-encrypted par chaîne et ne sont déchiffrées qu'à l'exécution, compliquant davantage le scanning mémoire.

Detection ideas:

• Alerter sur les processus CREATE_SUSPENDED qui ne créent jamais de fenêtres GUI/console avant qu'une région mémoire soit allouée en RWX (peu fréquent pour du code légitime).
• Rechercher une séquence d'appels NtUnmapViewOfSection ➜ VirtualAllocEx ➜ WriteProcessMemory entre différents processus.
• Usage inhabituel d'utilitaires de développeur de confiance comme hôtes de hollowing, en particulier MSBuild.exe, RegAsm.exe, rundll32.exe, parentés par des loaders de courte durée.
• Chercher msbuild.exe lancé depuis des chemins modifiables par l'utilisateur ou sans contexte .sln/.proj correspondant, puis effectuant des connexions sortantes (ATT&CK T1127.001 + T1055.012).

Common host processes and path resolution

• MSBuild.exe est fréquemment choisi comme hôte de hollowing pour se fondre dans les outils développeur. Les loaders cherchent souvent les emplacements adaptés à l'architecture :
• C:\Windows\Microsoft.NET\Framework\v4.0.30319\MSBuild.exe
• C:\Windows\Microsoft.NET\Framework64\v4.0.30319\MSBuild.exe
• C:\Windows\System32\MSBuild.exe
• C:\Windows\SysWOW64\MSBuild.exe
• Sélectionner l'hôte correspondant à l'architecture du payload/OS avant d'appeler CreateProcess(..., CREATE_SUSPENDED, ...).

Hooking

• The SSDT (System Service Descriptor Table) pointe vers des fonctions kernel (ntoskrnl.exe) ou le driver GUI (win32k.sys) afin que les processus utilisateur puissent appeler ces fonctions.
• Un rootkit peut modifier ces pointeurs vers des adresses qu'il contrôle.
• Les IRP (I/O Request Packets) transmettent des fragments de données d'un composant à un autre. Presque tout dans le kernel utilise des IRP et chaque device object a sa propre table de fonctions qui peut être hookée : DKOM (Direct Kernel Object Manipulation)
• L'IAT (Import Address Table) est utile pour résoudre les dépendances. Il est possible de hooker cette table afin de détourner le code qui sera appelé.
• Hooks EAT (Export Address Table). Ces hooks peuvent être effectués depuis l'userland. L'objectif est de hooker les fonctions exportées par des DLLs.
• Inline Hooks : Ce type est difficile à réaliser. Cela implique de modifier le code des fonctions elles-mêmes, par exemple en insérant un jump au début.

Références

• Unit42 – New Infection Chain and ConfuserEx-Based Obfuscation for DarkCloud Stealer
• Check Point Research – Under the Pure Curtain: From RAT to Builder to Coder
• Unit 42 – PhantomVAI Loader Delivers a Range of Infostealers
• MITRE ATT&CK – Trusted Developer Utilities Proxy Execution: MSBuild (T1127.001)
• VMDetector – virtualization checks (open-source)