【C】wow64函数的简单操作实例

Ayala

1. 
   
2. #include <ntdef.h>
   
3. #include <ntddk.h>
   
4. 
   
5. #pragma comment(lib,"kernel32.lib")
   
6. #pragma comment(lib,"ntdll.lib")
   
7. 
   
8. #ifndef GetProcAddress
   
9. __int32 __stdcall GetProcAddress(hModule,lpProcName);
   
10. #endif
    
11. #ifndef GetModuleHandle
    
12. __int32 __stdcall GetModuleHandleA(lpMoudleName);
    
13. __int32 __stdcall GetModuleHandleW(lpMoudleName);
    
14. #if !defined(_UNICODE) && !defined(_UNICODE_)
    
15. #define GetModuleHandle GetModuleHandleA
    
16. #else
    
17. #define GetModuleHandle GetModuleHandleW
    
18. #endif
    
19. #endif
    
20. 
    
21. 
    
22. /*
    
23. PROCESS_BASIC_INFORMATION_WOW64 struc
    
24.         Reserved1                 Qword ?
    
25.         struc PebBaseAddress
    
26.                 lo dword ?
    
27.                 hi  dword ?
    
28.         ends
    
29.         Reserved2                Qword ?
    
30.         Reserved3                Qword ?
    
31.         UniqueProcessId Qword ?
    
32.         Reserved4                Qword ?
    
33. PROCESS_BASIC_INFORMATION_WOW64 ends
    
34. MEMORY_BASIC_INFORMATION_WOW64 struc
    
35.         BaseAddress                 QWORD ?
    
36.         AllocationBase                 QWORD ?
    
37.         AllocationProtect   DWORD ?
    
38.                                                 DWORD ?
    
39.         RegionSize                        QWORD ?
    
40.         State                                DWORD ?
    
41.         Protect                                DWORD ?
    
42.         _Type                                DWORD ?
    
43.                                                 DWORD ?
    
44. MEMORY_BASIC_INFORMATION_WOW64 ends
    
45. */
    
46. #pragma pack(show)
    
47. #pragma pack(push,8)
    
48. typedef struct _PROCESS_BASIC_INFORMATION_WOW64{
    
49.     NTSTATUS ExitStatus;
    
50.     __int64  PebBaseAddress;
    
51.     __int64  AffinityMask;
    
52.     __int64  BasePriority;
    
53.     __int64  UniqueProcessId;
    
54.     __int64  InheritedFromUniqueProcessId;
    
55. }PROCESS_BASIC_INFORMATION_WOW64,*PPROCESS_BASIC_INFORMATION_WOW64;
    
56. 
    
57. typedef struct _MEMORY_BASIC_INFORMATION_WOW64{
    
58.     __int64 BaseAddress;
    
59.     __int64 AllocationBase;
    
60.     __int32 AllocationProtect;
    
61.     //__int32 align_8;
    
62.         __int64 RegionSize;
    
63.     __int32 State;
    
64.     __int32 Protect;
    
65.     __int32 Type;
    
66.         //__int32 _ali;
    
67. }MEMORY_BASIC_INFORMATION_WOW64,*PMEMORY_BASIC_INFORMATION_WOW64;
    
68. 
    
69. #ifndef MEMORY_INFORMATION_CLASS
    
70. typedef enum _MEMORY_INFORMATION_CLASS{
    
71.         MemoryBasicInformation,
    
72.        
    
73.         //...
    
74.         MaxMemoryInfoClass
    
75. }MEMORY_INFORMATION_CLASS;       
    
76.        
    
77. #endif
    
78. #pragma pack(pop)
    
79. 
    
80. typedef NTSTATUS(
    
81. NTAPI
    
82. *_imp__NtWow64QueryInformationProcess64)(
    
83.     IN HANDLE ProcessHandle,
    
84.     IN PROCESSINFOCLASS ProcessInformationClass,
    
85.     OUT PVOID ProcessInformation64,
    
86.     IN ULONG Length,
    
87.     OUT PULONG ReturnLength OPTIONAL
    
88.     );
    
