diff --git a/content/secu_logicielle/3_assembleur_approfondissement/index.md b/content/secu_logicielle/3_assembleur_approfondissement/index.md index 762b3e7..f5ee6a0 100644 --- a/content/secu_logicielle/3_assembleur_approfondissement/index.md +++ b/content/secu_logicielle/3_assembleur_approfondissement/index.md @@ -9,7 +9,7 @@ categories: ["Sécurité logicielle", "Cours"] Prenons `IP` comme compteur et `A` , `B`, `C` et `D` comme registres. -```asm {linenos=true} +```asm {linenos=inline} 0x00: mov $1, A 0x05: mov $2, B 0x0a: mov $3, C @@ -282,3 +282,125 @@ impactés**. cmpl %eax %ebx # %ebx - %eax cmovgel $1 %edx # si %ebx > ebx (res > 0) alors %edx = 1 ``` + +### Diverses instruction + + * `nop` : ne fait rien à part incrémenter le *pointeur d'instruction*. Elle + peut servier à remplir un espace mémoire afin d'éviter de décaller le + restrant du code. + * `halt`: met en pause le CPU + + + +### Travail sur les flottants + +Les flotants ont une longueur de *32bits*, les doubles de *64bits*, le +processeur lui les traite sur *80bits* : + + * **un bit** de signe + * **15 bits** d'exposants + * **64 bits** de mantisse + +Pour information, nombre = mantisse = 10^exposant. + +Le processeur dispose de 8 registres (`st0` à `st7`). Leurs accès ne se fait pas +directement mais via `push` / `pop` + +ils sont gérés dans une unité à part , qui dispose aussi des ses propres *flags* +sur *16bits*. Les 6 premiers bits sont réservés aux exceptions: + +position | flag | fonction +---------|------|---------- + 0 | IE | Invalid Operation + 1 | DE | Denormalized Operand Exception + 2 | FE | Zero Divide Exception + 3 | OE | Overflow Exception + 4 | UE | Underflow Exception + 5 | PE | Precision Exception + +Voici les suivants: + +position | flag | fonction +---------|------|---------- + 7 | ES | Error Summary Status + 8 9 10 14 | C1-C4 | Condition Code + 11 12 13 | TOP | Top of stack pointer + 15 | B | FPU busy + +#### Les instructions + +Le FPU dispose de ses propres instructions par exemple: + + * `fadd`, `faddp` : addition flotante : + ```asm + faddp # Ajouter st1 à st0 + fadd a # Ajouter a à st0 + fadd a b # Ajouter a à b + ``` + * `fsub`, `fsubp`: soustraction flottante + * `fmul`, `fmulp`: multiplication flottante + * `fdiv`, `fdivp`: division flottante + * `fchs` : changement de signe (`st(i)`) + * `fabs`: retourne la valeur absolue (`st(i)`) + * `fsqrt`: retourne la racine carré (`st(i)`) + * `fsin`, `fcos` retourne le sinus, le cosinus (`st(i)`) + * `fcomi`: compare l'opérande avec `st0` + ```asm + fcomi st2 + ``` + * `fcmovb`, `fcmove`, `fcmovbe`: move si en dessous, egal, en dessous ou égal + +### SSE (Streaming SIMD Extentions) + +C'est un ensemble de 70 instructions ajoutées au processeurs Intel en 1999, 8 +registres supplémentaires sont implémentés : `xmm0` à `xmm7` d'une longueur de +*128bits*. La version 64 bits ajoute 8 registes de plus (`xmm8` à `xmm16`). + +#### Instruction + +Voici quelques exemples de mnémonique spécifiques à cette partie: + + * `movss` qui permet de déplacement, deux opérandes la source (adresse ou + registre `xmm`) et une destination (resitre `xmm`). + * `addss`: additions, s'utilise comme `movss`. + * `subss`, `mulss`, `divss`: respectivement soustrasction, multiplication et + division. Ces opération acceptent les même opérandes que `movss`. + +### Les appels systèmes en assembleur + +Pour passer en mode noyau, nous pouvons utiliser une interruption spécifique : +`0x80`, le numéro d'appel système doit être positionné dans `%eax` et les +paramètres dasn `ebx`, `ecx`, `edx`, `esi` et `edi`. La valeur de retour est +positionnée dans `eax`. + +En version *32bits* l'appel se fait via `int 0x80`. La version *64 bits* dispose +de l'instruction `syscall`. + +```asm +.data + +# Notre message et sa taille, elle nous sont nécessaire pour appeler +# notre appel système +msg: + .asciz "Hello World\n" + len = . - msg + +.text +.globl main +main: + # placement de nos paramètres dans nos différents registres + movl $len, %edx + movl $msg, %ecx + movl $1, %ebx + + # numéro de l'appel système sys_write dans eax + movl $4, %eax + + # Et lancement de notre interruption + int $0x80 + + # Relançons un appel système pour exit, avec 0 comme paramètre + movl $0, %ebx + movl $1, %eax + int $0x80 +```