reverse intro

hexadecimal

Le système hexadecimal utilise une base 16. C’est à dire que chaque caractère peut prendre 16 valeurs différentes.

On préfixe les nombres hexadécimals souvent par un Ox afin de les différencier des autres bases.

base 10 to base 16

(999)₁₀ = 3 * 256 + 14 * 16 + 7 * 1
(999)₁₀ = 3 * 16² + 14 * 16¹ + 7 * 16⁰
(999)₁₀ = 3 * 16² + E * 16¹ + 7 * 16⁰
(999)₁₀ = (0x3E7)₁₆

memory space

Combien de bits pour coder un caractère en base 16 ?
Chaque caractére peut prendre 16 valeurs :

• 1 bit -> 2¹ = 2 combinaisons
• 2 bits -> 2² = 4 combinaisons
• 3 bits -> 2³ = 8 combinaisons

• 4 bits -> 2⁴ = 16 combinaisons <– Donc 1 caractère occupe 4 bits.

• 0x8 -> occupe 4 bits
• 0x4A -> occupe 8 bits -> 1 octet
• 0x4A88 -> occupe 16 bits -> 2 octets

memory addressing

On utilise souvent la base hexadécimale pour donner des adresses mémoires. Par exemple 0x000008ff est une adresse mémoire sur une machine 32 bits.

Les machines 32 bits ont 32 bits d’adressage (ou 4 octets), c’est à dire que l’on peut localiser 2³² blocs de 1 octet dans la RAM. C’est à dire 4 Go maximum.

Les processeurs 64 bits quand à eux peuvent adresser 2⁶⁴ blocs différents. C’est à dire BEAUCOUP !

assembler (asm)

Voici un exemple de code écrit en langage C :

/* main.cpp */
int main (int arc, char* argv[]) {
  int nb1 = 10;
  int nb2 = 100;

  if(nb1 > nb2) {
    printf("%i est plus grand que %i", nb1, nb2);
  } else {
    printf("%i est plus petit que %i", nb1, nb2);
  }

  return 0;
}

Le processeur d’un ordinateur ne peut réaliser que de simples opérations (additions, soustractions, comparaison à 0,…). Il ne peut donc pas directement interpréter notre main.cpp. C’est pour cela que l’on passe par une phase de compilation qui nous permet d’obtenir un exécutable compréhensible par notre processeur.

example

0x000008d6      83f80a         cmp eax, 0xa
0x000008d9      7513           jne 0x8ee
0x000008db      488d3d430100.  lea rdi, qword str.Gagne
0x000008e2      b800000000     mov eax, 0
0x000008e7      e834feffff     call sym.imp.printf
0x000008ec      eb11           jmp 0x8ff
0x000008ee      488d3d440100.  lea rdi, qword str.Perdu
0x000008f5      b800000000     mov eax, 0
0x000008fa      e821feffff     call sym.imp.printf
0x000008ff      b800000000     mov eax, 0
0x00000904      c9             leave
0x00000905      c3             ret

La colonne de gauche représente les adresses mémoires (on reconnait la base hexadécimale 0x...), la seconde est le contenu mémoire (données stockées) jusqu’à la prochaine adresse mémoire. Enfin, la troisième colonne est la traduction de ce contenu en langage assembleur. Par exemple, eb11 est traduit par l’instruction jmp 0x8ff.

addresses evolution

Prenons par exemple les 4 premières lignes

Rappel

• un caractère hexadécimal occupe 4 bits
• un case memoire fait 1 octet

Pourquoi passe t-on de l’adresse 0x000008d6 à 0x000008d9 ?

Tout d’abord l’adresse 0x000008d6 pointe sur une suite de données correspondant à la directive 83f80a. Cette directive est une valeur hexadécimale qu’il faut stocker. Etant donné que 83f80a est composée de 6 caractéres hexa, il faut donc 3 octets pour stocker cette directive (6*4 = 24 bits = 3 octets).

De plus si on regarde le delta de 0x000008d9 - 0x000008d6 on retouve la valeur 3. Tout s’explique.

Voiçi un tableau avec le contenu de chaque case mémoire :

registers

Important: plus on est proche du processeur, plus la mémoire est rapide, plus vite sont exécutées les instructions.

Les registres forment une mémoire interne aux processeurs, plus on a de registres, plus on peut stocker de données, et moins on a besoin d’accès aux mémoires extérieurs (qui sont bien plus lentes).

Les processeurs x86 en 32 bits possèdent 8 registres généraux (EAX, EBX, ECX, EDX, ESP, EBP, ESI, EDI). En 64 bits, on passe à 16 registres logiques, mais dans les faits, il en existe bien plus (ex: 168) afin de paralléliser les instructions.

data registers

Ils sont utilisés pour stocker des résultats d’opérations élémentaires lors de l’exécution du programme.

De ces 4 registres, il existe plusieurs dérivés.

R: register
E: extended
H: high
L: low

Il existe aussi des registes de 8 bits pour A, B, C et D. Il suffit de rajouter H pour avoir les bits de poids fort, et L pour les bits de poids faible.

Cette variété de tailles de registres permet de stocker des données selon la taille qu’elles nécessitent.

pointer registers

Ils sont utilisés pour pointer des adresses mémoires.

PC= IP = Instruction Pointer (en x86)

