5

介绍

目前我正在使用某人的类来读取内存中的字节（通过指针）。到目前为止我的代码运行良好，如果可能的话，我真的不想改变类的设置方式（因为它有效），但希望可以对类和我的代码进行一些小的调整以使其高效.

我目前取得的成就：

  • 从内存中的指针地址开始，读取该地址的字节，将数据添加到数组中，将原始地址加 1，以便我们现在可以读取下一个地址（例如原始地址是 24004，一旦存储了字节，递增 1，下一个要读取的地址变为 24005）。

  • 读取下一个地址 (24005) 处的字节，将其添加到同一数组中，将 1 添加到该地址（读取的下一个变为 24006）。

  • 以此类推，迭代次数固定（大约 10,000 次）。

问题：

一个接一个地对 readprocessmemory 进行 10,000 次调用会导致系统在执行业务时延迟 20 秒。

我希望可以实现的目标：

仅执行 Readprocessmemory 一次，指定要读取的 10,000 个字节的数据（而不是一次只读取一个字节，进行 10,000 次迭代），以与我之前使用单个字节相同的格式将其保存到数组中（因此我知道数组 {0} (1) (2).. 等等。我现在只有数组 {0}，所以我想我需要一种有效的方法将这个非常大的数字分成 10,000 个数字（在另一个数组中） )) 每个地址存储的数据都是整数。因此对于 5 个地址：数组 {12345} 变为 {1}{2}{3}{4}{5}。例如，其中 1 2 3 4 或 5 也可以是 1 200 40 43 或 20。

所以理想情况下，如果我可以挥动我的新手魔杖，它会看起来像这样（下面的课程以及我到目前为止所拥有的）：

迭代代码：

 private void label1_Click(object sender, EventArgs e)
    {
        int[] valuesSeperated[200];
        List<byte> PreArray = new List<byte>();
        Process[] test = Process.GetProcessesByName("MyProcess"); //Get process handle 
        int baseAddress = test[0].MainModule.BaseAddress.ToInt32(); //Get base address
        byte ReadX  = MyClass.ReadPointerByte("MyProcess", BaseAddress, new int[] { 0xc, 0x0, 0x2 }); //call memory reading function (including memory offsets)
        PreArray.Add(ReadX);
                byte[] PreArrayToInt = PreArray.ToArray();
                int[] MYConvertedBytes = PreArray ToInt.Select(x => (int)x).ToArray();
                foreach (int i in MYConvertedBytes)
{
valuesSeperated // (don't really know what to do here, if the read was successful I would have a long number at [0], so now need to separate these as if I had read each one in memory one at a time. 
}

//new array with 10,000 values created.
    }

班级：

[DllImport("kernel32", EntryPoint = "ReadProcessMemory")]
private static extern byte ReadProcessMemoryByte(int Handle, int Address, ref byte Value, int Size, ref int BytesRead);

public static byte ReadPointerByte(string EXENAME, int Pointer, int[] Offset)
{
    byte Value = 0;
    checked
    {
        try
        {
            Process[] Proc = Process.GetProcessesByName(EXENAME);
            if (Proc.Length != 0)
            {
                int Bytes = 0;
                int Handle = OpenProcess(PROCESS_ALL_ACCESS, 0, Proc[0].Id);
                if (Handle != 0)
                {
                    foreach (int i in Offset)
                    {
                        ReadProcessMemoryInteger((int)Handle, Pointer, ref Pointer, 4, ref Bytes);
                        Pointer += i;
                    }
                    ReadProcessMemoryByte((int)Handle, Pointer, ref Value, 2, ref Bytes);
                    CloseHandle(Handle);
                }
            }
        }
        catch
        { }
    }
    return Value;
}
4

1 回答 1

3

一些建议：

  • 不要在“托管包装器”（ReadPointerByte 或其他...）中调用 OpenProcess / CloseHandle，您可以使用Process.Handle属性。

  • 为了避免与页面权限相关的可能错误，您可能需要使用VirtualProtectEx包装对 ReadProcessMemory 的调用（一个用于“取消保护”，允许读取，另一个用于“恢复”先前的保护）。

一些代码：

// from http://www.pinvoke.net/default.aspx/kernel32.readprocessmemory
[DllImport("kernel32", EntryPoint = "ReadProcessMemory")]
private static extern bool ReadProcessMemory(IntPtr Handle, IntPtr Address, 
    [Out] byte[] Arr, int Size, out int BytesRead);

public static byte[] ReadBytes(IntPtr hnd, IntPtr Pointer, int Length)
{
    byte[] Arr = new byte[Length];
    int Bytes = 0;
    if(!ReadProcessMemory(hnd, Pointer, Arr, Length, out Bytes)){
        // Throw exception ...
    }
    // Check if Bytes == Length ...
    return Arr;
}

private void button1_Click(object sender, EventArgs e)
{
    //Get process handle
    Process[] test = Process.GetProcessesByName("notepad++");  

    //Get base address
    IntPtr baseAddress = test[0].MainModule.BaseAddress; 

    int bytesToRead = 16;
    int[] valuesSeparated = new int[bytesToRead / 4];
    byte[] ret = ReadBytes(test[0].Handle, baseAddress, bytesToRead);

    // Interpret ret as you like ...

    // Convert ret to int[]
    valuesSeparated = ....

}

[迭代过程]

您在这里有两个选择：

  1. 获取目标进程内存的完整快照到一个字节[]，并在这个数组中执行你的算法
  2. 您可以为每次迭代执行一个 readprocessmemory。我相信这是你最好的选择。

无论目标进程内存读取技术如何，您的算法都是这样的（我很难将您的文本翻译成实现......）：

输入：进程的BaseAddress，偏移量

输出： byte[] Ret

脚步：

1: LastPtr = BaseAddress
2: IdxOffset = 0
3: Offset = Offsets[IdxOffset]
4: LastValue = Memory[LastPtr + Offset]
5: Ret.Add(LastValue)
6: IdxOffset++
7: LastPtr = LastValue // Is this it?????
8: If IdxOffset < Offsets.Length then return else goto 3
于 2012-09-05T13:13:03.993 回答