创建远程线程 调用游戏所有call

lyxy68

用到的函数:

HWND FindWindow(
  LPCTSTR lpClassName,  // class name(窗口的类名)
  LPCTSTR lpWindowName  // window name(窗口的标题)
); //查找窗口,成功则返回窗口的句柄; 失败返回 0



DWORD GetWindowThreadProcessId(
  HWND hWnd,             // handle to window (指定窗口句柄)
  LPDWORD lpdwProcessId  // process identifier(返回进程 ID 的指针)
); //函数返回线程 ID


HANDLE OpenProcess(
  DWORD dwDesiredAccess,  // access flag(访问选项)
  BOOL bInheritHandle,    // handle inheritance option(能否继承; True 表示能用 CreateProcess 继承句柄创建新进程)
  DWORD dwProcessId       // process identifier(指定进程 ID)
);//函数调用成功会返回进程句柄; 失败返回 0



//dwDesiredAccess 可选值:
PROCESS_TERMINATE         = $0001; {允许 TerminateProcess 使用进程句柄来关闭进程}
PROCESS_CREATE_THREAD     = $0002; {允许 CreateRemoteThread 使用进程句柄来创建线程}
PROCESS_VM_OPERATION      = $0008; {允许 VirtualProtectEx 使用进程句柄来改变进程的虚拟内存}
PROCESS_VM_READ           = $0010; {允许 ReadProcessMemory 使用进程句柄从进程的虚拟内存中读取数据}
PROCESS_VM_WRITE          = $0020; {允许 WriteProcessMemory 使用进程句柄向进程的虚拟内存中写入数据}
PROCESS_DUP_HANDLE        = $0040; {允许 DuplicateHandle 把进程句柄当作源句柄或目标句柄进行复制}
PROCESS_CREATE_PROCESS    = $0080; {默认值}
PROCESS_SET_QUOTA         = $0100; {允许 SetProcessWorkingSetSize 使用进程句柄来来设置虚拟内存的上限值}
PROCESS_SET_INFORMATION   = $0200; {允许 SetPriorityClass 使用进程句柄来设置进程优先级}
PROCESS_QUERY_INFORMATION = $0400; {允许 GetExitCodeProcess 或 GetPriorityClass 通过进程句柄读取进程信息}
SYNCHRONIZE               = $00100000; {允许任何等待的函数使用进程句柄}
PROCESS_ALL_ACCESS = (STANDARD_RIGHTS_REQUIRED or SYNCHRONIZE or$FFF);  {允许所有权限}



HANDLE CreateRemoteThread(
  HANDLE hProcess,                          // handle to process
  LPSECURITY_ATTRIBUTES lpThreadAttributes, // SD
  DWORD dwStackSize,                        // initial stack size
  LPTHREAD_START_ROUTINE lpStartAddress,    // thread function
  LPVOID lpParameter,                       // thread argument
  DWORD dwCreationFlags,                    // creation option
  LPDWORD lpThreadId                        // thread identifier
);


CreateRemoteThread提供了一个在远程进程中执行代码的方法,就像代码长出翅膀飞到别处运行。本文将做一个入门介绍，希望对广大编程爱好者有所帮助。

先解释一下远程进程，其实就是要植入你的代码的进程，相对于你的工作进程（如果叫本地进程的话）它就叫远程进程，可理解为宿主。

首先介绍一下我们的主要工具CreateRemoteThread，这里先将函数原型简单介绍以下。

CreateRemoteThread可将线程创建在远程进程中。

1. [hide]
   
2. 函数原型
   
3. HANDLE CreateRemoteThread(
   
4. HANDLE hProcess,                          // handle to process
   
5. LPSECURITY_ATTRIBUTES lpThreadAttributes, // SD
   
6. SIZE_T dwStackSize,                       // initial stack size
   
7. LPTHREAD_START_ROUTINE lpStartAddress,    // thread function
   
8. LPVOID lpParameter,                       // thread argument
   
9. DWORD dwCreationFlags,                    // creation option
   
10. LPDWORD lpThreadId                        // thread identifier
    
11. );
    
12. 参数说明：
    
13. hProcess
    
14. [输入] 进程句柄
    
15. lpThreadAttributes
    
16. [输入] 线程安全描述字，指向SECURITY_ATTRIBUTES结构的指针
    
17. dwStackSize
    
18. [输入] 线程栈大小，以字节表示
    
19. lpStartAddress
    
20. [输入] 一个LPTHREAD_START_ROUTINE类型的指针，指向在远程进程中执行的函数地址
    
21. lpParameter
    
22. [输入] 传入参数
    
23. dwCreationFlags
    
24. [输入] 创建线程的其它标志
    
25. 
    
26. lpThreadId
    
27. [输出] 线程身份标志，如果为NULL,则不返回
    
28. 
    
29. 返回值
    
30. 成功返回新线程句柄，失败返回NULL，并且可调用GetLastError获得错误值。
    
31. 
    
32. 接下来我们将以两种方式使用CreateRemoteThread，大家可以领略到CreateRemoteThread的神通，它使你的代码可以脱离你的进程，植入到别的进程中运行。
    
33. 
    
34. 
    
35. 第一种方式
    
36. 
    
37. 第一种方式，我们使用函数的形式。即我们将自己程序中的一个函数植入到远程进程中。
    
38. 
    
