X64环境遍历32位进程的模块驱动代码

海军上将

1. typedef struct _PEB_LDR_DATA
   
2. {
   
3.         ULONG Length;
   
4.         ULONG Initialized;
   
5.         PVOID64 SsHandle;
   
6.         LIST_ENTRY InLoadOrderModuleList;
   
7.         LIST_ENTRY InMemoryOrderModuleList;
   
8.         LIST_ENTRY InInitializationOrderModuleList;
   
9.         PVOID64 EntryInProgress;
   
10.         ULONG64 ShutdownInProgress;
    
11.         PVOID64 ShutdownThreadId;
    
12. }PEB_LDR_DATA, *PPEB_LDR_DATA;
    
13. 
    
14. typedef struct _LDR_DATA_TABLE_ENTRY {
    
15.         LIST_ENTRY64 InLoadOrderLinks;
    
16.         LIST_ENTRY64 InMemoryOrderLinks;
    
17.         LIST_ENTRY64 InInitializationOrderLinks;
    
18.         PVOID64 DllBase;
    
19.         PVOID64 EntryPoint;
    
20.         ULONG64 SizeOfImage;
    
21.         UNICODE_STRING64 FullDllName;
    
22.         UNICODE_STRING64 BaseDllName;
    
23.         ULONG Flags;
    
24.         USHORT LoadCount;
    
25.         USHORT TlsIndex;
    
26.         union {
    
27.                 LIST_ENTRY64 HashLinks;
    
28.                 struct {
    
29.                         PVOID64 SectionPointer;
    
30.                         ULONG64 CheckSum;
    
31.                 };
    
32.         };
    
33.         union {
    
34.                 struct {
    
35.                         ULONG TimeDateStamp;
    
36.                 };
    
37.                 struct {
    
38.                         PVOID64 LoadedImports;
    
39.                 };
    
40.         };
    
41.         ULONG64 * EntryPointActivationContext;
    
42.         PVOID64 PatchInformation;
    
43.         LIST_ENTRY64 ForwarderLinks;
    
44.         LIST_ENTRY64 ServiceTagLinks;
    
45.         LIST_ENTRY64 StaticLinks;
    
46. } LDR_DATA_TABLE_ENTRY, *PLDR_DATA_TABLE_ENTRY;

复制代码

1. //枚举进程并返回进程对象
   
2. PEPROCESS EnumProcessALL(char *ProcessName)//通过进程对象的对向链表遍历进程，缺点是进程名只能取十五个非中文字符
   
3. {
   
4.         CHAR TProcessName[32] = { 0 };
   
5.         CHAR CProcessName[16] = { 0 };
   
6.         RtlZeroMemory(TProcessName, 32);
   
7.         memcpy(TProcessName, ProcessName, strlen(ProcessName));//一般传进来的进程名不超过32个字符
   
8.         _strupr(TProcessName); //转换成大写
   
9. 
   
10.         PEPROCESS process;
    
11.         PLIST_ENTRY64 plist, plist1;
    
12.         process = PsGetCurrentProcess();
    
13.         plist1 = plist = *(PULONG64)((ULONG64)process + 0x188);
    
14. 
    
15.         do
    
16.         {
    
17.                 process = (ULONG64)plist1 - 0x188;
    
18.                 RtlZeroMemory(CProcessName, 16);
    
19.                 memcpy(CProcessName, (char*)process + 0x2e0, 16);//一般传进来的进程名不超过32个字符
    
20.                 _strupr(CProcessName);
    
21.                 if (strstr(CProcessName, TProcessName) != 0 && *(ULONG64*)((ULONG64)process + 0x200)!=0)//句柄表中有值才是活的进程，句柄表中无值是同名的死进程
    
22.                 {
    
23.                         return process;
    
24.                 }
    
25.             //进程对象从链表中摘除
    
26.             //((PLIST_ENTRY64)(plist1->Flink))->Blink = plist1->Blink;//让前一个节点的后指针指向我的后一个节点,抹hashlinks
    
27.                 //((PLIST_ENTRY64)(plist1->Blink))->Flink = plist1->Flink;//让后一个节点的前指针指向我的前一个节点
    
28.                 //64位KdPrint 输出十进制用%ld，输出十六进制%p
    
29.                 //KdPrint(("count %ld -- process name is %15s --process id is %ld\n", count, (char*)process + 0x2e0, *(ULONG64*)((ULONG64)process + 0x180)));
    
30.                 plist1 = plist1->Blink;
    
31.         } while (plist1 != plist);
    
32.         return 0;
    
33. }

