x64跨进程aob搜索源代码

brahmana

速度的确很快，支持通配符，没啥需要注意的，读内存换成自己的就可以了，通配符调用例子:xxxx??xx

wow64ext真的超级好用啊！

1. 
   
2. #pragma region FindSig
   
3. #include<Windows.h>
   
4. #include <vector>
   
5. #include <Psapi.h>
   
6. #include <iostream>
   
7. #include "wow64ext.h"
   
8. using namespace std;
   
9. typedef unsigned long DWORD;
   
10. typedef unsigned short WORD;
    
11. typedef unsigned char BYTE;
    
12. bool FHexCharValid(char c)
    
13. {
    
14.     if (c >= '0' && c <= '9' ||
    
15.         c >= 'A' && c <= 'F' ||
    
16.         c >= 'a' && c <= 'f' ||
    
17.         c == '?')
    
18.         return true;
    
19.     else
    
20.         return false;
    
21. }
    
22. bool FHexDecoder(char* Dec, char* Src)
    
23. {
    
24.     char HighC, LowC;
    
25.     DWORD dwSrcLen = strlen(Src) / 2;
    
26.     int i;
    
27.     for (i = 0; i < dwSrcLen; i++) {
    
28.         HighC = Src[i * 2], LowC = Src[i * 2 + 1];
    
29.         if (!FHexCharValid(LowC) || !FHexCharValid(HighC))
    
30.             return false;
    
31.         HighC -= '0';
    
32.         if (HighC > 9) HighC -= 7;
    
33.         if (HighC > 0xf) HighC -= 0x20;
    
34.         LowC -= '0';
    
35.         if (LowC > 9) LowC -= 7;
    
36.         if (LowC > 0xf) LowC -= 0x20;
    
37.         Dec[i] = (HighC << 4) | LowC;
    
38.     }
    
39.     return true;
    
40. }
    
41. bool __SundayHexInit__(char* Sub, DWORD*p, char* HexSub, unsigned long dwSubLen)
    
42. {
    
43.     if (!FHexDecoder(HexSub, Sub)) {
    
44.         return false;
    
45.     }
    
46.     DWORD i;
    
47. 
    
48.     for (i = 0; i < 0x100; i++) {
    
49.         p[i] = -1;
    
50.     }
    
51. 
    
52.     int WildAddr = 0;
    
53.     for (i = 0; i < dwSubLen; i++) {
    
54.         if (Sub[i * 2] == '?')
    
55.             WildAddr = i;
    
56.     }
    
57. 
    
58.     for (i = WildAddr + 1; i < dwSubLen; i++) {                     //扫描Sub，初始化 P 表
    
59.         p[(BYTE)HexSub[i]] = dwSubLen - i;
    
60.     }
    
61. 
    
62.     for (i = 0; i < 0x100; i++) {
    
63.         if (p[i] == -1)
    
64.             p[i] = dwSubLen - WildAddr;
    
65.     }
    
66.     return true;
    
67. }
    
68. int __SundayHex__(char* Src, unsigned long dwSrcLen, char* Sub, DWORD* p, char* HexSub, DWORD dwSubLen)
    
69. {
    
70.     //开始配对字符串
    
71.     //j为 Sub位置指标， k为 当前匹配位置
    
72.     DWORD j, k;
    
73.     j = dwSubLen - 1;                                   //初始化位置为 dwSubLen - 1,匹配顺序为从右到左
    
74. 
    
75.     bool bContinue = true;
    
76.     bool bSuccess;
    
77.     while (bContinue) {
    
78.         bSuccess = true;
    
79.         for (k = 0; k < dwSubLen; k++) {
    
80.             if (Sub[(dwSubLen - k - 1) * 2] != '?' && Src[j - k] != HexSub[dwSubLen - k - 1]) {
    
81.                 bSuccess = false;
    
82.                 break;
    
83.             }
    
84.         }
    
85.         if (bSuccess)
    
86.             bContinue = false;
    
87.         else {                                          //移动j指针
    
88.             if (j < dwSrcLen - 1)                                                        //防止j+1 >= dwSrcLen造成溢出
    
89.                 j += p[(BYTE)Src[j + 1]];
    
90.             else j++;
    
91.         }
    
92.         if (j >= dwSrcLen)
    
93.             break;
    
94.     }
    
95.     if (j < dwSrcLen)
    
96.         return j - dwSubLen + 1;
    
97.     else
    
98.         return -1;
    
99. }
    
100. int __SundayHexV__(char* Src, unsigned long dwSrcLen, char* Sub, DWORD* p, char* HexSub, DWORD dwSubLen, int v)
     
101. {
     
102.     //开始配对字符串
     
103.     //j为 Sub位置指标， k为 当前匹配位置
     
104.     DWORD j, k;
     
105.     j = dwSubLen - 1 + v;                                   //初始化位置为 dwSubLen - 1,匹配顺序为从右到左
     
106. 
     
107.     bool bContinue = true;
     
108.     bool bSuccess;
     
109.     while (bContinue) {
     
110.         bSuccess = true;
     
111.         for (k = 0; k < dwSubLen; k++) {
     
112.             if (Sub[(dwSubLen - k - 1) * 2] != '?' && Src[j - k] != HexSub[dwSubLen - k - 1]) {
     
113.                 bSuccess = false;
     
114.                 break;
     
115.             }
     
116.         }
     
117.         if (bSuccess)
     
118.             bContinue = false;
     
119.         else {                                          //移动j指针
     
120.             if (j < dwSrcLen - 1)                                                        //防止j+1 >= dwSrcLen造成溢出
     
121.                 j += p[(BYTE)Src[j + 1]];
     
122.             else j++;
     
123.         }
     
124.         if (j >= dwSrcLen)
     
125.             break;
     
126.     }
     
127.     if (j < dwSrcLen)
     
128.         return j - dwSubLen + 1;
     
129.     else
     
130.         return -1;
     
131. 
     
132. }
     
