From 030e2dd93bd8d0e6e7f9a63c9431d164191d9f0c Mon Sep 17 00:00:00 2001 From: Yorick Barbanneau Date: Mon, 20 Feb 2023 22:49:17 +0100 Subject: [PATCH] Add memory course --- .../secu_logicielle/4_acces_memoire/index.md | 167 ++++++++++++++++++ 1 file changed, 167 insertions(+) create mode 100644 content/secu_logicielle/4_acces_memoire/index.md diff --git a/content/secu_logicielle/4_acces_memoire/index.md b/content/secu_logicielle/4_acces_memoire/index.md new file mode 100644 index 0000000..88ffba0 --- /dev/null +++ b/content/secu_logicielle/4_acces_memoire/index.md @@ -0,0 +1,167 @@ +--- +title: "Sécurité logicielle : L'assembleur - approfondissement" +date: 2023-02-01 +tags: ["assembleur", "intel", "mémoire"] +categories: ["Sécurité logicielle", "Cours"] +--- + +## Accès direct à la mémoire + +Prenons le code en C suivant: + +```c +int i = 42; +int j = 43; + +int main() { + i = 1; + j = i; + j++; +} +``` + +Voici le code assembleur correspondant: + +```asm +i: + .long 42 +j: + .long 43 +main: + movl $1, i + # on ne peux pas faire movl j i, il va falloir passer par %eax + movl i, %eax + movl %eax, j + incl j + ret +``` + +## Accès indirects à la mémoire + +Prenons maintenant le code C suivant, avec des pointeurs et références: + +```c +int i = 42; +main(){ + int *x = &i; + *x = 0; + (*x)++ +} +``` + +Voici le code assembleur correspondant: + +```asm +i: + .long 42 +main: + movl $1, i + movl $i, %eax # récupérons l'adresse de i dans %eax + movl $0, (%eax) # (%eax) pointe vers l'adresse mémoire content dans %eax + incl (%eax) + ret +``` + +### Les tableaux + +Voici un code en C contenant un tableau: + +```c +int t[2] = {1,2}; +main() { + t[0] = 3; + t[1] = 4; + int *x = &t[1]; + *x = 0; + (*x)++; +} +``` +Et le code correspondant en assembleur: + +```asm {linenos=inline} +t: + .long 1 + .long 2 +main: + movl $3, t + movl $4, t+4 + movl $t+4, %eax + movl $0, (%eax) + incl (%eax) + ret +``` + +La déclaration de notre tableau ligne 1, 2 et 3 : `t` est une étiquette +contenant deux `long` (*4 octets*). La première affectation des éléments de t +dans notre `main` ligne 5 et ligne 6. Pour le second élément, on prend l'adresse +de `t` et on la décale de 4 octets. + +### Les structures + +D'un point de vue de l'assembleur, les structures sont vue comme les tableau : +des adresses mémoire, comme tout le reste! Ce que nous avons précédemment est +donc valable : **décalage** et **adresses mémoire**. + +N'oublions pas que **du point du vue du processeurs ce ne sont que des +adresses** + +### Pointeur de pointeur + +Voici un code en C: + +```c +int i = 42, j = 43; +int *x; +int **z; +main() { + x = &i; + z = &x; + [...] + *z = &j; +``` + +Et son pendant en assembleur: + +```asm {linenos=inline} +i:.long 42 +j:.long 43 +x:.long 0 +z:.long 0 +main: + movl $i, x + movl $x, z + [...] + movl z, %eax + movl $j, (%eax) +``` + +Comme on peut le voir ligne 1 à 4 tout est déclaré comme `long`. Pour +l'affectation de ` *z` ligne 9 et 10, nous passons par `%eax` pour faire le +relais. + +## La pile + +En assembleur, `esp` représente le pointeur de pile, La pile est LIFO : *Last In +First Out*, Fait important : **on descend sur la pile**. Autre fait important +la pile **n'est pas nettoyée** lors de la remontée. + +Deux instructions sont utilisée : + + * `pushl `: ajoute une valeur dans la pile et descent de pointeur + équivalent à: + ```asm + subl $4, %esp + movl , %eax + ``` + * `popl`: place la valeur de la pile dans `%eax` et remonte le pointeur, + équivalent de: + ```asm + movl (%exp) %eax + addl $4m %esp + ``` + +### Le registre epb + +Il se met par défaut au milieu du tas, son nom signifie *Base Pointer*. Il st +utilisé généralement pour marquer le début d'une structure de donnée sur la +pile.