Häufig verwendete APIs in Malware

Reading time: 9 minutes

Generisch

Netzwerk

TLS-Pinning und chunked Transport

Viele Loader kapseln ihren TCP-Stream in SslStream und pinnen das Server-Leaf-Zertifikat gegen eine eingebettete Kopie (certificate pinning). Bot-Info/Aufgaben werden komprimiert (z. B. GZip). Wenn Antworten eine Schwelle (~1 MB) überschreiten, werden Daten in kleine Chunks fragmentiert (z. B. 16 KB-Segmente), um größenbasierte Heuristiken zu vermeiden und Speicher-Spikes während der Deserialisation zu reduzieren.

Persistenz

Verschlüsselung

Anti-Analyse/VM

Länder-/Tastaturbasierte Ausführungsprüfung

Viele Stealer/Loader brechen bei bestimmten Locales ab, um Forscher zu umgehen und Einschränkungen von Threat-Actor-Gruppen einzuhalten. Typische Prüfungen:

• GetKeyboardLayout zur Auflistung installierter Layouts (pro Thread/User)
• GetLocaleInfoA/W zur Auflösung von Länder-/Regionscodes
• GetSystemDefaultLangID / GetUserDefaultLangID

Wenn eines davon mit einer Blockliste übereinstimmt (häufig CIS-Staaten), beendet sich der Loader sofort, bevor Netzwerk-IOCs oder Injection stattfinden.

Abwehr/Erkennung

• Markiere Prozesse, die mehrere Locale-/Tastatur-APIs früh in der Ausführung abfragen und dann ohne beobachtbare Aktivität beenden.
• Korrreliere mit Anti-VM-Checks (BIOS-Strings, PnP-Geräte, Festplattenmodell, Services), die aus Open-Source-Projekten (z. B. VMDetector) wiederverwendet werden, um gated execution zu erkennen.

Emulator-API-Fingerprinting & Schlafvermeidung

Malware fingerprinted häufig Sandbox-Emulatoren, indem nach Defenders virtualisierten Exports gesucht wird (sichtbar im Malware Protection Emulator). Wenn eines dieser Symbole vorhanden ist (case-insensitive Scan des Prozesses), wird die Ausführung für 10–30 Minuten verzögert und anschließend erneut geprüft, um Analysezeit zu verschwenden.

Beispiele für als Canaries genutzte API-Namen:

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

Typische Verzögerungsroutine (Userland):

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

Argument-Gatekeeping

• Operator verlangen manchmal, dass ein harmlos wirkender CLI-Switch vorhanden ist, bevor das payload ausgeführt wird (z. B. /i:--type=renderer, um Chromium-Child-Prozesse zu imitieren). Ist der Switch nicht vorhanden, beendet sich der loader sofort, was naive sandbox-Ausführung verhindert.

Stealth

Execution

Miscellaneous

• GetAsyncKeyState() -- Key logging
• SetWindowsHookEx -- Key logging
• GetForeGroundWindow -- Namen des aktiven Fensters abrufen (oder die Website aus einem Browser)
• LoadLibrary() -- Bibliothek importieren
• GetProcAddress() -- Bibliothek importieren
• CreateToolhelp32Snapshot() -- Auflistung laufender Prozesse
• GetDC() -- Screenshot erstellen
• BitBlt() -- Screenshot erstellen
• InternetOpen(), InternetOpenUrl(), InternetReadFile(), InternetWriteFile() -- Zugriff auf das Internet
• FindResource(), LoadResource(), LockResource() -- Zugriff auf Ressourcen der ausführbaren Datei

Malware Techniques

DLL Injection

Execute an arbitrary DLL inside another process

1. Finde den Prozess, in den die bösartige DLL injiziert werden soll: CreateToolhelp32Snapshot, Process32First, Process32Next
2. Öffne den Prozess: GetModuleHandle, GetProcAddress, OpenProcess
3. Schreibe den Pfad zur DLL in den Prozessspeicher: VirtualAllocEx, WriteProcessMemory
4. Erzeuge einen Thread im Prozess, der die bösartige DLL lädt: CreateRemoteThread, LoadLibrary

Other functions to use: NTCreateThreadEx, RtlCreateUserThread

Reflective DLL Injection

Load a malicious DLL without calling normal Windows API calls.
Die DLL wird in einen Prozess gemappt, löst die Importadressen auf, korrigiert die Relokationen und ruft die DllMain-Funktion auf.

Thread Hijacking

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

1. Finde einen Ziel-Thread: CreateToolhelp32Snapshot, Thread32First, Thread32Next
2. Öffne den Thread: OpenThread
3. Suspendiere den Thread: SuspendThread
4. Schreibe den Pfad zur bösartigen DLL in den Prozess des Opfers: VirtualAllocEx, WriteProcessMemory
5. Setze den Thread fort, damit die Library geladen wird: ResumeThread

PE Injection

