c++枚举系统句柄

米老鼠和蓝精鼠v

1、利用ToolHelp API
首先创建一个系统快照，然后通过对系统快照的访问完成进程的枚举获取系统快照使用CreateToolhelp32Snapshot 函数
函数原型声明如下：

HANDLE WINAPI CreateToolhelp32Snapshot(
DWORD dwFlags,
DWORD th32ProcessID
);
将dwFlags设置为TH32CS_SNAPPROCESS用于获取进程快照。函数调用成功后会返回一个快照的句柄，便可以使用Process32First、Process32Next进行枚举了

函数原型声明如下：

BOOL WINAPI Process32First(
HANDLE hSnapshot,
LPPROCESSENTRY32 lppe
);
BOOL WINAPI Process32Next( HANDLE hSnapshot, LPPROCESSENTRY32 lppe);

1. 下面是相关代码：
   
2. #include <windows.h>
   
3. #include <tlhelp32.h>
   
4. #include <stdio.h>
   
5. void useToolHelp()
   
6. {
   
7.     HANDLE procSnap = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 );
   
8.     if ( procSnap == INVALID_HANDLE_VALUE )
   
9.     {
   
10.         printf( "CreateToolhelp32Snapshot failed, %d ", GetLastError() );
    
11.         return;
    
12.     }
    
13. /*  */
    
14.     PROCESSENTRY32 procEntry = { 0 };
    
15.     procEntry.dwSize = sizeof(PROCESSENTRY32);
    
16.     BOOL bRet = Process32First( procSnap, &procEntry );
    
17.     while ( bRet )
    
18.     {
    
19.         wprintf( L"PID: %d (%s) ", procEntry.th32ProcessID, procEntry.szExeFile );
    
20.         bRet = Process32Next( procSnap, &procEntry );
    
21.     }
    
22.     CloseHandle( procSnap );
    
23. }
    
24. 
    
25. 
    
26. void main()
    
27. {
    
28.     useToolHelp();
    
29.     getchar();
    
30. }
    
31. 
    
32. 
    
33. 用此方法可以在进程ID和进程名称间进行转换，即通过进程名称获得进程ID，通过进程ID获取进程名称。
    
34. 
    
35. 2、通过psapi.dll提供的函数
    
36. 
    
37. 通过psapi.dll提供的EnumProcesses、EnumProcessModules实现
    
38. 
    
39. 函数原型声明如下：
    
40. BOOL EnumProcesses( DWORD* pProcessIds, DWORD cb, DWORD* pBytesReturned);BOOL EnumProcessModules( HANDLE hProcess, HMODULE* lphModule, DWORD cb, LPDWORD lpcbNeeded);
    
41. 
    
42. #include <windows.h>
    
43. #include <stdio.h>
    
44. #include <tchar.h>
    
45. #include "psapi.h"
    
46. #pragma comment(lib,"psapi.lib")
    
47. 
    
48. void PrintProcessNameAndID(DWORD processID)
    
49. {
    
50.      TCHAR szProcessName[MAX_PATH] = _T("<unknown>");
    
51.    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS,FALSE,processID);     
    
52.      //Process name.
    
53.    if(NULL!=hProcess)
    
54.    {
    
55.          HMODULE hMod;
    
56.      DWORD cbNeeded;
    
57.      if(EnumProcessModules(hProcess,&hMod,sizeof(hMod), &cbNeeded))         
    
58.      {
    
59.              GetModuleBaseName(hProcess,hMod,szProcessName,sizeof(szProcessName)/sizeof(TCHAR));                        
    
60.      }
    
61.    }
    
62.      wprintf(_T("PID: %d (%s) "),processID,szProcessName);
    
63.    CloseHandle(hProcess);
    
64. }
    
65. void main( )
    
