Je compile un fichier d'assemblage TASM (à exécuter en mode protégé) avec cette fonction qui utilise des variables globales:Hex rayons à défaut de décompiler le code assembleur en utilisant un tableau
array dd 0,29535,29535,29096,27889,35168,39271,24798,29855,29772,38197,22395
dd 56219,56131,56121,56133,24256,24229,24412,51616,37038,28755,29069,28107,46700,31766,30517,35050,33790,00000,0000,64000,64000,64000,64000,64000
dd 32190,10299,64000,25841,9185,25203,24473,25203,39396,64000,64000,64000,64000,64000,64000,64000,64000,15266,50285,25477,64000,64000
dd -1
adderVar EQU 0255442
result dd ?
modifyList proc near
PUSHAD
PUSH DS ES
mov edi,offset array
mov eax,adderVar
e:
cmp dword ptr [edi],-1
je f
add dword ptr eax,[edi]
mov dword ptr [edi],eax
add edi,4
jmp e
f:
mov [result],eax
POP ES DS
POPAD
ret
modifyList endp
Ce code ajoute un fixe la valeur (adderVar) au premier élément du tableau, puis la somme de tous les éléments précédents aux suivants, en s'arrêtant à un délimiteur de fin (-1).
Chargement du fichier OBJ dans l'IDA et la création d'un fichier C en utilisant Hex-Rays génère ce code:
int dword_3408E = 0; // weak
int dword_34092 = 29535; // weak
int dword_34096 = 29535; // weak
int dword_3409A = 29096; // weak
int dword_3409E = 27889; // weak
int dword_340A2 = 35168; // weak
int dword_340A6 = 39271; // weak
int dword_340AA = 24798; // weak
int dword_340AE = 29855; // weak
int dword_340B2 = 29772; // weak
int dword_340B6 = 38197; // weak
int dword_340BA = 22395; // weak
int dword_340BE = 56219; // weak
int dword_340C2 = 56131; // weak
int dword_340C6 = 56121; // weak
int dword_340CA = 56133; // weak
int dword_340CE = 24256; // weak
int dword_340D2 = 24229; // weak
int dword_340D6 = 24412; // weak
int dword_340DA = 51616; // weak
int dword_340DE = 37038; // weak
int dword_340E2 = 28755; // weak
int dword_340E6 = 29069; // weak
int dword_340EA = 28107; // weak
int dword_340EE = 46700; // weak
int dword_340F2 = 31766; // weak
int dword_340F6 = 30517; // weak
int dword_340FA = 35050; // weak
int dword_3411A = 64000; // weak
int dword_3411E = 32190; // weak
int dword_34126 = 64000; // weak
int dword_3412A = 25841; // weak
int dword_3412E = 9185; // weak
int dword_34132 = 25203; // weak
int dword_34136 = 24473; // weak
int dword_3413A = 25203; // weak
int dword_3415E = 64000; // weak
int dword_34162 = 15266; // weak
int dword_34166 = 50285; // weak
int dword_3417A; // weak
__int64 __usercall [email protected]<edx:eax>(__int64 [email protected]<edx:eax>)
{
int *v1; // [email protected]
signed int v2; // [email protected]
__int64 v4; // [sp-20h] [bp-20h]@1
v4 = a1;
v1 = &dword_3408E;
v2 = 255442;
while (*v1 != -1)
{
v2 += *v1;
*v1 = v2;
++v1;
}
dword_3417A = v2;
return v4;
}
// 3408E: using guessed type int dword_3408E;
// 3417A: using guessed type int dword_3417A;
Il semble que les valeurs 25477,64000,64000 et -1 delimiter sont absents de la variables, et que le code C suppose que tous les int seront adjacents. Quelqu'un aurait-il une idée de ce qui cause l'échec des rayons Hex, et comment modifier le code d'assemblage pour avoir une sortie C appropriée?
Avec 'add dword ptr eax, [édi]; mov dword ptr [edi], eax 'écrivez-vous simplement une somme courante dans le tableau? –
Oui, merci d'avoir repéré ça, je vais éditer ma question. – franck
Il n'y a pas de code C équivalent au code d'assemblage. Généralement, la décompilation en C ne peut fonctionner que si elle a été compilée à partir de C, et même alors, il y a beaucoup de raisons pour lesquelles cela pourrait échouer. Vous pourriez obtenir de meilleurs résultats en alignant le tableau, car un compilateur C lui donnerait une adresse qui est un multiple pair de 4. Supprimer toutes les instructions push et pop pourrait également aider. L'enregistrement et la restauration des registres de segments sont inutiles, mais la restauration d'enregistrement des autres registres peut ne pas l'être. –