cours/content/secu_logicielle/4_acces_memoire/index.md

title	date	tags	categories
Sécurité logicielle : L'assembleur - accès mémoire	2023-02-01	assembleur intel mémoire	Sécurité logicielle Cours

Accès direct à la mémoire

Prenons le code en C suivant:

int i = 42;
int j = 43;

int main() {
    i = 1;
    j = i;
    j++;
}

Voici le code assembleur correspondant:

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:

int i = 42;
main(){
    int *x = &i;
    *x = 0;
    (*x)++
}

Voici le code assembleur correspondant:

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:

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:

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:

int i = 42, j = 43;
int *x;
int **z;
main() {
    x = &i;
    z = &x;
    [...]
    *z = &j;

Et son pendant en assembleur:

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 à:

  subl $4, %esp
  movl <valeur>, %eax
  

• popl: place la valeur de la pile dans %eax et remonte le pointeur, équivalent de:

  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.