66. {
    
67.      DWORD aProcesses[1024], cbNeeded, cProcesses;
    
68.    unsigned int i;
    
69.    if(!EnumProcesses(aProcesses,sizeof(aProcesses),&cbNeeded))
    
70.          return;
    
71.    cProcesses = cbNeeded/sizeof(DWORD);
    
72.    for(i=0;i<cProcesses;i++)
    
73.          PrintProcessNameAndID(aProcesses);
    
74.      getchar();
    
75. }
    
76. 
    
77. 此方法由于需要进行OpenProcess操作，所以需要一定的权限，当权限不够时，有些进程将不能被打开。
    
78. 
    
79. 下面给出提升权限的相关代码：
    
80. 
    
81. void RaisePrivilege()
    
82. {
    
83.     HANDLE            hToken;
    
84.     TOKEN_PRIVILEGES    tp;
    
85.     tp.PrivilegeCount        = 1;
    
86.     tp.Privileges[0].Attributes    = SE_PRIVILEGE_ENABLED;
    
87.     if ( OpenProcessToken( GetCurrentProcess(), TOKEN_ALL_ACCESS, &hToken ) )
    
88.     {
    
89.         if ( LookupPrivilegeValue( NULL, SE_DEBUG_NAME, &tp.Privileges[0].Luid ) )
    
90.         {
    
91.             AdjustTokenPrivileges( hToken, FALSE, &tp, NULL, NULL, 0 );
    
92.         }
    
93.     }
    
94.     if ( hToken )
    
95.         CloseHandle( hToken );
    
96. }
    
97. 
    
98. 3、通过ntdll.dll提供的Native API
    
99. 使用Native API 中的ZwQuerySystemInformation的SystemProcessesAndThreadsInformation系统调用枚举进程由于该函数没有被导出，所以首先定义要使用到的结构和常量
    
100. 
     
101. typedef DWORD (WINAPI *ZWQUERYSYSTEMINFORMATION)(DWORD, PVOID, DWORD, PDWORD);
     
102. typedef struct _SYSTEM_PROCESS_INFORMATION
     
103. {
     
104. DWORD NextEntryDelta;
     
105. DWORD ThreadCount;
     
106. DWORD Reserved1[6];
     
107. FILETIME ftCreateTime;
     
108. FILETIME ftUserTime;
     
109. FILETIME ftKernelTime;
     
110. UNICODE_STRING ProcessName;
     
111. DWORD BasePriority;
     
112. DWORD ProcessId;
     
113. DWORD InheritedFromProcessId;
     
114. DWORD HandleCount;
     
115. DWORD Reserved2[2];
     
116. DWORD VmCounters;
     
117. DWORD dCommitCharge;
     
118. PVOID ThreadInfos[1];
     
119. }SYSTEM_PROCESS_INFORMATION, *PSYSTEM_PROCESS_INFORMATION;
     
120. #define SystemProcessesAndThreadsInformation 5
     
121. 然后动态加载ntdll.dll，获得函数的地址。便可以进行进程的枚举
     
122. 
     
123. #include <windows.h>
     
124. #include <ntsecapi.h>
     
125. #include <stdio.h>
     
126. typedef DWORD (WINAPI * ZWQUERYSYSTEMINFORMATION)( DWORD, PVOID, DWORD, PDWORD );
     
127. typedef struct _SYSTEM_PROCESS_INFORMATION
     
128. {
     
129.     DWORD        NextEntryDelta;
     
130.     DWORD        ThreadCount;
     
131.     DWORD        Reserved1[6];
     
132.     FILETIME    ftCreateTime;
     
133.     FILETIME    ftUserTime;
     
134.     FILETIME    ftKernelTime;
     
135.     UNICODE_STRING    ProcessName;
     
136.     DWORD        BasePriority;
     
137.     DWORD        ProcessId;
     
138.     DWORD        InheritedFromProcessId;
     
139.     DWORD        HandleCount;
     
140.     DWORD        Reserved2[2];
     
141.     DWORD        VmCounters;
     
142.     DWORD        dCommitCharge;
     
143.     PVOID        ThreadInfos[1];
     
144. }SYSTEM_PROCESS_INFORMATION, *PSYSTEM_PROCESS_INFORMATION;
     
