diff --git a/command/command.go b/command/command.go
index 208d211..df9581e 100644
--- a/command/command.go
+++ b/command/command.go
@@ -3,6 +3,7 @@ package command
 
 import "fmt"
 import "errors"
+
 import "github.com/Heisenberk/goshield/structure"
 import "github.com/Heisenberk/goshield/crypto"
 
diff --git a/command/command_test.go b/command/command_test.go
index d720532..391c178 100644
--- a/command/command_test.go
+++ b/command/command_test.go
@@ -2,7 +2,7 @@
 package command
 
 import "testing"
-//import "io/ioutil"
+
 import "github.com/Heisenberk/goshield/structure"
 
 // TestSansArgument teste la commande "./goshield"
diff --git a/crypto/decrypt.go b/crypto/decrypt.go
index ea30c8e..000bbbc 100644
--- a/crypto/decrypt.go
+++ b/crypto/decrypt.go
@@ -1,3 +1,4 @@
+// Package crypto contenant les fonctions de chiffrement/déchiffrement.
 package crypto
 
 import "crypto/aes"
@@ -18,13 +19,13 @@ func DecryptBlocAES(iv []byte, key []byte, input []byte) ([]byte, error){
 
 	// Si la taille de l'entrée est invalide on lance une erreur. 
 	if len(input)%aes.BlockSize != 0 {
-		return output, errors.New("Failure Decryption : Taille du bloc invalide.")
+		return output, errors.New("\033[31mFailure Decryption\033[0m : Taille du bloc invalide.")
 	}
 
 	// Preparation du bloc qui sera chiffré.
 	block, err := aes.NewCipher(key)
 	if err != nil {
-		return output, errors.New("Failure Decryption : Erreur lors du déchiffrement d'un bloc.")
+		return output, errors.New("\033[31mFailure Decryption\033[0m : Erreur lors du déchiffrement d'un bloc.")
 	}
 
 	// Chiffrement AES avec le mode opératoire CBC.
@@ -40,13 +41,13 @@ func DecryptFileAES(pathFile string, doc *structure.Documents) error{
 	// ouverture du fichier à déchiffrer
 	inputFile, err1 := os.Open(pathFile) 
 	if err1 != nil {
-		var texteError string = "Failure Decryption : Impossible d'ouvrir le fichier à déchiffrer "+pathFile+". "
+		var texteError string = "\033[31mFailure Decryption\033[0m : Impossible d'ouvrir le fichier à déchiffrer "+pathFile+". "
 		return errors.New(texteError)
 	}
 
 	// renvoie une erreur si l'extension n'est pas la bonne
 	if pathFile[(len(pathFile)-4):]!= ".gsh"{
-		var texteError string = "Failure Decryption : L'extension de "+pathFile+" est invalide (doit être \".gsh\"). "
+		var texteError string = "\033[31mFailure Decryption\033[0m : L'extension de "+pathFile+" est invalide (doit être \".gsh\"). "
 		return errors.New(texteError)
 	}
 
@@ -54,7 +55,7 @@ func DecryptFileAES(pathFile string, doc *structure.Documents) error{
 	signature := make([]byte, 8)
     _, err2 := inputFile.Read(signature)
     if err2 != nil {
-		var texteError string = "Failure Decryption : Format du fichier à déchiffrer "+pathFile+" invalide. "
+		var texteError string = "\033[31mFailure Decryption\033[0m : Format du fichier à déchiffrer "+pathFile+" invalide. "
 		return errors.New(texteError)
 	}
 
@@ -62,7 +63,7 @@ func DecryptFileAES(pathFile string, doc *structure.Documents) error{
     salt := make([]byte, 15)
     _, err22 := inputFile.Read(salt)
     if err22 != nil {
-		var texteError string = "Failure Decryption : Impossible de lire le salt du fichier chiffré "+pathFile+". "
+		var texteError string = "\033[31mFailure Decryption\033[0m : Impossible de lire le salt du fichier chiffré "+pathFile+". "
 		return errors.New(texteError)
 	}
 	doc.Salt=salt
@@ -72,7 +73,7 @@ func DecryptFileAES(pathFile string, doc *structure.Documents) error{
 	IV := make([]byte, 16)
 	_, err23 := inputFile.Read(IV)
     if err23 != nil {
-		var texteError string = "Failure Decryption : Impossible de lire la valeur d'initialisation du fichier chiffré "+pathFile+". "
+		var texteError string = "\033[31mFailure Decryption\033[0m : Impossible de lire la valeur d'initialisation du fichier chiffré "+pathFile+". "
 		return errors.New(texteError)
 	}
 
@@ -80,13 +81,13 @@ func DecryptFileAES(pathFile string, doc *structure.Documents) error{
 	lengthTab := make([]byte, 1)
 	_, err24 := inputFile.Read(lengthTab)
     if err24 != nil {
-		var texteError string = "Failure Decryption : Impossible de lire la taille du dernier bloc du fichier chiffré "+pathFile+". "
+		var texteError string = "\033[31mFailure Decryption\033[0m : Impossible de lire la taille du dernier bloc du fichier chiffré "+pathFile+". "
 		return errors.New(texteError)
 	}
 
 	stat, err2 := inputFile.Stat()
 	if err2 != nil {
-  		var texteError string = "Failure Decryption : Impossible d'interpréter le fichier à déchiffrer "+pathFile+". "
+  		var texteError string = "\033[31mFailure Decryption\033[0m : Impossible d'interpréter le fichier à déchiffrer "+pathFile+". "
 		return errors.New(texteError)
 	}
 
@@ -94,7 +95,7 @@ func DecryptFileAES(pathFile string, doc *structure.Documents) error{
 	var division int = (int)((stat.Size()-8-15-16-1)/aes.BlockSize) 
 	var iterations int = division
 	if (int)(stat.Size()-8-15-16-1)%aes.BlockSize != 0 {
-		var texteError string = "Failure Decryption : Fichier" + pathFile +" non conforme pour le déchiffrement AES. "
+		var texteError string = "\033[31mFailure Decryption\033[0m : Fichier" + pathFile +" non conforme pour le déchiffrement AES. "
 		return errors.New(texteError)
 	}
 
@@ -102,17 +103,13 @@ func DecryptFileAES(pathFile string, doc *structure.Documents) error{
     var nameOutput string=pathFile[:(len(pathFile)-4)]
     outputFile, err3 := os.Create(nameOutput)
     if err3 != nil {
-  		var texteError string = "Failure Decryption : Impossible d'écrire le fichier chiffré "+nameOutput+". "
+  		var texteError string = "\033[31mFailure Decryption\033[0m : Impossible d'écrire le fichier chiffré "+nameOutput+". "
 		return errors.New(texteError)
 	}
 
 	input := make([]byte, 16)
 	var cipherBlock []byte
 	temp := make([]byte, 16)
-
-	fmt.Println(iterations)
-	fmt.Println(lengthTab)
-	fmt.Println("coucou")
 	
 	for i:=0 ; i<iterations ; i++ {
 
@@ -126,7 +123,7 @@ func DecryptFileAES(pathFile string, doc *structure.Documents) error{
 		// lecture de chaque bloc de 16 octets
 		_, err8 := inputFile.Read(input)
 		if err8 != nil {
-  			var texteError string = "Failure Decryption : Impossible de lire dans le fichier à déchiffrer "+pathFile+". "
+  			var texteError string = "\033[31mFailure Decryption\033[0m : Impossible de lire dans le fichier à déchiffrer "+pathFile+". "
 			return errors.New(texteError)
 		}
 
@@ -137,7 +134,7 @@ func DecryptFileAES(pathFile string, doc *structure.Documents) error{
 		var err10 error
 		cipherBlock, err10 = DecryptBlocAES(IV, doc.Hash, input)
 		if err10 != nil {
-			var texteError string = "Failure Decryption : Impossible de déchiffrer le fichier "+pathFile+". "
+			var texteError string = "\033[31mFailure Decryption\033[0m : Impossible de déchiffrer le fichier "+pathFile+". "
 			return errors.New(texteError)
 		}
 		
@@ -146,13 +143,13 @@ func DecryptFileAES(pathFile string, doc *structure.Documents) error{
 			if lengthTab[0]!= 0 {
 				_, err11 := outputFile.Write(cipherBlock[:lengthTab[0]])
 				if err11 != nil {
-  					var texteError string = "Failure Decryption : Impossible d'écrire dans le fichier "+nameOutput+". "
+  					var texteError string = "\033[31mFailure Decryption\033[0m : Impossible d'écrire dans le fichier "+nameOutput+". "
 					return errors.New(texteError)
 				}
 			}else {
 				_, err12 := outputFile.Write(cipherBlock)
 				if err12 != nil {
-  					var texteError string = "Failure Decryption : Impossible d'écrire dans le fichier "+nameOutput+". "
+  					var texteError string = "\033[31mFailure Decryption\033[0m : Impossible d'écrire dans le fichier "+nameOutput+". "
 					return errors.New(texteError)
 				}
 			}
@@ -161,7 +158,7 @@ func DecryptFileAES(pathFile string, doc *structure.Documents) error{
 		}else {
 			_, err13 := outputFile.Write(cipherBlock)
 			if err13 != nil {
-  				var texteError string = "Failure Decryption : Impossible d'écrire dans le fichier "+nameOutput+". "
+  				var texteError string = "\033[31mFailure Decryption\033[0m : Impossible d'écrire dans le fichier "+nameOutput+". "
 				return errors.New(texteError)
 			}
 		}
@@ -171,97 +168,101 @@ func DecryptFileAES(pathFile string, doc *structure.Documents) error{
 	inputFile.Close()
 	outputFile.Close()
 
-	var messageSuccess string = "- Success Decryption "+pathFile+" : resultat dans le fichier "+nameOutput
+	var messageSuccess string = "- \033[32mSuccess Decryption\033[0m : "+pathFile+" : resultat dans le fichier "+nameOutput
     fmt.Println(messageSuccess)
 
 	return nil
 }
 
+// DecryptFolder déchiffre le contenu d'un dossier de chemin path avec les données doc. 
 func DecryptFolder (path string, d *structure.Documents) {
-    //On lit dans le dossier visée par le chemin
-   entries, err := ioutil.ReadDir(path)
 
+    // Lecture du chemin à déchiffrer. 
+   entries, err := ioutil.ReadDir(path)
     if err != nil {
-        fmt.Println("- Failure Decryption : impossible d'ouvrir "+path)
+        fmt.Println("- \033[31mFailure Decryption\033[0m : impossible d'ouvrir "+path)
     }
-    for _, entry := range entries {
 
-        // si l'extension du fichier est différent de .gsh on peut chiffrer le fichier
-        //if(p[len(p)-4:]==".gsh"){
-
-           //crypto.EncryptFileAES(path+entry.Name(),d)
-           
-           newPath := path+entry.Name()
+    // Déchiffrement de chaque élément du dossier. 
+    for _, entry := range entries {
 
-           fi, err := os.Stat(newPath)
-            valid := true
-            if err != nil {
-                fmt.Println("- Failure Decryption : "+newPath+" n'existe pas ")
-                valid = false
-            }
+        newPath := path+entry.Name()
+        fi, err := os.Stat(newPath)
+        valid := true
+        if err != nil {
+            fmt.Println("- \033[31mFailure Decryption\033[0m : "+newPath+" n'existe pas ")
+            valid = false
+        }
 
-            if valid == true {
-                mode := fi.Mode();
+        // si l'élément du dossier existe. 
+        if valid == true {
 
-                //si l'objet spécifié par le chemin est un dossier.
-                if(mode.IsDir()==true){
+            mode := fi.Mode();
 
-                    //Si l'utilisateur a oublié le "/" à la fin du chemin du fichier
-                    if(strings.LastIndexAny(newPath, "/") != len(newPath) - 1){
-                      newPath=newPath+ string(os.PathSeparator)
-                      //appeler EncryptFolder
-                      DecryptFolder(newPath, d)
-                    }
+            //si l'objet spécifié par le chemin est un dossier.
+            if(mode.IsDir()==true){
 
-                // si l'objet spécifié par le chemin est un fichier.
-                }else if mode.IsRegular()== true {
-                	if newPath[len(newPath)-4:]==".gsh"{
-                		errFile := DecryptFileAES(newPath,d)
-                    	if errFile != nil {
-                        	fmt.Println(errFile)
-                    	}
-                	}
-                    
+                //Si l'utilisateur a oublié le "/" à la fin du chemin du fichier
+                if(strings.LastIndexAny(newPath, "/") != len(newPath) - 1){
+                    newPath=newPath+ string(os.PathSeparator)
+                      
                 }
+                DecryptFolder(newPath, d)
 
+            // si l'objet spécifié par le chemin est un fichier.
+            }else if mode.IsRegular()== true {
+
+                // si l'extension du fichier est différent de .gsh on peut chiffrer le fichier.
+                if newPath[len(newPath)-4:]==".gsh"{
+                	errFile := DecryptFileAES(newPath,d)
+                    if errFile != nil {
+                        fmt.Println(errFile)
+                    }
+                }     
             }
-        //}
+        }
     }
 }
 
+// DecryptFileFolder déchiffre les éléments choisis par l'utilisateur avec les données doc. 
 func DecryptFileFolder(d *structure.Documents) {
 
+	// Pour chaque élément choisi par l'utilisateur. 
     for i := 0; i < len(d.Doc); i++ {
+
+    	// Ouverture de l'élément. 
         fi, err := os.Stat(d.Doc[i])
         valid := true
         if err != nil {
-            fmt.Println("- Failure Decryption : "+d.Doc[i]+" n'existe pas ")
+            fmt.Println("- \033[31mFailure Decryption\033[0m : "+d.Doc[i]+" n'existe pas ")
             valid = false
         }
 
+        // Si l'élément est valide. 
         if valid == true {
             mode := fi.Mode();
 
-            //si l'objet spécifié par le chemin est un dossier.
+            // Si l'élément spécifié par le chemin est un dossier.
             if(mode.IsDir()==true){
 
-                //Si l'utilisateur a oublié le "/" à la fin du chemin du fichier
+                // Si l'utilisateur a oublié le "/" à la fin du chemin du fichier.
                 if(strings.LastIndexAny(d.Doc[i], "/") != len(d.Doc[i]) - 1){
                   d.Doc[i]=d.Doc[i]+ string(os.PathSeparator)
-                  //appeler EncryptFolder
-                  DecryptFolder(d.Doc[i], d)
                 }
 
+                // Déchiffrement du dossier.
+                DecryptFolder(d.Doc[i], d)
+
             // si l'objet spécifié par le chemin est un fichier.
             }else if mode.IsRegular()== true {
+
+            	// Déchiffrement du fichier. 
                 errFile := DecryptFileAES(d.Doc[i],d)
                 if errFile != nil {
                     fmt.Println(errFile)
                 }
             }
-
         }
-        
     }
 }
 
diff --git a/crypto/decrypt_test.go b/crypto/decrypt_test.go
index 54422a9..2e6c779 100644
--- a/crypto/decrypt_test.go
+++ b/crypto/decrypt_test.go
@@ -1,3 +1,4 @@
+// Package crypto contenant les fonctions de chiffrement/déchiffrement.
 package crypto
 
 import "testing"
@@ -8,6 +9,7 @@ import "bytes"
 
 import "github.com/Heisenberk/goshield/structure"
 
+// Test de chiffrement sur un bloc. 
 func TestDecryptBlocAES(t *testing.T){
 
     // IV sur 16 octets (128 bits).
@@ -32,6 +34,7 @@ func TestDecryptBlocAES(t *testing.T){
 	
 }
 
+// Test de chiffrement suivi de déchiffrement sur le fichier env/test/test6.md
 func TestEncryptDecryptFile(t * testing.T){
 
 	var d structure.Documents
diff --git a/crypto/encrypt.go b/crypto/encrypt.go
index 5957459..d74c867 100644
--- a/crypto/encrypt.go
+++ b/crypto/encrypt.go
@@ -1,3 +1,4 @@
+// Package crypto contenant les fonctions de chiffrement/déchiffrement.
 package crypto
 
 import "math/rand"
@@ -28,13 +29,13 @@ func EncryptBlocAES(iv []byte, key []byte, input []byte) ([]byte, error) {
 
 	// Si la taille de l'entrée est invalide on lance une erreur. 
 	if len(input)%aes.BlockSize != 0 {
-		return output, errors.New("Failure Encryption : Taille du bloc invalide.")
+		return output, errors.New("\033[31mFailure Encryption\033[0m : Taille du bloc invalide.")
 	}
 
 	// Preparation du bloc qui sera chiffré. 
 	block, err := aes.NewCipher(key)
 	if err != nil {
-		return output, errors.New("Failure Encryption : Erreur lors du chiffrement d'un bloc.")
+		return output, errors.New("\033[31mFailure Encryption\033[0m : Erreur lors du chiffrement d'un bloc.")
 	}
 
 	// Chiffrement AES avec le mode opératoire CBC.
@@ -50,22 +51,21 @@ func EncryptFileAES(pathFile string, doc *structure.Documents) error{
 	// ouverture du fichier a chiffrer
 	inputFile, err1 := os.Open(pathFile) 
 	if err1 != nil {
-		var texteError string = "Failure Encryption : Impossible d'ouvrir le fichier à chiffrer "+pathFile+". "
+		var texteError string = "\033[31mFailure Encryption\033[0m : Impossible d'ouvrir le fichier à chiffrer "+pathFile+". "
 		return errors.New(texteError)
 	}
 	stat, err2 := inputFile.Stat()
 	if err2 != nil {
-  		var texteError string = "Failure Encryption : Impossible d'interpréter le fichier à chiffrer "+pathFile+". "
+  		var texteError string = "\033[31mFailure Encryption\033[0m : Impossible d'interpréter le fichier à chiffrer "+pathFile+". "
 		return errors.New(texteError)
 	}
 
 	// vérification de la bonne permission
 	if stat.Mode().String()[1]=='-' {
-		var texteError string = "Failure Encryption : Permission du fichier à chiffrer "+pathFile+" incorrecte . "
+		var texteError string = "\033[31mFailure Encryption\033[0m : Permission du fichier à chiffrer "+pathFile+" incorrecte . "
 		return errors.New(texteError)
 	}
 
-
 	var division int = (int)(stat.Size()/aes.BlockSize)
 	var iterations int = division
 	if (int)(stat.Size())%aes.BlockSize != 0 {
@@ -75,14 +75,14 @@ func EncryptFileAES(pathFile string, doc *structure.Documents) error{
 	// ouverture du fichier résultat
     outputFile, err3 := os.Create(pathFile+".gsh")
     if err3 != nil {
-  		var texteError string = "Failure Encryption : Impossible d'écrire le fichier chiffré "+pathFile+".gsh. "
+  		var texteError string = "\033[31mFailure Encryption\033[0m : Impossible d'écrire le fichier chiffré "+pathFile+".gsh. "
 		return errors.New(texteError)
 	}
 
 	// ecriture de la signature
 	_, err4 := outputFile.WriteString("GOSHIELD")
     if err4 != nil {
-  		var texteError string = "Failure Encryption : Impossible d'écrire dans le fichier chiffré "+pathFile+".gsh. "
+  		var texteError string = "\033[31mFailure Encryption\033[0m : Impossible d'écrire dans le fichier chiffré "+pathFile+".gsh. "
 		return errors.New(texteError) 
 	}
 
@@ -90,7 +90,7 @@ func EncryptFileAES(pathFile string, doc *structure.Documents) error{
 	CreateHash(doc)
 	_, err5 := outputFile.Write(doc.Salt)
 	if err5 != nil {
-  		var texteError string = "Failure Encryption : Impossible de générer le salt. "
+  		var texteError string = "\033[31mFailure Encryption\033[0m : Impossible de générer le salt. "
 		return errors.New(texteError)
 	}
 
@@ -98,7 +98,7 @@ func EncryptFileAES(pathFile string, doc *structure.Documents) error{
 	IV := CreateIV()
 	_, err6 := outputFile.Write(IV)
     if err6 != nil {
-  		var texteError string = "Failure Encryption : Impossible d'écrire la valeur d'initialisation IV. "
+  		var texteError string = "\033[31mFailure Encryption\033[0m : Impossible d'écrire la valeur d'initialisation IV. "
 		return errors.New(texteError) 
 	}
 
@@ -113,14 +113,10 @@ func EncryptFileAES(pathFile string, doc *structure.Documents) error{
 	lengthWritten[0]=byte(length)
 	_, err7 := outputFile.Write(lengthWritten)
 	if err7 != nil {
-  		var texteError string = "Failure Encryption : Impossible d'écrire la taille du dernier bloc chiffré. "
+  		var texteError string = "\033[31mFailure Encryption\033[0m : Impossible d'écrire la taille du dernier bloc chiffré. "
 		return errors.New(texteError)
 	}
 
-		fmt.Println(iterations)
-		fmt.Println(length)
-		fmt.Println(aes.BlockSize)
-
 	// chiffrement de chaque bloc de données et ecriture des donnees chiffrees
 	input := make([]byte, 16)
 	var cipherBlock []byte
@@ -132,7 +128,7 @@ func EncryptFileAES(pathFile string, doc *structure.Documents) error{
 		// lecture de chaque bloc de 16 octets
 		_, err8 := inputFile.Read(input)
 		if err8 != nil {
-  			var texteError string = "Failure Encryption : Impossible de lire dans le fichier à chiffrer "+pathFile+". "
+  			var texteError string = "\033[31mFailure Encryption\033[0m : Impossible de lire dans le fichier à chiffrer "+pathFile+". "
 			return errors.New(texteError)
 		}
 
@@ -145,14 +141,14 @@ func EncryptFileAES(pathFile string, doc *structure.Documents) error{
 		var err10 error
 		cipherBlock, err10 = EncryptBlocAES(IV, doc.Hash, input)
 		if err10 != nil {
-			var texteError string = "Failure Encryption : Impossible de chiffrer le fichier "+pathFile+". "
+			var texteError string = "\033[31mFailure Encryption\033[0m : Impossible de chiffrer le fichier "+pathFile+". "
 			return errors.New(texteError)
 		}
 
 		// écriture du bloc chiffré
 		_, err11 := outputFile.Write(cipherBlock)
 		if err11 != nil {
-  			var texteError string = "Failure Encryption : Impossible d'écrire dans le fichier "+pathFile+".gsh. "
+  			var texteError string = "\033[31mFailure Encryption\033[0m : Impossible d'écrire dans le fichier "+pathFile+".gsh. "
 			return errors.New(texteError)
 		}
 	}
@@ -161,94 +157,103 @@ func EncryptFileAES(pathFile string, doc *structure.Documents) error{
     outputFile.Close()
     inputFile.Close()
 
-    var messageSuccess string = "- Success Encryption : "+pathFile+" : resultat dans le fichier "+pathFile+".gsh"
+    var messageSuccess string = "- \033[32mSuccess Encryption\033[0m : "+pathFile+" : resultat dans le fichier "+pathFile+".gsh"
     fmt.Println(messageSuccess)
     return nil
 
 }
 
+// EncryptFolder chiffre le contenu d'un dossier de chemin path avec les données doc. 
 func EncryptFolder (path string, d *structure.Documents) {
-    //On lit dans le dossier visée par le chemin
-   entries, err := ioutil.ReadDir(path)
 
+    // On lit dans le dossier visée par le chemin
+   entries, err := ioutil.ReadDir(path)
     if err != nil {
-        fmt.Println("- Failure Encryption : impossible d'ouvrir "+path)
+        fmt.Println("- \033[31mFailure Encryption\033[0m : impossible d'ouvrir "+path)
     }
+
+    // Pour chaque élément du dossier. 
     for _, entry := range entries {
 
         p:=path + entry.Name()
-        // si l'extension du fichier est différent de .gsh on peut chiffrer le fichier
-        if(p[len(p)-4:]!=".gsh"){
 
-           //crypto.EncryptFileAES(path+entry.Name(),d)
+        // Si l'extension du fichier est différent de .gsh on peut chiffrer le fichier
+        if(p[len(p)-4:]!=".gsh"){
            
            newPath := path+entry.Name()
-           //fmt.Println(newPath)
-
            fi, err := os.Stat(newPath)
             valid := true
             if err != nil {
-                fmt.Println("- Failure Encryption : "+newPath+" n'existe pas ")
+                fmt.Println("- \033[31mFailure Encryption\033[0m : "+newPath+" n'existe pas ")
                 valid = false
             }
 
+            // Si l'élément du dossier est valide. 
             if valid == true {
+
                 mode := fi.Mode();
 
-                //si l'objet spécifié par le chemin est un dossier.
+                // Si l'objet spécifié par le chemin est un dossier.
                 if(mode.IsDir()==true){
 
-                    //Si l'utilisateur a oublié le "/" à la fin du chemin du fichier
+                    // Si l'utilisateur a oublié le "/" à la fin du chemin du fichier.
                     if(strings.LastIndexAny(newPath, "/") != len(newPath) - 1){
                       newPath=newPath+ string(os.PathSeparator)
-                      //appeler EncryptFolder
-                      EncryptFolder(newPath, d)
                     }
+                    // Chiffrement du dossier. 
+                    EncryptFolder(newPath, d)
 
-                // si l'objet spécifié par le chemin est un fichier.
+                // Si l'objet spécifié par le chemin est un fichier.
                 }else if mode.IsRegular()== true {
                     errFile := EncryptFileAES(newPath,d)
                     if errFile != nil {
                         fmt.Println(errFile)
                     }
                 }
-
             }
         }
     }
 }
 
+// DecryptFileFolder déchiffre les éléments choisis par l'utilisateur avec les données doc. 
 func EncryptFileFolder(d *structure.Documents) {
+
+	// Pour chaque élément choisi par l'utilisateur. 
     for i := 0; i < len(d.Doc); i++ {
+
+    	// Lecture de cet élément. 
         fi, err := os.Stat(d.Doc[i])
         valid := true
         if err != nil {
-            fmt.Println("- Failure Encryption : "+d.Doc[i]+" n'existe pas ")
+            fmt.Println("- \033[31mFailure Encryption\033[0m : "+d.Doc[i]+" n'existe pas ")
             valid = false
         }
 
+        // Si cet élément est valide. 
         if valid == true {
             mode := fi.Mode();
 
-            //si l'objet spécifié par le chemin est un dossier.
+            // Si l'objet spécifié par le chemin est un dossier.
             if(mode.IsDir()==true){
 
-                //Si l'utilisateur a oublié le "/" à la fin du chemin du fichier
+                // Si l'utilisateur a oublié le "/" à la fin du chemin du fichier. 
                 if(strings.LastIndexAny(d.Doc[i], "/") != len(d.Doc[i]) - 1){
                   d.Doc[i]=d.Doc[i]+ string(os.PathSeparator)
-                  //appeler EncryptFolder
-                  EncryptFolder(d.Doc[i], d)
+                  
                 }
 
-            // si l'objet spécifié par le chemin est un fichier.
+                // Chiffrement du dossier. 
+                EncryptFolder(d.Doc[i], d)
+
+            // Si l'objet spécifié par le chemin est un fichier.
             }else if mode.IsRegular()== true {
+
+            	// Chiffrement du fichier. 
                 errFile := EncryptFileAES(d.Doc[i],d)
                 if errFile != nil {
                     fmt.Println(errFile)
                 }
             }
-
         }
-        
     }
 }
\ No newline at end of file
diff --git a/crypto/encrypt_test.go b/crypto/encrypt_test.go
index 29f641e..cf84ab5 100644
--- a/crypto/encrypt_test.go
+++ b/crypto/encrypt_test.go
@@ -1,23 +1,10 @@
-
+// Package crypto contenant les fonctions de chiffrement/déchiffrement.
 package crypto
 
 import "testing"
 import "encoding/hex"
-//import "fmt"
-
-
-/*func TestXor(t *testing.T) {
-	a := []byte{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
-	b := []byte{254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254}
-	c := Xor (a, b)
-	test := []byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
-
-	if testEgaliteSlice(test, c) == false {
-    	t.Errorf("Assertion TestXor de encrypt_test FAILED.")
-    }
-
-}*/
 
+// Test qui chiffre un bloc. 
 func TestEncryptBlocAES(t *testing.T){
 	// IV sur 16 octets (128 bits).
 	iv := []byte{170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170}
diff --git a/crypto/hash.go b/crypto/hash.go
index bdd685c..a3d038c 100644
--- a/crypto/hash.go
+++ b/crypto/hash.go
@@ -1,3 +1,4 @@
+// Package crypto contenant les fonctions de chiffrement/déchiffrement.
 package crypto
 
 import "crypto/sha256"
@@ -33,7 +34,6 @@ func CreateHash(doc *structure.Documents) {
     // génération du hash. 
     hash.Write(concat)
     doc.Hash = hash.Sum(nil)
-
 }
 
 // DeductHash va déduire SHA256(salt|password) avec salt déjà initialisé. 
diff --git a/crypto/hash_test.go b/crypto/hash_test.go
index 6f077b9..6079386 100644
--- a/crypto/hash_test.go
+++ b/crypto/hash_test.go
@@ -1,10 +1,12 @@
+// Package crypto contenant les fonctions de chiffrement/déchiffrement.
 package crypto
 
 import "testing"
-//import "fmt"
 import "crypto/sha256"
+
 import "github.com/Heisenberk/goshield/structure"
 
+// testEgaliteSlice renvoie true si les deux slices sont égaux et false sinon. 
 func testEgaliteSlice(a, b []byte) bool {
 	if len(a)!= len(b){
 		return false
@@ -17,6 +19,7 @@ func testEgaliteSlice(a, b []byte) bool {
 	return true
 }
 
+// Test la bonne création d'un hash. 
 func TestCreateHash(t *testing.T) {
 	salt := []byte{84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84}
 	doc := structure.Documents{Mode: structure.ENCRYPT, Password: "password", Salt: salt}
diff --git a/env/JNotes b/env/JNotes
deleted file mode 160000
index f187b04..0000000
--- a/env/JNotes
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit f187b04cb9f328ae44c3efebfc3f7fb735fab20f
diff --git a/env/ScannerCommand.java b/env/ScannerCommand.java
deleted file mode 100644
index 0d87ece..0000000
--- a/env/ScannerCommand.java
+++ /dev/null
@@ -1,44 +0,0 @@
-package fr.uvsq.jnotes.command;
-
-import java.util.Scanner;
-
-/**
- * Classe ScannerCommand qui va lire les commandes de l'utilisateur qui n'a pas mis d'arguments au départ. 
- */
-public class ScannerCommand {
-	
-	/**
-	 * Scanner permettant d'interpréter les commandes de l'utilisateur. 
-	 */
-	private Scanner scanner;
-	
-	/**
-	 * Constructeur de ScannerCommand qui initialise le scanner. 
-	 */
-	public ScannerCommand() {
-		this.scanner = new Scanner(System.in);
-	}
-	
-	/**
-	 * Methode qui affiche les différentes commandes de l'application. 
-	 */
-	public void afficheCommandes() {
-		System.out.println("Commandes de Jnotes: ");
-		System.out.println(" ");
-		System.out.println("- edit/e [nom de la note] : créer ou modifier une note. ");
-		System.out.println("- list/ls : lister les notes existantes. ");
-		System.out.println("- delete/d [nom de la note]: supprimer une note. ");
-		System.out.println("- view/v [nom de la note]: voir une note. ");
-		System.out.println("- search/s [mot a rechercher] : rechercher dans les notes d'un mot clé. ");	
-		System.out.println("- param/p : visualiser les paramètres de configuration (application d'édition de note et le chemin du dossier des notes). ");
-		System.out.println("- param/p path [chemin] : modifier les paramètres de configuration (chemin du dossier des notes). ");
-		System.out.println("- param/p app [nom de l'application externe] : modifier les paramètres de configuration (app : application d'édition de note). ");
-	}
-	
-	/**
-	 * Méthode saisie qui va interpréter les commandes de l'utilisateur qui n'a pas mis d'arguments au départ. 
-	 */
-	public void saisie() {
-		// A remplir comme CalculatriceRPN
-	}
-}
diff --git a/goshield.go b/goshield.go
index 5c52003..8c5ab6f 100644
--- a/goshield.go
+++ b/goshield.go
@@ -9,8 +9,11 @@ import "github.com/Heisenberk/goshield/structure"
 // main représente la fonction principale de GoShield.
 func main() {
 
+	// Lecture de la demande de l'utilisateur. 
 	var d *structure.Documents
 	d, err := command.Parse(os.Args[1:])
+
+	// Interprétation de l'application en réponse à la demande de la commande de l'utilisateur. 
 	command.Interpret(d,err)
 
 }