¿Cómo acceder a la estructura en la memoria de otro programa?

Question

Sé cómo importar y usar read/writeprocessmomory en C#. Estoy trabajando en el entrenador de juegos. Necesito tener acceso "directo" a otra memoria de proceso depositada en struct. Puedo usar memoria de proceso de lectura o memoria de proceso de escritura, pero eso llevaría mucho tiempo para implementar muchas estructuras.

No es esta estructura en C++:

class CRenderer 
{ 
public: 
    char unknown0[1692]; //0x0000 
    BYTE ID07D54FC8; //0x069C 
    BYTE drawObjects; //0x069D 
    BYTE drawDeferred; //0x069E 
    BYTE drawParticles; //0x069F 
    BYTE ID07E1CA70; //0x06A0 
    BYTE drawBundledMeshes; //0x06A1 
    BYTE drawStaticMeshes; //0x06A2 
    BYTE drawSkinnedMeshes; //0x06A3 
    BYTE drawRoads; //0x06A4 
    BYTE drawTerrain; //0x06A5 
    BYTE drawUnderGrowth; //0x06A6 
    BYTE drawOverGrowth; //0x06A7 
    BYTE drawNameTags; //0x06A8 
    BYTE drawTrees; //0x06A9 
    BYTE ID07E1CE70; //0x06AA 
    BYTE ID07E1CDF0; //0x06AB 
    BYTE DrawFPS; //0x06AC 
    BYTE ID07E1CEF0; //0x06AD 
    BYTE ID07E1C8F0; //0x06AE 
    BYTE ID07E1C870; //0x06AF 
    BYTE drawGraphs; //0x06B0 
    BYTE ID07D55048; //0x06B1 
    BYTE drawSkyDome; //0x06B2 
    BYTE drawSunFlare; //0x06B3 
    BYTE drawPostProduction; //0x06B4 
    BYTE ID07D550C8; //0x06B5 
    char unknown1718[6534]; //0x06B6 
};//Size=0x203C(8252) 

¿Cómo representar esa estructura en C#? ¿Cuál es la forma más fácil de achive algo como esto:

//C++ 
DWORD RendererBase = (DWORD)GetModuleHandle("RendDx9.dll"); //Gets the base address of RenDX9.dll 
DWORD RendererOffset = RendererBase + 0x23D098; //Static address 
CRenderer *cRenderer = *(CRenderer**)RendererOffset; //Points to the class using the static offset 

cRenderer->drawSkyDome = 0; //No Sky 
cRenderer->DrawFPS = 1; //Show FPS 

En C# Quiero ser capaz de utilizar de esta manera:

cRenderer.drawSkyDome = 0; //No Sky 
cRenderer.DrawFPS = 1; //Show FPS 

Cómo utilizar otra memoria de proceso como struct en mi C# ¿solicitud?

Answer 1

Si necesita una estructura para ser compatible con un programa no administrado, puede usar el atributo [StructLayout] y sus amigos. P.ej. en su caso, sería algo así como:

[DllImport("kernel32.dll", CharSet=CharSet.Auto)] 
public static extern IntPtr GetModuleHandle(string lpModuleName); 

[StructLayout(LayoutKind.Sequential, Pack = 1)] 
public struct RendererData 
{ 
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1692)] 
    public byte[] Unknown; 
    public byte ID07D54FC8; 
    public byte DrawObjects; 
    public byte DrawDeferred; 
    // ... 
    public byte DrawFPS; 
    // ... 
    public byte DrawSkyDome; 
    // ... 
} 

void Main() 
{ 
    IntPtr rendererBase = GetModuleHandle("RendDx9.dll"); 
    if (rendererBase == IntPtr.Zero) 
    { 
     throw new InvalidOperationException("RendDx9.dll not found"); 
    } 
    IntPtr rendererAddr = IntPtr.Add(rendererBase, 0x23D098); 

    var data = new RendererData(); 
    Marshal.PtrToStructure(rendererAddr, data); 

    data.DrawSkyDome = 0; 
    data.DrawFPS = 1; 

    Marshal.StructureToPtr(data, rendererAddr, false); 
} 

No estoy seguro de si sería capaz de acceder a los datos del otro módulo de tal manera directa, pero se puede sustituir el método con ReadProcessMemory/WriteProcessMemory, el principio básico aún se mantendría (solo que esta vez, necesitaría administrar la memoria para la estructura).

Answer 2

Si desea leer o escribir la memoria que es propiedad de un proceso diferente, necesita usar ReadProcessMemory y WriteProcessMemory. Esa es la única forma de hacerlo.

Por lo que intenta hacer, no será suficiente escribir los valores de memoria en el otro proceso. Es probable que necesites invocar algunos métodos también. Si estas variables que está modificando son propiedades, entonces se deberá llamar al método de acceso a la propiedad. Si la variable contiene algo dinámico (por ejemplo, una lista, una cadena), entonces WriteProcessMemory no hará el trabajo.

Este tipo de cosas se suele hacer con una interfaz bien definida (y API), algún tipo de arquitectura de complemento, etc.