145. #define SystemProcessesAndThreadsInformation 5
     
146. void main()
     
147. {
     
148.     HMODULE hNtDll = GetModuleHandle( L"ntdll.dll" );
     
149.     if ( !hNtDll )
     
150.         return;
     
151.     ZWQUERYSYSTEMINFORMATION    ZwQuerySystemInformation    = (ZWQUERYSYSTEMINFORMATION) GetProcAddress( hNtDll, "ZwQuerySystemInformation" );
     
152.     ULONG                cbBuffer            = 0x10000;
     
153.     LPVOID                pBuffer                = NULL;
     
154.     pBuffer = malloc( cbBuffer );
     
155.     if ( pBuffer == NULL )
     
156.         return;
     
157.     ZwQuerySystemInformation( SystemProcessesAndThreadsInformation, pBuffer, cbBuffer, NULL );
     
158.     PSYSTEM_PROCESS_INFORMATION pInfo = (PSYSTEM_PROCESS_INFORMATION) pBuffer;
     
159.     for (;; )
     
160.     {
     
161.         wprintf( L"PID: %d (%ls) ", pInfo->ProcessId, pInfo->ProcessName.Buffer );
     
162.         if ( pInfo->NextEntryDelta == 0 )
     
163.             break;
     
164.         pInfo = (PSYSTEM_PROCESS_INFORMATION) ( ( (PUCHAR) pInfo) + pInfo->NextEntryDelta);
     
165.     }
     
166.     free( pBuffer );
     
167.     getchar();
     
168. }
     
169. 
     
170. 4、通过进程打开的句柄来枚举进程
     
171. 
     
172. #include <windows.h>
     
173. #include <ntsecapi.h>
     
174. #include <ntstatus.h>
     
175. #include <stdio.h>
     
176. typedef NTSTATUS (WINAPI * ZWQUERYSYSTEMINFORMATION)( DWORD, PVOID, DWORD, PDWORD );
     
177. typedef struct _SYSTEM_HANDLE_INFORMATION
     
178. {
     
179.     ULONG        ProcessId;
     
180.     UCHAR        ObjectTypeNumber;
     
181.     UCHAR        Flags;
     
182.     USHORT        Handle;
     
183.     PVOID        Object;
     
184.     ACCESS_MASK    GrantedAccess;
     
185. }SYSTEM_HANDLE_INFORMATION, *PSYSTEM_HANDLE_INFORMATION;
     
186. typedef struct _SYSTEM_HANDLE_INFORMATION_EX
     
187. {
     
188.     ULONG                NumberOfHandles;
     
189.     SYSTEM_HANDLE_INFORMATION    Information[1];
     
190. }SYSTEM_HANDLE_INFORMATION_EX, *PSYSTEM_HANDLE_INFORMATION_EX;
     
191. #define SystemHandleInformation 0x10 /* 16 */
     
192. void main()
     
