C++ , Cheat Engine/OllyDBG 从多级指针中找到基址 "static"

Question

我又回来了，沮丧并拼命寻求帮助:D。

我正在尝试为一个简单的程序创建一个作弊程序，它基本上是一个 .dll 文件，当它使用基地址注入(inject)主程序时，它将更改主程序中的整数值。问题是，我无法使用 Cheat Engine 找到它，主要是因为存在带有 NEGATIVE 的多级指针？抵消。例如:

//Starting pointer address
0x0033FCF0 -> 200

//Finding second level pointer using "Find out what's accessing this address" in Cheat Engine
**(mov eax,[ebp+08])** // **EAX=0x00000007** , **EPB=0x0033FCE8 => mov 00000007,[0033FCE8+08]**

2nd Level Pointer:
**(0033FCE8+18) -> 200**

所以我继续使用“找出什么是......”来查找下一个指针，但是在使用 T-SEARCH 和二级指针地址时，我得到了 7 - 8 个新的静态地址。

问题是，我无法分辨哪个是正确的，因为 Cheat Engine 拒绝让我使用 NEGATIVE 添加指针？抵消。

例子:

Base Pointer:
**mov eax,[epb-18] !!!** // Notice the **MINUS**

最重要的是， Cheat Engine 拒绝接受具有负偏移量的指针!

那么，是否有另一种方法可以从多级指针中找到基地址？
欢迎使用 OlyDBG/Idapro 解决方案。非常感谢各位!

这是我试图破解的简单程序的源代码:

#include <iostream>
#include <conio.h>
#include <windows.h>
#include <stdlib.h>

int main(){
    int hp = 100;
    while(1){
        std::cout << hp << std::endl;
        Sleep(3000);
        hp += 10;
        system("cls");
    }
    return 0;
}

我想要做的是用这个 .dll 编辑 hp 整数

#include <windows.h>
#define BASE    0xBASE_POINTERS_ADDRESS_WHICH_I_NEED_TO_FIND
#define OFFSET  0xTHE_OFFSET
#define VALUE   90
void MainFunction()
{
      while(1)
      {
            if (GetAsyncKeyState(VK_MENU)&0x8000 && GetAsyncKeyState('C')&0x8000) 
            MessageBox(0,L"Alt + C was pressed!",L"MessageBox! ",0);
            *(int*)((*(int*)BASE) + OFFSET) = VALUE;

            Sleep(100); //Let the program rest, otherwise it hogs cpu resources.
      }
}

BOOL WINAPI DllMain(HINSTANCE MyInstance,DWORD reason_for_call,LPVOID PointerToVoid)
{
         if (reason_for_call == DLL_PROCESS_ATTACH) CreateThread(0,0,(LPTHREAD_START_ROUTINE)&MainFunction,0,0,0);
         return true;
}

顺便说一句，我正在尝试破解 hp! ~ 哦，等等，我已经说过了，哦，好吧，随便吧；)

谢谢你们，上帝保佑你们!

Answer 1

我认为您误解了 Cheat Engine 的目标。

CE 允许您修改以持久方式存储在内存中的值。例如，在堆上，或者在程序的静态数据中。

例如，C++ 对象以确定性方式分配，因此它们永远不会移动。这就是为什么它们可以被一个在对象的整个生命周期中保持不变的指针引用的原因。该对象有时归另一个对象所有。如果您找到指向所有者对象的指针，您就找到了所谓的基指针。

例如 :

class Object
{
    bool dummy;
    int someField;
    Object* child;
};

现在想象你有一个嵌套的 3 树 Object .这意味着您有一个根 Object (n°1)，其 child是另一个 Object (n°2)，其 child是另一个 Object (n°3)。想象一下你做这样的事情:

int main(int argc, char** argv)
{
    Object root; // n°1
    root.child = new Object(); // n°2
    root.child->child = new Object(); // n°3

    return 0;
}

你有兴趣弄乱 n°3 的 someField值(value)。你知道 someField的地址, 相对于 Object , 是 +sizeof(bool) = 1 .
所以 (void*)&(object n°3) + 1是指向 someField 的指针你要。

现在，您如何找到指向对象 n°3 的指针？
知道 child的相对地址是 +sizeof(bool)+sizeof(int) = 5 .我们知道指向对象 n°3 的指针是 (void*)&(object n°2) + 5.

对象 n°2 的地址也是如此，我将其留作练习。

但是对象 n°1 呢？它没有在堆上分配。它在堆栈上。废话。所以我们必须找到另一种方法来找到存储对象 n°1 的地址。

局部变量存储在堆栈中。在汇编中，它们通过它们相对于寄存器 EBP 的偏移量来标识。 (或 ESP 如果函数不改变堆栈)。 EBP是栈顶，而 ESP是栈底。

在这个例子中:

function foo()
{
    int a;
    double b;
}

调用 foo 时，堆栈将增加到刚好容纳 a 和 b，即 sizeof(int) + sizeof(double)，或 12 个字节。 a 将存储在 EBP - sizeof(int) = EBP - 4 (与 ESP + 8 相同)并且 b 将存储在 EBP - sizeof(int) - sizeof(double) = EBP - 12 (与 ESP 相同)。 注意力! 编译器可以更改此顺序，因此变量的声明顺序在内存中不一定相同。优化也可以完全改变这一点。但让我们保持简单好吗？

回到我们的主要示例。我们有哪些局部变量？仅根。因此根将位于 EBP - 9直接地。但是，只有当 main 是调用堆栈顶部的函数时。没有调试器，你就做不到。

让我们假设我们的 EBP调用 main 时为 0028FF28(取自新编译的 C 程序)。

根然后在 (0x0028FF28 - 9) = 0x0028FF1F;
指向 root.child 的指针在 (0x0028FF1F + 5) = (0x0028FF24);
因此， root.child位于 *0x0028FF24。

指向 root.child->child 的指针在 (*0x0028FF24 + 5) = (假设是 10000)
然后 root.child->child是 *10000。

最后， root.child->child.someField是 *10000 + 3。

总结一下:你只需要找到root的静态地址就可以找到其余的。
root 不在堆或任何类型的持久内存上，但它在 main 的堆栈上，它在几乎所有程序中都持续存在，所以它几乎就像是永久的。
CE通过扫描整个进程内存空间来帮你找到一个静态地址

考虑到所有这些，您应该能够计算出 hp的堆栈上的相对地址，并找到一个指向它的静态指针(每次启动程序时，main 非常、非常、非常可能有一个静态帧地址)。如果您需要帮助，请使用调试器!我推荐免疫调试器。