Mettre à jour 'ReadMe.md'

ReadMe.md

@@ -0,0 +1,106 @@
+# 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