193. {
     
194.     HMODULE hNtDll = LoadLibrary( L"ntdll.dll" );
     
195.     if ( !hNtDll )
     
196.         return;
     
197.     ZWQUERYSYSTEMINFORMATION    ZwQuerySystemInformation    = (ZWQUERYSYSTEMINFORMATION) GetProcAddress( hNtDll, "ZwQuerySystemInformation" );
     
198.     ULONG                cbBuffer            = 0x4000;
     
199.     LPVOID                pBuffer                = NULL;
     
200.     NTSTATUS            s;
     
201.     do
     
202.     {
     
203.         pBuffer = malloc( cbBuffer );
     
204.         if ( pBuffer == NULL )
     
205.             return;
     
206.         memset( pBuffer, 0, cbBuffer );
     
207.         s = ZwQuerySystemInformation( SystemHandleInformation, pBuffer, cbBuffer, NULL );
     
208.         if ( s == STATUS_INFO_LENGTH_MISMATCH )
     
209.         {
     
210.             free( pBuffer );
     
211.             cbBuffer = cbBuffer * 2;
     
212.         }
     
213.     }
     
214.     while ( s == STATUS_INFO_LENGTH_MISMATCH );
     
215.     PSYSTEM_HANDLE_INFORMATION_EX    pInfo    = (PSYSTEM_HANDLE_INFORMATION_EX) pBuffer;
     
216.     ULONG                OldPID    = 0;
     
217.     for ( DWORD i = 0; i < pInfo->NumberOfHandles; i++ )
     
218.     {
     
219.         if ( OldPID != pInfo->Information.ProcessId )
     
220.         {
     
221.             OldPID = pInfo->Information.ProcessId;
     
222.             wprintf( L"PID: %d ", OldPID );
     
223.         }
     
224.     }
     
225.     free( pBuffer );
     
226.     FreeLibrary( hNtDll );
     
227.     getchar();
     
228. }
     
229. 一直在使用一个小工具叫unlocker。知道它是用关闭句柄的方法来删除文件的，但是自己也没有怎么研究过这东西。传说中更厉害的方法是直接向磁盘写0 和Xcb大法，最近准备好好研究这些删除方法。那么就从句柄开始吧。这里我只做枚举句柄的工作，因为关闭句柄就是把ZwDuplicateObject 的Options 这个参数赋值为DUPLICATE_CLOSE_SOURCE 。这里还要感谢一下sudami和NetRoc同学。。。O(∩_∩)O哈哈~
     
230. 
     
231. #include <ntddk.h>
     
232. 
     
233. #define AYA_DEVICE    L"\\Device\\EnumHandle"
     
234. #define AYA_LINK    L"\\DosDevices\\EnumHandle"
     
235. 
     
236. #define SystemHandleInformation 16
     
237. 
     
238. #define OB_TYPE_PROCESS 5
     
239. 
     
240. typedef struct _SYSTEM_HANDLE_TABLE_ENTRY_INFO
     
241. {
     
242.     USHORT    UniqueProcessId;
     
243.     USHORT    CreatorBackTraceIndex;
     
244.     UCHAR    ObjectTypeIndex;
     
245.     UCHAR    HandleAttributes;
     
246.     USHORT    HandleValue;
     
247.     PVOID    Object;
     
248.     ULONG    GrantedAccess;
     
249. } SYSTEM_HANDLE_TABLE_ENTRY_INFO, *PSYSTEM_HANDLE_TABLE_ENTRY_INFO;
     
250. 
     
251. typedef struct _SYSTEM_HANDLE_INFORMATION
     
252. {
     
253.     ULONG                NumberOfHandles;
     
254.     SYSTEM_HANDLE_TABLE_ENTRY_INFO    Handles[];
     
255. } SYSTEM_HANDLE_INFORMATION, *PSYSTEM_HANDLE_INFORMATION;
     
256. 
     
257. typedef enum _OBJECT_INFORMATION_CLASS {
     
258.     ObjectBasicInformation,
     
259.     ObjectNameInformation,
     
260.     ObjectTypeInformation,
     
261.     ObjectAllInformation,
     
262.     ObjectDataInformation
     
263. } OBJECT_INFORMATION_CLASS, *POBJECT_INFORMATION_CLASS;
     
264. 
     
265. typedef struct _OBJECT_BASIC_INFORMATION {
     
266.     ULONG        Attributes;
     
267.     ACCESS_MASK    DesiredAccess;
     
268.     ULONG        HandleCount;
     
269.     ULONG        ReferenceCount;
     
270.     ULONG        PagedPoolUsage;
     
271.     ULONG        NonPagedPoolUsage;
     
272.     ULONG        Reserved[3];
     
273.     ULONG        NameInformationLength;
     
274.     ULONG        TypeInformationLength;
     
275.     ULONG        SecurityDescriptorLength;
     
276.     LARGE_INTEGER    CreationTime;
     
277. } OBJECT_BASIC_INFORMATION, *POBJECT_BASIC_INFORMATION;
     
