---
title: "Sécurité logicielle : L'assembleur - accès mémoire"
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.