39. 步骤1：首先在你的进程中创建函数MyFunc，我们将把它放在另一个进程中运行，这里以windows
    
40. 
    
41. 计算器为目标进程。
    
42. static DWORD WINAPI MyFunc (LPVOID pData)
    
43. {
    
44. //do something
    
45. //...
    
46. //pData输入项可以是任何类型值
    
47. //这里我们会传入一个DWORD的值做示例，并且简单返回
    
48. return *(DWORD*)pData;
    
49. }
    
50. static void AfterMyFunc (void) {
    
51. }
    
52. 这里有个小技巧，定义了一个static void AfterMyFunc (void)；为了下面确定我们的代码大小
    
53. 
    
54. 步骤2：定位目标进程，这里是一个计算器
    
55. HWND hStart = ::FindWindow (TEXT("SciCalc"),NULL);
    
56. 
    
57. 步骤3：获得目标进程句柄，这里用到两个不太常用的函数（当然如果经常做线程/进程等方面的 项目的话，就很面熟了），但及有用
    
58. DWORD PID, TID;
    
59. TID = ::GetWindowThreadProcessId (hStart, &PID);
    
60. 
    
61. HANDLE hProcess;
    
62. hProcess = OpenProcess(PROCESS_ALL_ACCESS,false,PID);
    
63. 
    
64. 步骤4：在目标进程中配变量地址空间，这里我们分配10个字节，并且设定为可以读
    
65. 
    
66. 写PAGE_READWRITE，当然也可设为只读等其它标志，这里就不一一说明了。
    
67. char szBuffer[10];
    
68. *(DWORD*)szBuffer=1000;//for test
    
69. void *pDataRemote =(char*) VirtualAllocEx( hProcess, 0, sizeof(szBuffer), MEM_COMMIT,
    
70. 
    
71. PAGE_READWRITE );
    
72. 
    
73. 步骤5：写内容到目标进程中分配的变量空间
    
74. ::WriteProcessMemory( hProcess, pDataRemote, szBuffer,(sizeof(szBuffer),NULL);
    
75. 
    
76. 步骤6：在目标进程中分配代码地址空间
    
77. 计算代码大小
    
78. DWORD cbCodeSize=((LPBYTE) AfterMyFunc - (LPBYTE) MyFunc);
    
79. 分配代码地址空间
    
80. PDWORD pCodeRemote = (PDWORD) VirtualAllocEx( hProcess, 0, cbCodeSize, MEM_COMMIT,
    
81. 
    
82. PAGE_EXECUTE_READWRITE );
    
83. 
    
84. 步骤7：写内容到目标进程中分配的代码地址空间
    
85. WriteProcessMemory( hProcess, pCodeRemote, &MyFunc, cbCodeSize, NULL);
    
86. 
    
87. 步骤8：在目标进程中执行代码
    
88. 
    
89. HANDLE hThread = CreateRemoteThread(hProcess, NULL, 0,
    
90. (LPTHREAD_START_ROUTINE) pCodeRemote,
    
91. pDataRemote, 0 , NULL);
    
92. DWORD h;
    
93. if (hThread)
    
94. {
    
95. ::WaitForSingleObject( hThread, INFINITE );
    
96. ::GetExitCodeThread( hThread, &h );
    
97. TRACE("run and return %d\n",h);
    
98. ::CloseHandle( hThread );
    
99. }
    
100. 
     
101. 这里有几个值得说明的地方:
     
102. 使用WaitForSingleObject等待线程结束;
     
103. 使用GetExitCodeThread获得返回值；
     
104. 最后关闭句柄CloseHandle。
     
105. 
     
106. 步骤9：清理现场
     
107. 
     
108. 释放空间
     
109. ::VirtualFreeEx( hProcess, pCodeRemote,
     
110.                  cbCodeSize,MEM_RELEASE );
     
111. 
     
112. ::VirtualFreeEx( hProcess, pDataRemote,
     
113.                  cbParamSize,MEM_RELEASE );
     
114. 
     
115. 关闭进程句柄
     
116. ::CloseHandle( hProcess );
     
117. 
     
118. 
     
119. 
     
120. 
     
121. 第二种方式
     
122. 
     
123. 第二种方式，我们使用动态库的形式。即我们将自己一个动态库植入到远程进程中。
     
124. 
     
125. 这里不再重复上面相同的步骤,只写出其中关键的地方.
     
126. 关键1:
     
127. 在步骤5中将动态库的路径作为变量传入变量空间.
     
128. 关键2:
     
129. 在步骤8中,将GetProcAddress作为目标执行函数.
     
130. 
     
131. hThread = ::CreateRemoteThread( hProcess, NULL, 0,
     
132.             (LPTHREAD_START_ROUTINE )::GetProcAddress(
     
133.              hModule, "LoadLibraryA"),
     
134.              pDataRemote, 0, NULL );
     
135. 
     
136. 
     
137. 另外在步骤9,清理现场中首先要先进行释放我们的动态库.也即类似步骤8执行函数FreeLibrary
     
138. 
     
139. hThread = ::CreateRemoteThread( hProcess, NULL, 0,
     
140. (LPTHREAD_START_ROUTINE )::GetProcAddress(
     
141. hModule, "FreeLibrary"),
     
142. (void*)hLibModule, 0, NULL );[/hide]

复制代码