278. 
     
279. typedef struct _KOBJECT_NAME_INFORMATION {
     
280.     UNICODE_STRING    Name;
     
281.     WCHAR        NameBuffer[];
     
282. } KOBJECT_NAME_INFORMATION, *PKOBJECT_NAME_INFORMATION;
     
283. 
     
284. typedef struct _OBJECT_TYPE_INFORMATION {
     
285.     UNICODE_STRING    TypeName;
     
286.     ULONG        TotalNumberOfHandles;
     
287.     ULONG        TotalNumberOfObjects;
     
288.     WCHAR        Unused1[8];
     
289.     ULONG        HighWaterNumberOfHandles;
     
290.     ULONG        HighWaterNumberOfObjects;
     
291.     WCHAR        Unused2[8];
     
292.     ACCESS_MASK    InvalidAttributes;
     
293.     GENERIC_MAPPING GenericMapping;
     
294.     ACCESS_MASK    ValidAttributes;
     
295.     BOOLEAN        SecurityRequired;
     
296.     BOOLEAN        MaintainHandleCount;
     
297.     USHORT        MaintainTypeList;
     
298.     POOL_TYPE    PoolType;
     
299.     ULONG        DefaultPagedPoolCharge;
     
300.     ULONG        DefaultNonPagedPoolCharge;
     
301. } OBJECT_TYPE_INFORMATION, *POBJECT_TYPE_INFORMATION;
     
302. 
     
303. NTSYSAPI
     
304. NTSTATUS
     
305. NTAPI
     
306. ZwQueryObject(
     
307.     IN HANDLE Handle,
     
308.     IN OBJECT_INFORMATION_CLASS ObjectInformationClass,
     
309.     OUT PVOID ObjectInformation,
     
310.     IN ULONG ObjectInformationLength,
     
311.     OUT PULONG ReturnLength OPTIONAL
     
312.     );
     
313. 
     
314. 
     
315. NTSYSAPI
     
316. NTSTATUS
     
317. NTAPI
     
318. ZwQuerySystemInformation(
     
319.     ULONG SystemInformationClass,
     
320.     PVOID SystemInformation,
     
321.     ULONG SystemInformationLength,
     
322.     PULONG ReturnLength
     
323.     );
     
324. 
     
325. 
     
326. NTSYSAPI
     
327. NTSTATUS
     
328. NTAPI
     
329. ZwDuplicateObject(
     
330.     IN HANDLE SourceProcessHandle,
     
331.     IN HANDLE SourceHandle,
     
332.     IN HANDLE TargetProcessHandle OPTIONAL,
     
333.     OUT PHANDLE TargetHandle OPTIONAL,
     
334.     IN ACCESS_MASK DesiredAccess,
     
335.     IN ULONG HandleAttributes,
     
336.     IN ULONG Options
     
337.     );
     
338. 
     
339. 
     
340. NTSYSAPI
     
341. NTSTATUS
     
342. NTAPI
     
343. ZwOpenProcess(
     
344.     OUT PHANDLE ProcessHandle,
     
345.     IN ACCESS_MASK AccessMask,
     
346.     IN POBJECT_ATTRIBUTES ObjectAttributes,
     
347.     IN PCLIENT_ID ClientId
     
348.     );
     
349. 
     
350. 
     
351. NTSTATUS NTAPI AYA_EnumHandle();
     
352. 
     
353. 
     
354. void AYA_Unload( IN PDRIVER_OBJECT pDriverObj )
     
355. {
     
356.     UNICODE_STRING Temp;
     
357.     RtlInitUnicodeString( &Temp, AYA_LINK );
     
358.     IoDeleteSymbolicLink( &Temp );
     
359.     IoDeleteDevice( pDriverObj->DeviceObject );
     
360. }
     
