看流星社区

 找回密码
 注册账号
零基础辅助入门教学 原创 高清 专业课程售后(每日解答)
零基础辅助入门教学 原创 高清 专业课程售后(每日解答)
零基础辅助入门教学 原创 高清 专业课程售后(每日解答)
零基础辅助入门教学 原创 高清 专业课程售后(每日解答)
零基础辅助入门教学 原创 高清 专业课程售后(每日解答)
零基础辅助入门教学 原创 高清 专业课程售后(每日解答)
赞助广告位 请点击这里联系站长 QQ20209081
赞助广告位 请点击这里联系站长 QQ20209081
赞助广告位 请点击这里联系站长 QQ20209081
查看: 125|回复: 0

x64跨进程aob搜索源代码

[复制链接]
发表于 2019-9-10 14:53:03 | 显示全部楼层 |阅读模式

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

wow64ext真的超级好用啊!


  1. #pragma region FindSig
  2. #include<Windows.h>
  3. #include <vector>
  4. #include <Psapi.h>
  5. #include <iostream>
  6. #include "wow64ext.h"
  7. using namespace std;
  8. typedef unsigned long DWORD;
  9. typedef unsigned short WORD;
  10. typedef unsigned char BYTE;
  11. bool FHexCharValid(char c)
  12. {
  13.     if (c >= '0' && c <= '9' ||
  14.         c >= 'A' && c <= 'F' ||
  15.         c >= 'a' && c <= 'f' ||
  16.         c == '?')
  17.         return true;
  18.     else
  19.         return false;
  20. }
  21. bool FHexDecoder(char* Dec, char* Src)
  22. {
  23.     char HighC, LowC;
  24.     DWORD dwSrcLen = strlen(Src) / 2;
  25.     int i;
  26.     for (i = 0; i < dwSrcLen; i++) {
  27.         HighC = Src[i * 2], LowC = Src[i * 2 + 1];
  28.         if (!FHexCharValid(LowC) || !FHexCharValid(HighC))
  29.             return false;
  30.         HighC -= '0';
  31.         if (HighC > 9) HighC -= 7;
  32.         if (HighC > 0xf) HighC -= 0x20;
  33.         LowC -= '0';
  34.         if (LowC > 9) LowC -= 7;
  35.         if (LowC > 0xf) LowC -= 0x20;
  36.         Dec[i] = (HighC << 4) | LowC;
  37.     }
  38.     return true;
  39. }
  40. bool __SundayHexInit__(char* Sub, DWORD*p, char* HexSub, unsigned long dwSubLen)
  41. {
  42.     if (!FHexDecoder(HexSub, Sub)) {
  43.         return false;
  44.     }
  45.     DWORD i;

  46.     for (i = 0; i < 0x100; i++) {
  47.         p[i] = -1;
  48.     }

  49.     int WildAddr = 0;
  50.     for (i = 0; i < dwSubLen; i++) {
  51.         if (Sub[i * 2] == '?')
  52.             WildAddr = i;
  53.     }

  54.     for (i = WildAddr + 1; i < dwSubLen; i++) {                     //扫描Sub,初始化 P 表
  55.         p[(BYTE)HexSub[i]] = dwSubLen - i;
  56.     }

  57.     for (i = 0; i < 0x100; i++) {
  58.         if (p[i] == -1)
  59.             p[i] = dwSubLen - WildAddr;
  60.     }
  61.     return true;
  62. }
  63. int __SundayHex__(char* Src, unsigned long dwSrcLen, char* Sub, DWORD* p, char* HexSub, DWORD dwSubLen)
  64. {
  65.     //开始配对字符串
  66.     //j为 Sub位置指标, k为 当前匹配位置
  67.     DWORD j, k;
  68.     j = dwSubLen - 1;                                   //初始化位置为 dwSubLen - 1,匹配顺序为从右到左

  69.     bool bContinue = true;
  70.     bool bSuccess;
  71.     while (bContinue) {
  72.         bSuccess = true;
  73.         for (k = 0; k < dwSubLen; k++) {
  74.             if (Sub[(dwSubLen - k - 1) * 2] != '?' && Src[j - k] != HexSub[dwSubLen - k - 1]) {
  75.                 bSuccess = false;
  76.                 break;
  77.             }
  78.         }
  79.         if (bSuccess)
  80.             bContinue = false;
  81.         else {                                          //移动j指针
  82.             if (j < dwSrcLen - 1)                                                        //防止j+1 >= dwSrcLen造成溢出
  83.                 j += p[(BYTE)Src[j + 1]];
  84.             else j++;
  85.         }
  86.         if (j >= dwSrcLen)
  87.             break;
  88.     }
  89.     if (j < dwSrcLen)
  90.         return j - dwSubLen + 1;
  91.     else
  92.         return -1;
  93. }
  94. int __SundayHexV__(char* Src, unsigned long dwSrcLen, char* Sub, DWORD* p, char* HexSub, DWORD dwSubLen, int v)
  95. {
  96.     //开始配对字符串
  97.     //j为 Sub位置指标, k为 当前匹配位置
  98.     DWORD j, k;
  99.     j = dwSubLen - 1 + v;                                   //初始化位置为 dwSubLen - 1,匹配顺序为从右到左

  100.     bool bContinue = true;
  101.     bool bSuccess;
  102.     while (bContinue) {
  103.         bSuccess = true;
  104.         for (k = 0; k < dwSubLen; k++) {
  105.             if (Sub[(dwSubLen - k - 1) * 2] != '?' && Src[j - k] != HexSub[dwSubLen - k - 1]) {
  106.                 bSuccess = false;
  107.                 break;
  108.             }
  109.         }
  110.         if (bSuccess)
  111.             bContinue = false;
  112.         else {                                          //移动j指针
  113.             if (j < dwSrcLen - 1)                                                        //防止j+1 >= dwSrcLen造成溢出
  114.                 j += p[(BYTE)Src[j + 1]];
  115.             else j++;
  116.         }
  117.         if (j >= dwSrcLen)
  118.             break;
  119.     }
  120.     if (j < dwSrcLen)
  121.         return j - dwSubLen + 1;
  122.     else
  123.         return -1;

  124. }
  125. int SundayHex(char* Src, unsigned long dwSrcLen, char* Sub)
  126. {
  127.     DWORD dwSubLen = strlen(Sub);
  128.     if (dwSubLen % 2)                    //长度必须为2的倍数
  129.         return -1;
  130.     dwSubLen /= 2;

  131.     char* HexSub = new char[dwSubLen + 1];
  132.     DWORD* p = new DWORD[0x100];        //table P,标志距离
  133.     int i = -1;

  134.     if (__SundayHexInit__(Sub, p, HexSub, dwSubLen)) {


  135.         i = __SundayHex__(Src, dwSrcLen, Sub, p, HexSub, dwSubLen);
  136.     }

  137.     delete[]p;
  138.     delete[]HexSub;
  139.     return i;
  140. }
  141. vector< int> SundayHexV(char* Src, unsigned long dwSrcLen, char* Sub)
  142. {
  143.     vector< int> v;
  144.     DWORD dwSubLen = strlen(Sub);

  145.     if (dwSubLen % 2)                    //长度必须为2的倍数
  146.         return v;
  147.     dwSubLen /= 2;

  148.     char* HexSub = new char[dwSubLen + 1];
  149.     DWORD* p = new DWORD[0x100];        //table P,标志距离
  150.     int i = -1;



  151.     if (__SundayHexInit__(Sub, p, HexSub, dwSubLen)) {

  152.         i = __SundayHexV__(Src, dwSrcLen, Sub, p, HexSub, dwSubLen, 0);

  153.         while (i != -1)
  154.         {
  155.             v.push_back(i);
  156.             i = __SundayHexV__(Src, dwSrcLen, Sub, p, HexSub, dwSubLen, i + dwSubLen);

  157.         }

  158.     }

  159.     delete[]p;
  160.     delete[]HexSub;
  161.     return v;

  162. }
  163. DWORD64 __stdcall FindSig(const char* Value)
  164. {
  165.     vector <DWORD> 保存数组;
  166.     DWORD64 区段大小 = 0;
  167.     ULONG64 Start = 0, End = 0x7fffffffffffffff;
  168.     //if (dwPid == 0) return 保存数组;
  169.     MEMORY_BASIC_INFORMATION64 内存信息 = { 0 };


  170.     if (hFake1 != NULL)
  171.     {
  172.         while (VirtualQueryEx64(hFake1, Start, &内存信息, sizeof(内存信息)))
  173.         {
  174.             //cout << 内存信息.BaseAddress << endl;
  175.             if (内存信息.Protect != 1 && 内存信息.Protect != 16 && 内存信息.RegionSize != 1 && 内存信息.Protect != 512)
  176.             {

  177.                 区段大小 = (DWORD64)内存信息.BaseAddress + 内存信息.RegionSize - Start;
  178.                 //char tmpchar[255];
  179.                 //sprintf_s(tmpchar, "0x%I64x", 区段大小);
  180.                 //MessageBoxA(NULL, tmpchar, "Size", MB_OK);
  181.                 char* buf = new char[区段大小 + 1];
  182.                 if (ReadFast(Start, buf, 区段大小) == STATUS_SUCCESS)
  183.                 {
  184.                     vector<int>  dwValue = SundayHexV(buf, 区段大小, (char*)Value);
  185.                     for (size_t i = 0; i < dwValue.size(); i++)
  186.                     {
  187.                         //保存数组.push_back(Start + dwValue[i]);
  188.                         char tmpchar[255];
  189.                         sprintf_s(tmpchar, "0x%I64x", Start + dwValue[i]);
  190.                         MessageBoxA(NULL, tmpchar, "Result", MB_OK);
  191.                         return Start + dwValue[i];
  192.                     }
  193.                     //delete(buf);
  194.                 }
  195.                 //delete(buf);
  196.             }
  197.             if (End == 0) {
  198.                 break;
  199.             }

  200.             Start += 内存信息.RegionSize;
  201.             if (Start > End)
  202.                 break;
  203.         }
  204.         //CloseHandle(hProcess);
  205.     }

  206.     return 0;
  207. }
  208. #pragma endregion
复制代码
点击按钮快速添加回复内容: 支持 高兴 激动 给力 加油 苦寻 生气 回帖 路过 感恩
您需要登录后才可以回帖 登录 | 注册账号

本版积分规则

小黑屋|手机版|Archiver|看流星社区 |网站地图

GMT+8, 2019-11-12 07:14

Powered by Kanliuxing X3.4

© 2010-2019 kanliuxing.com

快速回复 返回顶部 返回列表