Portable Execution Injection: Die ausführbare Datei wird in den Speicher des Opferprozesses geschrieben und von dort ausgeführt.

Process Hollowing (a.k.a RunPE)

Process Hollowing ist einer der bevorzugten defence-evasion / execution Tricks, die von Windows-Malware verwendet werden. Die Idee ist, einen legitimen Prozess im suspended Zustand zu starten, sein Original-Image aus dem Speicher zu entfernen (hollow) und an seiner Stelle ein arbitrary PE hineinzukopieren. Wenn der primäre Thread schließlich fortgesetzt wird, führt der bösartige Entry-Point unter dem Deckmantel einer vertrauenswürdigen Binary aus (häufig von Microsoft signiert).

Typischer Ablauf:

1. Starte einen harmlosen Host (z. B. RegAsm.exe, rundll32.exe, msbuild.exe) im suspended Zustand, sodass noch keine Instruktionen ausgeführt werden.

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. Lese das bösartige payload in den Speicher und parse die PE-Header, um SizeOfImage, sections und den neuen EntryPoint zu erhalten.
3. NtUnmapViewOfSection / ZwUnmapViewOfSection – die ursprüngliche Image-Base des suspendierten Prozesses entkoppeln (unmap).
4. VirtualAllocEx – RWX-Speicher der Größe SizeOfImage im Remote-Prozess reservieren.
5. WriteProcessMemory – zuerst die Headers kopieren, dann über die Sections iterieren und deren Rohdaten kopieren.
6. SetThreadContext – den Wert von EAX/RAX (RCX auf x64) oder Rip in der Kontextstruktur patchen, sodass EIP auf den EntryPoint des payloads zeigt.
7. ResumeThread – der Thread wird fortgesetzt und führt den vom Angreifer gelieferten Code aus.

Minimales Proof-of-Concept (x86) Skelett:

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);
}

Praktische Hinweise aus der DarkCloud Stealer-Kampagne:

• Der Loader wählte RegAsm.exe (Teil des .NET Framework) als Host – eine signierte Binärdatei, die wahrscheinlich nicht auffällt.
• Der entschlüsselte VB6-stealer (holographies.exe) wird nicht auf die Festplatte geschrieben; er existiert nur innerhalb des hollowed process, was statische Erkennung erschwert.
• Sensible Strings (Regexes, Pfade, Telegram-Credentials) sind RC4-encrypted pro String und werden erst zur Laufzeit entschlüsselt, was Memory-Scanning zusätzlich kompliziert.

Erkennungsansätze:

• Alarm bei CREATE_SUSPENDED Prozessen, die keine GUI/Console-Fenster erzeugen, bevor ein Speicherbereich als RWX alloziert wird (bei legitimen Programmen selten).
• Suche nach der Aufrufsequenz NtUnmapViewOfSection ➜ VirtualAllocEx ➜ WriteProcessMemory über verschiedene Prozesse hinweg.
• Ungewöhnliche Nutzung vertrauenswürdiger Developer-Utilities als hollowing hosts, insbesondere MSBuild.exe, RegAsm.exe, rundll32.exe, parented von kurzlebigen Loadern.
• Hunt nach msbuild.exe, das aus user-writable Pfaden gestartet wurde oder ohne entsprechenden .sln/.proj Kontext läuft und dann ausgehende Verbindungen herstellt (ATT&CK T1127.001 + T1055.012).

Common host processes und Pfadauflösung

• MSBuild.exe wird häufig als hollowing host gewählt, um sich in Developer-Tooling einzufügen. Loader durchsuchen oft architektur-geeignete Orte:
• 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
• Wähle den Host passend zur aktuellen Payload/OS-Architektur, bevor CreateProcess(..., CREATE_SUSPENDED, ...) aufgerufen wird.

Hooking

• Die SSDT (System Service Descriptor Table) zeigt auf Kernel-Funktionen (ntoskrnl.exe) oder GUI-Treiber (win32k.sys), sodass Benutzerprozesse diese Funktionen aufrufen können.
• Ein Rootkit kann diese Pointer auf von ihm kontrollierte Adressen ändern.
• IRP (I/O Request Packets) übertragen Datenstücke von einer Komponente zur anderen. Fast alles im Kernel nutzt IRPs, und jedes device object hat seine eigene Funktionstabelle, die gehookt werden kann: DKOM (Direct Kernel Object Manipulation).
• Die IAT (Import Address Table) ist nützlich, um Abhängigkeiten aufzulösen. Es ist möglich, diese Tabelle zu hooken, um den aufzurufenden Code zu kapern.
• EAT (Export Address Table) Hooks. Diese Hooks können aus dem userland durchgeführt werden. Ziel ist es, von DLLs exportierte Funktionen zu hooken.
• Inline Hooks: Diese sind schwer umzusetzen. Hierbei wird der Code der Funktion selbst verändert, z. B. indem am Anfang ein Jump eingefügt wird.

References

• 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)