89. typedef NTSTATUS(
    
90. NTAPI
    
91. *_imp__NtWow64QueryVirtualMemory64)(
    
92.     IN HANDLE ProcessHandle,
    
93.         IN PVOID64 BaseAddress,
    
94.     /*IN PVOID BaseAddressLow,
    
95.     IN PVOID BaseAddressHigh,*/
    
96.     IN MEMORY_INFORMATION_CLASS MemoryInformationClass,
    
97.     OUT PVOID MemoryInformation, /* NB must be 64bit aligned */
    
98.     IN ULONG64 Length,
    
99.         /*IN ULONG LengthLow,
    
100.     IN ULONG LengthHigh,*/
     
101.     OUT PULONGLONG ReturnLength OPTIONAL
     
102.     );
     
103. typedef NTSTATUS(
     
104. NTAPI
     
105. *_imp__NtWow64ReadVirtualMemory64)(
     
106.     IN HANDLE ProcessHandle,
     
107.         IN PVOID64 Address,
     
108.     /*IN PVOID AddressLow,
     
109.     IN PVOID AddressHigh,*/
     
110.     OUT PVOID Buffer,
     
111.         IN ULONG64 BufferSize,
     
112.     /*IN ULONG BufferSizeLow,
     
113.     IN ULONG BufferSizeHigh,*/
     
114.     OUT PULONGLONG BytesRead OPTIONAL
     
115.     );
     
116. typedef NTSTATUS(
     
117. NTAPI
     
118. *_imp__NtWow64WriteVirtualMemory64)(
     
119.     IN HANDLE ProcessHandle,
     
120.     IN PVOID AddressLow,
     
121.     IN PVOID AddressHigh,
     
122.     IN PVOID Buffer,
     
123.     IN ULONG BufferSizeLow,
     
124.     IN ULONG BufferSizeHigh,
     
125.     OUT PULONGLONG BytesWritten OPTIONAL
     
126.     );
     
127. 
     
128. typedef struct _delayload_t{
     
129.         __int32                 modbase;
     
130.         char *                  modname;
     
131.         struct{
     
132.                 __int32 pb;
     
133.                 char *  pn;
     
134.         }fp[];
     
135. }delayload_t,*delayload_p;
     
136. 
     
137. 
     
138. int __delayload(delayload_t* lt)
     
139. {
     
140.         int ret=0,i=0;
     
141.        
     
142.         lt->modbase = GetModuleHandle(lt->modname);
     
143.         if (!lt->modbase) goto done;
     
144.        
     
145.         while (lt->fp[i].pn)
     
146.         {
     
147.                 lt->fp[i].pb=GetProcAddress(lt->modbase,lt->fp[i].pn);
     
148.                 if (!lt->fp[i].pb) goto done;
     
149.                 i++;
     
150.         }
     
151.         ret=1;
     
152. done:       
     
153.         return ret;
     
154. }
     
155. 
     
156. delayload_t imp_ntdll =        {0,\
     
157.                                                 "ntdll.dll",\
     
158.                                                         {
     
159. #define NtWow64QueryInformationProcess64 ((_imp__NtWow64QueryInformationProcess64)(imp_ntdll.fp[0].pb))
     
160.                                                                 {
     
161.                                                                         0,\
     
162.                                                                         "NtWow64QueryInformationProcess64"
     
163.                                                                 },
     
164. #define NtWow64QueryVirtualMemory64 ((_imp__NtWow64QueryVirtualMemory64)(imp_ntdll.fp[1].pb))
     
165.                                                                 {
     
166.                                                                         0,\
     
167.                                                                         "NtWow64QueryVirtualMemory64"
     
168.                                                                 },
     
169. #define NtWow64ReadVirtualMemory64 ((_imp__NtWow64ReadVirtualMemory64)(imp_ntdll.fp[2].pb))
     
170.                                                                 {
     
171.                                                                         0,\
     
172.                                                                         "NtWow64ReadVirtualMemory64"
     
173.                                                                 },
     
174. #define NtWow64WriteVirtualMemory64 ((_imp__NtWow64WriteVirtualMemory64)(imp_ntdll.fp[3].pb))
     
175.                                                                 {
     
176.                                                                         0,\
     
177.                                                                         "NtWow64WriteVirtualMemory64"
     
178.                                                                 },
     
179.                                                                 {
     
180.                                                                         0,\
     
181.                                                                         0
     
182.                                                                 }
     
183.                                                         }
     
184.                                                 };
     
