Les bases de l'asm

 

Introduction 

    Quoi de plus ardu que d'essayer de résumer l'asm pour n'en garder que l'essentiel. De plus, comment voulez-vous posséder un bon niveau de programmeur mais aussi d'analyste si des instructions vous font défaut? D'un autre côté, rien ne sert de se leurrer, peu sont ceux qui peuvent se vanter de connaître toutes les instructions sur le bout des doigts ainsi que toutes les astuces qui en découlent. C'est pourquoi je ne perdrais pas ici mon temps à détailler toutes les instructions ni à faire du plagia (en cherchant un peu, Google regorge de tutos plus ou moins bien expliqués et complets sur l'asm). Je vais simplement présenter brièvement l'asm et faire un bref rappel de quelques instructions qui me semblent intéressantes pour le cracking mais sans rentrer dans les détails techniques, ainsi que de quelques astuces utilisées avec celles-ci. Libre à vous de continuer votre apprentissage sur d'autres sites.

 

Les registres

    Les registres principaux sont : EAX, EBX,ECX, EDX, EDI, ESI, EBP, ESP, EIP et les Flags.

    Ce sont des petites zones de stockage logées dans le processeur auxquels il a un accès très rapide (beaucoup plus rapide qu'en mémoire).

    Ils ont tous une taille de 32 bits (4 bytes).

    EAX, EBX, ECX et EDX sont les registres de travail. La partie basse (les 16bits de poids fort) de chacun d'eux peut être utilisée directement mais reste une partie du registre de 32bits, c'est à dire que s'il l'on modifie AX (la partie basse de EAX), on modifiera EAX. En plus de cela, la partie basse peut être de nouveau séparée en 2 parties de 8bits (la partie haute AH et la partie basse AL pour AX, BH et BL pour BX, ...). De nouveau si l'on modifie l'une des 2 parties, c'est tout le registre qui est modifié (AX est modifié donc EAX aussi).   

    EDI et ESI servent principalement pour des instructions d'adressage (lors de traitements de chaînes de caractères par exemple) mais peuvent aussi servir de registres de travail.

    EBP et ESP sont des registres de pile, ESP désigne toujours le sommet de la pile. EBP permet de travailler dans la pile sans devoir utiliser ESP qu'il ne vaut mieux pas modifier.

    EIP désigne l'adresse de l'instruction courante.

    Le registre de Flags est un registre dont chaque bit (indicateur) indique un état. Les instructions arithmétiques, logiques et de comparaison modifient la valeur des indicateurs.

 

La pile

    La pile est un espace mémoire régit par le système LIFO (Last In First Out). La dernière valeur à avoir été empilée sera la première à être dépilée. Imaginez une pile d'assiettes : la dernière que vous avez déposée sur le paquet sera celle que vous reprendrez en première, c'est le principe de la pile. On y accède par des PUSH et des POP

   

Quelques instructions courantes   

    NOP (90h)

    La plus simple à expliquer : cette instruction ne fait rien! Vous le savez peut-être mais nous ne pouvons modifier la taille d'un programme sans des conséquences désastreuses. C'est là que cette instruction prend toute son utilité. Elle permet de supprimer une instructions sans modifier la taille du programme (si l'instruction à "effacer" tient sur plusieurs bytes remplacez autant de bytes que nécessaires par NOP).

 

    MOV destination, source

    Cette instruction copie la valeur de source dans destination. Les 2 opérandes doivent avoir la même taille. Il n'y peut y avoir au maximum qu'un accès mémoire par instruction. Si vous voulez par exemple mettre la valeur de [00401234] dans [00405678], vous devrez faire par exemple:
    MOV EBX , [401234]

    MOV [405678] , EBX    

mov eax , 45                ; Mettre 45 dans eax

   

    ADD destination, source

    Cette instruction additionne le contenu de destination à celui de source. Le résultat est placé dans destination.

mov eax,45

add eax,10                   ; eax <= eax (45)  + 10      donc eax vaudra 55

   

    SUB destination, source

    Cette instruction soustrait le contenu de source à celui de destination. Le résultat est placé dans destination.

mov eax,45

sub eax,5                      ; eax <= eax (45) - 5       donc eax vaudra 40

 

    INC destination

    Cette instruction incrémente destination d'une unité

mov eax,10

inc eax                        ; eax <= eax + 1

 

    DEC destination

    Cette instruction décrémente destination d'une unité

mov eax,10

dec eax                      ; eax <= eax - 1

 

    JMP label

    Modifie l'EIP en l'adresse désignée par label. Ce que l'on désigne par un saut.

jmp label

; instructions non exécutées

label:

; instructions à éxécuter

 

    PUSH source

    Place la valeur de source au sommet de la pile.

 

    POP destination

    Place la valeur au sommet de la pile dans destination.

mov eax,15

push eax                ; Place la valeur de eax (15) sur la pile

pop ebx                  ; Récupère la valeur au sommet de la pile (15, c'est celle que l'on vient de mettre) et la place dans ebx

 

    CMP destination, source

    Cette instruction effectue la soustraction de destination et source mais ne conserve pas le résultat. Seuls les Flags sont modifiés.

    Le ZF (Zero Flag) est positionné à 1 si le résultat de la soustraction est nul (donc que les 2 valeurs sont égales).

    Le CF (Carry Flag) est positionné à 1 si le résultat ne tient pas sur 32bits (donc que le résultat est est inférieur à 0).

    Le SF (Sign Flag) est positionné à 1 si le résultat est négatif.

    Le OF (Overflow Flag) est positionné à 1 si le résultat a provoqué un débordement (lorsqu'on travaille avec des nombres signés).

mov eax,5

cmp eax,10                 ; eax < à 10  => ZF=0, SF=1 et CF=1

cmp eax,2                   ; eax > à 2  => ZF=0, SF=0 et CF=0

cmp eax,5                    ; eax = 5  => ZF=1, SF=0 et CF=0

  

 

  Les sauts conditionnels

    Fonctionne comme un JMP mais saute en fonction de l'état de certains bits du registre de Flags.

    Les différents sauts sont :

Mnémo

Saut si  …

Indicat. testés
JA

Supérieur

CF = 0 et ZF = 0
JAE

Supérieur ou égal

CF = 0
JB

Inférieur

CF = 1
JBE

Inférieur ou égal

CF = 1 ou ZF = 1
JC

CF = 1

CF = 1
JCXZ

Registre CX à 0

CX = 0
JE

Egal

ZF = 1
JG*

Supérieur

ZF = 0 et SF = OF
JGE*

Supérieur ou égal

SF = OF
JL*

Inférieur

SF<>OF
JLE*

Inférieur ou égal

ZF = 1 ou SF<>OF
JNA

Pas supérieur

CF = 1 ou ZF = 1
JNAE

Pas supérieur ni égal

CF = 1
JNB

Pas inférieur

CF = 0
JNBE

Pas inférieur ni égal

CF = 0 et ZF = 0
JNC

CF = 0

CF = 0
JNE

Pas égal

ZF = 0
JNG*

Pas supérieur

ZF = 1 et SF<>OF
JNGE*

Pas supérieur ni égal

SF<>OF
JNL*

Pas inférieur

SF = OF
JNLE*

Pas inférieur ni égal

ZF = 0 et SF = OF
JNO

OF = 0

OF = 0
JNP

PF=0

PF = 0
JNS*

SF=0

SF = 0
JNZ

ZF=0

ZF = 0
JO*

OF=1

OF = 1
JP

PF=1

PF = 1
JPE

Parité paire

PF = 1
JPO

Parité impaire

PF = 0

* Utiliser avec des nombres signés

 

mov eax,2

cmp eax,5

je lblfin            ; On ne saute pas puisque 2<>5

; Instructions qui vont être exécutées puisque eax <> 5 et donc on ne sautera pas

lblfin:

 

Les opérations logiques

 

    Les opérations logiques travaillent toutes bit à bit. Elle peuvent servir à comparer deux valeurs, tester certains bits mais aussi à forcer certains bits à une certaine valeur.

 

    AND destination, source

    Le AND effectue un ET LOGIQUE de destination et source. Le AND peut se traduire par une multiplication de bits.

    Voici la table logique : 

A

B

AND

0

0

0

0

1

0

1

0

0

1

1

1

   

mov al,14h         ; 00010100b

mov bl,2Fh         ; 00101111b

and al,bl              ; 00000100b  = 04h   => al va prendre la valeur 04h

 

    OR destination, source

    Le OR effectue un OU inclusif de destination et source. Le OR peut se traduire par une addition de bits sans report.

   

A

B

OR

0

0

0

0

1

1

1

0

1

1

1

1

 

mov al,14h          ; 00010100b

mov bl,2Fh         ; 00101111b

or al,bl                 ; 00111111b = 3Fh => al va prendre la valeur 3Fh

 

    XOR destination, source

    Le XOR effectue un OU inclusif de destination et source. Le XOR peut se traduire par une addition de bits avec report.

A

B

XOR

0

0

0

0

1

1

1

0

1

1

1

0

 

mov al,14h          ; 00010100b

mov bl,2Fh         ; 00101111b

xor al,bl               ; 00111011b = 3Bh => al va prendre la valeur 3Bh

 

   

    Voilà, ce n'est évidemment pas complet mais j'espère que cela vous permettra de commencer mes cours sans trop galérer.

    Si vous voulez compléter votre apprentissage, et je vous conseille de le faire quitte à garder les liens et à les utiliser par après, voici quelques sites non exhaustifs qui vous permettrons d'apprendre les bases (plus ou moins par ordre de difficulté) :

http://benoit-m.developpez.com/assembleur/tutoriel Les bases de l'asm
http://asm.developpez.com/intro/index.php Aussi
http://www.developpez.com/ Un site regroupant les bases de beaucoup de langages
http://www.deamoncrack.host.sk/Pages/cours-asm.htm Si vous n'avez pas trop de temps et que vous avez juste besoin d'un rappel
http://www.chez.com/pageasm/ Intro à la programmation win32 mais aussi DOS
http://win32assembly.online.fr/ Le site de référence pour la programmation win32 mais en anglais
les opcodes Très complet mais en anglais

 

 

Bon crack,                         

Crisanar         

         [ << Intro ] [ Intro à Olly >> ]

 

Dernière mise à jour le 04/10/2004 16:45