登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›驱动开发：内核LoadLibrary实现DLL注入

驱动开发：内核LoadLibrary实现DLL注入

明思义 2025-6-6 20:00:55
远程线程注入是最常用的一种注入技术，在应用层注入是通过CreateRemoteThread这个函数实现的，该函数通过创建线程并调用 LoadLibrary 动态载入指定的DLL来实现注入，而在内核层同样存在一个类似的内核函数RtlCreateUserThread，但需要注意的是此函数未被公开，RtlCreateUserThread其实是对NtCreateThreadEx的包装，但最终会调用ZwCreateThread来实现注入，RtlCreateUserThread是CreateRemoteThread的底层实现。
基于LoadLibrary实现的注入原理可以具体分为如下几步；

  • 1.调用AllocMemory,在对端应用层开辟空间，函数封装来源于《内核远程堆分配与销毁》章节；
  • 2.调用MDLWriteMemory，将DLL路径字符串写出到对端内存，函数封装来源于《内核MDL读写进程内存》章节；
  • 3.调用GetUserModuleAddress，获取到kernel32.dll模块基址，函数封装来源于《内核远程线程实现DLL注入》章节；
  • 4.调用GetModuleExportAddress，获取到LoadLibraryW函数的内存地址，函数封装来源于《内核远程线程实现DLL注入》章节；
  • 5.最后调用本章封装函数MyCreateRemoteThread，将应用层DLL动态转载到进程内，实现DLL注入；
总结起来就是首先在目标进程申请一块空间，空间里面写入要注入的DLL的路径字符串或者是一段ShellCode，找到该内存中LoadLibrary的基址并传入到RtlCreateUserThread中，此时进程自动加载我们指定路径下的DLL文件。
注入依赖于RtlCreateUserThread这个未到处内核函数，该内核函数中最需要关心的参数是ProcessHandle用于接收进程句柄，StartAddress接收一个函数地址，StartParameter用于对函数传递参数，具体的函数原型如下所示；
  1. typedef DWORD(WINAPI* pRtlCreateUserThread)(
  2.     IN HANDLE                    ProcessHandle,          // 进程句柄
  3.     IN PSECURITY_DESCRIPTOR      SecurityDescriptor,
  4.     IN BOOL                      CreateSuspended,
  5.     IN ULONG                     StackZeroBits,
  6.     IN OUT PULONG                StackReserved,
  7.     IN OUT PULONG                StackCommit,
  8.     IN LPVOID                    StartAddress,          // 执行函数地址 LoadLibraryW
  9.     IN LPVOID                    StartParameter,        // 参数传递
  10.     OUT HANDLE                   ThreadHandle,          // 线程句柄
  11.     OUT LPVOID                   ClientID
  12.     );
复制代码
由于我们加载DLL使用的是LoadLibraryW函数，此函数在运行时只需要一个参数，我们可以将DLL的路径传递进去，并调用LoadLibraryW以此来将特定模块拉起，该函数的定义规范如下所示；
  1. HMODULE LoadLibraryW(
  2.   [in] LPCWSTR lpLibFileName
  3. );
复制代码
根据上一篇文章中针对注入头文件lyshark.h的封装，本章将继续使用这个头文件中的函数，首先我们实现这样一个功能，将一段准备好的UCHAR字符串动态的写出到应用层进程内存，并以宽字节模式写出在对端内存中，这段代码可以写为如下样子；
  1. // 署名权
  2. // right to sign one's name on a piece of work
  3. // PowerBy: LyShark
  4. // Email: me@lyshark.com
  6. #include "lyshark.h"
  8. // 驱动卸载例程
  9. VOID UnDriver(PDRIVER_OBJECT driver)
  10. {
  11.         DbgPrint("Uninstall Driver \n");
  12. }
  14. // 驱动入口地址
  15. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
  16. {
  17.         DbgPrint("Hello LyShark \n");
  19.         DWORD process_id = 7112;
  20.         DWORD create_size = 1024;
  21.         DWORD64 ref_address = 0;
  23.         // 分配内存堆 《内核远程堆分配与销毁》 核心代码
  24.         NTSTATUS Status = AllocMemory(process_id, create_size, &ref_address);
  26.         DbgPrint("对端进程: %d \n", process_id);
  27.         DbgPrint("分配长度: %d \n", create_size);
  28.         DbgPrint("[*] 分配内核堆基址: %p \n", ref_address);
  30.         UCHAR DllPath[256] = "C:\\hook.dll";
  31.         UCHAR Item[256] = { 0 };
  33.         // 将字节转为双字
  34.         for (int x = 0, y = 0; x < strlen(DllPath) * 2; x += 2, y++)
  35.         {
  36.                 Item[x] = DllPath[y];
  37.         }
  39.         // 写出内存 《内核MDL读写进程内存》 核心代码
  40.         ReadMemoryStruct ptr;
  42.         ptr.pid = process_id;
  43.         ptr.address = ref_address;
  44.         ptr.size = strlen(DllPath) * 2;
  46.         // 需要写入的数据
  47.         ptr.data = ExAllocatePool(PagedPool, ptr.size);
  49.         // 循环设置
  50.         for (int i = 0; i < ptr.size; i++)
  51.         {
  52.                 ptr.data[i] = Item[i];
  53.         }
  55.         // 写内存
  56.         MDLWriteMemory(&ptr);
  58.         Driver->DriverUnload = UnDriver;
  59.         return STATUS_SUCCESS;
  60. }
