Retrouver le code source (Delphi ou autre) d'un code ASM

[Velcro]

Bonjour,

J'ai besoin de récupérer une partie de code source d'un programme dont l'auteur a abandonné le projet et reste injoignable. À partir du programme Delphi, j'ai pu obtenir le code assembleur de la procédure voulue.

Comme je n'arrive pas bien à lire l'assembleur, quelqu'un peut-il me le traduire en autre chose ?

Le code concerne une boite de dialogue dans laquelle un champ de saisie permet de rentrer une clé, un autre permet de lire une clé, et un bouton permet de transformer la première vers la deuxième.

S'il y a besoin d'autres parties de code assembleur, je peux les fournir.

Merci !

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
004AB11C   55                     push    ebp
004AB11D   8BEC                   mov     ebp, esp
004AB11F   33C9                   xor     ecx, ecx
004AB121   51                     push    ecx
004AB122   51                     push    ecx
004AB123   51                     push    ecx
004AB124   51                     push    ecx
004AB125   51                     push    ecx
004AB126   51                     push    ecx
004AB127   51                     push    ecx
004AB128   8955F8                 mov     [ebp-$08], edx
004AB12B   8945FC                 mov     [ebp-$04], eax
004AB12E   33C0                   xor     eax, eax
004AB130   55                     push    ebp
004AB131   68E7B14A00             push    $004AB1E7
 
***** TRY
|
004AB136   64FF30                 push    dword ptr fs:[eax]
004AB139   648920                 mov     fs:[eax], esp
004AB13C   8D55F0                 lea     edx, [ebp-$10]
004AB13F   8B45FC                 mov     eax, [ebp-$04]
 
* Reference to control Edit1 : TEdit
|
004AB142   8B80D8020000           mov     eax, [eax+$02D8]
 
* Reference to: controls.TControl.GetText(TControl):TCaption;
|
004AB148   E8F3A3F8FF             call    00435540
004AB14D   8B45F0                 mov     eax, [ebp-$10]
004AB150   8D55F4                 lea     edx, [ebp-$0C]
 
* Reference to: sysutils.Trim(AnsiString):AnsiString;
|
004AB153   E898EBF5FF             call    00409CF0
004AB158   8B55F4                 mov     edx, [ebp-$0C]
004AB15B   8B45FC                 mov     eax, [ebp-$04]
 
* Reference to control Edit1 : TEdit
|
004AB15E   8B80D8020000           mov     eax, [eax+$02D8]
 
* Reference to: controls.TControl.SetText(TControl;TCaption);
|
004AB164   E807A4F8FF             call    00435570
004AB169   8D55EC                 lea     edx, [ebp-$14]
004AB16C   8B45FC                 mov     eax, [ebp-$04]
 
* Reference to control Edit1 : TEdit
|
004AB16F   8B80D8020000           mov     eax, [eax+$02D8]
 
* Reference to: controls.TControl.GetText(TControl):TCaption;
|
004AB175   E8C6A3F8FF             call    00435540
004AB17A   8B45EC                 mov     eax, [ebp-$14]
 
* Reference to: system.@LStrLen:Integer;
|
004AB17D   E8AE8EF5FF             call    00404030
004AB182   83F805                 cmp     eax, +$05
004AB185   7C2D                   jl      004AB1B4
004AB187   8D55E4                 lea     edx, [ebp-$1C]
004AB18A   8B45FC                 mov     eax, [ebp-$04]
 
* Reference to control Edit1 : TEdit
|
004AB18D   8B80D8020000           mov     eax, [eax+$02D8]
 
* Reference to: controls.TControl.GetText(TControl):TCaption;
|
004AB193   E8A8A3F8FF             call    00435540
004AB198   8B45E4                 mov     eax, [ebp-$1C]
004AB19B   8D55E8                 lea     edx, [ebp-$18]
 
* Reference to : TClientSocket._PROC_00487ED4()
|
004AB19E   E831CDFDFF             call    00487ED4
004AB1A3   8B55E8                 mov     edx, [ebp-$18]
004AB1A6   8B45FC                 mov     eax, [ebp-$04]
 
* Reference to control Edit2 : TEdit
|
004AB1A9   8B80E0020000           mov     eax, [eax+$02E0]
 
* Reference to: controls.TControl.SetText(TControl;TCaption);
|
004AB1AF   E8BCA3F8FF             call    00435570
004AB1B4   33C0                   xor     eax, eax
004AB1B6   5A                     pop     edx
004AB1B7   59                     pop     ecx
004AB1B8   59                     pop     ecx
004AB1B9   648910                 mov     fs:[eax], edx
 
****** FINALLY
|
004AB1BC   68EEB14A00             push    $004AB1EE
004AB1C1   8D45E4                 lea     eax, [ebp-$1C]
 
* Reference to: system.@LStrClr(String;String);
|
004AB1C4   E8E78BF5FF             call    00403DB0
004AB1C9   8D45E8                 lea     eax, [ebp-$18]
 
* Reference to: system.@LStrClr(String;String);
|
004AB1CC   E8DF8BF5FF             call    00403DB0
004AB1D1   8D45EC                 lea     eax, [ebp-$14]
004AB1D4   BA02000000             mov     edx, $00000002
 
