Sunday算法特征码搜索C++ 支持通配符

小子不忘记

感谢论坛sunday算法和特征码搜索的参考，在原来基础上增加功能进行了少许的修改。

1. DWORD aobScan(HANDLE hProcess, HMODULE hModule, string 特征码,int CallOffset=0,DWORD* outCallAddre=0,int BaseAddreOffset=0, DWORD* outBaseAddr=0)
   
2.         {//进程PID，模块句柄，特征码，CallOffset：找call偏移-上负下正，BaseAddreOffset：找基址偏移；偏移是从特征码地址算起
   
3.                 string tzm = DeletStringPace(特征码);//删除特征码所有空格
   
4.                 int tzmLen = tzm.length() / 2;//特征码长度
   
5.                 if (tzm.length() % 2 != 0)/*特征码长度不能为单数*/ return 0;
   
6.                 byte* tzmByte = new byte[tzmLen];//定义一个字节变量并开辟指定长度的内存空间
   
7.                 int 通配符首次位置 = StringToByte(tzm, tzmByte);
   
8. 
   
9.                 MODULEINFO mMoudleInfo;
   
10.                 GetModuleInformation(hProcess, hModule, &mMoudleInfo, sizeof(mMoudleInfo));
    
11.                 DWORD  ModuleBeginAddr = (DWORD)hModule;//模块开始地址
    
12.                 DWORD  ModuleSize =mMoudleInfo.SizeOfImage;//模块大小
    
13.                 DWORD  ModuleEndAddr = ModuleBeginAddr + ModuleSize;//模块结束地址
    
14. 
    
15.                 BYTE *pMemBuffer = NULL;//存放读取的内存数据的缓冲区               
    
16.                 MEMORY_BASIC_INFORMATION mbi;//内存信息
    
17.                 clock_t nBeginTime = clock();//记录起始搜索时间
    
18. 
    
19.                 while (ModuleBeginAddr < ModuleEndAddr)//结束条件
    
20.                 {//开始扫描内存
    
21.                         memset(&mbi, 0, sizeof(MEMORY_BASIC_INFORMATION));//查询地址空间中内存地址的信息
    
22.                         if (VirtualQueryEx(hProcess, (LPCVOID)ModuleBeginAddr, &mbi, sizeof(mbi)) == 0)break;;
    
23.                        
    
24.                         if (MEM_COMMIT == mbi.State && PAGE_READWRITE == mbi.Protect || PAGE_EXECUTE_READWRITE == mbi.Protect)
    
25.                         {//过滤内存空间, 根据内存的状态和保护属性进行过滤
    
26.                                 if (pMemBuffer) {// 申请动态内存
    
27.                                         delete[] pMemBuffer; pMemBuffer = NULL;
    
28.                                 }
    
29.                                 pMemBuffer = new BYTE[mbi.RegionSize];
    
30.                                 if (!ReadProcessMemory(hProcess, (LPCVOID)ModuleBeginAddr, pMemBuffer, mbi.RegionSize, 0))continue;
    
31.                                 UINT deviation = SundayCmp(pMemBuffer, mbi.RegionSize, tzmByte, tzmLen, 通配符首次位置);
    
32.                                 if (-1 != deviation)//deviation是偏移
    
33.                                 {//-1为没有找到
    
34.                                         clock_t nEndTime = clock();//记录结束时间
    
35.                                         printf(" %x  用时：%d 毫秒\r\n", ModuleBeginAddr + deviation, nEndTime - nBeginTime);
    
36.                                         if (0!=CallOffset)
    
37.                                         {//如果是找call
    
38.                                                 DWORD temp;
    
39.                                                 memcpy(&temp, &pMemBuffer[deviation  + CallOffset + 1], 4);//拷贝出对应地址上的机器码，复制4个字节
    
40.                                                 printf(" 返回call： %X  用时：%d 毫秒\r\n", ModuleBeginAddr + deviation+ CallOffset + temp +5, nEndTime - nBeginTime);
    
41.                                                 *outCallAddre= ModuleBeginAddr + deviation + CallOffset + temp +5;//下一条指令地址(也就是目标地址 + 5)
    
42.                                         }
    
43.                                         if (0!=BaseAddreOffset)
    
44.                                         {//如果是找基址
    
45.                                                 DWORD temp;
    
46.                                                 memcpy(outBaseAddr, &pMemBuffer[deviation + BaseAddreOffset], 4);//拷贝出对应地址上的机器码，复制4个字节
    
47.                                                 printf(" 返回基址： %X \r\n", outBaseAddr);//
    
48.                                         }
    
49.                                         return ModuleBeginAddr + deviation;//返回特征码地址
    
50.                                 }
    
51.                         }
    
52.                         ModuleBeginAddr += mbi.RegionSize; //取下一块内存地址
    
53.                 }
    
54.                 return -1;//没找到返回
    
55.         }
    
