hacktricks/src/reversing/common-api-used-in-malware.md

191 lines
9.6 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

# Algemene API's wat in Malware gebruik word
{{#include ../banners/hacktricks-training.md}}
## Generies
### Netwerk
| Rauwe Sockets | WinAPI Sockets |
| ------------- | -------------- |
| socket() | WSAStratup() |
| bind() | bind() |
| listen() | listen() |
| accept() | accept() |
| connect() | connect() |
| read()/recv() | recv() |
| write() | send() |
| shutdown() | WSACleanup() |
### Volharding
| Registrasie | Lêer | Diens |
| ---------------- | ------------- | ---------------------------- |
| RegCreateKeyEx() | GetTempPath() | OpenSCManager |
| RegOpenKeyEx() | CopyFile() | CreateService() |
| RegSetValueEx() | CreateFile() | StartServiceCtrlDispatcher() |
| RegDeleteKeyEx() | WriteFile() | |
| RegGetValue() | ReadFile() | |
### Enkripsie
| Naam |
| --------------------- |
| WinCrypt |
| CryptAcquireContext() |
| CryptGenKey() |
| CryptDeriveKey() |
| CryptDecrypt() |
| CryptReleaseContext() |
### Anti-Analise/VM
| Funksie Naam | Assembly Instruksies |
| --------------------------------------------------------- | --------------------- |
| IsDebuggerPresent() | CPUID() |
| GetSystemInfo() | IN() |
| GlobalMemoryStatusEx() | |
| GetVersion() | |
| CreateToolhelp32Snapshot \[Kontroleer of 'n proses loop\] | |
| CreateFileW/A \[Kontroleer of 'n lêer bestaan\] | |
### Stealth
| Naam | |
| ------------------------ | -------------------------------------------------------------------------- |
| VirtualAlloc | Toewys geheue (packers) |
| VirtualProtect | Verander geheue toestemming (packer gee uitvoerings toestemming aan 'n afdeling) |
| ReadProcessMemory | Inspuiting in eksterne prosesse |
| WriteProcessMemoryA/W | Inspuiting in eksterne prosesse |
| NtWriteVirtualMemory | |
| CreateRemoteThread | DLL/Proses inspuiting... |
| NtUnmapViewOfSection | |
| QueueUserAPC | |
| CreateProcessInternalA/W | |
### Uitvoering
| Funksie Naam |
| ---------------- |
| CreateProcessA/W |
| ShellExecute |
| WinExec |
| ResumeThread |
| NtResumeThread |
### Divers
- GetAsyncKeyState() -- Sleutel logging
- SetWindowsHookEx -- Sleutel logging
- GetForeGroundWindow -- Kry die naam van die lopende venster (of die webwerf van 'n blaaier)
- LoadLibrary() -- Importeer biblioteek
- GetProcAddress() -- Importeer biblioteek
- CreateToolhelp32Snapshot() -- Lys lopende prosesse
- GetDC() -- Skermskoot
- BitBlt() -- Skermskoot
- InternetOpen(), InternetOpenUrl(), InternetReadFile(), InternetWriteFile() -- Toegang tot die Internet
- FindResource(), LoadResource(), LockResource() -- Toegang tot hulpbronne van die uitvoerbare
## Malware Tegnieke
### DLL Inspuiting
Voer 'n arbitrêre DLL binne 'n ander proses uit
1. Vind die proses om die kwaadwillige DLL in te spuit: CreateToolhelp32Snapshot, Process32First, Process32Next
2. Maak die proses oop: GetModuleHandle, GetProcAddress, OpenProcess
3. Skryf die pad na die DLL binne die proses: VirtualAllocEx, WriteProcessMemory
4. Skep 'n draad in die proses wat die kwaadwillige DLL sal laai: CreateRemoteThread, LoadLibrary
Ander funksies om te gebruik: NTCreateThreadEx, RtlCreateUserThread
### Reflektiewe DLL Inspuiting
Laai 'n kwaadwillige DLL sonder om normale Windows API-oproepe te doen.\
Die DLL word binne 'n proses gemap, dit sal die invoeradresse oplos, die herlokasies regmaak en die DllMain-funksie aanroep.
### Draad Hijacking
Vind 'n draad van 'n proses en laat dit 'n kwaadwillige DLL laai
1. Vind 'n teiken draad: CreateToolhelp32Snapshot, Thread32First, Thread32Next
2. Maak die draad oop: OpenThread
3. Suspend die draad: SuspendThread
4. Skryf die pad na die kwaadwillige DLL binne die slagoffer proses: VirtualAllocEx, WriteProcessMemory
5. Herbegin die draad wat die biblioteek laai: ResumeThread
### PE Inspuiting
Portabele Uitvoering Inspuiting: Die uitvoerbare sal in die geheue van die slagoffer proses geskryf word en daarvandaan uitgevoer word.
### Proses Hollowing (ook bekend as **RunPE**)
`Process Hollowing` is een van die gunsteling **verdediging-ontwyking / uitvoering** truuks wat deur Windows malware gebruik word. Die idee is om 'n *legitieme* proses in die **gesuspendeerde** toestand te begin, die oorspronklike beeld uit geheue te verwyder (hol) en 'n **arbitrêre PE** in sy plek te kopieer. Wanneer die primêre draad uiteindelik herbegin word, voer die kwaadwillige toegangspunt uit onder die dekmantel van 'n vertroude binêre (dikwels deur Microsoft onderteken).
Tipiese werksvloei:
1. Begin 'n goedaardige gasheer (bv. `RegAsm.exe`, `rundll32.exe`, `msbuild.exe`) **gesuspendeer** sodat geen instruksies nog loop nie.
```c
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. Lees die kwaadwillige payload in geheue en ontleed sy PE kopstukke om `SizeOfImage`, afdelings en die nuwe `EntryPoint` te verkry.
3. **NtUnmapViewOfSection** / **ZwUnmapViewOfSection** ontkoppel die oorspronklike beeldbasis van die gesuspendeerde proses.
4. **VirtualAllocEx** reserveer RWX geheue van `SizeOfImage` binne die afgeleë proses.
5. **WriteProcessMemory** kopieer die `Headers` eerste, dan oor afdelings iterasie en kopieer hul ruwe data.
6. **SetThreadContext** patch die waarde van `EAX/RAX` (`RCX` op x64) of `Rip` in die konteksstruktuur sodat `EIP` na die payload se `EntryPoint` wys.
7. **ResumeThread** die draad gaan voort, en voer die aanvaller-geleverde kode uit.
Minimale bewys-van-konsep (x86) skelet:
```c
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);
}
```
Praktiese notas waargeneem in die **DarkCloud Stealer** veldtog:
* Die loader het `RegAsm.exe` (deel van die .NET Framework) as gasheer gekies 'n ondertekende binêre wat onwaarskynlik aandag sal trek.
* Die gedekripteerde VB6 stealer (`holographies.exe`) word *nie* op skyf gelaat nie; dit bestaan slegs binne die uitgeholde proses, wat statiese opsporing moeiliker maak.
* Sensitiewe strings (regexes, paaie, Telegram akrediteer) is **RC4-geënkripteer** per string en word slegs tydens uitvoering gedekripteer, wat geheue skandering verder kompliseer.
Opsporingsidees:
* Alarmeer op `CREATE_SUSPENDED` prosesse wat nooit GUI/konsole vensters skep voordat 'n geheuegebied as **RWX** (selde vir goedaardige kode) toegeken word nie.
* Soek vir 'n oproepvolgorde `NtUnmapViewOfSection ➜ VirtualAllocEx ➜ WriteProcessMemory` oor verskillende prosesse.
## Hooking
- Die **SSDT** (**System Service Descriptor Table**) verwys na kernfunksies (ntoskrnl.exe) of GUI stuurprogram (win32k.sys) sodat gebruikersprosesse hierdie funksies kan aanroep.
- 'n Rootkit kan hierdie wysers na adresse wat hy beheer, verander.
- **IRP** (**I/O Request Packets**) stuur stukke data van een komponent na 'n ander. Byna alles in die kern gebruik IRP's en elke toestelobjek het sy eie funksietabel wat gehook kan word: DKOM (Direct Kernel Object Manipulation)
- Die **IAT** (**Import Address Table**) is nuttig om afhanklikhede op te los. Dit is moontlik om hierdie tabel te hook om die kode wat aangeroep sal word, te kap.
- **EAT** (**Export Address Table**) Hooks. Hierdie hooks kan vanaf **userland** gedoen word. Die doel is om geexporteerde funksies deur DLL's te hook.
- **Inline Hooks**: Hierdie tipe is moeilik om te bereik. Dit behels die aanpassing van die kode van die funksies self. Miskien deur 'n sprongetjie aan die begin hiervan te plaas.
## References
- [Unit42 New Infection Chain and ConfuserEx-Based Obfuscation for DarkCloud Stealer](https://unit42.paloaltonetworks.com/new-darkcloud-stealer-infection-chain/)
{{#include ../banners/hacktricks-training.md}}