复制代码

1. WCHAR removeName[256] = { 0 };
   
2. PEPROCESS pebprocess=0;
   
3. VOID HideDLLByPEBandNThash()//遍历进程用户层模块by PEB
   
4. {
   
5.         pebprocess = EnumProcessALL("dnf");
   
6.         if (pebprocess == NULL)
   
7.         {
   
8.                 KdPrint(("dnf process is null \n"));
   
9.                 return;
   
10.         }
    
11.         PPEB processPEB=0;
    
12.         PPEB_LDR_DATA  pldr_data, pldr_dataT;
    
13.         LIST_ENTRY InLoadOrderModuleList;
    
14.         LIST_ENTRY InMemoryOrderModuleList;
    
15.         LIST_ENTRY InInitializationOrderModuleList;
    
16.         PLIST_ENTRY plistLDR, plistLDR1;
    
17.         PLDR_DATA_TABLE_ENTRY ldr_table_entry;
    
18.         UNICODE_STRING KeattachProce;
    
19.         UNICODE_STRING KeDetachProce;
    
20.         PIMAGE_DOS_HEADER pimage_dos_header;
    
21.         PIMAGE_NT_HEADERS pimage_nt_header;
    
22. 
    
23.         MyKeAttachProcess((PKPROCESS)pebprocess);//附加到我们要摘链的用户层进程
    
24.         processPEB = *(ULONG64*)((ULONG64)pebprocess + 0x338);//取得PEB
    
25.         if (processPEB==0)
    
26.         {
    
27.                 KdPrint(("peb is null \n"));
    
28.                 MyKeDetachProcess(pebprocess);
    
29.                 return;
    
30.         }
    
31.         KdPrint(("X64peb is %x\n", processPEB));
    
32.         pldr_data = *(ULONG64*)((ULONG64)processPEB + 0x18);//取得_PEB_LDR_DATA
    
33.         InLoadOrderModuleList = pldr_data->InLoadOrderModuleList;//从_PEB_LDR_DATA取得按加载顺序组织的模块链表
    
34.         InMemoryOrderModuleList = pldr_data->InMemoryOrderModuleList;//从_PEB_LDR_DATA取得按内存顺序组织的模块链表
    
35.         InInitializationOrderModuleList = pldr_data->InInitializationOrderModuleList;
    
36.         /**********先处理x64NT模块中的那份HASH表，此表里面保存的是进程所有已加载模块******/
    
37.         PLIST_ENTRY pNThash, pnt;
    
38.         PLDR_DATA_TABLE_ENTRY pNTHashTalbeList;
    
39.         plistLDR = InLoadOrderModuleList.Blink;
    
40.         plistLDR1 = plistLDR;
    
41.         do
    
42.         {
    
43.                 ldr_table_entry = plistLDR;
    
44.                 memset(removeName, 0, 256 * 2);
    
45.                 RtlCopyMemory(removeName, ldr_table_entry->FullDllName.Buffer, ldr_table_entry->FullDllName.Length);
    
46.                 _wcsupr(removeName);
    
47.                 if (wcsstr(removeName, L"NTDLL") != 0 )//通过PEB遍历模块,如果找到NT模块就处理里面的HASHTABLE
    
48.                 {
    
49.                         //64位WIN7环境下syswow64目录下的NT模块基址加偏移0x13A940就是那份HASH数组的地址
    
50.                         pNThash = (PLIST_ENTRY)((ULONG64)ldr_table_entry->DllBase + 0x13A940);//在NTDLL里搜字符串LdrpHashTable可以定位此数组地址
    
51.                         KdPrint(("X64NT base is %p--hashtable is %p\n", ldr_table_entry->DllBase, pNThash));
    
52.                         //nt模块里的HASHtable是个数组，该数组有32个成员,每个成员是LIST_ENTRY,
    
53.                         //每个(LIST_ENTRY)双向链表维护了一组哈希值相同的模块
    
54.                         //每个进程中的NT基址是相同的,但是这个hashtalbe是和进程相关的,
    
55.                         //也就是说每一个进程有一份独立的hashtalbe
    
56.                         for (ULONG64 i = 0; i < 32; i++, pNThash++)
    
57.                         {
    
58.                                 //如果数组中某个(LIST_ENTRY)双向链表成员是空,那么该元素的Blink和Flink的值就是LIST_ENTRY的地址
    
59.                                 if (pNThash->Blink != pNThash)
    
60.                                 {
    
61.                                         pnt = pNThash->Blink;
    
62.                                         do
    
63.                                         {
    
64.                                                 pNTHashTalbeList = (ULONG64)pnt - 0x70;//X64 WIN7环境下hashlinks在_LDR_DATA_TABLE_ENTRY中的偏移是0x70
    
65.                                                 //memset(removeName, 0, 256 * 2);
    
66.                                                 if (MmIsAddressValid(pNTHashTalbeList->FullDllName.Buffer))
    
67.                                                 {
    
68.                                                         //RtlCopyMemory(removeName, pNTHashTalbeList->FullDllName.Buffer, pNTHashTalbeList->FullDllName.Length);
    
69.                                                         //_wcsupr(removeName);
    
70.                                                         //if (wcsstr(removeName, L"AACD") != 0 || wcsstr(removeName, L"ABCD") != 0 || wcsstr(removeName, L"ACCD") != 0)
    
71.                                                         //{
    
72.                                                         //        KdPrint(("find AACD IN NTDLL HASHTABLE AND REMOVE\n"));
    
73.                                                         //        //pnt->Flink->Blink = pnt->Blink;//让前一个节点的后指针指向我的后一个节点,抹hashlinks
    
74.                                                         //        //pnt->Blink->Flink = pnt->Flink;//让后一个节点的前指针指向我的前一个节点
    
75.                                                         //}
    
76.                                                         KdPrint(("X64nt hash index %d--dll base is %x  -size %x--name %wZ\n", i, pNTHashTalbeList->DllBase, pNTHashTalbeList->SizeOfImage, &pNTHashTalbeList->FullDllName));
    
77.                                                 }
    
78.                                                 pnt = pnt->Blink;
    
79.                                         } while (pnt != pNThash);//如果某个成员有值就循环遍历
    
80.                                 }
    
81.                         }
    
82.                         break;
    
83.                 }
    
84.                 plistLDR = plistLDR->Blink;
    
85.         } while (plistLDR != plistLDR1);
    
86. 
    
87.         /*****************遍历x64PEB LDR第一个链表并将指定模块摘链******************************/
    
88.         plistLDR = InLoadOrderModuleList.Blink;
    
89.         plistLDR1 = plistLDR;
    
90.         ULONG64 count = 0;
    
91.         do
    
92.         {
    
93.                 count = count + 1;
    
94.                 ldr_table_entry = plistLDR;
    
95.                 //memset(removeName, 0, 256 * 2);
    
96.                 //RtlCopyMemory(removeName, ldr_table_entry->BaseDllName.Buffer, ldr_table_entry->BaseDllName.Length);
    
97.                 //_wcsupr(removeName);
    
98.                 //if (wcsstr(removeName, L"AACD") != 0 || wcsstr(removeName, L"ABCD") != 0 || wcsstr(removeName, L"ACCD") != 0)//如果是我们要摘链的模块就进行摘链
    
99.                 //{
    
100.                 //        KdPrint(("find and remove"));
     
101.                 //        pimage_dos_header = ldr_table_entry->DllBase;
     
102.                 //        KdPrint(("e_magic is %s\n", &pimage_dos_header->e_magic));
     
103.                 //        PageProtectOff();
     
104.                 //        //pimage_dos_header->e_magic= "0x1234";
     
105.                 //        pimage_nt_header = pimage_dos_header->e_lfanew + (ULONG64)ldr_table_entry->DllBase;
     
106.                 //        ULONG64 sizeheader = pimage_nt_header->OptionalHeader.SizeOfHeaders;
     
107.                 //        KdPrint(("size of header is %d\n", sizeheader));
     
108.                 //        memset(pimage_dos_header, 0, sizeheader);//整个PE头全部清零
     
109.                 //        //pimage_nt_header->Signature = "0x87654321";
     
110.                 //        PageProtectOn();
     
111.                 //        plistLDR->Flink->Blink = plistLDR->Blink;//让前一个节点的后指针指向我的后一个节点
     
112.                 //        plistLDR->Blink->Flink = plistLDR->Flink;//让后一个节点的前指针指向我的前一个节点
     
113.                 //        break;
     
114.                 //}
     
115.                 KdPrint(("X64 LDR one index %d--base is %x--size %x--file name is %wZ\n",count, ldr_table_entry->DllBase, ldr_table_entry->SizeOfImage, &ldr_table_entry->FullDllName));
     
116.                 plistLDR = plistLDR->Blink;
     
117.         } while (plistLDR != plistLDR1);
     
118.         /*****************遍历x64PEB LDR第二个链表并将指定模块摘链***************************/
     
119.         plistLDR = InMemoryOrderModuleList.Blink;
     
120.         plistLDR1 = plistLDR;
     
121.         count = 0;
     
122.         do
     
123.         {
     
124.                 count = count + 1;
     
125.                 ldr_table_entry = (ULONG64)plistLDR - 0x10;
     
126.                 //memset(removeName, 0, 128 * 2);
     
127.                 //RtlCopyMemory(removeName, ldr_table_entry->BaseDllName.Buffer, ldr_table_entry->BaseDllName.Length);
     
128.                 //_wcsupr(removeName);
     
129.                 //if (wcsstr(removeName, L"AACD") != 0 || wcsstr(removeName, L"ABCD") != 0 || wcsstr(removeName, L"ACCD") != 0)//如果是我们要摘链的模块就进行摘链
     
130.                 //{
     
131.                 //        KdPrint(("find and remove"));
     
132.                 //        plistLDR->Flink->Blink = plistLDR->Blink;//让前一个节点的后指针指向我的后一个节点
     
133.                 //        plistLDR->Blink->Flink = plistLDR->Flink;//让后一个节点的前指针指向我的前一个节点
     
134.                 //        break;
     
135.                 //}
     
136.                 KdPrint(("X64 LDR two index %d--base is %x--size %x--file name is %wZ\n", count, ldr_table_entry->DllBase, ldr_table_entry->SizeOfImage, &ldr_table_entry->FullDllName));
     
137.                 plistLDR = plistLDR->Blink;
     
138.         } while (plistLDR1 != plistLDR);
     
139.         /*****************遍历x64PEB LDR第三个链表并将指定模块摘链***************************/
     
140.         plistLDR = InInitializationOrderModuleList.Blink;
     
141.         plistLDR1 = plistLDR;
     
142.         count = 0;
     
143.         do
     
144.         {
     
145.                 count = count + 1;
     
146.                 ldr_table_entry = (ULONG64)plistLDR - 0x20;
     
147.                 //memset(removeName, 0, 128 * 2);
     
148.                 //RtlCopyMemory(removeName, ldr_table_entry->BaseDllName.Buffer, ldr_table_entry->BaseDllName.Length);
     
149.                 //_wcsupr(removeName);
     
150.                 //if (wcsstr(removeName, L"AACD") != 0 || wcsstr(removeName, L"ABCD") != 0 || wcsstr(removeName, L"ACCD") != 0)//如果是我们要摘链的模块就进行摘链
     
151.                 //{
     
152.                 //        KdPrint(("find and remove"));
     
153.                 //        plistLDR->Flink->Blink = plistLDR->Blink;//让前一个节点的后指针指向我的后一个节点
     
154.                 //        plistLDR->Blink->Flink = plistLDR->Flink;//让后一个节点的前指针指向我的前一个节点
     
155.                 //        break;
     
156.                 //}
     
157.                 KdPrint(("X64 LDR  three index %d--base is %x--size %x--file name is %wZ\n", count, ldr_table_entry->DllBase, ldr_table_entry->SizeOfImage, &ldr_table_entry->FullDllName));
     
158.                 plistLDR = plistLDR->Blink;
     
159.         } while (plistLDR1 != plistLDR);
     
160.         /*****************x64PEB三个链表指定模块摘链完毕***************************/
     
161. 
     
162.         //////开始遍历x64环境中的 PEB32三个链表中的模块，X64平台中的32位程序有两个PEB，一个里面保存了X64模块，一个里面保存了X86模块
     
163.         ULONG processPEB32=0;
     
164.         PPEB_LDR_DATA32  pldr_data32, pldr_dataT32;
     
165.         LIST_ENTRY32 InLoadOrderModuleList32;
     
166.         LIST_ENTRY32 InMemoryOrderModuleList32;
     
167.         LIST_ENTRY32 InInitializationOrderModuleList32;
     
168.         PLIST_ENTRY32 plistLDR32, plistLDR132;
     
169.         PLDR_DATA_TABLE_ENTRY32 ldr_table_entry32;
     
170. 
     
171.         processPEB32 = *(ULONG*)((ULONG64)pebprocess + 0x320);//取得PEB32 //process是ulong64类型
     
172.         if (processPEB32==0)
     
173.         {
     
174.                 KdPrint(("processPEB32 if null \n"));
     
175.                 MyKeDetachProcess(pebprocess);
     
176.                 return;
     
177.         }
     
178.         KdPrint(("wow64peb is %x\n", processPEB32));
     
179.         pldr_data32 = *(ULONG*)((ULONG)processPEB32 + 0xc);//取得_PEB_LDR_DATA
     
180.         InLoadOrderModuleList32 = pldr_data32->InLoadOrderModuleList;//从_PEB_LDR_DATA取得按加载顺序组织的模块链表
     
181.         InMemoryOrderModuleList32 = pldr_data32->InMemoryOrderModuleList;//从_PEB_LDR_DATA取得按内存顺序组织的模块链表
     
182.         InInitializationOrderModuleList32 = pldr_data32->InInitializationOrderModuleList;
     
183.         /**********先处理x64NT32模块中的那份HASH表，此表里面保存的是进程所有已加载的32位模块******/
     
184.         PLIST_ENTRY32 pNThash32, pnt32;
     
185.         PLDR_DATA_TABLE_ENTRY32 pNTHashTalbeList32;
     
186.         plistLDR32 = InLoadOrderModuleList32.Blink;
     
187.         plistLDR132 = plistLDR32;
     
188.         do
     
189.         {
     
190.                 ldr_table_entry32 = plistLDR32;
     
191.                 memset(removeName, 0, 256 * 2);
     
192.                 RtlCopyMemory(removeName, ldr_table_entry32->FullDllName.Buffer, ldr_table_entry32->FullDllName.Length);
     
193.                 _wcsupr(removeName);
     
194.                 if (wcsstr(removeName, L"NTDLL") != 0)//通过PEB遍历模块,如果找到NT模块就处理里面的HASHTABLE
     
195.                 {
     
196.                         //64位WIN7环境下syswow64目录下的NT模块基址加偏移0x104800就是那份HASH数组的地址
     
197.                         pNThash32 = (PLIST_ENTRY32)((ULONG)ldr_table_entry32->DllBase + 0x104800);//在NTDLL里搜字符串LdrpHashTable可以定位此数组地址
     
198.                         KdPrint(("NT base is %x--hashtable is %x\n", ldr_table_entry32->DllBase, pNThash32));
     
199.                         //nt模块里的HASHtable是个数组，该数组有32个成员,每个成员是LIST_ENTRY,
     
200.                         //每个(LIST_ENTRY)双向链表维护了一组哈希值相同的模块
     
201.                         //每个进程中的NT基址是相同的,但是这个hashtalbe是和进程相关的,
     
202.                         //也就是说每一个进程有一份独立的hashtalbe
     
203.                         for (ULONG i = 0; i < 32; i++, pNThash32++)
     
204.                         {
     
205.                                 //如果数组中某个(LIST_ENTRY)双向链表成员是空,那么该元素的Blink和Flink的值就是LIST_ENTRY的地址
     
206.                                 if (pNThash32->Blink != pNThash32)
     
207.                                 {
     
208.                                         pnt32 = pNThash32->Blink;
     
209.                                         do
     
210.                                         {
     
211.                                                 pNTHashTalbeList32 = (ULONG)pnt32 - 0x3C;
     
212.                                                 if (MmIsAddressValid(pNTHashTalbeList32->FullDllName.Buffer))
     
213.                                                 {
     
214.                                                         KdPrint(("wow64 nt hush index %d--dll base is %x -size %x --name %S\n", i, pNTHashTalbeList32->DllBase, pNTHashTalbeList32->SizeOfImage,pNTHashTalbeList32->FullDllName.Buffer));
     
215.                                                 }
     
216.                                                 pnt32 = pnt32->Blink;
     
217.                                         } while (pnt32 != pNThash32);//如果某个成员有值就循环遍历
     
218.                                 }
     
219.                         }
     
220.                         break;
     
221.                 }
     
222.                 plistLDR32 = plistLDR32->Blink;
     
223.         } while (plistLDR32 != plistLDR132);
     
224. 
     
225.         /*****************遍历x64 PEB32 LDR第一个链表并将指定模块摘链******************************/
     
226.         plistLDR32 = InLoadOrderModuleList32.Blink;
     
227.         plistLDR132 = plistLDR32;
     
228.     count = 0;
     
229.         do
     
230.         {
     
231.                 count = count + 1;
     
232.                 ldr_table_entry32 = plistLDR32;
     
233.                 KdPrint(("wow64 LDR one index %d--base is %x--size %x--file name is %ws\n", count, ldr_table_entry32->DllBase, ldr_table_entry32->SizeOfImage, ldr_table_entry32->FullDllName.Buffer));
     
234.                 plistLDR32 = plistLDR32->Blink;
     
235.         } while (plistLDR32 != plistLDR132);
     
236.         /*****************遍历x64 PEB32 LDR第二个链表并将指定模块摘链***************************/
     
237.         plistLDR32 = InMemoryOrderModuleList32.Blink;
     
238.         plistLDR132 = plistLDR32;
     
239.         count = 0;
     
240.         do
     
241.         {
     
242.                 count = count + 1;
     
243.                 ldr_table_entry32 = (ULONG)plistLDR32 - 8;
     
244.                 KdPrint(("wow64 LDR two index %d--base is %x--size %x--file name is %S\n", count, ldr_table_entry32->DllBase, ldr_table_entry32->SizeOfImage, ldr_table_entry32->FullDllName.Buffer));
     
245.                 plistLDR32 = plistLDR32->Blink;
     
246.         } while (plistLDR132 != plistLDR32);
     
247.         /*****************遍历x64 PEB32 LDR第三个链表并将指定模块摘链***************************/
     
248.         plistLDR32 = InInitializationOrderModuleList32.Blink;
     
249.         plistLDR132 = plistLDR32;
     
250.         count = 0;
     
251.         do
     
252.         {
     
253.                 count = count + 1;
     
254.                 ldr_table_entry32 = (ULONG)plistLDR32 - 0x10;
     
255.                 KdPrint(("wow64 LDR three index %d--base is %x--size %x--file name is %ws\n", count, ldr_table_entry32->DllBase, ldr_table_entry32->SizeOfImage, ldr_table_entry32->FullDllName.Buffer));
     
256.                 plistLDR32 = plistLDR32->Blink;
     
257.         } while (plistLDR132 != plistLDR32);
     
258.         MyKeDetachProcess(pebprocess);
     
259. }

复制代码