# Processeur sécurisé 



Ce dépot regroupe les différents composants permettant d'exécuter un programme écrit dans un langage dérivé du C sur un processeur sécurisé contre le détournement du flot d'exécution par buffer overflow.

La chaine est divisée en 5 étapes, 3 obligatoires et 2 facultatives.

- Compiler le code avec le module *Compilateur*, cela va généré un premier code assembleur sans registres.
- Facultatif : Interpreter ce code assembleur avec le module *Interpreteur* pour vérifier le comportement du programme.
- Intégrer les registres dans le code assembleur avec le module *CrossAssembleur*.
- Facultatif : Interpreter ce code assembleur avec le module *InterpreteurRegistres* pour vérifier le comportement du programme.
- Exécuter le code sur le processeur sur un FPGA

### Technologies : 
    - Compilateur           : Lex Yacc (flex et bison), C (gcc), Makefile (make)
    - Interpreteur          : Lex Yacc (flex et bison), C (gcc), Makefile (make)
    - CrossAssembleur       : Lex Yacc (flex et bison), C (gcc), Makefile (make)
    - CompilateurRegistre   : Lex Yacc (flex et bison), C (gcc), Makefile (make)
    - Processeur            : Digilent FPGA Basys3 Artix7, Vivado (2016.4)

### Mots clés : 
    Sécurité, BufferOverflow, BOF, Processeur, Compilateur, FPGA.

# Utilisation 

Pour cloner le GIT **ET** les sous modules, veuillez utiliser la commande :
``` bash
git clone --recurse-submodules https://git.etud.insa-toulouse.fr/pfaure/PSI.git
```

Si vous avez cloné le dépot de manière "classique", vous pouvez utiliser les commandes suivantes afin de télécharger les sous-modules :
``` bash
git submodule init
git submodule update
```

Un Makefile a été inclus afin de simplifier la chaine de compilation et d'exécution. 

## Versions
Attention, il existe deux versions du projet, une avec la sécurité implémentée, et une sans. Soyez vigilent a avoir les modules dans la même version. Pour compilateur, il faut juste changer la valeur du *#define SECURISED ()*. Pour les interpreteurs et le processeur il s'agit de branches différentes.

### Compilation du projet

#### Compilation de tout le projet : 
``` bash
make compile QUOI="all"
```

#### Compilation du Compilateur uniquement : 
``` bash
make compile QUOI="compilateur"
```

#### Compilation de l'Interpreteur uniquement : 
``` bash
make compile QUOI="interpreteur"
```

#### Compilation du CrossAssembleur uniquement : 
``` bash
make compile QUOI="cross_assembleur"
```

#### Compilation de l'InterpreteurRegistres uniquement : 
``` bash
make compile QUOI="interpreteur_registres"
```

### Exploitation du projet

#### Réalisation de toute la chaine : 
``` bash
make exec QUOI="all" SOURCE="prefixe_file"
```
Ceci va compiler le fichier **prefixe_file.c**, générer les fichiers assembleur et binaire, et modifier le code du processeur pour charger le programme. (Ne réalise pas les étapes facultatives)

#### Compilation d'un fichier : 
``` bash
make exec QUOI="compile" SOURCE="prefixe_file"
```
Ceci va compiler le fichier **prefixe_file.c** et générer le fichier assembleur orienté mémoire **prefixe_file.memasm**

#### Interpretation d'un assembleur mémoire : 
``` bash
make exec QUOI="interprete" SOURCE="prefixe_file"
```
Ceci va interpreter le fichier **prefixe_file.memasm**

#### CrossAssemblage d'un assembleur mémoire : 
``` bash
make exec QUOI="cross_assemble" SOURCE="prefixe_file"
```
Ceci va transformer le fichier **prefixe_file.memasm** en fichier **prefixe_file.regasm** afin d'intégrer les registres

#### Interpretation d'un assembleur registre : 
``` bash
make exec QUOI="interprete_registres" SOURCE="prefixe_file"
```
Ceci va interpreter le fichier **prefixe_file.regasm**

#### Charger le programme dans le code VHDL du processeur : 
``` bash
make exec QUOI="load" SOURCE="prefixe_file"
```
Ceci va injecter le code du fichier **prefixe_file.bin** dans la mémoire d'instruction