Suivez-nous sur X
|
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z,
ALL
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
A propos d'Obligement
|
|
David Brunet
|
|
|
|
Test de Sherlock
(Article écrit par Kamel Biskri et extrait d'Amiga News - février 1995)
|
|
Un désassembleur symbolique
Sherlock est un outil servant à produire de l'assembleur à partir de fichiers binaires (le
plus souvent des exécutables). Someware nous cite l'utilité d'un tel programme, à savoir
l'apprentissage (rien de tel que l'exercice), maintenance de logiciels qui ne sont plus mis à
jour et qui plantent sur les nouveaux systèmes (pour un usage personnel bien sûr !), optimisation
de logiciels dont on n'a pas le source (même remarque), etc.
Installation
Aucune difficulté rencontrée, il suffit de suivre les conseils d'installation de la documentation et ça
fonctionne. Je ne m'éternise pas sur la documentation, ayant moi-même reçu une préversion de
celle-ci. Néanmoins, Sherlock est la version définitive. A noter tout de même qu'une certaine
connaissance en assembleur est la bienvenue, du moins pour ceux qui désirent affiner le travail
jusqu'à obtenir un résultat optimal. Pour les personnes disposant de peu de mémoire, une version
allégée de Sherlock existe ; ceux ayant une machine à base de 68000 ne doivent pas s'impatienter
car pour eux le temps de désassemblage sera plus long. Je tiens tout de même à signaler que la
documentation est suffisamment explicite pour un bon usage du produit, notamment grâce à un
exemple de travail suivi pas à pas.
Le vif du sujet
Regardons sans plus tarder les fonctions de ce produit : désassemblage des exécutables sauf
ceux contenant des "hunk overlays" (peu utilisés mais cela existe, Cf. Deluxe Paint), possibilité de
désassembler des bibliothèques Amiga (fichiers *.library dans Libs:), reconnaissance des
processeurs 680x0 (inclus EC pour le 68030 et EC, LC pour le 68040) et des coprocesseurs 68881 et 68882 ainsi
que la MMU (68851). Évidemment, le désassemblage n'est pas parfait du premier coup. Si Sherlock
rencontre un opérande qui fait un saut relatif par rapport à un registre fixe et un autre
variant, ce dernier n'est pas connu. Ainsi, une partie du code sera désassemblée en tant que
donnée. Cela a été prévu et vous disposez d'un langage de commande simple mais puissant (fichier
ASCII), qui vous permet de dire : attention ! Là il y a du code (nouvelle séquence). De ce fait,
Sherlock continuera son travail jusqu'à la rencontre d'une fin de séquence.
Ce langage de commande vous permet d'affiner au maximum le désassemblage. Par exemple, les
compilateurs C créent souvent une table pointée par un registre d'adresse, souvent A4 d'ailleurs.
Cette table contient des pointeurs sur des séquences de code. Le langage interne à Sherlock
vous permet de lui dire : attention ! Ici se situe une table de pointeurs sur des nouvelles
séquences (donc à désassembler en tant que code). Cela se fait avec une ligne de commande.
Vous allez me dire oui mais il y a donc un travail personnel à mettre en oeuvre. Tout à fait,
le programme parfait n'est pas encore né, tout au moins dans sa version automatique et optimale.
Néanmoins, les spécificités de Sherlock nous amènent à produire un travail presque parfait mais
avec un peu de réflexion et de temps.
Ce produit se distingue vraiment par le désassemblage
symbolique des appels aux bibliothèques Amiga. Pour cela, jeter un coup d'oeil à l'exemple. Un
petit mot tout de même : jsr -552(a6) deviendra si A6 pointe ExecBase, jsr _LVOOpenLibrary(a6).
Ceci ne se fait (malheureusement pour nous) pas de manière ultime. Je m'explique : il se peut que
Sherlock ne puisse pas déterminer qui appelle une routine X. Ne connaissant pas le contexte, il
ne pourra pas mettre le symbole approprié. Vous pouvez donc lui dire qui appelle la fonction,
ainsi il pourra y mettre un symbole. Pour cela, une certaine gymnastique intellectuelle est à
fournir. Mais la documentation est là pour vous faire comprendre comment y parvenir.
La seule chose que je regrette c'est que ce cheminement de pensée ne soit pas automatisé (utopie ?). Une
instruction est toutefois présente pour facilité la symbolisation des appels de bibliothèques
(Cf. exemple). Ce désassemblage symbolique peut se faire sur n'importe quelle bibliothèque si vous
en possédez les fichiers "*.fd" qui sont en général fourni avec la partie de la bibliothèque
"réservée" aux développeurs. Un petit exemple rapide sous Shell :
5.> sherlock c:sysihack ram:t Sherlock v1.1.
(c)Copyright 1993 Fabien Campagne, Someware,
Tous Droits Réservés.
Première Passe.
Données du segment 0
Données du segment 1
Données du segment 2
Création du fichier ram:t/sysihack1.i
Création du fichier ram:t/sysihack1.s
Création du fichier ram:t/sysihack2.i
Création du fichier ram:t/sysihack2.s
Création du fichier ram:t/sysihack3.i
Création du fichier ram:t/sysihack3.s
Seconde Passe.
Fin de Sherlock
|
Les fichiers *.i contiennent les includes comme suit :
Label4: equ $4
XREF h1o0
XREF h2o2e
XREF h2o24
XREF h2o12
XREF h2o0
; exec.library
_LVOSupervisor EQU -30
_LVOexecPrivate1 EQU -36
_LVOexecPrivate2 EQU -42
_LVOexecPrivate3 EQU -48
_LVOexecPrivate4 EQU -54
_LVOexecPrivate5 EQU -60
_LVOexecPrivate6 EQU -66
etc.
|
Les fichiers *.s sont les sources des différents segments, ils contiennent du code ou des données ou les deux, par exemple :
INCLUDE "sysihack1.i"
; sysihack1.s automatiquement généré par Sherlock 1.1.
; segment 0: chargé à début=797c010, fin=797e7b0.
; segment 1: chargé à début=790a850, fin=790a8d4.
; segment 2: chargé à début=288f0, fin=28928.
SECTION "",CODE
h0o0: suba.w #$5c,a7
movem.l a2-a6/d2-d3,-(a7)
lea (h1o0).l,a4
movea.l ($4).w,a1
move.l a1,$0(a4)
lea h0o612(PC),a1
movea.l $0(a4),a6
moveq #36,d0
jsr _LVOOpenLibrary(a6)
move.l d0,$28(a7)
; en mettant Lib $28(a7)="dos.library"Sherlock
; sera capable d'un meilleur désassemblage
; symbolique.
beq.w h0o606
suba.l a1,a1
jsr _LVOFindTask(a6)
movea.l d0,a5
movea.l d0,a0
move.l $ac(a0),d1
asl.l #$2,d1
movea.l d1,a3
move.l a3,d0
bne.w h0o484
lea $5c(a5),a2
movea.l a2,a0
jsr _LVOWaitPort(a6)
movea.l a2,a0
jsr _LVOGetMsg(a6)
move.l d0,$80(a4)
etc.
|
Sherlock crée également deux autres fichiers "sysihack_info" et "sysihack_dmf". Ils ressemblent à ceci :
Sherlock v1.1 a généré ce fichier d'information pour votre agrément.
Bibliothèques partagées ouvertes par les parties désassemblées de l'exécutable :
exec.library
intuition.library
Indication sur la correspondance avec les processeurs :
MC68000: oui
MC68020/MC68030: non
MC68040: non
MC68881/MC68882/MC68851: non
# Sherlock automatic DMakeFile generation.
SOURCES = sysihack1.s sysihack2.s sysihack3.s
EXE = sysihack
OBJ = $(SOURCES:*.s:*.o)
all: $(EXE)
$(OBJ) : $(SOURCES)
phxass -o%(left) -n %(right)
$(EXE) : $(OBJ)
phxlnk -o%(left) %(right)
|
Le premier, comme vous pouvez le constater, donne des informations sur les processeurs pour lesquels
le programme a été compilé, le second vous permet grâce aux utilitaires livrés avec Sherlock (Phxass
l'assembleur et Dmake le Make) de réassembler les différents fichiers et ainsi produire un
exécutable fonctionnel.
Vous pouvez également grâce aux fichiers d'entrée, mettre des commentaires, changer le nom de
symboles (Sherlock reconnaît les "hunks symbols" (symboles de segment) s'ils sont présents). Un point pratique est
l'apparition d'un "hit enforcer" ; vous notez le décalage, et en commentaire vous écrivez "Hit Enforcer".
Ensuite, sur le source, vous apercevrez le nom de l'instruction qui génère un problème. Libre
à vous de rectifier (pas mal pour le débogage). Pour les plus acharnés d'entre vous, il est
possible de désassembler la mémoire ou des secteurs d'un périphérique logique Amiga (disquette ou disque dur).
Pour conclure
Quelques points de détail : il est dommage que le texte ne soit pas mis en chaînes de
caractères, surtout pour ce qui veulent faire des traductions.
dc.l $43616e63 ; 'Canc'
dc.l $656c0000 ; 'el..'
|
Ci-dessus, voici la traduction de "Cancel.." générée par Sherlock. Un dc.b "Cancel.." serait
plus lisible et facilement modifiable. Une option permettant d'avoir tous les segments dans un seul
fichier n'aurait pas été superflue, un numéro de version et une aide dans la ligne de commande
non plus. Comme suit version "nomdeprogramme" et Sherlock? qui donnerait les paramètres. Un
désassemblage des puces spécifiques Amiga, ne serait pas de trop pour ceux d'entre vous qui désirent
sourcer des démos (color00 et plus parlant que $dff180).
Mis à part ces petits manques, il faut reconnaître qu'à l'usage, Sherlock se trouve être un
très bon produit. Il permet d'aller très loin dans la symbolisation, ce qui entraîne une
meilleure compréhension du logiciel sourcé. Je vous le recommande donc, d'autant que son prix
est raisonnable. En attendant de nouvelles spécificités, bon désassemblage ! Fin de séquence RTS.
PS : aidez-vous d'un débogueur comme Monam, il vous permettra de savoir si vous avez affaire à
du code ou à des données, tout simplement en chargeant le programme et en vous positionnant au
décalage qui vous semble ambigu.
Nom : Sherlock 1.1.
Auteur : Fabien Campagne.
Éditeur : Someware.
Genre : desassembleur.
Date : 1995.
Configuration minimale : Amiga OCS, 68000, 512 ko de mémoire, AmigaOS 2.0.
Licence : commercial.
Prix : 590 FF.
|
Soutenez le travail de l'auteur
|
|
|