开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 系统/网络安全 > 查看源码
Psapi.cpp
资源名称：getadmin.zip　[点击查看]
上传用户：yihongxs01
上传日期：2007-01-05
资源大小：48k
文件大小：14k
源码类别：

系统/网络安全

开发平台：

WINDOWS

Psapi.cpp：源码内容
  1. #include <windows.h>
  3. DWORD PsGetProcessIdFromModuleName(LPCTSTR szName);
  5. extern "C"{
  7. DWORD __stdcall NtQuerySystemInformation(DWORD,DWORD,DWORD,DWORD);
  8. DWORD __stdcall NtQueryInformationProcess(DWORD,DWORD,DWORD,DWORD,DWORD);
  9. DWORD __stdcall RtlNtStatusToDosError(DWORD);
  10. }
  11. #pragma warning( disable : 4035 )
  13. DWORD __declspec(naked) __stdcall 
  14. EnumProcesses(DWORD* ProcessesId,
  15. DWORD SizeofProcessesIds/*sizeof ProcessesId*/,
  16. DWORD* done)
  17. {
  18. __asm{
  20. ; S u b r o u t i n e
  21. ;EnumProcesses proc ,  pProcessesId: DWORD,
  22. ; sizeofProcessesId :DWORD,
  23. ; pDone: DWORD
  25.                 mov     eax,  fs:0
  26. push ebp
  27. mov ebp, esp
  28. push 0FFFFFFFFh
  29. push 731B3448h
  30. push 731B2E38h
  31. push eax
  32.                 mov      fs:0, esp
  33. sub esp, 14h ; Integer Subtraction
  34. push ebx
  35. push esi
  36. push edi
  37. mov esi, 8000h
  38. xor edi, edi ; Logical Exclusive OR
  39. mov [ebp-18h], esp
  41. loc_731B2B37: ; CODE XREF: EnumProcesses+61.j
  42. push esi
  43. push edi
  44. call dword ptr LocalAlloc ; Indirect Call Near Procedure
  45. mov [ebp-1Ch], eax
  46. cmp eax, edi ; Compare Two Operands
  47. jz loc_731B2C12 ; Jump if Zero (ZF=1)
  48. push edi
  49. push esi
  50. push eax
  51. push 5
  52. call NtQuerySystemInformation ; Indirect Call Near Procedure
  53. cmp eax, 0C0000004h ; Compare Two Operands
  54. jnz short loc_731B2B6D ; Jump if Not Zero (ZF=0)
  55. push dword ptr [ebp-1Ch]
  56. call dword ptr LocalFree ; Indirect Call Near Procedure
  57. add esi, 8000h ; Add
  58. jmp short loc_731B2B37 ; Jump
  59. ;哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪
  61. loc_731B2B6D: ; CODE XREF: EnumProcesses+50.j
  62. test eax, eax ; Logical Compare
  63. jge short loc_731B2B84 ; Jump if Greater or Equal (SF=OF)
  64. push eax
  65. call RtlNtStatusToDosError ; Indirect Call Near Procedure
  66. push eax
  67. call dword ptr SetLastError ; Indirect Call Near Procedure
  68. jmp loc_731B2C12 ; Jump
  69. ;哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪
  71. loc_731B2B84: ; CODE XREF: EnumProcesses+65.j
  72. xor esi, esi ; Logical Exclusive OR
  73. mov edx, [ebp+0Ch]
  74. shr edx, 2 ; Shift Logical Right
  75. xor edi, edi ; Logical Exclusive OR
  76. mov ecx, [ebp+8]
  78. loc_731B2B91: ; CODE XREF: EnumProcesses+AB.j
  79. mov eax, [ebp-1Ch]
  80. add eax, esi ; Add
  81. cmp edi, edx ; Compare Two Operands
  82. jnb short loc_731B2BAF ; Jump if Not Below (CF=0)
  83. mov dword ptr [ebp-4], 0
  84. mov ebx, [eax+44h]
  85. mov [ecx+edi*4], ebx
  86. inc edi ; Increment by 1
  87. mov dword ptr [ebp-4], 0FFFFFFFFh
  89. loc_731B2BAF: ; CODE XREF: EnumProcesses+8E.j
  90. mov eax, [eax]
  91. add esi, eax ; Add
  92. test eax, eax ; Logical Compare
  93. jnz short loc_731B2B91 ; Jump if Not Zero (ZF=0)
  94. mov esi, 1
  95. mov [ebp-4], esi
  96. lea ecx, ds:0[edi*4] ; Load Effective Address
  97. mov eax, [ebp+10h]
  98. mov [eax], ecx
  99. mov dword ptr [ebp-4], 0FFFFFFFFh
  100. push dword ptr [ebp-1Ch]
  101. call dword ptr LocalFree ; Indirect Call Near Procedure
  102. mov eax, esi
  103. jmp short loc_731B2C14 ; Jump
  105. loc_731B2C12: ; CODE XREF: EnumProcesses+3A.j
  106. ; EnumProcesses+75.j
  107. xor eax, eax ; Logical Exclusive OR
  109. loc_731B2C14: ; CODE XREF: EnumProcesses+D3.j
  110. mov ecx, [ebp-10h]
  111. pop edi
  112.                 mov      fs:0, ecx
  113. pop esi
  114. pop ebx
  115. mov esp, ebp
  116. pop ebp
  117. retn 0Ch ; Return Near from Procedure
  118. }
  119. //;EnumProcesses endp
  120. }
  124. DWORD __declspec(naked) __stdcall 
  125. EnumProcessModules(HANDLE hProcess,
  126.  HMODULE* hModule /*array*/,
  127.  DWORD SizeofhModule/* sizeof(hModule) */,
  128.  DWORD* done)
  129. {
  130. __asm
  131. {
  132. ; S u b r o u t i n e
  135. mov eax, fs:0
  136. push ebp
  137. mov ebp, esp
  138. push 0FFFFFFFFh
  139. push 731B3178h
  140. push 731B2E38h
  141. push eax
  142. mov fs:0, esp
  143. sub esp, 78h ; Integer Subtraction
  144. lea eax, [ebp-40h] ; Load Effective Address
  145. push ebx
  146. push esi
  147. push edi
  148. mov [ebp-18h], esp
  149. push 0
  150. push 18h
  151. push eax
  152. push 0
  153. push dword ptr [ebp+8]
  154. call NtQueryInformationProcess ; Indirect Call Near Procedure
  155. test eax, eax ; Logical Compare
  156. jge short loc_731B15BF ; Jump if Greater or Equal (SF=OF)
  157. push eax
  158. call RtlNtStatusToDosError ; Indirect Call Near Procedure
  159. push eax
  160. call dword ptr SetLastError ; Indirect Call Near Procedure
  161. jmp loc_731B169E ; Jump
  162. ;哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪
  164. loc_731B15BF: ; CODE XREF: EnumProcessModules+3B.j
  165. push 0
  166. lea eax, [ebp-28h] ; Load Effective Address
  167. push 4
  168. push eax
  169. mov eax, [ebp-3Ch]
  170. add eax, 0Ch ; Add
  171. push eax
  172. push dword ptr [ebp+8]
  173. call dword ptr ReadProcessMemory ; Indirect Call Near Procedure
  174. test eax, eax ; Logical Compare
  175. jz loc_731B169E ; Jump if Zero (ZF=1)
  176. mov esi, [ebp-28h]
  177. push 0
  178. add esi, 14h ; Add
  179. push 4
  180. lea eax, [ebp-1Ch] ; Load Effective Address
  181. push eax
  182. push esi
  183. push dword ptr [ebp+8]
  184. call dword ptr ReadProcessMemory ; Indirect Call Near Procedure
  185. test eax, eax ; Logical Compare
  186. jz loc_731B169E ; Jump if Zero (ZF=1)
  187. mov eax, [ebp+10h]
  188. xor edi, edi ; Logical Exclusive OR
  189. shr eax, 2 ; Shift Logical Right
  190. cmp esi, [ebp-1Ch] ; Compare Two Operands
  191. mov [ebp-24h], eax
  192. jz short loc_731B1657 ; Jump if Zero (ZF=1)
  193. mov ebx, [ebp+0Ch]
  195. loc_731B1612: ; CODE XREF: EnumProcessModules+E6.j
  196. mov eax, [ebp-1Ch]
  197. push 0
  198. sub eax, 8 ; Integer Subtraction
  199. push 48h
  200. lea ecx, [ebp-88h] ; Load Effective Address
  201. push ecx
  202. push eax
  203. push dword ptr [ebp+8]
  204. call dword ptr ReadProcessMemory ; Indirect Call Near Procedure
  205. test eax, eax ; Logical Compare
  206. jz short loc_731B169E ; Jump if Zero (ZF=1)
  207. cmp edi, [ebp-24h] ; Compare Two Operands
  208. jnb short loc_731B1649 ; Jump if Not Below (CF=0)
  209. mov dword ptr [ebp-4], 0
  210. mov eax, [ebp-70h]
  211. mov [ebx], eax
  212. mov dword ptr [ebp-4], 0FFFFFFFFh
  214. loc_731B1649: ; CODE XREF: EnumProcessModules+C5.j
  215. add ebx, 4 ; Add
  216. inc edi ; Increment by 1
  217. mov eax, [ebp-80h]
  218. mov [ebp-1Ch], eax
  219. cmp esi, eax ; Compare Two Operands
  220. jnz short loc_731B1612 ; Jump if Not Zero (ZF=0)
  222. loc_731B1657: ; CODE XREF: EnumProcessModules+9E.j
  223. mov eax, 1
  224. mov [ebp-4], eax
  225. lea edx, ds:0[edi*4] ; Load Effective Address
  226. mov ecx, [ebp+14h]
  227. mov [ecx], edx
  228. mov dword ptr [ebp-4], 0FFFFFFFFh
  229. jmp short loc_731B16A0 ; Jump
  231. loc_731B169E: ; CODE XREF: EnumProcessModules+4B.j
  232. ; EnumProcessModules+6A.j ...
  233. xor eax, eax ; Logical Exclusive OR
  235. loc_731B16A0: ; CODE XREF: EnumProcessModules+103.j
  236. mov ecx, [ebp-10h]
  237. pop edi
  238. mov fs:0, ecx
  239. pop esi
  240. pop ebx
  241. mov esp, ebp
  242. pop ebp
  243. retn 10h ; Return Near from Procedure
  244. }
  245. //EnumProcessModules endp
  247. }
  250. __declspec(naked) sub_731B14A5()
  251. {
  252. __asm{
  253. ; S u b r o u t i n e
  255. ;sub_731B14A5 proc near ; CODE XREF: GetModuleFileNameExW+11.p
  256. ; GetModuleBaseNameW+11.p ...
  257. push ebp
  258. mov ebp, esp
  259. sub esp, 20h ; Integer Subtraction
  260. push ebx
  261. lea eax, [ebp-20h] ; Load Effective Address
  262. push esi
  263. push edi
  264. push 0
  265. mov esi, [ebp+8]
  266. push 18h
  267. push eax
  268. push 0
  269. push esi
  270. call NtQueryInformationProcess ; Indirect Call Near Procedure
  271. test eax, eax ; Logical Compare
  272. jge short loc_731B14D3 ; Jump if Greater or Equal (SF=OF)
  273. push eax
  274. call RtlNtStatusToDosError ; Indirect Call Near Procedure
  275. push eax
  276. jmp loc_731B1557 ; Jump
  277. ;哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪
  279. loc_731B14D3: ; CODE XREF: sub_731B14A5+1F.j
  280. cmp dword ptr [ebp+0Ch], 0 ; Compare Two Operands
  281. mov edi, [ebp-1Ch]
  282. jnz short loc_731B14F3 ; Jump if Not Zero (ZF=0)
  283. push 0
  284. lea eax, [ebp+0Ch] ; Load Effective Address
  285. push 4
  286. lea ecx, [edi+8] ; Load Effective Address
  287. push eax
  288. push ecx
  289. push esi
  290. call dword ptr ReadProcessMemory ; Indirect Call Near Procedure
  291. test eax, eax ; Logical Compare
  292. jz short loc_731B155D ; Jump if Zero (ZF=1)
  294. loc_731B14F3: ; CODE XREF: sub_731B14A5+35.j
  295. push 0
  296. lea eax, [ebp-8] ; Load Effective Address
  297. push 4
  298. add edi, 0Ch ; Add
  299. push eax
  300. push edi
  301. push esi
  302. call dword ptr ReadProcessMemory ; Indirect Call Near Procedure
  303. test eax, eax ; Logical Compare
  304. jz short loc_731B155D ; Jump if Zero (ZF=1)
  305. mov edi, [ebp-8]
  306. push 0
  307. add edi, 14h ; Add
  308. push 4
  309. lea eax, [ebp-4] ; Load Effective Address
  310. push eax
  311. push edi
  312. push esi
  313. call dword ptr ReadProcessMemory ; Indirect Call Near Procedure
  314. test eax, eax ; Logical Compare
  315. jz short loc_731B155D ; Jump if Zero (ZF=1)
  316. cmp [ebp-4], edi ; Compare Two Operands
  317. jz short loc_731B1555 ; Jump if Zero (ZF=1)
  318. mov ebx, [ebp+10h]
  320. loc_731B152C: ; CODE XREF: sub_731B14A5+AE.j
  321. mov eax, [ebp-4]
  322. push 0
  323. sub eax, 8 ; Integer Subtraction
  324. push 48h
  325. push ebx
  326. push eax
  327. push esi
  328. call dword ptr ReadProcessMemory ; Indirect Call Near Procedure
  329. test eax, eax ; Logical Compare
  330. jz short loc_731B155D ; Jump if Zero (ZF=1)
  331. mov eax, [ebp+0Ch]
  332. cmp [ebx+18h], eax ; Compare Two Operands
  333. jz short loc_731B1568 ; Jump if Zero (ZF=1)
  334. mov eax, [ebx+8]
  335. mov [ebp-4], eax
  336. cmp eax, edi ; Compare Two Operands
  337. jnz short loc_731B152C ; Jump if Not Zero (ZF=0)
  339. loc_731B1555: ; CODE XREF: sub_731B14A5+82.j
  340. push 6
  342. loc_731B1557: ; CODE XREF: sub_731B14A5+29.j
  343. call dword ptr SetLastError ; Indirect Call Near Procedure
  345. loc_731B155D: ; CODE XREF: sub_731B14A5+4C.j
  346. ; sub_731B14A5+63.j ...
  347. xor eax, eax ; Logical Exclusive OR
  349. loc_731B155F: ; CODE XREF: sub_731B14A5+C8.j
  350. pop edi
  351. pop esi
  352. pop ebx
  353. mov esp, ebp
  354. pop ebp
  355. retn 0Ch ; Return Near from Procedure
  356. loc_731B1568: ; CODE XREF: sub_731B14A5+A4.j
  357. mov eax, 1
  358. jmp short loc_731B155F ; Jump
  359. ;sub_731B14A5 endp
  360.  
  361.  }
  363. }
  367. DWORD __declspec(naked) __stdcall GetModuleBaseNameW(HANDLE hProcess,HMODULE hMod,
  368. WCHAR* szProcessName,
  369. DWORD SizeofszProcessName/* sizeof szProcessName*/ )
  370. {
  371. __asm
  372. {
  373. ; S u b r o u t i n e
  375. push ebp
  376. mov ebp, esp
  377. sub esp, 48h ; Integer Subtraction
  378. push esi
  379. lea eax, [ebp-48h] ; Load Effective Address
  380. push eax
  381. push dword ptr [ebp+0Ch]
  382. push dword ptr [ebp+8]
  383. call sub_731B14A5 ; Call Procedure
  384. test eax, eax ; Logical Compare
  385. jnz short loc_731B1793 ; Jump if Not Zero (ZF=0)
  386. xor eax, eax ; Logical Exclusive OR
  387. jmp short loc_731B17CB ; Jump
  389. loc_731B1793: ; CODE XREF: GetModuleBaseNameW+18.j
  390. movzx esi, word ptr [ebp-1Ah] ; Move with Zero-Extend
  391. mov eax, [ebp+14h]
  392. add eax, eax ; Add
  393. cmp esi, eax ; Compare Two Operands
  394. jbe short loc_731B17A2 ; Jump if Below or Equal (CF=1 | ZF=1)
  395. mov esi, eax
  397. loc_731B17A2: ; CODE XREF: GetModuleBaseNameW+29.j
  398. push 0
  399. push esi
  400. push dword ptr [ebp+10h]
  401. push dword ptr [ebp-18h]
  402. push dword ptr [ebp+8]
  403. call dword ptr ReadProcessMemory ; Indirect Call Near Procedure
  404. test eax, eax ; Logical Compare
  405. jnz short loc_731B17BC ; Jump if Not Zero (ZF=0)
  406. xor eax, eax ; Logical Exclusive OR
  407. jmp short loc_731B17CB ; Jump
  409. loc_731B17BC: ; CODE XREF: GetModuleBaseNameW+41.j
  410. movzx eax, word ptr [ebp-1Ah] ; Move with Zero-Extend
  411. cmp eax, esi ; Compare Two Operands
  412. jnz short loc_731B17C7 ; Jump if Not Zero (ZF=0)
  413. sub esi, 2 ; Integer Subtraction
  415. loc_731B17C7: ; CODE XREF: GetModuleBaseNameW+4D.j
  416. mov eax, esi
  417. shr eax, 1 ; Shift Logical Right
  419. loc_731B17CB: ; CODE XREF: GetModuleBaseNameW+1C.j
  420. ; GetModuleBaseNameW+45.j
  421. pop esi
  422. mov esp, ebp
  423. pop ebp
  424. retn 10h ; Return Near from Procedure
  425. ;GetModuleBaseNameW endp
  426. }
  427. }
  430. DWORD __declspec(naked) __stdcall GetModuleBaseNameA(HANDLE hProcess,HMODULE hMod,
  431. char* szProcessName,
  432. DWORD SizeofszProcessName/* sizeof szProcessName*/ )
  433. {
  435. __asm
  436. {
  437. push ebx
  438. push esi
  439. mov esi, [esp+18h]
  440. push edi
  441. push ebp
  442. lea eax, ds:0[esi*2] ; Load Effective Address
  443. push eax
  444. push 0
  445. call dword ptr LocalAlloc ; Indirect Call Near Procedure
  446. mov edi, eax
  447. test edi, edi ; Logical Compare
  448. jnz short loc_731B17F4 ; Jump if Not Zero (ZF=0)
  449. xor eax, eax ; Logical Exclusive OR
  450. jmp short loc_731B1830 ; Jump
  451. ;哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪哪
  453. loc_731B17F4: ; CODE XREF: GetModuleBaseNameA+1C.j
  454. push esi
  455. push edi
  456. push dword ptr [esp+20h]
  457. push dword ptr [esp+20h]
  458. call GetModuleBaseNameW ; Call Procedure
  459. mov ecx, eax
  460. cmp eax, esi ; Compare Two Operands
  461. mov ebx, eax
  462. jnb short loc_731B180E ; Jump if Not Below (CF=0)
  463. lea ecx, [ebx+1] ; Load Effective Address
  465. loc_731B180E: ; CODE XREF: GetModuleBaseNameA+37.j
  466. xor ebp, ebp ; Logical Exclusive OR
  467. push ebp
  468. push ebp
  469. push esi
  470. push dword ptr [esp+28h]
  471. push ecx
  472. push edi
  473. push ebp
  474. push ebp
  475. call dword ptr WideCharToMultiByte ; Indirect Call Near Procedure
  476. test eax, eax ; Logical Compare
  477. jnz short loc_731B1827 ; Jump if Not Zero (ZF=0)
  478. xor ebx, ebx ; Logical Exclusive OR
  480. loc_731B1827: ; CODE XREF: GetModuleBaseNameA+51.j
  481. push edi
  482. call dword ptr LocalFree ; Indirect Call Near Procedure
  483. mov eax, ebx
  485. loc_731B1830: ; CODE XREF: GetModuleBaseNameA+20.j
  486. pop ebp
  487. pop edi
  488. pop esi
  489. pop ebx
  490. retn 10h ; Return Near from Procedure
  491. ;GetModuleBaseNameA endp
  492. }
  493. }
  498. DWORD PsGetProcessIdFromModuleName(LPCTSTR szName)
  499. {
  500. DWORD ProcessesId[1024],cProcesses,done;
  501. DWORD pid;
  502. HMODULE hMod;
  503. HANDLE hProcess;
  504. char szProcessName[MAX_PATH];
  505. unsigned i;
  508. if(!EnumProcesses(ProcessesId,sizeof(ProcessesId),&done))
  509. {
  510. return (DWORD)-1;
  511. }
  513. cProcesses = done / sizeof(DWORD);
  515. for(i=2;i<cProcesses;i++)
  516. {
  517. strcpy(szProcessName,"unknown");
  518. pid = ProcessesId[i];
  520. hProcess = OpenProcess(PROCESS_QUERY_INFORMATION|
  521. PROCESS_VM_READ,
  522. FALSE,pid);
  523. if(!hProcess) continue;
  526. if(EnumProcessModules(hProcess,&hMod,sizeof(hMod),&done) )
  527. {
  528. GetModuleBaseNameA(hProcess,hMod,szProcessName,sizeof(szProcessName));
  529. }
  531. CloseHandle(hProcess);
  533. if(!strcmp(szProcessName,szName)) return pid;
  534. }
  536. return 0;
  537. }