Necesito saber todo el espacio de direcciones de memoria utilizado por un proceso. El espacio de memoria se escaneará más tarde para ubicar valores dentro del proceso e identificar sus ubicaciones / direcciones. Mi proceso actual para esto es tomar la dirección base de cada módulo a través de su (dirección base + tamaño de memoria).

Estoy probando esto en un proceso con un valor conocido en una dirección conocida. Cuando busco esa dirección específica, obtengo el valor que espero. Sin embargo, cuando escaneo (lo que creo que es) todo el espacio de direcciones utilizado por el proceso, no puedo encontrar el valor en ninguna parte.

Sé que existe un valor numérico "4143000" en 0x0CF8DC38 y 0x0CF8DDDC. Cuando llamo aReadMemoryBytes (module, module.BaseAddress, 4, (IntPtr) (0x0CF8DC38)) Vuelvo bytes (152, 55, 63, 0). Cuando llamo a BitConverter.GetBytes (4143000) obtengo el mismo conjunto de bytes. Cuando uso un escáner de memoria diferente en ese proceso, encuentro ese valor en esas direcciones.

Sin embargo, cuando escaneo las "direcciones conocidas", no encuentro este valor en ningún lado. Parece que mi código ni siquiera encuentra esas direcciones en uso por el proceso.

Así, mi pregunta es doble:

¿Cómo puedo encontrar estas direcciones dentro de este proceso? Me preocupa que pueda estar tratando con direcciones absolutas en la memoria del sistema versus direcciones relativas dentro de un proceso. ¿Lo estoy haciendo bien

.

// (in the calling method)
foreach (ProcessModule module in process.Modules) {
    ParameterizedThreadStart pst = new ParameterizedThreadStart(p => SearchModule(module, value));
    Thread t = new Thread(pst);
    t.Start(); }

private unsafe void SearchModule(ProcessModule module, string value)
{
Process process = getProcess;
int iVal;
double dVal;
int.TryParse(value, out iVal);
double.TryParse(value, out dVal);
for (Int64 addr = (Int64)module.BaseAddress; addr + value.Length < (Int64)module.BaseAddress + module.ModuleMemorySize; addr++)
{
    // Compare ints
    if (iVal > 0)
    {
        byte[] ExpectedBytes = BitConverter.GetBytes(iVal);
        byte[] ActualBytes = ReadMemoryBytes(module, (IntPtr)addr, (uint)ExpectedBytes.Length, (IntPtr)addr);

        bool isMatch = true;
        for (int i = 0; i < ExpectedBytes.Length; i++)
            if (ExpectedBytes[i] != ActualBytes[i])
                isMatch = false;
        if (isMatch)
            PossibleAddresses.Add((IntPtr)addr);
    }
}

private byte[] ReadMemoryBytes(ProcessModule mod, IntPtr memAddress, uint size, IntPtr BaseAddress)
{
    byte[] buffer = new byte[size];
    IntPtr bytesRead;
    unsafe
    {
        ReadProcessMemory(processPointer, BaseAddress, buffer, size, out bytesRead);
        return buffer;
    }
}

[DllImport("kernel32.dll")]
public static extern IntPtr OpenProcess(UInt32 dwDesiredAccess, Int32 bInheritHandle, UInt32 dwProcessId);
[DllImport("kernel32.dll")]
public static extern Int32 CloseHandle(IntPtr hObject);
[DllImport("kernel32.dll")]
public static extern Int32 ReadProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, [In, Out] byte[] buffer, UInt32 size, out IntPtr lpNumberOfBytesRead);