Partage de la mémoire entre deux processus (C, Windows)

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

Question

Étant donné que je n'ai pas trouvé de réponse à la question posée précédemment ici J'essaie une approche différente.

Est-il possible de partager la mémoire entre deux processus?

Le second processus tire les informations d'une injection puisqu'il s'agit d'un programme hérité pour lequel il n'est plus pris en charge.

Mon idée est d’y injecter du code, dans la structure que je passe au programme injecté, de transmettre l’adresse (ou autre) à la mémoire partagée où se trouvent les données que j’ai besoin d’exécuter. Une fois les données obtenues, je vais renseigner mes propres variables dans le fil injecté.

Est-ce possible? Comment?

Le code est apprécié.

EDIT:

Je pense que ce n'est pas clair alors je vais clarifier. Je sais comment injecter. Je le fais déjà. Le problème ici est de passer des données dynamiques à l’injection.

Était-ce utile?

La solution

Vous pouvez essayer un fichier mappé en mémoire .

Ceci en donne un peu plus, étape par étape détail.

Autres conseils

Bien que Windows prenne en charge la mémoire partagée via son API de mappage de fichiers , vous ne pouvez pas facilement injecter directement un mappage de mémoire partagée dans un autre processus, car MapViewOfFileEx ne prend pas d'argument de processus.

Toutefois, vous pouvez injecter des données en allouant de la mémoire dans un autre processus à l'aide de VirtualAllocEx et WriteProcessMemory . Si vous deviez copier un descripteur à l'aide de DuplicateHandle , puis injectez une souche appelant MapViewOfFileEx , vous pourrait établir un mappage de mémoire partagée dans un autre processus. De toute façon, on dirait que vous allez injecter du code, cela devrait bien fonctionner pour vous.

Pour résumer, vous devez:

  • Créez un identifiant de segment de mémoire partagée anonyme en appelant CreateFileMapping avec INVALID_HANDLE_VALUE pour hFile et NULL pour lpName.
  • Copiez ce descripteur dans le processus cible avec DuplicateHandle
  • Allouez de la mémoire pour le code à l'aide de VirtualAllocEx . , avec flAllocationType = MEM_COMMIT | MEM_RESERVE et flProtect = PAGE_EXECUTE_READWRITE
  • Ecrivez votre code de raccord dans cette mémoire, à l'aide de WriteProcessMemory . Ce talon devra probablement être écrit en assembleur. Passez la HANDLE de DuplicateHandle en l’écrivant quelque part ici.
  • Exécutez votre fichier de remplacement à l'aide de CreateRemoteThread . Le module de remplacement doit ensuite utiliser le HANDLE obtenu pour appeler MapViewOfFileEx . Les processus auront alors un segment de mémoire partagée commun.

Cela peut sembler un peu plus facile si votre stub charge une bibliothèque externe - appelez-le simplement LoadLibrary (la recherche de l'adresse de LoadLibrary est laissée au lecteur) et faites votre travail à partir de l'entrée dllmain de la bibliothèque. point. Dans ce cas, utiliser une mémoire partagée nommée sera probablement plus simple que de jouer avec DuplicateHandle. Voir l'article MSDN sur CreateFileMapping pour plus de détails, mais passez essentiellement INVALID_HANDLE_VALUE pour hFile et un nom pour lpName.

Modifier : dans la mesure où votre problème est de transmettre des données et non d'injecter du code, voici quelques options.

  1. Utilisez une mémoire partagée de taille variable. Votre souche obtient la taille et le nom ou un descripteur de la mémoire partagée. Ceci est approprié si vous n’avez besoin que d’échanger des données une fois. Notez que la taille d'un segment de mémoire partagée ne peut pas être facilement modifiée après sa création.
  2. Utilisez un canal nommé . Votre souche obtient le nom ou une poignée du tuyau. Vous pouvez ensuite utiliser un protocole approprié pour échanger des blocs de taille variable - par exemple, écrivez un size_t pour la longueur, suivi du message réel. Vous pouvez également utiliser PIPE_TYPE_MESSAGE et PIPE_READMODE_MESSAGE et surveiller ERROR_MORE_DATA pour déterminer le lieu de fin des messages. Cela convient si vous devez échanger des données plusieurs fois.

Modifier 2 : voici un aperçu de la manière dont vous pourriez implémenter le stockage des poignées ou des pointeurs pour votre stub: 

.db B8            ;; mov eax, imm32
.dl handle_value  ;; fill this in (located at the start of the image + one byte)
;; handle value is now in eax, do with it as you will
;; more code follows...

Vous pouvez également simplement utiliser un nom fixe, ce qui est probablement plus simple.

Avez-vous essayé d'utiliser des pipes (pour la mémoire) ou même la sérialisation (pour vos objets)? Vous pouvez utiliser des fichiers pour gérer la mémoire entre les processus. Les sockets sont également utiles pour la communication entre les processus.

Le mappage de la mémoire est la solution, vous n'avez même pas besoin de créer un espace de mémoire permanent, le secteur de la mémoire sort du cadre lorsque tous les processus qui le partagent sont arrêtés. Il y a aussi d'autres moyens. Un moyen rapide et sale de transmettre des données d'une application C à une autre consiste simplement à utiliser le système d'exploitation. Sur la ligne de commande, tapez app1 | app2 . Ainsi, app2 sera la destination de sortie de app1 ou une commande printf de app1 l'enverrait à app2 (cela s'appelle la tuyauterie).

Vous pouvez essayer d'utiliser Boost.Interprocess . communiquer entre deux processus. Mais pour injecter du code dans un logiciel existant, non pris en charge auparavant, vous devrez probablement utiliser la méthode de @ bdonlan en utilisant WriteProcessMemory .

Si vous parlez de Windows, le principal obstacle est que les processus vivent chacun dans leur propre espace d'adressage virtuel. Malheureusement, vous ne pouvez pas transmettre les adresses de mémoire normales d'un processus à l'autre et obtenir les résultats escomptés. (Les threads, par contre, vivent tous dans le même espace adresse, ce qui explique pourquoi les threads peuvent voir la mémoire de la même manière.)

Cependant, Windows dispose d’un espace mémoire partagé que vous devez être très prudent pour gérer correctement. Tout processus qui alloue de l'espace dans la mémoire partagée est responsable de la libération explicite de cette mémoire. Cela contraste avec la mémoire locale, qui disparaît plus ou moins à la mort du processus.

Voir cet exemple d'article MSDN pour des idées sur l'utilisation de l'espace mémoire partagé. pour conquérir le monde. Euh, interface avec les logiciels existants. Ou peu importe :) Bonne chance, quoi que vous fassiez!

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