C++ 优化大地址空间上的循环

我正在尝试调试进程的虚拟内存，这要求我在其虚拟内存中搜索一系列已知的常量字节，但是由于偏移量一直在动态变化，我必须遍历整个地址空间以找到所需的字节。目前我有这些循环，它们可以工作，但是它们需要很长时间才能运行，平均需要15-30秒才能完成

BYTE target[15] = { 0xFG, 0x93, 0x32, 0x1A, 0xB0, 0x9F, 0xC7, 0x00, 0x11, 0x00,
                        0x3F, 0x01, 0x00, 0x00, 0x00 };
    BYTE buff[15];
    int count = 0;
    DWORD target_addr = 0;
    for (DWORD i = 0x401000; i <= 0x2000000; i++)
    {
        count = 0;
        ReadProcessMemory(procName, (LPCVOID)i, (LPVOID)buff, 15, &real);
        for (int j = 0; j < 15; j++)
        {
            if (target[j] == buff[j])
                count++;
            else
                break;
        }
        if (count == 15)
        {
            target_addr = i;
            break;
        }
    }

字节目标[15]={0xFG，0x93，0x32，0x1A，0xB0，0x9F，0xC7，0x00，0x11，0x00，
0x3F，0x01，0x00，0x00，0x00}；
字节buff[15]；
整数计数=0；
DWORD target_addr=0；
对于（DWORD i=0x401000；i我假设您在从
i
开始的每次迭代中读取15个字节，如果内存不相等，则读取从
i+1
开始的接下来15个字节，因此您不需要考虑您可能知道其他14个字节相等的事实。如果您向后查看15个字节，您可以知道如果
k
最后一个字节相等，则uffer不相等，这允许直接向前移动
15-k
字节，并且不验证下一次迭代中的
k
第一个字节

我还没有测试下面的代码，但我认为有了这一总体思路，它将允许加快步伐

BYTE target[15] = { 0xFG, 0x93, 0x32, 0x1A, 0xB0, 0x9F, 0xC7, 0x00, 0x11, 0x00,
                    0x3F, 0x01, 0x00, 0x00, 0x00 };
BYTE buff[15];
DWORD target_addr = 0;
DWORD current = 0x401000;
DWORD max = 0x2000000;
int previousEqual = 0;
while (!target_addr && current < max)
{
    int count = 15;
    ReadProcessMemory(procName, (LPCVOID)i, (LPVOID)buff, 15, &real);
    while (target[count-1] == buff[count-1])
    {
         --count;
    }
    if (count == previousEqual)
    {
        target_addr = current;
    }
    else
    {
        current += count;
        previousEqual = 15-count;
    }
}

字节目标[15]={0xFG，0x93，0x32，0x1A，0xB0，0x9F，0xC7，0x00，0x11，0x00，
0x3F，0x01，0x00，0x00，0x00}；
字节buff[15]；
DWORD target_addr=0；
DWORD电流=0x401000；
DWORD最大值=0x2000000；
int-previousEqual=0；
而（！target_addr&¤t
ReadProcessMemory速度很慢，您是否尝试过一次读取超过15个字节？您也可以使用滑动窗口比较DWORD而不是字节。您需要比15个字节大得多的缓冲区，或者将进程的内存映射到您自己的内存中。此外，请使用
memmem（）
用于搜索。最后，您没有检查块之间的潜在重叠。