FindResource      ; tìm resource trong file
LoadResource      ; load resource vào bộ nhớ
SizeofResource    ; lấy kích thước resource

VirtualAllocEx      ; cấp phát vùng nhớ trong tiến trình đích
WriteProcessMemory  ; ghi dữ liệu vào vùng nhớ vừa cấp phát

// Bước 1: Lấy handle tiến trình nạn nhân
hVictimProcess = OpenProcess(PROCESS_ALL_ACCESS, 0, victimProcessID);

// Bước 2: Cấp phát vùng nhớ trong tiến trình nạn nhân
pNameInVictimProcess = VirtualAllocEx(hVictimProcess, ..., sizeof(maliciousLibraryName), ...);

// Bước 3: Ghi tên DLL độc hại vào vùng nhớ đó
WriteProcessMemory(hVictimProcess, ..., maliciousLibraryName, sizeof(maliciousLibraryName), ...);

// Bước 4: Lấy địa chỉ của LoadLibrary trong Kernel32.dll
GetModuleHandle("Kernel32.dll");
GetProcAddress(..., "LoadLibraryA");

// Bước 5: Tạo thread trong tiến trình nạn nhân để gọi LoadLibrary
CreateRemoteThread(hVictimProcess, ..., LoadLibraryAddress, pNameInVictimProcess, ...);

// Thường có 2 lần gọi VirtualAllocEx + WriteProcessMemory:

// Lần 1: Ghi DATA cho remote thread
VirtualAllocEx(hProcess, ..., sizeOfData, ...);
WriteProcessMemory(hProcess, pData, data, sizeOfData, ...);

// Lần 2: Ghi CODE của remote thread
VirtualAllocEx(hProcess, ..., sizeOfCode, ...);
WriteProcessMemory(hProcess, pCode, code, sizeOfCode, ...);

// Chạy thread với code và data vừa inject
CreateRemoteThread(hProcess, ..., pCode, pData, ...);

; Tạo tiến trình ở trạng thái suspended
push CREATE_SUSPENDED    ; dwCreationFlags = 0x4
...
call ds:CreateProcessA

; Sau đó thực hiện replacement:
; ZwUnmapViewOfSection  → giải phóng bộ nhớ gốc
; VirtualAllocEx        → cấp phát lại cho malware
; WriteProcessMemory    → ghi malware vào (header + từng section)
; SetThreadContext      → chỉnh entry point
; ResumeThread          → tiến trình "svchost.exe" chạy malware

WH_KEYBOARD     → high-level hook, chạy trong context tiến trình bị hook
WH_KEYBOARD_LL  → low-level hook, event gửi thẳng về tiến trình cài hook

SetWindowsHookEx(
    idHook,      // Loại hook: WH_KEYBOARD, WH_CBT, v.v.
    lpfn,        // Con trỏ đến hàm hook
    hMod,        // Handle DLL chứa hàm hook (high-level) hoặc module local (low-level)
    dwThreadId   // Thread ID cụ thể, hoặc 0 = tất cả threads (bắt buộc = 0 với low-level)
);

push offset LibFileName   ; "hook.dll"
call LoadLibraryA
; eax = handle của hook.dll

push offset ProcName      ; "MalwareProc"
push eax                  ; hModule = hook.dll
call GetProcAddress
; eax = địa chỉ của MalwareProc

call GetNotepadThreadId   ; hàm tự định nghĩa → lấy thread ID của notepad.exe

push eax                  ; dwThreadId
push hModule              ; hmod
push edi                  ; lpfn = MalwareProc
push WH_CBT               ; idHook (ít dùng → ít bị IPS phát hiện)
call SetWindowsHookExA

DllMain của hook.dll chạy → thực thi toàn bộ code độc hại
↓
Gọi ngay LoadLibrary + UnhookWindowsHookEx trong DllMain
→ Đảm bảo message flow không bị ảnh hưởng
→ Hook tự gỡ bỏ sau khi DLL đã được load

1. Malware chọn một binary hợp lệ (vd: notepad.exe)
2. Sửa PE structure → thêm section mới tên ".detour"
   - Đặt giữa export table và debug symbols
   - Chứa PE header gốc + import address table mới
3. Dùng setdll tool (có trong Detours SDK) để:
   - Sửa PE header → trỏ đến import table mới
   - Import table mới có thêm evil.dll
4. Kết quả: mỗi lần notepad.exe khởi động → evil.dll tự động được load

// Bước 1: Tìm tiến trình và thread mục tiêu
CreateToolhelp32Snapshot → Process32First/Next   // tìm tiến trình
Thread32First/Next                               // tìm thread trong tiến trình đó

// Bước 2: Mở handle đến thread
OpenThread(dwDesiredAccess, bInheritHandle, dwThreadId)

// Bước 3: Queue APC vào thread đó
QueueUserAPC(
    pfnAPC,    // Hàm sẽ được gọi (vd: LoadLibraryA)
    hThread,   // Handle của thread mục tiêu
    dwData     // Tham số truyền vào pfnAPC (vd: "dbnet.dll")
)

; Ví dụ thực tế - inject dbnet.dll vào svchost.exe
push [dwThreadId]
push 0
push 10h
call OpenThread             ; Mở handle thread
mov  esi, eax

push "dbnet.dll"            ; dwData = tên DLL cần load
push esi                    ; hThread
push ds:LoadLibraryA        ; pfnAPC
call QueueUserAPC

KeInitializeApc(
    PKAPC Apc,           // KAPC structure (ESI trong ví dụ)
    PKTHREAD Thread,     // Thread mục tiêu (arg_0)
    ...
    PKNORMAL_ROUTINE NormalRoutine,  // ≠ 0 → user-mode APC
    KPROCESSOR_MODE ApcMode,         // = 1 → user-mode
    PVOID NormalContext              // Tham số cho NormalRoutine
);

KeInsertQueueApc(
    PKAPC Apc,           // KAPC structure đã init
    ...
);

; Rootkit example
push ebx
push 1                   ; ApcMode = 1 → user-mode ← dấu hiệu quan trọng
push [ebp+arg_4]
push ebx
push offset sub_11964    ; NormalRoutine ≠ 0 ← dấu hiệu quan trọng
push 2
push [ebp+arg_0]         ; Thread mục tiêu (svchost.exe thread)
push esi                 ; KAPC structure
call ds:KeInitializeApc

push [ebp+arg_C]
push [ebp+arg_8]
push esi
call edi                 ; KeInsertQueueApc