复制代码
运行如上方所示的代码，将会在目标进程7112中开辟一段内存空间，并写出C:\hook.dll字符串，运行效果图如下所示；
1.png

此处你可以通过x64dbg附加到应用层进程内，并观察内存0000000002200000会看到如下字符串已被写出，双字类型则是每一个字符空一格，效果图如下所示；
2.png

继续实现所需要的子功能，实现动态获取Kernel32.dll模块里面LiadLibraryW这个导出函数的内存地址，这段代码相信你可以很容易的写出来，根据上节课的知识点我们可以二次封装一个GetProcessAddress来实现对特定模块基址的获取功能，如下是完整代码案例；
  1. // 署名权
  2. // right to sign one's name on a piece of work
  3. // PowerBy: LyShark
  4. // Email: me@lyshark.com
  6. #include "lyshark.h"
  8. // 实现取模块基址
  9. PVOID GetProcessAddress(HANDLE ProcessID, PWCHAR DllName, PCCHAR FunctionName)
  10. {
  11.         PEPROCESS EProcess = NULL;
  12.         NTSTATUS Status = STATUS_SUCCESS;
  13.         KAPC_STATE ApcState;
  14.         PVOID RefAddress = 0;
  16.         // 根据PID得到进程EProcess结构
  17.         Status = PsLookupProcessByProcessId(ProcessID, &EProcess);
  18.         if (Status != STATUS_SUCCESS)
  19.         {
  20.                 return Status;
  21.         }
  23.         // 判断目标进程是32位还是64位
  24.         BOOLEAN IsWow64 = (PsGetProcessWow64Process(EProcess) != NULL) ? TRUE : FALSE;
  26.         // 验证地址是否可读
  27.         if (!MmIsAddressValid(EProcess))
  28.         {
  29.                 return NULL;
  30.         }
  32.         // 将当前线程连接到目标进程的地址空间(附加进程)
  33.         KeStackAttachProcess((PRKPROCESS)EProcess, &ApcState);
  35.         __try
  36.         {
  37.                 UNICODE_STRING DllUnicodeString = { 0 };
  38.                 PVOID BaseAddress = NULL;
  40.                 // 得到进程内模块基地址
  41.                 RtlInitUnicodeString(&DllUnicodeString, DllName);
  43.                 BaseAddress = GetUserModuleAddress(EProcess, &DllUnicodeString, IsWow64);
  45.                 if (!BaseAddress)
  46.                 {
  47.                         return NULL;
  48.                 }
  50.                 DbgPrint("[*] 模块基址: %p \n", BaseAddress);
  52.                 // 得到该函数地址
  53.                 RefAddress = GetModuleExportAddress(BaseAddress, FunctionName, EProcess);
  54.                 DbgPrint("[*] 函数地址: %p \n", RefAddress);
  55.         }
  56.         __except (EXCEPTION_EXECUTE_HANDLER)
  57.         {
  58.                 return NULL;
  59.         }
  61.         // 取消附加
  62.         KeUnstackDetachProcess(&ApcState);
  63.         return RefAddress;
  64. }
  66. VOID Unload(PDRIVER_OBJECT pDriverObj)
  67. {
  68.         DbgPrint("[-] 驱动卸载 \n");
  69. }
  71. NTSTATUS DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegPath)
  72. {
  73.         DbgPrint("Hello LyShark.com \n");
  75.         // 取模块基址
  76.         PVOID pLoadLibraryW = GetProcessAddress(5200, L"kernel32.dll", "LoadLibraryW");
  78.         DbgPrint("[*] 所在内存地址 = %p \n", pLoadLibraryW);
  80.         DriverObject->DriverUnload = Unload;
  81.         return STATUS_SUCCESS;
  82. }
