获取进程完整路径名附源码

蓝灵火焰

文章里对于如何获取其他进程，提供了两种方法，但是都不太方便，
在我的驱动里，我是在PsSetCreateProcessNotifyRoutine的回调函数里获取进程路径，
能得到的进程信息是PID，于是动手改了下上面的代码，
如下：

C++代码

1. NTSTATUS     
   
2.     GetProcessImagePath(   
   
3.         IN  DWORD   dwProcessId,   
   
4.         OUT PUNICODE_STRING ProcessImagePath   
   
5.     )   
   
6. {   
   
7.     NTSTATUS Status;   
   
8.     HANDLE hProcess;   
   
9.     PEPROCESS pEprocess;   
   
10.     ULONG returnedLength;   
    
11.     ULONG bufferLength;   
    
12.     PVOID buffer;   
    
13.     PUNICODE_STRING imageName;   
    
14.       
    
15.     PAGED_CODE(); // this eliminates the possibility of the IDLE Thread/Process   
    
16.    
    
17.     if (NULL == ZwQueryInformationProcess) {   
    
18.    
    
19.         UNICODE_STRING routineName;   
    
20.    
    
21.         RtlInitUnicodeString(&routineName, L"ZwQueryInformationProcess");   
    
22.    
    
23.         ZwQueryInformationProcess =   
    
24.                (QUERY_INFO_PROCESS) MmGetSystemRoutineAddress(&routineName);   
    
25.    
    
26.         if (NULL == ZwQueryInformationProcess) {   
    
27.             DbgPrint("Cannot resolve ZwQueryInformationProcess\n");   
    
28.         }   
    
29.     }   
    
30.         
    
31.     Status = PsLookupProcessByProcessId((HANDLE)dwProcessId, &pEprocess);   
    
32.     if (!NT_SUCCESS(Status))
    
33.         return Status;
    
34.         
    
35.     Status = ObOpenObjectByPointer(pEprocess,          // Object   
    
36.                                    OBJ_KERNEL_HANDLE,  // HandleAttributes   
    
37.                                    NULL,               // PassedAccessState OPTIONAL   
    
38.                                    GENERIC_READ,       // DesiredAccess   
    
39.                                    *PsProcessType,     // ObjectType   
    
40.                                    KernelMode,         // AccessMode   
    
41.                                    &hProcess);   
    
42.     if (!NT_SUCCESS(Status))
    
43.         return Status;  
    
44.         
    
45.         
    
46.     //   
    
47.     // Step one - get the size we need   
    
48.     //   
    
49.     Status = ZwQueryInformationProcess( hProcess,   
    
50.                                         ProcessImageFileName,   
    
51.                                         NULL, // buffer   
    
52.                                         0, // buffer size   
    
53.                                         &returnedLength);   
    
54.         
    
55.    
    
56.     if (STATUS_INFO_LENGTH_MISMATCH != Status) {   
    
57.    
    
58.         return Status;   
    
59.    
    
60.     }   
    
61.    
    
62.     //   
    
63.     // Is the passed-in buffer going to be big enough for us?     
    
64.     // This function returns a single contguous buffer model...   
    
65.     //   
    
66.     bufferLength = returnedLength - sizeof(UNICODE_STRING);   
    
67.       
    
68.     if (ProcessImagePath->MaximumLength < bufferLength) {   
    
69.    
    
70.         ProcessImagePath->Length = (USHORT) bufferLength;   
    
71.    
    
72.         return STATUS_BUFFER_OVERFLOW;   
    
73.            
    
74.     }   
    
75.    
    
76.     //   
    
77.     // If we get here, the buffer IS going to be big enough for us, so   
    
78.     // let's allocate some storage.   
    
79.     //   
    
80.     buffer = ExAllocatePoolWithTag(PagedPool, returnedLength, 'ipgD');   
    
81.    
    
82.     if (NULL == buffer) {   
    
83.    
    
84.         return STATUS_INSUFFICIENT_RESOURCES;   
    
85.            
    
86.     }   
    
87.    
    
88.     //   
    
89.     // Now lets go get the data   
    
90.     //   
    
91.     Status = ZwQueryInformationProcess( hProcess,   
    
92.                                         ProcessImageFileName,   
    
93.                                         buffer,   
    
94.                                         returnedLength,   
    
95.                                         &returnedLength);   
    
96.    
    
97.     if (NT_SUCCESS(Status)) {   
    
98.         //   
    
99.         // Ah, we got what we needed   
    
100.         //   
     
101.         imageName = (PUNICODE_STRING) buffer;   
     
102.    
     
103.         RtlCopyUnicodeString(ProcessImagePath, imageName);   
     
104.            
     
105.     }   
     
106.         
     
107.     ZwClose(hProcess);   
     
108.    
     
109.     //   
     
110.     // free our buffer   
     
111.     //   
     
112.     ExFreePool(buffer);   
     
113.    
     
114.     //   
     
115.     // And tell the caller what happened.   
     
116.     //      
     
117.     return Status;   
     
118.       
     
119. }   
     
