En Ruby, cómo leo valores de memoria de un proceso externo?

Question

Así que simplemente quiero hacer es hacer un programa de Ruby que lee algunos valores de dirección de memoria conocido en la memoria virtual de otro proceso. A través de mi investigación y el conocimiento básico de la hexagonal de la edición x86 de un proceso que se ejecuta el montaje en la memoria, he encontrado la dirección base y las compensaciones de los valores en la memoria que quiero. No quiero cambiarlos; Sólo quiero leerlos. Le pregunté a un desarrollador de un editor de memoria de la forma de abordar este resumen de la lengua y asumiendo una plataforma Windows. Me dijo que las llamadas win32api para OpenProcess, CreateProcess, ReadProcessMemory y WriteProcessMemory eran el camino a seguir utilizando C o C ++. Creo que el camino a seguir sería simplemente utilizando la clase Win32API y mapear dos instancias de la misma; Uno ya sea para OpenProcess o CreateProcess, dependiendo de si el usuario ya tiene º proceso que se ejecuta o no, y otro caso se asignará a ReadProcessMemory. Probablemente todavía tengo que encontrar la función para obtener la lista de procesos en ejecución, así que sé qué proceso se ejecuta es el que yo quiero si está en ejecución.

Esto llevaría algo de trabajo para poner todos juntos, pero estoy pensando que no sería demasiado malo para código de arriba. Es simplemente una nueva área de programación para mí ya que nunca he trabajado este bajo nivel de un lenguaje de alto nivel (bueno, nivel superior al de todos modos C). Me pregunto de las maneras de abordar esto. Yo sólo podía usar un grupo o llamadas win32api, pero eso significa tener que lidiar con un montón de cuerdas y la matriz paquete y desembalaje que depende del sistema Quiero, finalmente, hacer este trabajo multiplataforma ya que el proceso que estoy leyendo desde que se produce a partir un ejecutable que tiene múltiples plataformas construye, (sé que los cambios de dirección de memoria de sistema a sistema. la idea es tener un archivo plano que contiene todos los mapas de memoria para que el programa de Ruby solo puede coincidir con el entorno de la plataforma actual a la asignación de memoria a juego. ) pero desde el aspecto de las cosas que acabo a tener que hacer una clase que envuelve todo lo que es el sistema de la plataforma actual compartidos relacionados con la memoria llamadas a funciones de biblioteca.

Por lo que sé, ya podría existir una gema Ruby que se encarga de todo esto para mí que estoy simplemente no encontrar. También podría posiblemente tratar la edición de los archivos ejecutables para cada generación para que así cada vez que los valores de la memoria que quiero leer desde se escriben en el proceso, aunque también lo hace una copia del nuevo valor a un espacio en la memoria compartida que de alguna manera tengo rubí hacer una instancia de una clase que es un puntero bajo el capó para esa dirección de memoria compartida y de alguna señal al programa de ruby ??que el valor se actualiza y debe ser recargada. Básicamente, un sistema basado en la interrupción sería bueno, pero dado que el propósito de la lectura de estos valores es sólo para enviar a un marcador transmitido desde un servidor central, que podría sólo se adhieren a un sistema basado en el sondeo que envía actualizaciones a intervalos de tiempo fijos. Asimismo, sólo podía abandonar Rubí por completo e ir a por C o C ++, pero no sé los casi tan bien. De hecho, me sé más de 86 C ++ y C Lo único que sé por lo que el sistema independiente ANSI C y nunca he tratado con las bibliotecas del sistema compartida antes.

Entonces, ¿hay una joya o módulo menos conocidos disponibles que ya ha hecho esto? Si no, entonces cualquier información adicional sobre la forma de lograr esto sería bueno. Supongo, cuento largo, ¿cómo lo hago todo esto?

Gracias de antemano, Grg

PS:. También una confirmación de que esas llamadas win32api deben dirigirse a la biblioteca kernel32.dll sería bueno

Answer 1

Tome un vistazo a win32utils . Estoy pensando que debería, al menos, conseguir que en sus pies, y le dará ejemplos de cómo cavar en la propia API si los propios gemas no lo hacen el trabajo para usted. Es posible que tenga que morder la bala y escribir un módulo en C.

Answer 2

Uso Rubí-FFI:

Si conoce C y la API de Win32, entonces puede que le resulte más fácil de gema uso Ruby-FFI. Ruby-FFI envuelve funciones C de forma transparente, lo que permite utilizar cualquier función Win32.

Para la memoria compartida llamada, Win32 proporciona CreateFileMapping( ) y MapViewOfFile( ).

Estos tienen las cabeceras

# WINBASEAPI HANDLE WINAPI CreateFileMappingA(HANDLE,LPSECURITY_ATTRIBUTES,DWORD,DWORD,DWORD,LPCSTR);
# WINBASEAPI PVOID WINAPI MapViewOfFile(HANDLE,DWORD,DWORD,DWORD,DWORD);

Al pasar en un 0xFFFFFFFF identificador de archivo no válido en CreateFileMapping, se puede evitar el trato con los archivos en absoluto, y simplemente definir su memoria compartida utilizando matrices y punteros.

A continuación se muestra un ejemplo simplificado que lee de la memoria compartida. (Una versión de calidad de la producción sería usar semáforos en el lector y escritor, y un buffer circular, para permitir que ambos procesos para proceder de forma asíncrona sin dejar de asegurar que el escritor no sobrescribe un buffer hasta que el lector ha terminado de leerlo.)

simplificado Rubí Ejemplo:

require 'ffi'

module Win32
   extend FFI::Library
   ffi_lib 'kernel32'  # see winbase.h
   attach_function :CreateFileMapping, 
            :CreateFileMappingA,[ :uint, :pointer, :long, :long, :long, :pointer ], :pointer   
            # suffix A indicates the ASCII version
   attach_function :MapViewOfFile, 
            :MapViewOfFile,[ :pointer, :long, :long, :long, :long ], :pointer  
end

memoryName = "Share Memory Name"
sz_buf = 1000  # bytes  (250 ints, 4 bytes each)
num_ints = sz_buf / 4

# Windows constants
PAGE_READWRITE = 0x0004
FILE_MAP_WRITE = 2

# Get handle to shared memory
hMemory = Win32.CreateFileMapping(0xFFFFFFFF, nil, PAGE_READWRITE, 0, sz_buf, memoryName)

# Create pointer into shared memory in the reader's memory space 
pMemory = FFI::MemoryPointer.new(:int, num_ints )
pMemory = Win32.MapViewOfFile(hMemory, FILE_MAP_WRITE, 0, 0, sz_buf)

# Read from shared memory buffer
puts pMemory.read_array_of_int(sz_buf).join(" ")  

Información útil:

• (como arriba) en C / Win32. de hecho, se puede utilizar el módulo de grabación presenta aquí para probar el código anterior -. acaba de cambiar el tipo de char * a int
• semáforos para el acceso de sincronización