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 :

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 :

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 :

make compile QUOI="all"

Compilation du Compilateur uniquement :

make compile QUOI="compilateur"

Compilation de l'Interpreteur uniquement :

make compile QUOI="interpreteur"

Compilation du CrossAssembleur uniquement :

make compile QUOI="cross_assembleur"

Compilation de l'InterpreteurRegistres uniquement :

make compile QUOI="interpreteur_registres"

Exploitation du projet

Réalisation de toute la chaine :

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 :

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 :

make exec QUOI="interprete" SOURCE="prefixe_file"

Ceci va interpreter le fichier prefixe_file.memasm

CrossAssemblage d'un assembleur mémoire :

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 :

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 :

make exec QUOI="load" SOURCE="prefixe_file"

Ceci va injecter le code du fichier prefixe_file.bin dans la mémoire d'instruction