120. 
     
121. typedef NTSTATUS (*QUERY_INFO_PROCESS) (
     
122.     __in HANDLE ProcessHandle,
     
123.     __in PROCESSINFOCLASS ProcessInformationClass,
     
124.     __out_bcount(ProcessInformationLength) PVOID ProcessInformation,
     
125.     __in ULONG ProcessInformationLength,
     
126.     __out_opt PULONG ReturnLength
     
127.     );
     
128. QUERY_INFO_PROCESS ZwQueryInformationProcess;
     
129. NTSTATUS GetProcessImageName(PUNICODE_STRING ProcessImageName)
     
130. {
     
131.     NTSTATUS status;
     
132.     ULONG returnedLength;
     
133.     ULONG bufferLength;
     
134.     PVOID buffer;
     
135.     PUNICODE_STRING imageName;
     
136.    
     
137.     PAGED_CODE(); // this eliminates the possibility of the IDLE Thread/Process
     
138.     if (NULL == ZwQueryInformationProcess) {
     
139.         UNICODE_STRING routineName;
     
140.         RtlInitUnicodeString(&routineName, L"ZwQueryInformationProcess");
     
141.         ZwQueryInformationProcess =
     
142.                (QUERY_INFO_PROCESS) MmGetSystemRoutineAddress(&routineName);
     
143.         if (NULL == ZwQueryInformationProcess) {
     
144.             DbgPrint("Cannot resolve ZwQueryInformationProcess\n");
     
145.         }
     
146.     }
     
147.     //
     
148.     // Step one - get the size we need
     
149.     //
     
150.     status = ZwQueryInformationProcess( NtCurrentProcess(),
     
151.                                         ProcessImageFileName,
     
152.                                         NULL, // buffer
     
153.                                         0, // buffer size
     
154.                                         &returnedLength);
     
155.     if (STATUS_INFO_LENGTH_MISMATCH != status) {
     
156.         return status;
     
157.     }
     
158.     //
     
159.     // Is the passed-in buffer going to be big enough for us?  
     
160.     // This function returns a single contguous buffer model...
     
161.     //
     
162.     bufferLength = returnedLength - sizeof(UNICODE_STRING);
     
163.    
     
164.     if (ProcessImageName->MaximumLength < bufferLength) {
     
165.         ProcessImageName->Length = (USHORT) bufferLength;
     
166.         return STATUS_BUFFER_OVERFLOW;
     
167.         
     
168.     }
     
169.     //
     
170.     // If we get here, the buffer IS going to be big enough for us, so
     
171.     // let's allocate some storage.
     
172.     //
     
173.     buffer = ExAllocatePoolWithTag(PagedPool, returnedLength, 'ipgD');
     
174.     if (NULL == buffer) {
     
175.         return STATUS_INSUFFICIENT_RESOURCES;
     
176.         
     
177.     }
     
178.     //
     
179.     // Now lets go get the data
     
180.     //
     
181.     status = ZwQueryInformationProcess( NtCurrentProcess(),
     
182.                                         ProcessImageFileName,
     
183.                                         buffer,
     
184.                                         returnedLength,
     
185.                                         &returnedLength);
     
186.     if (NT_SUCCESS(status)) {
     
187.         //
     
188.         // Ah, we got what we needed
     
189.         //
     
190.         imageName = (PUNICODE_STRING) buffer;
     
191.         RtlCopyUnicodeString(ProcessImageName, imageName);
     
192.         
     
193.     }
     
194.     //
     
195.     // free our buffer
     
196.     //
     
197.     ExFreePool(buffer);
     
198.     //
     
199.     // And tell the caller what happened.
     
200.     //   
     
201.     return status;
     
202.    
     
203. }

复制代码