求指导 调用函数功能没实现

wslyz640

1.rar (2.13 KB, 下载次数: 3)

2012-11-23 00:19 上传

点击文件名下载附件
阅读权限: 10

麻烦大家帮我看下这代码  这是原版源码


我用的是VC2010    使用的Unicode字符集   最后我把字符都转过来了  但是在调用MySystem函数的时候 一直没有实现功能  麻烦打击帮帮忙

马大哈

1. // ss.cpp: 主项目文件。
   
2. #include <windows.h>
   
3. #include <tlhelp32.h>
   
4. #include <aclapi.h>
   
5. #include <Psapi.h>
   
6. #pragma comment(lib,"Psapi.lib")
   
7. 
   
8. 
   
9. int ProcessExit(LPCTSTR szProcName,int x)
   
10. {
    
11.         PROCESSENTRY32        pe;
    
12.         DWORD        dwRet;
    
13.         BOOL        bFound = FALSE;
    
14.         HANDLE hProcess;
    
15.         char fileName[1024] = {0};
    
16.         HANDLE hSP = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    
17.         if (hSP)
    
18.         {
    
19.                 pe.dwSize = sizeof(pe);
    
20. 
    
21.                 for (dwRet = Process32First(hSP, &pe);
    
22.                         dwRet;
    
23.                         dwRet = Process32Next(hSP, &pe))
    
24.                 {
    
25.                         if(x){
    
26.                                 if (lstrcmpi( szProcName, pe.szExeFile) == 0)
    
27.                                 {
    
28.                                         bFound = TRUE;
    
29.                                         break;
    
30.                                 }
    
31.                         }
    
32.                         else
    
33.                         {
    
34.                                 hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,FALSE,pe.th32ProcessID);
    
35.                                 if(hProcess)
    
36.                                 {
    
37.                                         Sleep(1);
    
38.                                         GetModuleFileNameEx(hProcess,NULL, (LPSTR)fileName,sizeof(fileName));
    
39.                                         Sleep(1);
    
40.                                         if (lstrcmpi( szProcName, fileName) == 0)
    
41.                                         {
    
42.                                                 bFound = TRUE;
    
43.                                                 break;
    
44.                                         }
    
45.                                 }
    
46.                                 CloseHandle(hProcess);
    
47.                         }
    
48.                 }
    
49.                 CloseHandle(hSP);       
    
50.         }
    
51.         return bFound;
    
52. }
    
53. BOOL EnableDebugPriv( LPCTSTR szPrivilege )
    
54. {
    
55. 
    
56.         HANDLE hToken;
    
57.         LUID sedebugnameValue;
    
58.         TOKEN_PRIVILEGES tkp;
    
59. 
    
60.         if ( !OpenProcessToken( GetCurrentProcess(),
    
61.                 TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
    
62.                 &hToken ) )
    
63.         {
    
64.                 return FALSE;
    
65.         }
    
66.         if ( !LookupPrivilegeValue( NULL, szPrivilege, &sedebugnameValue ) )
    
67.         {
    
68.                 CloseHandle( hToken );
    
69.                 return FALSE;
    
70.         }
    
71. 
    
72.         tkp.PrivilegeCount = 1;
    
73.         tkp.Privileges[0].Luid = sedebugnameValue;
    
74.         tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
    
75. 
    
76.         if ( !AdjustTokenPrivileges( hToken, FALSE, &tkp, sizeof tkp, NULL, NULL ) )
    
77.         {
    
78.                 CloseHandle( hToken );
    
79.                 return FALSE;
    
80.         }
    
81. 
    
82.         return TRUE;
    
83. }
    
84. 
    
85. 
    
86. DWORD GetProcessId( LPCTSTR szProcName )
    
87. {
    
88.         PROCESSENTRY32 pe;  
    
89.         DWORD dwPid;
    
90.         DWORD dwRet;
    
91.         BOOL bFound = FALSE;
    
92. 
    
93.         //
    
94.         // 通过 TOOHLP32 函数枚举进程
    
95.         //
    
96. 
    
97.         HANDLE hSP = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 );
    
