pointeur ASM en C++ ?

Le
Dan1024
Bonjour,

J'ai un code ASM à passer en C++ et j'arrive à un résultat qui marche
mais très, très moche, n'y aurait il pas une méthode beaucoup plus
élégante ?

Le code ASM: ESI contient une adresse, résultat dans EDX.

mov ecx,[esi+00000278h]
mov edx,[ecx]
mov edx,[edx+000000FCh]
mov edx,[edx+24h]

Mon code C++, ca marche mais c'est très moche, ReturnData
contient la même adresse que ESI, retour dans Result:

DWORD* temp1 = (DWORD*)(reinterpret_cast<char*>(ReturnData+0x278));
DWORD* temp2=(DWORD*)*temp1;
DWORD temp3=(DWORD)*temp2;
DWORD* temp4 = (DWORD*)(reinterpret_cast<char*>(temp3+0xfc));
DWORD temp5=*temp4;
DWORD* temp6 = (DWORD*)(reinterpret_cast<char*>(temp5+0x24));
DWORD Result=*temp6;

Merci d'avance pour tout conseil

Dan
Vidéos High-Tech et Jeu Vidéo
Téléchargements
Vos réponses
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
Serge Paccalin
Le #310526
Le lundi 13 août 2007 à 03:56:22, Dan1024 a écrit dans
fr.comp.lang.c++ :

J'ai un code ASM à passer en C++ et j'arrive à un résultat qui marche
mais très, très moche, n'y aurait il pas une méthode beaucoup plus
élégante ?

Le code ASM: ESI contient une adresse, résultat dans EDX.

mov ecx,[esi+00000278h]
mov edx,[ecx]
mov edx,[edx+000000FCh]
mov edx,[edx+24h]

Mon code C++, ca marche mais c'est très moche, ReturnData
contient la même adresse que ESI, retour dans Result:

DWORD* temp1 = (DWORD*)(reinterpret_cast<char*>(ReturnData+0x278));
DWORD* temp2=(DWORD*)*temp1;
DWORD temp3=(DWORD)*temp2;
DWORD* temp4 = (DWORD*)(reinterpret_cast<char*>(temp3+0xfc));
DWORD temp5=*temp4;
DWORD* temp6 = (DWORD*)(reinterpret_cast<char*>(temp5+0x24));
DWORD Result=*temp6;

Merci d'avance pour tout conseil


Déjà, c'est dommage de mélanger casts à la C et reinterpret_cast<>.
Ensuite, pourquoi caster deux fois certaines expressions ?

DWORD temp = *reinterpret_cast<DWORD *>(ReturnData + 0x278);
temp = *reinterpret_cast<DWORD *>(temp);
temp = *reinterpret_cast<DWORD *>(temp + 0xfc);
DWORD Result = *reinterpret_cast<DWORD *>(temp + 0x24);

