changer un pointeur d’adresse d’une autre application

J’ai besoin de quelqu’un pour éditer le titre, je ne peux pas trouver un meilleur titre.


Supposons un programme simple appelé source.exe :

 #include  int main() { int a = 5; printf("%p", &a); return 0; } 

Je veux écrire une autre application, change.exe , qui change a dans ce qui précède.

J’ai essayé quelque chose comme ça:

 int main() { int * p = (int*) xxx; // xxx is what have printed above *p = 1; printf("%d", *p); return 0; } 

Ça ne marche pas en supposant que j’ai les droits d’administrateur, y a-t-il un moyen de faire ce que j’ai essayé ci-dessus? Merci.

En premier lieu, lorsque vous exécutez le deuxième programme, le a du premier disparaîtra depuis longtemps (ou sera chargé dans une position différente). En second lieu, de nombreux systèmes d’exploitation protègent les programmes en les chargeant dans des espaces séparés.

Ce que vous semblez vraiment rechercher, ce sont les mécanismes de communication inter-processus (IPC), en particulier la mémoire partagée ou les fichiers mappés en mémoire.

Sur la plupart des ordinateurs traditionnels utilisés par les utilisateurs, le système d’exploitation utilise la mémoire virtuelle. Cela signifie que deux processus peuvent tous deux utiliser l’adresse 0x12340000 et qu’il peut faire référence à deux pièces de mémoire différentes.

Cela est utile pour un certain nombre de raisons, notamment la fragmentation de la mémoire et le fait de permettre le démarrage et l’arrêt de plusieurs applications à des moments aléatoires.

Sur certains systèmes, tels que les DSP TI par exemple, il n’y a pas de MMU et donc pas de mémoire virtuelle. Sur ces systèmes, quelque chose comme votre application de démonstration pourrait fonctionner.

Je me sentais un peu aventureux, alors j’ai pensé à écrire quelque chose comme cela sous Windows, en utilisant WinAPI, bien sûr. Comme ptrace sous Linux, les appels utilisés par ce code ne devraient être utilisés que par les débogueurs et ne sont normalement pas visibles dans les codes d’application normaux.

En outre, pour ouvrir la mémoire d’un autre processus en écriture, vous devez ouvrir le PROCESS_VM_WRITE processus avec les privilèges PROCESS_VM_WRITE et PROCESS_VM_OPERATION . Toutefois, cela n’est possible que si l’application ouvrant le processus a le privilège SeDebugPriviledge activé. J’ai exécuté l’application en mode élevé avec des privilèges d’administrateur, mais je ne sais pas vraiment si cela a un effet sur SeDebugPriviledge .

Quoi qu’il en soit, voici le code que j’ai utilisé pour cela. Il a été compilé avec VS2008.

 #include  #include  #include  #include  int main() { char cmd[2048]; int a = 5; printf("%p %d\n", &a, a); sprintf(cmd, "MemChange.exe %lu %x", GetCurrentProcessId(), &a); system(cmd); printf("%p %d\n", &a, a); return 0; } 

Et voici le code pour MemChange.exe que ce code appelle.

 #include  #include  int main(int argc, char **argv) { DWORD pId; LPVOID pAddr; HANDLE pHandle; SIZE_T bytesWritten; int newValue = 666; sscanf(argv[1], "%lu", &pId); sscanf(argv[2], "%x", &pAddr); pHandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pId); WriteProcessMemory(pHandle, pAddr, &newValue, sizeof(newValue), &bytesWritten); CloseHandle(pHandle); fprintf(stderr, "Written %u bytes to process %u.\n", bytesWritten, pId); return 0; } 

Mais s’il vous plaît, n’utilisez pas ce code. C’est horrible, il n’y a pas de vérification d’erreur et probablement des fuites comme l’enfer. Il a été créé uniquement pour illustrer ce qui peut être fait avec WriteProcessMemory . J’espère que ça aide.

  1. Pourquoi pensez-vous que cela est possible – les débogueurs ne peuvent que lire?
  2. Si c’était possible, toutes sortes de chaos pourraient se produire!
  3. La mémoire partagée vient à l’esprit.