复制代码
编译并运行如上驱动代码，将自动获取PID=5200进程中Kernel32.dll模块内的LoadLibraryW的内存地址，输出效果图如下所示；
3.png

实现注入的最后一步就是调用自定义函数MyCreateRemoteThread该函数实现原理是调用RtlCreateUserThread开线程执行，这段代码的最终实现如下所示；
  1. // 署名权
  2. // right to sign one's name on a piece of work
  3. // PowerBy: LyShark
  4. // Email: me@lyshark.com
  6. #include "lyshark.h"
  8. // 定义函数指针
  9. typedef PVOID(NTAPI* PfnRtlCreateUserThread)
  10. (
  11.         IN HANDLE ProcessHandle,
  12.         IN PSECURITY_DESCRIPTOR SecurityDescriptor,
  13.         IN BOOLEAN CreateSuspended,
  14.         IN ULONG StackZeroBits,
  15.         IN OUT size_t StackReserved,
  16.         IN OUT size_t StackCommit,
  17.         IN PVOID StartAddress,
  18.         IN PVOID StartParameter,
  19.         OUT PHANDLE ThreadHandle,
  20.         OUT PCLIENT_ID ClientID
  21. );
  23. // 实现取模块基址
  24. PVOID GetProcessAddress(HANDLE ProcessID, PWCHAR DllName, PCCHAR FunctionName)
  25. {
  26.         PEPROCESS EProcess = NULL;
  27.         NTSTATUS Status = STATUS_SUCCESS;
  28.         KAPC_STATE ApcState;
  29.         PVOID RefAddress = 0;
  31.         // 根据PID得到进程EProcess结构
  32.         Status = PsLookupProcessByProcessId(ProcessID, &EProcess);
  33.         if (Status != STATUS_SUCCESS)
  34.         {
  35.                 return Status;
  36.         }
  38.         // 判断目标进程是32位还是64位
  39.         BOOLEAN IsWow64 = (PsGetProcessWow64Process(EProcess) != NULL) ? TRUE : FALSE;
  41.         // 验证地址是否可读
  42.         if (!MmIsAddressValid(EProcess))
  43.         {
  44.                 return NULL;
  45.         }
  47.         // 将当前线程连接到目标进程的地址空间(附加进程)
  48.         KeStackAttachProcess((PRKPROCESS)EProcess, &ApcState);
  50.         __try
  51.         {
  52.                 UNICODE_STRING DllUnicodeString = { 0 };
  53.                 PVOID BaseAddress = NULL;
  55.                 // 得到进程内模块基地址
  56.                 RtlInitUnicodeString(&DllUnicodeString, DllName);
  58.                 BaseAddress = GetUserModuleAddress(EProcess, &DllUnicodeString, IsWow64);
  60.                 if (!BaseAddress)
  61.                 {
  62.                         return NULL;
  63.                 }
  65.                 DbgPrint("[*] 模块基址: %p \n", BaseAddress);
  67.                 // 得到该函数地址
  68.                 RefAddress = GetModuleExportAddress(BaseAddress, FunctionName, EProcess);
  69.                 DbgPrint("[*] 函数地址: %p \n", RefAddress);
  70.         }
  71.         __except (EXCEPTION_EXECUTE_HANDLER)
  72.         {
  73.                 return NULL;
  74.         }
  76.         // 取消附加
  77.         KeUnstackDetachProcess(&ApcState);
  78.         return RefAddress;
  79. }
  81. // 远程线程注入函数
  82. BOOLEAN MyCreateRemoteThread(ULONG pid, PVOID pRing3Address, PVOID PParam)
  83. {
  84.         NTSTATUS status = STATUS_UNSUCCESSFUL;
  85.         PEPROCESS pEProcess = NULL;
  86.         KAPC_STATE ApcState = { 0 };
  88.         PfnRtlCreateUserThread RtlCreateUserThread = NULL;
  89.         HANDLE hThread = 0;
  91.         __try
  92.         {
  93.                 // 获取RtlCreateUserThread函数的内存地址
  94.                 UNICODE_STRING ustrRtlCreateUserThread;
  95.                 RtlInitUnicodeString(&ustrRtlCreateUserThread, L"RtlCreateUserThread");
  96.                 RtlCreateUserThread = (PfnRtlCreateUserThread)MmGetSystemRoutineAddress(&ustrRtlCreateUserThread);
  97.                 if (RtlCreateUserThread == NULL)
  98.                 {
  99.                         return FALSE;
  100.                 }
  102.                 // 根据进程PID获取进程EProcess结构
  103.                 status = PsLookupProcessByProcessId((HANDLE)pid, &pEProcess);
  104.                 if (!NT_SUCCESS(status))
  105.                 {
  106.                         return FALSE;
  107.                 }
  109.                 // 附加到目标进程内
  110.                 KeStackAttachProcess(pEProcess, &ApcState);
  112.                 // 验证进程是否可读写
  113.                 if (!MmIsAddressValid(pRing3Address))
  114.                 {
  115.                         return FALSE;
  116.                 }
  118.                 // 启动注入线程
  119.                 status = RtlCreateUserThread(ZwCurrentProcess(),
  120.                         NULL,
  121.                         FALSE,
  122.                         0,
  123.                         0,
  124.                         0,
  125.                         pRing3Address,
  126.                         PParam,
  127.                         &hThread,
  128.                         NULL);
  129.                 if (!NT_SUCCESS(status))
  130.                 {
  131.                         return FALSE;
  132.                 }
  134.                 return TRUE;
  135.         }
  137.         __finally
  138.         {
  139.                 // 释放对象
  140.                 if (pEProcess != NULL)
  141.                 {
  142.                         ObDereferenceObject(pEProcess);
  143.                         pEProcess = NULL;
  144.                 }
  146.                 // 取消附加进程
  147.                 KeUnstackDetachProcess(&ApcState);
  148.         }
  150.         return FALSE;
  151. }
  153. VOID Unload(PDRIVER_OBJECT pDriverObj)
  154. {
  155.         DbgPrint("[-] 驱动卸载 \n");
  156. }
  158. NTSTATUS DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegPath)
  159. {
  160.         DbgPrint("Hello LyShark.com \n");
  162.         ULONG process_id = 5200;
  163.         DWORD create_size = 1024;
  164.         DWORD64 ref_address = 0;
  166.         // -------------------------------------------------------
  167.         // 取模块基址
  168.         // -------------------------------------------------------
  170.         PVOID pLoadLibraryW = GetProcessAddress(process_id, L"kernel32.dll", "LoadLibraryW");
  171.         DbgPrint("[*] 所在内存地址 = %p \n", pLoadLibraryW);
  173.         // -------------------------------------------------------
  174.         // 应用层开堆
  175.         // -------------------------------------------------------
  177.         NTSTATUS Status = AllocMemory(process_id, create_size, &ref_address);
  179.         DbgPrint("对端进程: %d \n", process_id);
  180.         DbgPrint("分配长度: %d \n", create_size);
  181.         DbgPrint("分配的内核堆基址: %p \n", ref_address);
  183.         // 设置注入路径,转换为多字节
  184.         UCHAR DllPath[256] = "C:\\lyshark_hook.dll";
  185.         UCHAR Item[256] = { 0 };
  187.         for (int x = 0, y = 0; x < strlen(DllPath) * 2; x += 2, y++)
  188.         {
  189.                 Item[x] = DllPath[y];
  190.         }
  192.         // -------------------------------------------------------
  193.         // 写出数据到内存
  194.         // -------------------------------------------------------
  196.         ReadMemoryStruct ptr;
  198.         ptr.pid = process_id;
  199.         ptr.address = ref_address;
  200.         ptr.size = strlen(DllPath) * 2;
  202.         // 需要写入的数据
  203.         ptr.data = ExAllocatePool(PagedPool, ptr.size);
  205.         // 循环设置
  206.         for (int i = 0; i < ptr.size; i++)
  207.         {
  208.                 ptr.data[i] = Item[i];
  209.         }
  211.         // 写内存
  212.         MDLWriteMemory(&ptr);
  214.         // -------------------------------------------------------
  215.         // 执行开线程函数
  216.         // -------------------------------------------------------
  218.         // 执行线程注入
  219.         // 参数1：PID
  220.         // 参数2：LoadLibraryW内存地址
  221.         // 参数3：当前DLL路径
  222.         BOOLEAN flag = MyCreateRemoteThread(process_id, pLoadLibraryW, ref_address);
  223.         if (flag == TRUE)
  224.         {
  225.                 DbgPrint("[*] 已完成进程 %d 注入文件 %s \n", process_id, DllPath);
  226.         }
  228.         DriverObject->DriverUnload = Unload;
  229.         return STATUS_SUCCESS;
  230. }
复制代码
编译这段驱动程序，并将其放入虚拟机中，在C盘下面放置好一个名为lyshark_hook.dll文件，运行驱动程序将自动插入DLL到Win32Project进程内，输出效果图如下所示；
4.png

回到应用层进程，则可看到如下图所示的注入成功提示信息；
5.png


来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
明思义
2025-6-6 20:00:55

0

粉丝关注

14

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