--
___________
_/ _ _`_`_`_) Serge PACCALIN -- sp ad mailclub.net
_L_) Il faut donc que les hommes commencent
-'(__) par n'être pas fanatiques pour mériter
_/___(_) la tolérance. -- Voltaire, 1763

Sylvain Togni
Le #310525
Dan1024 wrote:

J'ai un code ASM à passer en C++ et j'arrive à un résultat qui marche
mais très, très moche, n'y aurait il pas une méthode beaucoup plus
élégante ?


Pas vraiment, faire mumuse avec la mémoire n'est jamais très
élégant en C++.

Le code ASM: ESI contient une adresse, résultat dans EDX.

mov ecx,[esi+00000278h]
mov edx,[ecx]
mov edx,[edx+000000FCh]
mov edx,[edx+24h]

Mon code C++, ca marche mais c'est très moche, ReturnData
contient la même adresse que ESI, retour dans Result:

DWORD* temp1 = (DWORD*)(reinterpret_cast<char*>(ReturnData+0x278));
DWORD* temp2=(DWORD*)*temp1;
DWORD temp3=(DWORD)*temp2;
DWORD* temp4 = (DWORD*)(reinterpret_cast<char*>(temp3+0xfc));
DWORD temp5=*temp4;
DWORD* temp6 = (DWORD*)(reinterpret_cast<char*>(temp5+0x24));
DWORD Result=*temp6;


Ça peut juste être un peu nettoyé

DWORD temp1 = *reinterpret_cast<DWORD*>(ReturnData+0x278);
DWORD temp2 = *reinterpret_cast<DWORD*>(temp1);
DWORD temp3 = *reinterpret_cast<DWORD*>(temp2+0xfc);
DWORD Result = *reinterpret_cast<DWORD*>(temp3+0x24);

--
Sylvain Togni

Pierre Barbier de Reuille
Le #310485
On 12 août, 19:56, "Dan1024"
Bonjour,

J'ai un code ASM à passer en C++ et j'arrive à un résultat qui marc he
mais très, très moche, n'y aurait il pas une méthode beaucoup plus
élégante ?

Le code ASM: ESI contient une adresse, résultat dans EDX.

mov ecx,[esi+00000278h]
mov edx,[ecx]
mov edx,[edx+000000FCh]
mov edx,[edx+24h]

Mon code C++, ca marche mais c'est très moche, ReturnData
contient la même adresse que ESI, retour dans Result:

DWORD* temp1 = (DWORD*)(reinterpret_cast<char*>(ReturnData+0x278));
DWORD* temp2=(DWORD*)*temp1;
DWORD temp3=(DWORD)*temp2;
DWORD* temp4 = (DWORD*)(reinterpret_cast<char*>(temp3+0xfc));
DWORD temp5=*temp4;
DWORD* temp6 = (DWORD*)(reinterpret_cast<char*>(temp5+0x24));
DWORD Result=*temp6;

Merci d'avance pour tout conseil

Dan


La question principale est: pourquoi ne pas mettre temp1 directement
du bon type ?
DWORD ***temps1 = *reinterpret_cast<DWORD****>(ReturnData+0x278);
DWORD *temp2 = *(*temp1 + 0xfc);
DWORD result = *(temp2+0x24);

Pierre

Sylvain Togni
Le #310484
Pierre Barbier de Reuille wrote:

La question principale est: pourquoi ne pas mettre temp1 directement
du bon type ?
DWORD ***temps1 = *reinterpret_cast<DWORD****>(ReturnData+0x278);
DWORD *temp2 = *(*temp1 + 0xfc);
DWORD result = *(temp2+0x24);


Certainement parce que ce n'est pas équivalent.

--
Sylvain Togni

Pierre Barbier de Reuille
Le #310483
On 13 août, 09:44, Sylvain Togni <"sylvain.togni at
visionobjects.com"> wrote:
Pierre Barbier de Reuille wrote:

La question principale est: pourquoi ne pas mettre temp1 directement
du bon type ?
DWORD ***temps1 = *reinterpret_cast<DWORD****>(ReturnData+0x278);
DWORD *temp2 = *(*temp1 + 0xfc);
DWORD result = *(temp2+0x24);


Certainement parce que ce n'est pas équivalent.


Mmmmhhh ... on va dire que c'est autant équivalent que tous les autre
codes proposés ! Ou alors il faut m'expliquer plus que ça.
Mais en effet, il faut corriger car les décalages d'adresses doivent
être divisés par la taille d'un pointeur... Du coup ça donnerait (en
supposant une architecture 32bits et en supposant que ReturnData est
un void* ou un char*):

DWORD ***temps1 = *reinterpret_cast<DWORD****>(ReturnData+0x278);
DWORD *temp2 = *(*temp1 + 0x3f);
DWORD result = *(temp2+9);

Si ReturnData est d'un autre type, il faut aussi corriger le 0x278 de
la même façon ...

Pierre


Dan1024
Le #310482
"Serge Paccalin" a écrit dans le message de news:
Déjà, c'est dommage de mélanger casts à la C et reinterpret_cast<>.
Ensuite, pourquoi caster deux fois certaines expressions ?

DWORD temp = *reinterpret_cast<DWORD *>(ReturnData + 0x278);
temp = *reinterpret_cast<DWORD *>(temp);
temp = *reinterpret_cast<DWORD *>(temp + 0xfc);
DWORD Result = *reinterpret_cast<DWORD *>(temp + 0x24);


Génial, ca marche est c'est assez joli, merci beaucoup, je vais essayer
de piger le truc pour faire les autres, autant l'asm c'est limpide autant
j'ai de la peine avec les reinterpret_cast. (enfin en relisant c'est assez
clair quand même)

"Pierre Barbier de Reuille" a écrit dans le message de news:
La question principale est: pourquoi ne pas mettre temp1 directement
du bon type ?
DWORD ***temps1 = *reinterpret_cast<DWORD****>(ReturnData+0x278);
DWORD *temp2 = *(*temp1 + 0xfc);
DWORD result = *(temp2+0x24);


Désolé Pierre, la ca plante sur la derniere ligne.

En tout cas merci à tous pour vos réponses.

Dan

Fabien LE LEZ
Le #310481
On Tue, 14 Aug 2007 04:06:35 +0200, "Dan1024"
autant l'asm c'est limpide autant
j'ai de la peine avec les reinterpret_cast.


C'est logique : la manière de penser et de faire les choses utilisée
en assembleur x86, est très différente de celle utilisée en C++. Du
coup, les méthodes assembleur s'appliquent mal au C++.

Pierre Barbier de Reuille
Le #310480
On 13 août, 20:06, "Dan1024"
"Serge Paccalin" a écrit dans le message de news:

Déjà, c'est dommage de mélanger casts à la C et reinterpret_cast <>.
Ensuite, pourquoi caster deux fois certaines expressions ?

DWORD temp = *reinterpret_cast<DWORD *>(ReturnData + 0x278);
temp = *reinterpret_cast<DWORD *>(temp);
temp = *reinterpret_cast<DWORD *>(temp + 0xfc);
DWORD Result = *reinterpret_cast<DWORD *>(temp + 0x24);


Génial, ca marche est c'est assez joli, merci beaucoup, je vais essayer
de piger le truc pour faire les autres, autant l'asm c'est limpide autant
j'ai de la peine avec les reinterpret_cast. (enfin en relisant c'est assez
clair quand même)

"Pierre Barbier de Reuille" a écrit dans le message de news:

La question principale est: pourquoi ne pas mettre temp1 directement
du bon type ?
DWORD ***temps1 = *reinterpret_cast<DWORD****>(ReturnData+0x278);
DWORD *temp2 = *(*temp1 + 0xfc);
DWORD result = *(temp2+0x24);


Désolé Pierre, la ca plante sur la derniere ligne.

En tout cas merci à tous pour vos réponses.

Dan


Oups ... j'ai oublié de convertir le premier décalage ^^
donc il fallait lire:

DWORD* temp2 = *(*temp1 + 0x3f);

Désolé,

Pierre
Pierre


Falk Tannhäuser
Le #310479
Fabien LE LEZ schrieb:
On Tue, 14 Aug 2007 04:06:35 +0200, "Dan1024"
autant l'asm c'est limpide autant
j'ai de la peine avec les reinterpret_cast.


C'est logique : la manière de penser et de faire les choses utilisée
en assembleur x86, est très différente de celle utilisée en C++. Du
coup, les méthodes assembleur s'appliquent mal au C++.


En C++ ou C "idiomatique", l'équivalent du code posté aurait
probablement consisté à dé-référencer des pointeurs sur des struct dont
les champs sont d'autres pointeurs... Il est même possible que ce code
assembleur soit issu d'un compilateur C++, les offset (00000278h,
000000FCh, 24h) correspondant à des offset des champs dans des
différentes structures pointées.

Falk


Dan1024
Le #310478
From: "Falk Tannhäuser"
Il est même possible que ce code assembleur soit issu d'un compilateur
C++, les offset (00000278h, 000000FCh, 24h) correspondant à des
offset des champs dans des différentes structures pointées.


C'est exactement ca. Et rassurez vous ce n'est pas du tout
pour pirater un truc... Je rajoute juste des fonctionnalités ;)
(SDK incomplete)

Dan

Publicité
Poster une réponse
Anonyme