361. 
     
362. 
     
363. NTSTATUS AYA_Dispatch( IN PDEVICE_OBJECT pDeviceObj, IN PIRP pIrp )
     
364. {
     
365.     NTSTATUS        ns = STATUS_SUCCESS;
     
366.     PIO_STACK_LOCATION    stIrp;
     
367. 
     
368.     stIrp = IoGetCurrentIrpStackLocation( pIrp );
     
369. 
     
370.     switch ( stIrp->MajorFunction )
     
371.     {
     
372.     case IRP_MJ_CREATE:
     
373.         break;
     
374.     case IRP_MJ_CLOSE:
     
375.         break;
     
376.     case IRP_MJ_DEVICE_CONTROL:
     
377.         break;
     
378.     default:
     
379.         pIrp->IoStatus.Status = STATUS_INVALID_PARAMETER;
     
380.         break;
     
381.     }
     
382. 
     
383.     ns = pIrp->IoStatus.Status;
     
384.     IoCompleteRequest( pIrp, IO_NO_INCREMENT );
     
385.     return(ns);
     
386. }
     
387. 
     
388. 
     
389. NTSTATUS DriverEntry( IN PDRIVER_OBJECT pDriverObj, IN PUNICODE_STRING RegistryPath )
     
390. {
     
391.     NTSTATUS    ns = STATUS_SUCCESS;
     
392.     UNICODE_STRING    AYA;
     
393.     UNICODE_STRING    AYAL;
     
394.     PDEVICE_OBJECT    pDevice;
     
395. 
     
396.     ns = AYA_EnumHandle();
     
397.     RtlInitUnicodeString( &AYA, AYA_DEVICE );
     
398.     ns = IoCreateDevice( pDriverObj, 0, &AYA, FILE_DEVICE_UNKNOWN, 0, FALSE, &pDevice );
     
399. 
     
400.     RtlInitUnicodeString( &AYAL, AYA_LINK );
     
401.     ns = IoCreateSymbolicLink( &AYAL, &AYA );
     
402. 
     
403.     pDriverObj->MajorFunction[IRP_MJ_CREATE]                =
     
404.         pDriverObj->MajorFunction[IRP_MJ_CLOSE]                =
     
405.             pDriverObj->MajorFunction[IRP_MJ_DEVICE_CONTROL]    = AYA_Dispatch;
     
406. 
     
407.     pDriverObj->DriverUnload = AYA_Unload;
     
408. 
     
409. 
     
410.     return(ns);
     
411. }
     
412. 
     
413. 
     
414. NTSTATUS AYA_EnumHandle()
     