185. 
     
186. int main()
     
187. {
     
188.         __declspec(align(8)) PROCESS_BASIC_INFORMATION_WOW64  pbi={0};
     
189.         __declspec(align(8)) MEMORY_BASIC_INFORMATION_WOW64         pbm={0};
     
190.         __declspec(align(8)) char outbuffer[PAGE_SIZE];
     
191.        
     
192.         __int64        dwbytes;
     
193.         NTSTATUS        Status;
     
194.         HANDLE                ProcessHandle;
     
195.         OBJECT_ATTRIBUTES oa;
     
196.         CLIENT_ID         ClientId={0};
     
197.        
     
198.         __delayload(&imp_ntdll);
     
199.        
     
200.         while (1)
     
201.         {
     
202.                 printf("process id=");
     
203.                 scanf("%d",&ClientId.UniqueProcess);
     
204.                
     
205.                 InitializeObjectAttributes( &oa, NULL, 0, NULL, NULL );
     
206.                 Status=ZwOpenProcess(&ProcessHandle,\
     
207.                                                                 PROCESS_ALL_ACCESS,\
     
208.                                                                 &oa,\
     
209.                                                                 &ClientId);
     
210.                 if (!NT_SUCCESS(Status)) {
     
211. 
     
212.                         printf("OpenProcess failed 0x%lx\n",Status);
     
213.                         continue;
     
214.                 }
     
215.                
     
216.                 Status=NtWow64QueryInformationProcess64(ProcessHandle,\
     
217.                                                                                                 ProcessBasicInformation,\
     
218.                                                                                                 &pbi,\
     
219.                                                                                                 sizeof(pbi),\
     
220.                                                                                                 (PULONG)&dwbytes);
     
221.                 if (!NT_SUCCESS(Status)) {
     
222. 
     
223.                         printf("NtWow64QueryInformationProcess64 failed 0x%lx\n",Status);
     
224.                         goto done;
     
225.                 }
     
226.                 printf("procss %d peb base=0x%llX\n",ClientId.UniqueProcess,pbi.PebBaseAddress);
     
227.                                
     
228.                
     
229.                 Status=NtWow64QueryVirtualMemory64(ProcessHandle,\
     
230.                                                                                         (PVOID64)pbi.PebBaseAddress,\
     
231.                                                                                         MemoryBasicInformation,\
     
232.                                                                                         &pbm,\
     
233.                                                                                         (ULONG64)sizeof(pbm),\
     
234.                                                                                         (PULONGLONG)&dwbytes);
     
235.                 if (!NT_SUCCESS(Status)) {
     
236. 
     
237.                         printf("NtWow64QueryVirtualMemory64 failed 0x%lx\n",Status);
     
238.                         goto done;
     
239.                 }
     
240.                 // do nothing;
     
241.                
     
242.                 printf("base=0x%llx size=%lld\n",pbm.BaseAddress,pbm.RegionSize);
     
243.                
     
244.                
     
245.                 Status=NtWow64ReadVirtualMemory64(ProcessHandle,\
     
246.                                                                                         (PVOID64)pbi.PebBaseAddress,\
     
247.                                                                                         &outbuffer,\
     
248.                                                                                         (ULONG64)sizeof(outbuffer),\
     
249.                                                                                         (PULONGLONG)&dwbytes);
     
250.                 if (!NT_SUCCESS(Status)) {
     
251. 
     
252.                         printf("NtWow64ReadVirtualMemory64 failed 0x%lx\n",Status);
     
253.                         goto done;
     
254.                 }
     
255.                 // do nothing;
     
256.                 printf("tRead=%lld, rRead=%lld\n",(ULONG64)sizeof(outbuffer),(ULONG64)dwbytes);
     
257. done:               
     
258.                 Status=ZwClose(ProcessHandle);
     
259.         }
     
260. 
     
261.         system("pause");
     
262.         return 0;
     
263. }
     

复制代码

besteast