98.         if ( hSP )
    
99.         {
    
100.                 pe.dwSize = sizeof( pe );
     
101. 
     
102.                 for ( dwRet = Process32First( hSP, &pe );
     
103.                         dwRet;
     
104.                         dwRet = Process32Next( hSP, &pe ) )
     
105.                 {
     
106.                         if ( lstrcmpi(szProcName, pe.szExeFile) == 0 )
     
107.                         {
     
108.                                 dwPid = pe.th32ProcessID;
     
109.                                 bFound = TRUE;
     
110.                                 break;
     
111.                         }
     
112.                 }
     
113. 
     
114.                 CloseHandle( hSP );
     
115. 
     
116.                 if ( bFound == TRUE )
     
117.                 {
     
118.                         return dwPid;
     
119.                 }
     
120.         }
     
121. 
     
122.         return NULL;
     
123. }
     
124. 
     
125. 
     
126. BOOL MySystem( LPTSTR szProcessName )
     
127. {
     
128.         HANDLE hProcess;
     
129.         HANDLE hToken, hNewToken;
     
130.         DWORD dwPid;
     
131. 
     
132.         PACL pOldDAcl = NULL;
     
133.         PACL pNewDAcl = NULL;
     
134.         BOOL bDAcl;
     
135.         BOOL bDefDAcl;
     
136.         DWORD dwRet;
     
137. 
     
138.         PACL pSacl = NULL;
     
139.         PSID pSidOwner = NULL;
     
140.         PSID pSidPrimary = NULL;
     
141.         DWORD dwAclSize = 0;
     
142.         DWORD dwSaclSize = 0;
     
143.         DWORD dwSidOwnLen = 0;
     
144.         DWORD dwSidPrimLen = 0;
     
145. 
     
146.         DWORD dwSDLen;
     
147.         EXPLICIT_ACCESS ea;
     
148.         PSECURITY_DESCRIPTOR pOrigSd = NULL;
     
149.         PSECURITY_DESCRIPTOR pNewSd = NULL;
     
150. 
     
151.         STARTUPINFO si;
     
152.         PROCESS_INFORMATION pi;
     
153. 
     
154.         BOOL bError;
     
155. 
     
156.         if (!EnableDebugPriv("SeDebugPrivilege"))
     
157.         {
     
158.                 bError = TRUE;
     
159.                 goto Cleanup;
     
160.         }
     
161. 
     
162.         if ( ( dwPid = GetProcessId("WINLOGON.EXE") ) == NULL )
     
163.         {
     
164.                 bError = TRUE;
     
165.                 goto Cleanup;
     
166.         }
     
167. 
     
168.         hProcess = OpenProcess( MAXIMUM_ALLOWED, FALSE, dwPid );
     
169.         if ( hProcess == NULL )
     
170.         {
     
171.                 bError = TRUE;
     
172.                 goto Cleanup;
     
173.         }
     
174. 
     
175.         if ( !OpenProcessToken( hProcess, READ_CONTROL | WRITE_DAC, &hToken ) )
     
176.         {
     
177.                 bError = TRUE;
     
178.                 goto Cleanup;
     
179.         }
     
180. 
     
181.         ZeroMemory( &ea, sizeof( EXPLICIT_ACCESS ) );
     
182.         BuildExplicitAccessWithName( &ea,
     
183.                 "Everyone",
     
184.                 TOKEN_ALL_ACCESS,
     
185.                 GRANT_ACCESS,
     
186.                 0 );
     
187. 
     
188.         if ( !GetKernelObjectSecurity( hToken,
     
189.                 DACL_SECURITY_INFORMATION,
     
190.                 pOrigSd,
     
191.                 0,
     
192.                 &dwSDLen ) )
     
193.         {
     
194. 
     
195.                 if ( GetLastError() == ERROR_INSUFFICIENT_BUFFER )
     
196.                 {
     
197.                         pOrigSd = ( PSECURITY_DESCRIPTOR ) HeapAlloc( GetProcessHeap(),
     
198.                                 HEAP_ZERO_MEMORY,
     
199.                                 dwSDLen );
     
200.                         if ( pOrigSd == NULL )
     
201.                         {
     
202.                                 bError = TRUE;
     
203.                                 goto Cleanup;
     
204.                         }
     
205. 
     
206.                         if ( !GetKernelObjectSecurity( hToken,
     
207.                                 DACL_SECURITY_INFORMATION,
     
208.                                 pOrigSd,
     
209.                                 dwSDLen,
     
210.                                 &dwSDLen ) )
     
211.                         {
     
212.                                 bError = TRUE;
     
213.                                 goto Cleanup;
     
214.                         }
     
215.                 }
     
216.                 else
     
217.                 {
     
218.                         bError = TRUE;
     
219.                         goto Cleanup;
     
220.                 }
     
221.         }
     
222. 
     
223.         if ( !GetSecurityDescriptorDacl( pOrigSd, &bDAcl, &pOldDAcl, &bDefDAcl ) )
     
224.         {
     
225.                 bError = TRUE;
     
226.                 goto Cleanup;
     
227.         }
     
228. 
     
229. 
     
230.         dwRet = SetEntriesInAcl( 1, &ea, pOldDAcl, &pNewDAcl );
     
231.         if ( dwRet != ERROR_SUCCESS )
     
232.         {
     
233.                 pNewDAcl = NULL;
     
234. 
     
235.                 bError = TRUE;
     
236.                 goto Cleanup;
     
237.         }
     
238. 
     
239.         if ( !MakeAbsoluteSD( pOrigSd,
     
240.                 pNewSd,
     
241.                 &dwSDLen,
     
242.                 pOldDAcl,
     
243.                 &dwAclSize,
     
244.                 pSacl,
     
245.                 &dwSaclSize,
     
246.                 pSidOwner,
     
247.                 &dwSidOwnLen,
     
248.                 pSidPrimary,
     
249.                 &dwSidPrimLen ) )
     
250.         {
     
251. 
     
252.                 if ( GetLastError() == ERROR_INSUFFICIENT_BUFFER )
     
253.                 {
     
254.                         pOldDAcl = ( PACL ) HeapAlloc( GetProcessHeap(),
     
255.                                 HEAP_ZERO_MEMORY,
     
256.                                 dwAclSize );
     
257.                         pSacl = ( PACL ) HeapAlloc( GetProcessHeap(),
     
258.                                 HEAP_ZERO_MEMORY,
     
259.                                 dwSaclSize );
     
260.                         pSidOwner = ( PSID ) HeapAlloc( GetProcessHeap(),
     
261.                                 HEAP_ZERO_MEMORY,
     
262.                                 dwSidOwnLen );
     
263.                         pSidPrimary = ( PSID ) HeapAlloc( GetProcessHeap(),
     
264.                                 HEAP_ZERO_MEMORY,
     
265.                                 dwSidPrimLen );
     
266.                         pNewSd = ( PSECURITY_DESCRIPTOR ) HeapAlloc( GetProcessHeap(),
     
267.                                 HEAP_ZERO_MEMORY,
     
268.                                 dwSDLen );
     
269. 
     
270.                         if ( pOldDAcl == NULL ||
     
271.                                 pSacl == NULL ||
     
272.                                 pSidOwner == NULL ||
     
273.                                 pSidPrimary == NULL ||
     
274.                                 pNewSd == NULL )
     
275.                         {
     
276.                                 bError = TRUE;
     
277.                                 goto Cleanup;
     
278.                         }
     
279. 
     
280.                         if ( !MakeAbsoluteSD( pOrigSd,
     
281.                                 pNewSd,
     
282.                                 &dwSDLen,
     
283.                                 pOldDAcl,
     
284.                                 &dwAclSize,
     
285.                                 pSacl,
     
286.                                 &dwSaclSize,
     
287.                                 pSidOwner,
     
288.                                 &dwSidOwnLen,
     
289.                                 pSidPrimary,
     
290.                                 &dwSidPrimLen ) )
     
291.                         {
     
292.                                 bError = TRUE;
     
293.                                 goto Cleanup;
     
294.                         }
     
295.                 }
     
296.                 else
     
297.                 {
     
298.                         bError = TRUE;
     
299.                         goto Cleanup;
     
300.                 }
     
301.         }
     
302. 
     
303.         if ( !SetSecurityDescriptorDacl( pNewSd, bDAcl, pNewDAcl, bDefDAcl ) )
     
304.         {
     
305.                 bError = TRUE;
     
306.                 goto Cleanup;
     
307.         }
     
308. 
     
309.         if ( !SetKernelObjectSecurity( hToken, DACL_SECURITY_INFORMATION, pNewSd ) )
     
310.         {
     
311.                 bError = TRUE;
     
312.                 goto Cleanup;
     
313.         }
     
314. 
     
315.         if ( !OpenProcessToken( hProcess, TOKEN_ALL_ACCESS, &hToken ) )
     
316.         {
     
317.                 bError = TRUE;
     
318.                 goto Cleanup;
     
319.         }
     
320. 
     
321.         if ( !DuplicateTokenEx( hToken,
     
322.                 TOKEN_ALL_ACCESS,
     
323.                 NULL,
     
324.                 SecurityImpersonation,
     
325.                 TokenPrimary,
     
326.                 &hNewToken ) )
     
327.         {
     
328.                 bError = TRUE;
     
329.                 goto Cleanup;
     
330.         }
     
331. 
     
332. 
     
333.         ZeroMemory( &si, sizeof( STARTUPINFO ) );
     
334.         si.cb = sizeof( STARTUPINFO );
     
335. 
     
336.         ImpersonateLoggedOnUser( hNewToken );
     
337. 
     
338.         if ( !CreateProcessAsUser( hNewToken,
     
339.                 NULL,
     
340.                 szProcessName,
     
341.                 NULL,
     
342.                 NULL,
     
343.                 FALSE,
     
344.                 NULL, //NORMAL_PRIORITY_CLASS | CREATE_NEW_CONSOLE,
     
345.                 NULL,
     
346.                 NULL,
     
347.                 &si,
     
348.                 &pi ) )
     
349.         {
     
350.                 bError = TRUE;
     
351.                 goto Cleanup;
     
352.         }
     
353. 
     
354.         bError = FALSE;
     
355. 
     
356. Cleanup:
     
357.         if ( pOrigSd )
     
358.         {
     
359.                 HeapFree( GetProcessHeap(), 0, pOrigSd );
     
360.         }
     
361.         if ( pNewSd )
     
362.         {
     
363.                 HeapFree( GetProcessHeap(), 0, pNewSd );
     
364.         }
     
365.         if ( pSidPrimary )
     
366.         {
     
367.                 HeapFree( GetProcessHeap(), 0, pSidPrimary );
     
368.         }
     
369.         if ( pSidOwner )
     
370.         {
     
371.                 HeapFree( GetProcessHeap(), 0, pSidOwner );
     
372.         }
     
373.         if ( pSacl )
     
374.         {
     
375.                 HeapFree( GetProcessHeap(), 0, pSacl );
     
376.         }
     
377.         if ( pOldDAcl )
     
378.         {
     
379.                 HeapFree( GetProcessHeap(), 0, pOldDAcl );
     
380.         }
     
381. 
     
382.         CloseHandle( pi.hProcess );
     
383.         CloseHandle( pi.hThread );
     
384.         CloseHandle( hToken );
     
385.         CloseHandle( hNewToken );
     
386.         CloseHandle( hProcess );
     
387. 
     
388.         if ( bError )
     
389.         {
     
390.                 return FALSE;
     
391.         }
     
392. 
     
393.         return TRUE;
     
394. }
     
395. int main(int argc, char* argv[])
     
396. {
     
397.         MySystem("cmd.exe");
     
398.         return 0;
     
399. }
     

复制代码

帮你把代码发上来.

论坛里玩VS2010的好象不多,帮顶顶

lxl1638

粗略看了一下，这份源码在网上见过，但我没有调试，有一点可以肯定的，就是使用Unicode字符集绝对不能通过