In Ruby, come ho letto i valori della memoria da un processo esterno?

StackOverflow https://stackoverflow.com/questions/2838502

Domanda

Quindi tutto quello che semplicemente voglio fare è fare un programma di Ruby che legge alcuni valori dal noto indirizzo di memoria nella memoria virtuale di un altro processo. Attraverso la mia ricerca e la conoscenza di base di hex editing x86 di un processo in esecuzione di assemblaggio nella memoria, ho trovato l'indirizzo di base e offset per i valori in memoria che voglio. Io non voglio cambiare loro; Voglio solo leggerli. Ho chiesto a uno sviluppatore di un editor di memoria come affrontare questa astratta del linguaggio e assumendo una piattaforma Windows. Mi ha detto le chiamate Win32API per OpenProcess, CreateProcess, ReadProcessMemory, e WriteProcessMemory erano la strada da percorrere utilizzando C o C ++. Credo che la strada da percorrere sarebbe solo utilizzando la classe Win32API e la mappatura di due istanze di esso; Uno per uno OpenProcess o CreateProcess, a seconda se l'utente ha già th processo in esecuzione o meno, e un altro caso verrà mappato ReadProcessMemory. Probabilmente ho ancora bisogno di trovare la funzione per ottenere la lista dei processi in esecuzione in modo da sapere quale processo in esecuzione è quello che voglio se è in esecuzione già.

Questo sarebbe prendere un po 'di lavoro per mettere tutti insieme, ma sto immaginando che non sarebbe stato troppo brutto per il codice su. E 'solo una nuova area di programmazione per me dal momento che non ho mai lavorato questo livello basso da un linguaggio ad alto livello (o meglio, di più alto livello di C in ogni modo). Mi chiedo solo dei modi per avvicinarsi a questo. Potrei basta usare un mucchio o chiamate Win32API, ma questo significa avere a che fare con un gruppo di stringhe e array di pacco e disfare che dipende dal sistema Voglio infine fare questo lavoro cross-platform in quanto il processo che sto leggendo da è prodotto da un eseguibile che ha la piattaforma più animazioni, (so che i cambiamenti di indirizzo di memoria da sistema a sistema. l'idea è quella di avere un file flat che contiene tutte le mappature di memoria in modo che il programma in Ruby può semplicemente abbinare l'ambiente attuale piattaforma per la mappatura della memoria corrispondente. ), ma dagli sguardi delle cose che dovrò solo per fare una classe che avvolge tutto ciò che è il sistema della piattaforma corrente condivise chiamate di funzione relative memoria di libreria.

Per quanto ne so, non ci potrebbe già esistere una gemma rubino che si prende cura di tutto questo per me che sto solo non trovare. Potrei anche, eventualmente, provare a modificare gli eseguibili per ogni generazione di fare in modo ogni volta che i valori di memoria che voglio leggere vengono scritti dal processo, si scrive anche una copia del nuovo valore ad uno spazio nella memoria condivisa che ho in qualche modo ho rubino fanno un'istanza di una classe che è un puntatore sotto il cofano per quell'indirizzo di memoria condivisa e in qualche modo segnalare al programma rubino che il valore è stato aggiornato e deve essere ricaricata. In pratica un sistema di interruzione basato sarebbe bello, ma dal momento che lo scopo di lettura di questi valori è solo quello di inviare a un quadro di valutazione trasmesso da un server centrale, ho potuto solo attenersi a un sistema basato su di polling che invia gli aggiornamenti a intervalli di tempo fissi. Ho anche potuto solo abbandonare Rubino del tutto e andare per il C o C ++, ma non so chi quasi pure. Io in realtà so più 86 di C ++ e so solo C per quanto riguarda sistema indipendente ANSI C e non ho mai affrontato con librerie di sistema condivise prima.

Così, c'è una gemma o un modulo meno noti disponibili che ha già fatto questo? Se no, allora tutte le ulteriori informazioni su come raggiungere questo obiettivo sarebbe bello. Credo che, per farla breve, come faccio a fare tutto questo?

Grazie in anticipo, Grg

PS:. Anche una conferma che quelle chiamate Win32API dovrebbero mirare a biblioteca kernel32.dll sarebbe bello

È stato utile?

Soluzione

Date un'occhiata al win32utils . Sto pensando che dovrebbe almeno ottenere in piedi, e vi darà esempi di come scavare nella api in sé se le gemme stessi non lavoro per voi. Potrebbe essere necessario stringere i denti e scrivere un modulo in C.

Altri suggerimenti

Usa Ruby-FFI:

Se si conosce C e l'API Win32, allora si potrebbe trovare più facile da usare Ruby-FFI gioiello. Ruby-FFI avvolge funzioni C in modo trasparente, che consente di utilizzare qualsiasi funzione Win32.

Per la memoria condivisa denominata, Win32 fornisce CreateFileMapping( ) e MapViewOfFile( ).

Questi hanno le intestazioni 

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

Passando in un invalido handle di file 0xFFFFFFFF in CreateFileMapping, si può evitare di trattare con i file a tutti, e semplicemente definire la memoria condivisa utilizzando vettori e puntatori.

Di seguito è riportato un esempio semplificato che legge dalla memoria condivisa. (Una versione di qualità della produzione userebbe semafori nel lettore e scrittore, e un buffer circolare, per consentire entrambi i processi di procedere asincrono pur garantendo che lo scrittore non sovrascrivere un buffer finché il lettore ha finito di leggerlo.)

semplificato Rubino Esempio: 

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(" ")

Alcune informazioni utili:

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top