* Reference to: system.@LStrArrayClr;
|
004AB1D9   E8F68BF5FF             call    00403DD4
004AB1DE   8D45F4                 lea     eax, [ebp-$0C]
 
* Reference to: system.@LStrClr(String;String);
|
004AB1E1   E8CA8BF5FF             call    00403DB0
004AB1E6   C3                     ret
 
 
* Reference to: system.@HandleFinally;
|
004AB1E7   E94086F5FF             jmp     0040382C
004AB1EC   EBD3                   jmp     004AB1C1
 
****** END
|
004AB1EE   8BE5                   mov     esp, ebp
004AB1F0   5D                     pop     ebp
004AB1F1   C3                     ret

[Obsidian]

Bonjour,

Envoyé par Velcro

Comme je n'arrive pas bien à lire l'assembleur, quelqu'un peut-il me le traduire en autre chose ?

D'abord, il n'existe pas un assembleur normalisé mais il y en a autant que de familles de micro-processeurs. Ensuite, ce n'est pas bijectif : chaque compilateur produit son code exécutable final en fonction de ce qu'il lit et, à cette occasion, résout la majorité des symboles et formules du code source. Tu ne peux donc pas remonter complètement d'un code assembleur vers le code source original.

Le code concerne une boite de dialogue dans laquelle un champ de saisie permet de rentrer une clé, un autre permet de lire une clé, et un bouton permet de transformer la première vers la deuxième.

S'il y a besoin d'autres parties de code assembleur, je peux les fournir.

Que cherches-tu à savoir exactement ? Tu veux uniquement qu'on te décrive ce que fait ton code ou tu as une autre idée en tête ?

Parce qu'en l'occurrence, ce code ne fait qu'appeler dans l'ordre toutes les routines que tu as citées toi-même : affichage du champs de saisie, du bouton, etc. Il n'y aucune référence interne ni saut à l'intérieur de la routine, sauf pour la gestion des exceptions avec Try Catch Finally.

[Velcro]

Je souhaite savoir quel est l'algorithme qui est utilisé pour passer d'un champ à l'autre. Le deuxième champ contient un code servant à désinstaller une application sur des postes, et comme cette application doit être désinstallée de tout un parc, j'aimerais éviter d'avoir à saisir le code pour chaque ordinateur.

EDIT: je n'y connais rien en assembleur (au mieux je sais ce que signifie mov eax, ebx), et j'espèrerais qu'on puisse trouver l'agorithme quelque part dans ce code.

[Obsidian]

Hélas non. Ce code assembleur est très court, même s'il paraît fourni par rapport au code source d'un langage de plus haut niveau.

Les premières lignes sont le prologue classique de l'ouverture d'un cadre de pile et de l'entrée dans une fonction : on empile EBP puis on sauvegarde ESP (le pointeur de pile) dans EBP pour pouvoir ramener cette pile dans son état initial en restaurant ce pointeur en cas de pépin (comprendre : une exception). « XOR ecx,ecx » met ECX à zéro et les « push ECX » réservent et nettoient simultanément 28 octets dans la pile pour les variables locales.Les « mov » suivants servent à sauvegarder les paramètres de la fonction, passés initialement dans les registres EAX et EDX. Un nouveau « push EBP » permet de remonter plusieurs cadres de pile en cascade si besoin et, enfin, le « push 004AB1E7 » correspond à l'adresse de ton « Finaly » tout en bas de ton code. En tête de pile, un simple « ret » nous y emmènera directement au lieu de quitter la fonction.

Ce prologue est la section la plus longue de ton programme et pourtant, il ne correspond encore à rien ! C'est en gros ce qui est produit à partir du moment où tu as écrit « BEGIN ». Tout le reste du code correspond à la gestion de tes objets et tu vois qu'à chaque fois, le code est ridicule : un registre chargé, un appel à une fonction extérieure et c'est à peu près tout.

Ton désassembleur a le bon goût de te mettre en commentaire les appels auquels chaque section correspond. Tu peux presque les considérer, donc, comme le code source original !

Tout cela est dû au fait qu'on est en présence d'un MVC et de programmation orientée objet : les fonctions qui nous intéressent sont considérées comme des méthodes ou fonction-membres de ces dits objets et la routine que tu as désassemblée ne fait que les invoquer. Tout le travail se fait donc automatiquement et à un autre endroit.

Question subsidiaire : de quel logiciel s'agit-il ?

En outre, le MVC fait que tes objets sont sollicités lorsqu'un événement extérieur au programme se produit, comme un clic de la part de l'utilisateur. Dans ce cas, c'est le système d'exploitation, puis le framework utilisé, qui vont automatiquement appeler de leur propre chef une fonction de callback définie à l'avance, et parfois même directement à la compilation.

Il n'y a plus qu'à trouver la bonne routine.

[Velcro]

Merci pour les explications !

Peut-être que la routine qui génère le code est cachée derrière "TClientSocket._PROC_00487ED4".

Le programme d'appelle IACA mais n'a pas de diffusion publique, vu qu'il sert uniquement au sein des établissements scolaires.

De toute façon je l'ai en grande partie supprimé via des scripts, mais j'aurais aimé connaître l'algo... juste pour le fun.

[Obsidian]

S'agit-il de ceci ? : http://crdp.ac-reims.fr/iaca/