Obligement - L'Amiga au maximum

Lundi 26 juin 2017 - 07:13  

Translate

En De Nl Nl
Es Pt It Nl


Rubriques

 · Accueil
 · A Propos
 · Articles
 · Galeries
 · Glossaire
 · Hit Parade
 · Liens
 · Liste jeux Amiga
 · Quizz
 · Téléchargements
 · Trucs et astuces


Articles

 · Actualité (récente)
 · Actualité (archive)
 · Comparatifs
 · Dossiers
 · Entrevues
 · Matériel (tests)
 · Matériel (bidouilles)
 · Points de vue
 · En pratique
 · Programmation
 · Reportages
 · Tests de jeux
 · Tests de logiciels
 · Tests de compilations
 · Articles divers

 · Articles in english
 · Articles in other languages


Twitter

Suivez-nous sur Twitter




Liens

 · Sites de téléchargements
 · Associations
 · Pages Personnelles
 · Moteurs de recherche
 · Pages de liens
 · Constructeurs matériels
 · Matériel
 · Autres sites de matériel
 · Réparateurs
 · Revendeurs
 · Presse et médias
 · Programmation
 · Développeurs logiciels
 · Logiciels
 · Développeurs de jeux
 · Jeux
 · Autres sites de jeux
 · Scène démo
 · Divers
 · Informatique générale


Jeux Amiga

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


Trucs et astuces

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


Glossaire

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


Partenaires

Annuaire Amiga

Amedia Computer

Relec

Hit Parade


Soutien

N'hésitez pas à soutenir le projet Obligement



Contact

David Brunet

Courriel

 


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 une 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.

Sherlock

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 "hunks", 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" symboles s'ils sont présents). Un point pratique est l'apparition d'un "hit enforcer" ; vous notez l'offset, 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 device 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 "hunks" 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 à l'offset 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.


[Retour en haut] / [Retour aux articles]