Discussion :

[KevinDA]

Marche pas :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

WriteProcessMemory(hProc, (BYTE*)(faFound), &calcul + 279620, sizeof(calcul + 279620), 0);

Marche :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
int nouveau_calcul = calcul + 279620;
 
WriteProcessMemory(hProc, (BYTE*)(faFound), &nouveau_calcul, sizeof(nouveau_calcul), 0);

Bonjour, avec WriteProcessMemory dans le 1er exemple j'ai pas réussit a modifier l'adresse car avec le & et le + marche pas.
Par contre dans le 2èmes exemple ça marche mais je suis obligé de créer une autre variable.
J'ai tous essayé dans le 1er exemple, les parenthèses : &(calcul + 279620)
Avec &calcul + &279620 etc...
Mais rien ne marche.

Quelqu'un a une idée ?

[koala01]

Salut,

D'abord et avant tout: que cherches tu réellement à faire avec WriteProcessMemory As tu seulement conscience que cette fonction n'est en rien une fonction C++, qu'il ne s'agit que d'une fonction fournie par Windows (ce qui implique que tu peux dire adieu à la portabilité).

Ensuite, comprends tu ne serait-ce que la moitié de ce que tu fais dans les deux codes car cela me semble pour le moins scabreux

Allez, pour te donner une idée: quand tu as le code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
WriteProcessMemory(hProc, (BYTE*)(faFound), &calcul + 279620, sizeof(calcul + 279620), 0);

S'il n'y a pas grand chose à dire sur les deux premiers paramètres que tu transmet à la fonction (bon, il y aurait bien une ou deux choses à dire, mais on peut partir du principe que c'est correct ), les choses se gâtent énormément en ce qui concerne les troisième et quatrième paramètres

Ce qui me laisse à penser que tu ne comprends absolument pas ce que tu fais, on va donc essayer de te l'expliquer:

un code proche de &calcul + 278620 signifie que, quoi que puisse être calcul, tu vas en prendre l'adresse mémoire à laquelle calcul se trouve, (ca, c'est la partie &calcul) puis que tu ajoutes la valeur 27860 (ca, c'est la partie + 278620) afin d'obtenir l'adresse mémoire à laquelle la fonction writeProcessMemory doit aller chercher le buffer qui contient les informations que tu veux écrire en mémoire.

C'est peut-être ce que tu veux effectivement faire, cependant, je serais bien plus enclin à parier -- sans voir le reste du code, et donc avec tout le risque d'erreur que cela comporte -- que calcul représente déjà le buffer que tu veux transmettre à la fonction.

Ce qui aurait pour résultat, si le buffer que tu veux transmettre a une taille de 278 620 byte (ce qui me semble énorme) de fournir l'adresse mémoire à laquelle le buffer fini. Cherchez l'erreur! Car l'adresse attendue ici est celle ... du début du buffer

Le quatrième paramètre me semble tout aussi surprenant, car il doit normalement indiquer la taille du buffer.

Si, à la limite, tu utilisais sizeof(calcul) (quoi que calcul soit sensé représenter) et pour autant que calcul ne soit pas composé (entre autre) d'un pointeur pour lequel tu aurais eu recours à l'allocation dynamique de la mémoire (ou en tout cas que seule l'adresse de ce pointeur t'intéresse), cela pourrait ** éventuellement ** passer, parce que tu transmettrait effectivement le nombre de bytes qui composent la donnée calcul que tu viens de transmettre (comme troisième paramètre) en tant que buffer.

Il est cependant plus vraisemblable que cette "valeur magique" de 278 620 que l'on trouve dans ton code corresponde effectivement à la taille de ton buffer "calcul", et que ce serait donc tout simplement cette valeur qui devrait être transmise comme quatrième paramètre

Enfin, et pour que tu puisse malgré tout comprendre ton problème:

L'opérateur sizeof() permet de récupérer la taille (en nombre de bytes) requise en mémoire pour permettre la représentation d'une donnée quelconque.

Cela peut fonctionner (et donner le même résultat) de deux manières:

• Soit on donne un identifiant de type (ex sizeof( int) pourrait te renvoyer 4)
• soit on fournit une donnée bien particulière, par exemple
  

  Code :

  Sélectionner tout - Visualiser dans une fenêtre à part

  1
  2
  int monInt;
  sizeof(monInt); // pourrait renvoyer 4

Quand tu écris sizeof(calcul + 278620) ce que tu places dans les parenthèses n'a simplement aucun sens pour la fonction

Tu ne peux même pas t'en sortir avec un code proche de sizeof(calcul) + sizeof(278620) car, même si le premier sizeof te donnerait effectivement la taille de calcul, le deuxième sizeof utiliserait le "type par défaut" utilisé pour sizeof (typiquement le type int) et te renverrait donc ... 4

Quant à écrire un code qui serait proche de sizeof(calcul) + 278620 (qui serait aussi accepté par le compilateur), j'ai tout lieu de croire que tu en viendrait à transmettre au final le double de la taille de calcul si celle ci est effectivement de 278 620 bytes, et ca, ca risque vraiment d'occasionner des catastrophes lors de l'appel à la fonction WriteProcessMemory

[KevinDA]

En faite je voulez tous simplement ajouter calcul + 279620. Mais je vois que c'est pas possible, donc je créer une variable supplémentaire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
int nouveau_calcul = calcul + 279620;
 
WriteProcessMemory(hProc, (BYTE*)(faFound), &nouveau_calcul, sizeof(nouveau_calcul), 0);

C'est plus simple. Je vois pas l’intérêt dans cette fonction WriteProcessMemory de récupérer l'adresse mémoire de la variable. C'était plus simple logiquement que ça marche de cette manière :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
WriteProcessMemory(hProc, (BYTE*)(faFound), calcul + 279620, sizeof(calcul + 279620), 0);

[Bousk]

Ce que tu penses être plus simple n'a surtout aucun sens syntaxique.
WriteProcessMemory ça écrit un buffer, parce que c'est générique, et calcul + 279620 n'en est absolument pas un. C'est juste une valeur entière.
De même, sizeof retourne la taille d'un type, alors tu peux bien écrire sizeof(calcul + 27960) ou sizeof(2147483647) ou sizeof(0) ou sizeof(int), ça changera pas la taille de l'int qui stocke sa valeur.

Mais surtout la grande question pour ma part est : comment on peut être amené à utiliser WriteProcessMemory en étant clairement débutant en C++ ?

[KevinDA]

Avant de proposer une inscription à ce forum je pense qu'il est préférable de préciser au personne qui seront plus critiqué qu' aider. Je suis vraiment dessus, c'était plus simple de mettre un exemple que de me critiquer.

[Médinoc]

Le problème, c'est qu'on ne sait pas ce que tu veux vraiment faire.
Une question ne peut avoir de réponse que si elle est suffisamment bien posée pour donner tout le contexte nécessaire.

D'où viennent ces adresses? Quel est l'autre processus? S'agit-il d'une autre instance du même programme?
Les deux processus communiquent-ils? Si oui, il existe des mécanismes plus fiables que WriteProcessMemory() pour échanger des données (un segment de mémoire partagée, par exemple).