Dans Ruby, comment je lis les valeurs de la mémoire d'un processus externe?

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

Question

Donc tout ce que je veux simplement faire est de faire un programme Ruby qui lit des valeurs de l'adresse mémoire connue dans la mémoire virtuelle d'un autre processus. Grâce à mes recherches et des connaissances de base de l'édition hexagonale de x86 d'un processus en cours d'exécution assemblage en mémoire, j'ai trouvé l'adresse de base et les compensations pour les valeurs en mémoire que je veux. Je ne veux pas les changer; Je veux juste les lire. J'ai demandé à un développeur d'un éditeur de mémoire comment aborder cette abstraite du langage et en supposant une plate-forme Windows. Il m'a dit que les appels Win32API pour OpenProcess, CreateProcess, ReadProcessMemory et WriteProcessMemory étaient la voie à suivre en utilisant C ou C ++. Je pense que la voie à suivre serait juste en utilisant la classe Win32API et cartographier deux cas de celui-ci; L'un pour les deux OpenProcess ou CreateProcess, selon que l'utilisateur a déjà e processus en cours d'exécution ou non, et une autre instance sera mis en correspondance avec ReadProcessMemory. J'ai probablement encore besoin de trouver la fonction pour obtenir la liste des processus en cours d'exécution, donc je sais quel processus en cours d'exécution est celui que je veux si elle est déjà en cours.

Cela prendra un certain travail pour mettre tous ensemble, mais je suis en pensant qu'il ne serait pas trop mauvais pour le code vers le haut. Il est juste une nouvelle zone de programmation pour moi puisque je ne l'ai jamais travaillé ce faible niveau d'un langage de haut niveau (bien, niveau supérieur à C de toute façon). Je me demande simplement des façons d'aborder ce sujet. Je pouvais utiliser un groupe ou des appels Win32API, mais cela signifie avoir à traiter avec un tas de cordes et paquet tableau et le déballage qui est dépend du système que je veux éventuellement faire cette croix-plate-forme de travail depuis le processus que je suis en train de lire est produite à partir de un exécutable qui a plate-forme multiple construit, (je sais que les changements d'adresse mémoire du système à système. l'idée est d'avoir un fichier plat qui contient toutes les applications de mémoire pour que le programme Ruby peut simplement correspondre à l'environnement de la plate-forme actuelle à la cartographie de la mémoire correspondante. ) mais des regards des choses que je vais devoir faire une classe qui enveloppe quel que soit le système de plate-forme actuelle partagé les appels de fonctions liées à la mémoire bibliothèque.

Pour tout ce que je sais, il pourrait déjà exister un petit bijou Ruby qui prend soin de tout cela pour moi que je suis tout simplement pas trouver. Je pourrais aussi essayer éventuellement de modifier les executables pour chaque génération de faire en sorte à chaque fois que les valeurs de mémoire que je veux lire sont écrits par le processus, il écrit également une copie de la nouvelle valeur à un espace dans la mémoire partagée que j'ai en quelque sorte Ruby faire une instance d'une classe qui est un pointeur sous le capot à cette adresse de mémoire partagée et le signal en quelque sorte au programme Ruby que la valeur a été mis à jour et doit être rechargée. Fondamentalement, un système d'interruption serait bien, mais étant donné que le but de la lecture de ces valeurs est juste pour envoyer à un tableau de bord diffusé à partir d'un serveur central, je pouvais tenir à un système de vote qui envoie des mises à jour à intervalles de temps fixes. Je pouvais abandonner aussi Ruby tout à fait et aller pour C ou C ++, mais je ne sais pas les presque aussi bien. Je sais en fait plus que x86 C ++ et je ne sais C autant que système indépendant ANSI C et ont jamais traité avec les bibliothèques partagées du système avant.

Ainsi est-il un bijou ou un module moins connu disponible qui a déjà fait? Dans le cas contraire, toute information supplémentaire quant à la façon d'y arriver serait bien. Je suppose que, longue histoire courte, comment dois-je faire tout cela?

Merci à l'avance, GRG

PS:. Aussi une confirmation que ces appels Win32API devraient viser à la bibliothèque kernel32.dll serait bien

Était-ce utile?

La solution

Jetez un oeil à win32utils . Je pense que devrait au moins vous mettre sur vos pieds, et vous donner des exemples de la façon de creuser dans le api lui-même si les gemmes eux-mêmes ne fonctionnent pas pour vous. Vous pourriez avoir besoin de mordre la balle et d'écrire un module en C.

Autres conseils

Utilisez Ruby-IFF:

Si vous connaissez C et l'API Win32, il vous trouverez peut-être plus facile à utiliser gem Ruby-FFI. Ruby-FFI enveloppe transparente fonctions C, vous permettant d'utiliser toutes les fonctions Win32.

Pour le nom de la mémoire partagée, Win32 fournit CreateFileMapping( ) et MapViewOfFile( ).

Ceux-ci ont les en-têtes 

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

En passant dans une poignée de fichier non valide 0xFFFFFFFF dans CreateFileMapping, vous pouvez éviter de traiter des fichiers à tous, et de définir simplement votre mémoire partagée à l'aide des tableaux et des pointeurs.

Voici un exemple simplifié qui lit de la mémoire partagée. (Une version de qualité de la production utiliserait sémaphores dans le lecteur et écrivain, et un tampon circulaire, pour permettre aux deux processus de procéder de manière asynchrone, tout en veillant à ce que l'auteur ne remplace pas un tampon jusqu'à ce que le lecteur a terminé la lecture.)

simplifié Ruby Exemple: 

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

Quelques informations utiles:

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top