415. {
     
416.     NTSTATUS            ns = STATUS_SUCCESS;
     
417.     ULONG                ulSize;
     
418.     PVOID                pSysBuffer;
     
419.     PSYSTEM_HANDLE_INFORMATION    pSysHandleInfo;
     
420.     SYSTEM_HANDLE_TABLE_ENTRY_INFO    pSysHandleTEI;
     
421.     OBJECT_BASIC_INFORMATION    BasicInfo;
     
422.     PKOBJECT_NAME_INFORMATION    pNameInfo;
     
423.     POBJECT_TYPE_INFORMATION    pTypeInfo;
     
424.     OBJECT_ATTRIBUTES        oa;
     
425.     ULONG                ulProcessID;
     
426.     HANDLE                hProcess;
     
427.     HANDLE                hHandle;
     
428.     HANDLE                hDupObj;
     
429.     CLIENT_ID            cid;
     
430.     ULONG                i;
     
431. 
     
432.     ulSize = 100;
     
433.     do
     
434.     {
     
435.         pSysBuffer    = ExAllocatePoolWithTag( PagedPool, ulSize, 'A0' );
     
436.         ns        = ZwQuerySystemInformation( SystemHandleInformation, pSysBuffer, ulSize, NULL );
     
437.         ulSize        *= 2;
     
438.         if ( !NT_SUCCESS( ns ) )
     
439.         {
     
440.             ExFreePool( pSysBuffer );
     
441.         }
     
442.     }
     
443.     while ( !NT_SUCCESS( ns ) );
     
444. 
     
445. 
     
446.     pSysHandleInfo = (PSYSTEM_HANDLE_INFORMATION) pSysBuffer;
     
447.     for ( i = 0; i < pSysHandleInfo->NumberOfHandles; i++ )
     
448.     {
     
449.         pSysHandleTEI = pSysHandleInfo->Handles;
     
450. 
     
451.         if ( pSysHandleTEI.ObjectTypeIndex != OB_TYPE_PROCESS )
     
452.         {
     
453.             continue;
     
454.         }
     
455. 
     
456.         ulProcessID        = (ULONG) pSysHandleTEI.UniqueProcessId;
     
457.         cid.UniqueProcess    = (HANDLE) ulProcessID;
     
458.         cid.UniqueThread    = (HANDLE) 0;
     
459.         hHandle            = (HANDLE) pSysHandleTEI.HandleValue;
     
460. 
     
461. 
     
462.         InitializeObjectAttributes( &oa, NULL, 0, NULL, NULL );
     
463.         ns = ZwOpenProcess( &hProcess, PROCESS_DUP_HANDLE, &oa, &cid );
     
464.         if ( !NT_SUCCESS( ns ) )
     
465.         {
     
466.             KdPrint( ("ZwOpenProcess : Fail ") );
     
467.             break;
     
468.         }
     
469.         ns = ZwDuplicateObject( hProcess, hHandle, NtCurrentProcess(), &hDupObj, \
     
470.                     PROCESS_ALL_ACCESS, 0, DUPLICATE_SAME_ACCESS );
     
471. 
     
472.         if ( !NT_SUCCESS( ns ) )
     
473.         {
     
474.             KdPrint( ("ZwDuplicateObject : Fail ") );
     
475.             break;
     
476.         }
     
477. 
     
478.         ZwQueryObject( hDupObj, ObjectBasicInformation, &BasicInfo, \
     
479.                    sizeof(OBJECT_BASIC_INFORMATION), NULL );
     
480. 
     
481.         pNameInfo = ExAllocatePoolWithTag( PagedPool, BasicInfo.NameInformationLength, 'A1' );
     
482.         RtlZeroMemory( pNameInfo, BasicInfo.NameInformationLength );
     
483. 
     
484.         ZwQueryObject( hDupObj, ObjectNameInformation, pNameInfo, \
     
485.                    BasicInfo.NameInformationLength, NULL );
     
486. 
     
487.         pTypeInfo = ExAllocatePoolWithTag( PagedPool, BasicInfo.TypeInformationLength, 'A2' );
     
488.         RtlZeroMemory( pTypeInfo, BasicInfo.TypeInformationLength );
     
489. 
     
490.         ZwQueryObject( hDupObj, ObjectTypeInformation, pTypeInfo, \
     
491.                    BasicInfo.TypeInformationLength, NULL );
     
492. 
     
493.         KdPrint( ("NAME:%wZ\t\t\tTYPE:%wZ\n", &(pNameInfo->Name), &(pTypeInfo->TypeName) ) );
     
494. 
     
495.         ExFreePool( pNameInfo );
     
496.         ExFreePool( pTypeInfo );
     
497.     }
     
498. 
     
499.     ZwClose( hDupObj );
     
500.     ZwClose( hProcess );
     
501.     ZwClose( hHandle );
     
502.     ExFreePool( pSysBuffer );
     
503. 
     
504.     if ( !NT_SUCCESS( ns ) )
     
505.     {
     
506.         return(STATUS_UNSUCCESSFUL);
     
507.     }
     
508. 
     
509.     return(ns);
     
510. }

复制代码