Entrez les termes que vous recherchez. Envoyer un formulaire de recherche

Les instructions assembleur

Correspondance Hexa Assembleur

Instruction Assembleur

Détails des Instructions

Les instructions conditionnelles

Les registres

Exemple

Correspondance Hexa Assembleur

Il faut savoir que chaque instruction est codée en Assembleur, il suffit donc de remplacer ce code par un autre. Encore faut-il connaitre ces codes, c'est ce dont on va parler dans ce chapitre. Tout d'abord, on va commencer par les quelques instructions souvent utilisée:

Donc par exemple on veut changer un jne en un je, on va ouvrir le programme avec ollydbg et on recherche l'instruction que vous voulez changer. Une fois celle-ci trouvée, vous devriez avoir un truc du genre:JNE
Puisqu'on veut obtenir un je, on vas donc remplacer le 75 par un 74, assez simple non ?

Détails des instructions

La première instruction : MOV
Cette instruction vient de l'anglais "move" qui signifie déplacer mais attention, le sens de ce terme est modifié car l'instruction MOV ne déplace pas mais place tout simplement. Cette instruction nécessite deux opérandes (deux variables) qui sont la destination et la source. Ceux-ci peuvent être des registres généraux ou des emplacements mémoire. Cependant, les deux opérandes ne peuvent pas être toutes les deux des emplacements mémoire. De même, la destination ne peut pas être ce qu'on appelle une valeur immédiate (les nombres sont des valeurs immédiates, des valeurs dont on connait immédiatement le résultat) donc pas de MOV 10,AX. Ceci n'a pas de sens, comment pouvez-vous mettre dans le nombre 10, la valeur de AX ? 10 n'est pas un registre.
Une autre règle à respecter, les opérandes doivent être de la même taille donc pas de MOV AX,AL, cela me semble assez logique. On ne peut pas utiliser une valeur immédiate avec un registre de segment (MOV ES,5 = impossible mais MOV ES,AX = possible).
Quelques exemples :

MOV AL,CL (place le contenu de CL dans AL) donc si AL=5 et CL=10, nous aurons AL=10 et CL=10.

MOV CX,ES:[DI] (place dans CX, le contenu 16 bits de l'emplacement ES:[DI]). Donc si le word (le word est l'unité correspondant à 16 bits) ES:[DI]=34000, nous aurons CX=34000.