133. int SundayHex(char* Src, unsigned long dwSrcLen, char* Sub)
     
134. {
     
135.     DWORD dwSubLen = strlen(Sub);
     
136.     if (dwSubLen % 2)                    //长度必须为2的倍数
     
137.         return -1;
     
138.     dwSubLen /= 2;
     
139. 
     
140.     char* HexSub = new char[dwSubLen + 1];
     
141.     DWORD* p = new DWORD[0x100];        //table P,标志距离
     
142.     int i = -1;
     
143. 
     
144.     if (__SundayHexInit__(Sub, p, HexSub, dwSubLen)) {
     
145. 
     
146. 
     
147.         i = __SundayHex__(Src, dwSrcLen, Sub, p, HexSub, dwSubLen);
     
148.     }
     
149. 
     
150.     delete[]p;
     
151.     delete[]HexSub;
     
152.     return i;
     
153. }
     
154. vector< int> SundayHexV(char* Src, unsigned long dwSrcLen, char* Sub)
     
155. {
     
156.     vector< int> v;
     
157.     DWORD dwSubLen = strlen(Sub);
     
158. 
     
159.     if (dwSubLen % 2)                    //长度必须为2的倍数
     
160.         return v;
     
161.     dwSubLen /= 2;
     
162. 
     
163.     char* HexSub = new char[dwSubLen + 1];
     
164.     DWORD* p = new DWORD[0x100];        //table P,标志距离
     
165.     int i = -1;
     
166. 
     
167. 
     
168. 
     
169.     if (__SundayHexInit__(Sub, p, HexSub, dwSubLen)) {
     
170. 
     
171.         i = __SundayHexV__(Src, dwSrcLen, Sub, p, HexSub, dwSubLen, 0);
     
172. 
     
173.         while (i != -1)
     
174.         {
     
175.             v.push_back(i);
     
176.             i = __SundayHexV__(Src, dwSrcLen, Sub, p, HexSub, dwSubLen, i + dwSubLen);
     
177. 
     
178.         }
     
179. 
     
180.     }
     
181. 
     
182.     delete[]p;
     
183.     delete[]HexSub;
     
184.     return v;
     
185. 
     
186. }
     
187. DWORD64 __stdcall FindSig(const char* Value)
     
188. {
     
189.     vector <DWORD> 保存数组;
     
190.     DWORD64 区段大小 = 0;
     
191.     ULONG64 Start = 0, End = 0x7fffffffffffffff;
     
192.     //if (dwPid == 0) return 保存数组;
     
193.     MEMORY_BASIC_INFORMATION64 内存信息 = { 0 };
     
194. 
     
195. 
     
196.     if (hFake1 != NULL)
     
197.     {
     
198.         while (VirtualQueryEx64(hFake1, Start, &内存信息, sizeof(内存信息)))
     
199.         {
     
200.             //cout << 内存信息.BaseAddress << endl;
     
201.             if (内存信息.Protect != 1 && 内存信息.Protect != 16 && 内存信息.RegionSize != 1 && 内存信息.Protect != 512)
     
202.             {
     
203. 
     
204.                 区段大小 = (DWORD64)内存信息.BaseAddress + 内存信息.RegionSize - Start;
     
205.                 //char tmpchar[255];
     
206.                 //sprintf_s(tmpchar, "0x%I64x", 区段大小);
     
207.                 //MessageBoxA(NULL, tmpchar, "Size", MB_OK);
     
208.                 char* buf = new char[区段大小 + 1];
     
209.                 if (ReadFast(Start, buf, 区段大小) == STATUS_SUCCESS)
     
210.                 {
     
211.                     vector<int>  dwValue = SundayHexV(buf, 区段大小, (char*)Value);
     
212.                     for (size_t i = 0; i < dwValue.size(); i++)
     
213.                     {
     
214.                         //保存数组.push_back(Start + dwValue[i]);
     
215.                         char tmpchar[255];
     
216.                         sprintf_s(tmpchar, "0x%I64x", Start + dwValue[i]);
     
217.                         MessageBoxA(NULL, tmpchar, "Result", MB_OK);
     
218.                         return Start + dwValue[i];
     
219.                     }
     
220.                     //delete(buf);
     
221.                 }
     
222.                 //delete(buf);
     
223.             }
     
224.             if (End == 0) {
     
225.                 break;
     
226.             }
     
227. 
     
228.             Start += 内存信息.RegionSize;
     
229.             if (Start > End)
     
230.                 break;
     
231.         }
     
232.         //CloseHandle(hProcess);
     
233.     }
     
234. 
     
235.     return 0;
     
236. }
     
237. #pragma endregion
     

复制代码