56. 
    
57. 
    
58. int StringToByte(string &markCode,byte* pMarkCode)
    
59.         {//带通配符的string字符串转byte字节数组
    
60.                 int markCodeLen = markCode.length() / 2;
    
61.                 int 通配符第1次出现的位置 = 0;
    
62.                 //pMarkCode = new BYTE[markCodeLen];
    
63.                 for (int i = 0; i < markCodeLen; i++)
    
64.                 {
    
65.                         string tempStr = markCode.substr(i * 2, 2);
    
66.                         if (tempStr == "??")
    
67.                         {
    
68.                                 pMarkCode[i] = 0x3F;
    
69.                                 if (通配符第1次出现的位置 == 0) 通配符第1次出现的位置 = i;
    
70.                         }
    
71.                         else {
    
72.                                 pMarkCode[i] = strtoul(tempStr.c_str(), 0, 16);
    
73.                         }
    
74.                 }
    
75.                 return 通配符第1次出现的位置;
    
76.         }
    
77. 
    
78. 
    
79. 
    
80. int SundayCmp(byte* dest, int destLen, byte* pattern, int patternLen, int 通配符第1次出现的位置)
    
81.         {
    
82.                 int nOffset = 0;//偏移量
    
83.                 int i = 0, j = 0, nCount = 0;//数组下标：内存、特征码、返回地址
    
84. 
    
85.                 int Shift[0xFF + 1] = { 0 };//Sunday算法模板数组赋值，+1防止特征码出现FF时越界
    
86.                 for (int i = 0; i < 通配符第1次出现的位置; i++) {
    
87.                         Shift[pattern[i]] = i + 1;
    
88.                 }
    
89. 
    
90.                 while (j < patternLen)
    
91.                 {//以特征码长度进行循环
    
92.                         if (dest[i] == pattern[j] || pattern[j] == 0x3F)//0x3F代表通配符
    
93.                         {//如果相等
    
94.                                 i++; j++;
    
95.                         }
    
96.                         else
    
97.                         {
    
98.                                 nOffset = i - j + 通配符第1次出现的位置;
    
99.                                 if (nOffset > destLen - patternLen)/*判断偏移量是否大于缓冲区*/ break;
    
100.                                 if (Shift[dest[nOffset]])
     
101.                                 {//判断 Shift模板数组 里有没有 内存偏移后的值，有则回溯，否则+1
     
102.                                         i = nOffset - Shift[dest[nOffset]] + 1;
     
103.                                         j = 0;
     
104.                                 }
     
105.                                 else
     
106.                                 {
     
107.                                         i = nOffset + 1;
     
108.                                         j = 0;
     
109.                                 }
     
110.                         }
     
111.                 }
     
112.                 if (j == patternLen)
     
113.                 {//计算找到的目标地址：//特征码地址 = 当前内存块基址 + i偏移 - 特征码长度
     
114.                         return  i - patternLen;
     
115.                 }
     
116.                 return -1;
     
117.         }
     

复制代码