MOV CL,DS:[SI] (place dans CL, le contenu 8 bits (byte) de l'emplacement DS:[SI]). Donc si DS:[SI] (attention en 8 bits) = 12, CL vaudra 12.

Au sujet de ces emplacements mémoire, il faut que vous vous les représentiez comme des "cases" de 8 bits, comme le plus petit registre fait 8 bits, on ne peut pas diviser la mémoire en emplacements plus petits. On peut prendre directement 16 bits en mémoire (un word) ou carrément un dword (32 bits). Il est tres important de saisir cette notion. Un exemple concret : vous avez des livres sur une étagère, le livre se trouvant toute à gauche est le 1er de la liste, nous nous déplacons de gauche à droite. Un livre est un byte (8 bits), 2 livres sont un word (16 bits), 4 livres font un dword (32 bits). Si nous faisons MOV AX,ES:[DI], nous allons prendre 2 livres, en commencant par le livre se trouvant à l'emplacement DI et en prenant ensuite le livre se trouvant à l'emplacement DI+1 (l'emplacement suivant dans votre rangée de livre, 1 byte plus loin en mémoire).
Voici un autre exemple :
MOV EAX,ES:[DI] (place un dword depuis ES:[DI] dans EAX). C'est comme si on copiait 4 livres dans EAX.

Et quelques exemples incorrects :

MOV 1,10 (impossible et pas logique)

MOV ES:[DI],DS:[SI] (incodable malheureusement)

MOV ES,10 (incodable, il faut passer par un registre général donc MOV ES,AX ou MOV ES,CX mais pas de MOV ES,AL).

Ce qu'il faut retenir c'est que l'instruction MOV est comme le signe '=' MOV ES,CX c'est comme faire ES=CX.

Une autre instruction : JMP

JMP est une simplification pour exprimer le mot JUMP qui signifie sauter en anglais. JMP va servir dans le programme pour "passer" d'une opération à une autre, de sauter dans le programme à différents endroits pour effectuer d'autrest taches. Je ne vais pas m'attarder dans des explications sur le pointeur d'instruction mais sachez que chaque instruction est désignée par un emplacement en mémoire (défini par CS:[IP]). L'instruction JMP va donc modifier la valeur de IP et par conséquence changer d'instruction. On peut utiliser JMP avec des valeurs immédiates.
Exemples :
JMP 10 (il aura pour effet de passer, non pas à l'instruction qui se trouve à la ligne 10 , mais à l'emplacement mémoire 10. Une instruction n'est pas forcément de taille 1, certaines peuvent s'étaler sur plusieurs bytes.)

Il est plus simple d'utiliser des "étiquettes qu'on peut écrire sous la forme "ETIQUETTES:". Avec les étiquettes, il suffit d'écrire JMP ETIQUETTES pour arriver directement à l'instruction qui suit le étiquette. Un petit exemple de code:

DEBUT :
MOV AX,14
JMP DEBUT

Ce programme ne fait rien sinon placer continuellement 14 dans AX, on appelle cela une boucle. Nous verrons plus tard qu'il existe différents types de sauts.
Quelques instructions arithmétiques : ADD et SUB

ADD sert à additionner, et nécessite deux opérandes : une source et une destination. La destination prendra la valeur de source + destination. Les règles de combinaison sont les mêmes que pour MOV mais avec SUB et ADD, l'utilisation des registres de segment est impossible.
Exemples :

ADD AX,CX (si AX=10 et CX=20 alors nous aurons AX=30 et CX=20) ADD EAX,EBX ADD AX,-123 (l'assembleur autorise les nombres négatifs) SUB DI,12 Quelques exemples impossibles : ADD AX,CL (comme pour MOV, un 16 bits avec un 8 bits sont incompatibles) SUB ES:[DI],DS:[SI] ADD ES,13 (impossible car c'est un registre de segment)

À présent, nous abordons l'instruction PUSH qui signifie Pousser. Cette instruction permet de placer une valeur au sommet de la pile. PUSH doit être accompagné d'une valeur de 16 ou 32 bits (souvent un registre) ou d'une valeur immédiate.
Exemple 1:
PUSH AX
PUSH BX

En premier lieu, AX est placé en haut de la pile et ensuite BX est placé au sommet, AX est repoussé au deuxième rang.
Exemple 2:

PUSH 1230
PUSH AX

Nous plaçons dans la pile, la valeur 1230 (qui aurait pu être aussi un 32 bits) et ensuite AX, ce qui place 1230 au deuxième rang.
Passons maintenant à l'instruction de "récupération" qui se nomme POP (sortir-tirer). Cette instruction demande comme PUSH, une valeur de 16 ou 32 bits (seulement un registre). Elle prend la première valeur de la pile et la place dans le registre qui suit l'instruction.
Exemple 1:
Nous avions PUSH AX et PUSH BX et maintenant nous allons les sortir de la pile en utilisant
POP BX
POP AX

Nous retrouvons les valeurs initiales de AX et BX mais nous aurions eu aussi la possibilité de faire d'abord POP AX et POP BX, ce qui aurait placé dans AX, la valeur BX (1er dans la pile) et dans BX, la valeur AX (2ème).
Exemple 2:

La première partie était PUSH 1230 et PUSH AX. Nous allons placer dans CX, la valeur de AX (1er de pile) et dans DX, le nombre 1230 (2ème puisque "pilé" après)

POP CX
POP DX

Dans CX, nous avons la valeur de AX et dans DX, nous avons 1230.
La pile est très utile pour garder la valeur d'un registre que l'on va utiliser afin de le retrouver intact un peu plus loin. Souvent dans des routines, le programmeur doit utilise tout les registres mais leur nombre est limité (utilisation des registres au maximum = gain de vitesse). Le programmeur va donc utiliser les fonctions de la pile pour pouvoir utiliser les registres et garder leur valeur actuelle pour une utilisation ultérieure. Malheureusement les instructions de la pile ralentissent le programme, la pile étant de toute façon plus lente que les registres qui sont au coeur du CPU.

Instructions Assembleur

Cette liste non-exhaustive vient de Alligator27

********************************************************************************
                        | LES INSTRUCTIONS ASSEMBLEUR |
                        |              PAR            |
 			|          ALLIGATOR427	      |   09/96
*********************************************************************************

AAA	ajustement ascii de  apres une addition. Format BCD
AAD	ajustement ascii de  avant une division BCD
AAM	ajustement ascii de  apres une multiplication. Format BCD
AAS	ajustement ascii de  apres une soustraction.
ADC	addition avec retenue 
ADD	addition sans retenue
AND	operation logique ET
ARPL	ajuste le niveau du privilege (mode protégée)
BOUND	teste un nombre par rapport a des limites
BSF	cherche 1 bit de droite a gauche
BSR	"  "   "   "  "  gauche a droite
BSWAP	conversion d'un registre en un format INTEL
BT	charge 1 bit en CF
BTC	" "  "   "   "  "  et complement
BTR	" " " " "  " " " " puis le met a 0 dans la source
BTS	" " " " " " " " " " " " " " " " "1 " " " " "" "  "
CALL	appel de sous programme
CBW	convertit l'octet signé de  en un mot dans 
CDQ	convertit le mot signé de EAX en un quadruple mot dans 
CLC	mets l'indicateur a 0 dans CF
CLD	" " " " "  " " " " " " " " DF
CLI	" " " " " " " " "  " " " " IF
CLTS	mets a 0 l'indicateur de changement de contexte Task-Switch-Flag
	mode protégée.
CMC	complemente l'indicateur CF
CMP	comparaison logique
CMPS[b][w] compare des chaines de caracteres
CMPSD	compare des chaines de caractere 80386()
CMPXCHG	compare l'accumulateur avec AL, AX, ou EAX
CWD	convertit le contenu signe de AX en un double mots DX:AX
CWDE	"  " " " " "" " "" " " " " " " " "" " " " " " " "  dans EAX
DAA	ajustement decimal de AL apres une addition BCD
DAS	"  " " " " " " " " " " " " " " " " soustraction BCD
DEC	decrementation 
DIV	division non signee
ENTER	construit un cadre de pile pour une procedure de haut niveau.
ESC	acces pour le coprocesseur
HLT	arret du processeur en attente d'un evenement externe
IBTS 	insere une chaine de bits (mode protegee)
IDIV	division signée
IMUL	multiplication signée
IN	lit un octet ou mot sur un port peripherique
INC	incrementation
INS[b][w] lit une chaine sur un port
INT 	interruption logiciel
INTO	active l'interruption 4 si l'indicateur OF est armé
INBD	efface le contenu de la mem cache du 486
INVLPG	exploitation du 486 en mode virtuel. multiprocesseur 8088
IRET	retour d'interruption
IRETD	" " " " " " " " " "" depuis un segment de 32bits
JA	branchement si superieur
JAE	 "" "  " " "" "  " ""  " ou egal
JB	branchement si inferieur
JBE	" " " " " " " " " " " " " ou egal
JC	branchement si CF est a 1
JNC	 " " " " ""  " ""  " "" 0
JCXZ	 " " " " " " " CX " " " " 
JECXZ	branchement si le registre ECX est a 0
JE	branchement en cas d'egalité
JG	branchement si arithmetiquement superieur ou egale
JMP	branchement a l'adresse indiquée
JNA	branchement si non superieur
JNAE	branchement si non superieur ou egal
JNB	branchement si non inferieur
JNBE	 "" " " " "" "  " " "" " " " ou egal
JNE	branchement en cas de non egalité
JNG	branchement si arithmetiquement non superieur
JNGE	 " " " " "" " " "" " " "  " ""  " " ""  "" " ou egal
JNL	branchement si non inferieur arithmetiquement
JNLE	branchaement si arithmetiquement non inferieur ou egale
JNO	branchement si l'indicateur OF est a 0
JNP	branchement si parité impaire (indicateur PF a 0)
JNS	branchement si positif
JNZ	branchement si different
JO	branchement si OF est a 1
JP	branchement si parité pair. indicateur PF est a 1
JPE	" " " " " " " " " " " " " " " " " " " " " " " " " 
JPO	" " " "" " " " " "  " "impair. " " " " " "" " " 0
JS	branchement si negatif
JZ	branchement en cas d'egalité
LAHF	charge en AH la partie basse du registre des indicateurs
LAR	charge le drout d'acces (mode protegée)
LDS	charge une adresse physique en DS: registre
LEA 	" " " " " " "" "  "effective
LEAVE	libere le cadre de pile, installer par entrée
LES	charge une adresse physique en ES: registre
LFS	" " " "" "  "" " "  " "" " " " FS: " '" "
LGDT	charge le registre de la table des descripteurs globaux (mode protégée)
LGS	charge une adresse physique en GS: registre
LIDT	charge le registre de la table des descripteurs d'interruption (MODE P)
LLDT	charge le registre de la table des descripteurs locaux
LMSW	" " "  le mot d'etat de la machine (mode protégée)
LOCK	verrouille le bus
LODS[b][w] charge AL/AX avec le contenu de DS:SI
LODSD	charge EAX avec le contenu de DS:SI
LOOP	branchament tant que CX #0
LOOPE	" " " "" " "  " ""  " " " "et ZF =1
LOOPNZ	" "  " " " " ""  "" "  " "" "  ""=0
LOOPZ	" " " " " " " "  " " ""  "" " "  =1
LSL	charge une limite de segment (mode protegée)
LSS	charge une adresse physique en SS: registre
LTR	charge le registre de tache (mode protégée)
MOV	tranfere une donnée
MOVS	transfere une chaine de caractere octet par octet ou mot pour mot de 
	DS:SI en ES:DI
MOVSD	transfere une chaine de caracteres double mot par double mot
MOVSX	tranfert avec extension de signe
MOVZX	tranfert avec une extension de 0
MUL	multiplication non signée
NEG 	negation par complement de 2
NOP	pas d'operation, voir utilisation de samsom pour ex:
NOT	operation logique NON complement a 1
OR	operation logique OU inclusif
OUT	transmets un octet ou mot a un periph
OUTS[b][w] transmets une chaine a un port
OUTSD	transmets un double mot a un port
POP	depile un mot
POPA	depile les registres
POPAD	depile tous les registres 32 bits
POPF	depile un mot et le tranfere vers le registre des indicateurs
POPFD	 " """ " DOUBLE MOT "" " " " " "" " " "" " " " " "" " " "  "" "  "" "  
	sur 32bits
PUSH:	empile une valeur
PUSHA	empile tous les registres
PUSHAD	" " " " " ""  " " ""  "" 32 bits
PUSHF	empile le registre des indicateurs
PUSHFD	empile le registre des indicateurs a 32bits
RCL	rotation a gauche a travers CF
RCR	rotation a droite a travers CF
REP[z][nz] prefixes de repetition
REP[e][ne] pour traiter les chaines de caractere en association  avec CX et 
	les indicateurs
RET[n][f] retour de sous programme
ROL	rotation a gauche
ROR	rotation a droite
SAHF	copie AH dans la partie basse du registre des indicateurs.
SAL	decalage a gauche avec introduction de 0
SAR	" " " "  " droite avec signe
SBB	soustraction non signée avec prise en compte de CF
SCAS[b][w] compare une chaine octet par octet ou mot par mot avec le contenu de 
	AL/AX
SCASD	compare une chaine double mot par double mot avec le contenu EAX
SETA	initialisation a 1 si CF et ZF sont a 0, sinon initialisation a 0
SETAE	" " " " " " " " " "  "" est a 0, sinon init. a 0
SETB	" " " " " " " " " " " " " " " 1, " " " " " " " " 
SETBE	"  " " " " " " " " " " CF ou ZF est a 1, sinon initialisation a 0
SETE	" " " " " " " " " " "  ZF est a 1, sinon init. a 0
SETG	" " " " " " " " " " " " " " " " 0 et SF=OF, sinon init. a 0
SETGE	 " " " " " " " " " " " SF=OF, sinon init. a 0
SETL	" " " " " " " " " " "  SF#OF, sinon init. a 0
SETLE	" " " " " " " " " " "  ZF est a 1 et SF#OF, sino init a 0
SETNA	" " " " " " " " " " "  CF ou ZF est a 1, init a 0
SETNAE	" " " " " " " " " " "  CF est a 1, sinon init. a 0
SETNB	" " ""  " " ""  ""  "" CF est a 0, sinon init a 0
SETNBE	" " " " " " " ""  " " "CF et ZF sont a 0, sinon, init. a 0
SETNE	" " " " " " " " " " "  ZF est a 0, sino init a 0
SETNG	" " " " " " " " " " " " " " " " 1 ou SF#OF, sinon init. a 0
SETNGE	" " " " " " ""  " " " "SF#OF, sinon init. a 0
SETNL	" " " " " " " " " " " "SF et OF sont egaux, sinon init. a 0
SETNLE	" " " " " " " " " " " "ZF est a 0 et SF=OF, sinon init a 0
SETNO	" " " " " " " " " " "  OF est a 0, sinon init a 0
SETNP   " " " " " " " " " " " "PF est a 0, " " " "" " " " 
SETNS	" " " " " " ""  " "" " SF " " " " " " "" " " " "" 
SETNZ	" " "" " " " "" " " " "ZF " " " ""  " "" " "  " "
SETO	" " " " " " " " ""  "  OF est a 1, "" " "" " " "" 
SETP	" " " " " " " " " " "  PF  " " " " " " " " " "" " 
SETPE	" " " " "" " " " " " "  " " " " " " ""  "" "  "" " 
SETPO	" " " " " " " " " " " " " " " " 0, " " " " " " "" "
SETS	" " " " " " " " " " " " SF est a 1, sinon " " " " " 
SETZ	" " " " " " " " "" " "  ZF " " " " " " " " ""  ""  "
SGDT	sauvegarde le registre de la table des descripteurs globaux(mode prot.)
SHL	voir SAL
SHLD	decalage double a gauche
SHR	decalage a droite avec introduction de 0
SHRD	decalage double a droite
SIDT	sauvegarde le registre de la table des interruptions. (mode protégée)
SLDT	" " " " " " " " " " " " " " " " " " "" descripteurs locaux (mode P)
SMSW	sauvegarde le mot d'etat de la machine (mode P)
STC	mets a 1 l'indicateur CF
STD	" " " " ""  ""  " " " DF
STI	" " " " "  " " "" "  "IF
STIOS[b][w] transfert octet par octet, mot par mot le contenu de AL en ES:DI
STOSD	transfert double mot par double mot le contenu de EAX en ES:DI
STR	sauvegarde le registre de tache (mode Protégée)
SUB	soustraction non signée
TEST	test si un bit est a 1
VERR	test l'autorisation de lecture d'un segment (mode prot‚g‚e)
VERW	test l'autorisation d'ecriture dans un segment (mode prot‚g‚e)
XADD	addition signée
WAIT	attends que la ligne BUSY ne soit plus actif
XBINVD	efface le contenu de la memoire cache du 486
XBTS	prends une chaine de bits (mode protégée)
XCHG 	echange les contenus de 2 registres
XLAT	charge en AL l'octet de la table DS:BX+AL
XOR	operation logique ou exclusive

Les instructions conditionnelles

effectue le saut :
plus grand que (nombres non-signés) ---> JA 
plus petit que (nombres non-signés) ---> JB 
plus grand que (nombres signés) -------> JG
plus petit que (nombres signés) -------> JL
égal à (signé et non-signé) -----------> JE ou parfois JZ

  
|      EAX      | 32 Bits   Accumulateur 
--------|  AX   | 16 Bits 
        | AH| AL|  8 Bits 
================= 
|      EBX      | 32 Bits   Base 
--------|  BX   | 16 Bits 
        | BH| BL|  8 Bits 
================= 
|      ECX      | 32 Bits   Compteur 
--------|  CX   | 16 Bits 
        | CH| CL|  8 Bits 
================= 
|      EDX      | 32 Bits   Données 
--------|  DX   | 16 Bits 
        | DH| DL|  8 Bits 
================= 
|      ESI      | 32 Bits   Index de Source 
--------|  SI   | 16 Bits 
================= 
|      EDI      | 32 Bits   Index de Destination 
--------|  DI   | 16 Bits 
================= 
|      ESP      | 32 Bits   Pointeur de Pile 
--------|  SP   | 16 Bits 
================= 
|      EBP      | 32 Bits   Pointeur de Base 
--------|  BP   | 16 Bits

  cs:005B 9A91028560     call   6085:0291
  cs:0060 803E520001     cmp    byte ptr [0052],01   /// ici, comparaison
  cs:0065 751E           jne    0085  ////ici, saut si faux
  cs:0067 BF5401         mov    di,0154
  cs:006A 1E             push   ds

  cs:005B 9A91028560     call   6085:0291
  cs:0060 803E520001     cmp    byte ptr [0052],01
  cs:0065 741E           je    0085
  cs:0067 BF5401         mov    di,0154
  cs:006A 1E             push   ds

  cs:005B 9A91028560     call   6085:0291
  cs:0060 803E520001     cmp    byte ptr [0052],01
  cs:0065 EB1E           jmp    0085   ////---- ici
  cs:0067 BF5401         mov    di,0154
  cs:006A 1E             push   ds

avec un éditeur hexadécimal, on cherchera donc :
80 3E 52 00 01 74 1E BF 54 01  et on remplace par
-- -- -- -- -- EB -- -- -- --

  cs:005B 9A91028560     call   6085:0291
  cs:0060 803E520001     cmp    byte ptr [0052],01
  cs:0065 EB00           jmp    0067
  cs:0067 BF5401         mov    di,0154
  cs:006A 1E             push   ds