ESP et EBP stockent des adresses 32 bits pour délimiter le stack frame courante.

À partir de ces 3 registres, il existe plusieurs dérivées.

index registers

À partir de ces 2 registres, il existe plusieurs dérivées :

control registers (flags)

Ces flags de 16 bit sont mis à jour après chaque opération.

Par exemple, EFLAGS contient des indicateurs, des interrupteurs, etc… Ces flags sont essentiellement utilisés pour des comparaisons, mais pas que.

Il en existe d’autres…

segment registers

Pour décrire le partage mémoire.

Utilisé pour faciliter la lecture et l’écriture sur la mémoire.

Il en existe d’autres qui ont le rôle de définir d’autres espaces mémoires comme ES, FS, GS.

adressage

Toute adresse dans une programme est définie par l’adresse de début de segement et par le décallage (offset). Cela nous permet de trouver l’adresse exacte d’une instruction grace à la somme de ces 2 valeurs.

initialized variables

[nom_variable] taille valeur

# exemple de définition de variables
ma_lettre DB 'm'
mon_age	DW 12345
mon_negatif DW -12345
grand_nombre DQ	123456789
reel DD	1.234

unitialized variables

constantes

CONSTANT_NAME EQU expression

TOTAL_STUDENTS equ 50

# numeric constant
%assign TOTAL 10

# both numeric and string constants
%define PTR [EBP+4]

unary operations

• DIV divisor ; unsigned data
• IDIV divisor ; signed data
  • 16-bit: (AX) / 8-bit divisor = AL(quotient) and AH(remainder)
  • 32-bit: (DX AX) / 16-bit divisor = AX(quotient) and DX(remainder)
  • 64-bit: (EDX EAX) / 32-bit divisor = EAX(quotient) and EDX(remainder)
• idivq S -> RDX:RAX / S = RAX(quotient) and RDX(remainder)
• divq S -> RDX:RAX / S = RAX(quotient) and RDX(remainder)

binary operations

MUL multiply unsigned data
IMUL integer mutltiply signed data

• AL * multiplier(of 8-bit) = AH AL = AX
• AX * multiplier(of 16-bit) = DX AX
• EAX * multiplier(of 32-bit) = EDX EAX
• imulq S -> RAX * S(of 32-bit) = RDX:RAX
• mulq S -> RAX * S(of 32-bit) = RDX:RAX

logic instructions

conditions

# compare desti à src avec soustraction
CMP desti, src

CMP DX,	00
JE  L7
...
L7: ... 

INC	EDX
CMP	EDX, 10	; Compares whether the counter has reached 10
JLE	LP1     ; If it is less than or equal to 10, then jump to LP1

# faire un saut sur un label
JMP	label

data movement

Instruction with one suffix

Instruction wih two suffix

Instructions with no suffixes

virtual memory

Lorsque l’on lance un programme, celui-ci est chargé en mémoire afin d’être exécuté. Pour cela, un processus est créé. Ce processus ne possède pas d’accès direct à la mémoire physique de la machine. Mais il va avoir accès à une mémoire virtuelle d’une taille de 4 Go (sur machine 32 bits). Le processus est encapsulé dans une sandbox (bac à sable) afin d’être séparé des autres. Lors de son exécution, le processus pense être seul à s’exécuter sur la machine (ce qui n’est pas le cas).

page tables

Les tables de pages sont utilisées pour créer une interface entre la mémoire virtuelle (point de vue du processus) et la mémoire physique (point de vue machine). Chaque processus est associé à une table de page. Cette table associe les espaces mémoires virtuelles utilisés par le processus, avec des espaces physiques de la mémoire. C’est le kernel qui réalise cette tâche.

On peut voir sur ce schéma que le processus 1 a accès à une mémoire virtuelle. Derrière celle-ci se cache le système de table de page vue précédemment.

memory segmentation

Lorsqu’un programme est chargé en mémoire afin de créer un processus la mémoire est segmentée.

$ size ./rop # taille des sections + ajouter code

stack frame : zone mémoire dans la pile, avec toutes les informations nécessaires à l’appel de cette fonction + var. locales de la fonction.

example

On peut utiliser la commande size afin de connaitre la taille des séctions.

// main.c
#include <stdio.h>

int main (int argc, char* argv[]) {

  return 0;
}

$ gcc main.c -o a.out
$ size a.out
text	   data	    bss	    dec	    hex	filename
1537	    544	      8	   2089	    829	a.out

On peut voire la taille des séctions de notre exécutable de départ.

// main.c
#include <stdio.h>

int var_global;

int main (int argc, char* argv[]) {
  // ou static int var_static;
  return 0;
}

$ gcc main.c -o a.out
$ size a.out
text	   data	    bss	    dec	    hex	filename
1537	    544	     12	   2089	    829	a.out

La variable var_global est non initialisée, elle se retrouve donc dans la section .bss. Même chose si nous avions définie une varaible static dans le main().

// main.c
#include <stdio.h>

int var_global_1 = 10;

int main (int argc, char* argv[]) {
  
  return 0;
}

$ gcc main.c -o a.out
$ size a.out
text	   data	    bss	    dec	    hex	filename
1537	    548	      8	   2089	    829	a.out

La variable var_global est maintenant initialisée, elle se retrouve donc dans la section .data.