Add memory course

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 <valeur>`: ajoute une valeur dans la pile et descent de pointeur 
+     équivalent à:
+     ```asm
+     subl $4, %esp
+     movl <valeur>, %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.