167 lines
3.1 KiB
Markdown
167 lines
3.1 KiB
Markdown
---
|
|
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.
|