Feature/tests unitaires (#42)

* Documentation de la fonction d'entropie

* Essai de fusion (1/2)

* Implementation de la fonction de validation du texte déchiffrer

* Récupération du main (1/2)

* Mise en place des tests unitaires (1/4)

* Revert "Mise en place des tests unitaires (1/4)"

This reverts commit e965801.

* Mise en place des tests unitaires (1/4)

* Définition de la classe de gestion des rapports de ission et implémentatioon de la fonction de génération des rapport de synthèse

* Implémentation de la fonction de recherche d'anciens rapports

* Mise en place des tests liés à l'analyzer aes cbc

* Corrections de typage et de logique

* Correction du comportement à la levée de l'exception

* Correction de la lgoque de test de test_exception_déchiffrer

* Corection de la logique de test_verification_texte_dechiffre

* fix: Utilisation de pathlib pour une gestion portable des chemins.

* merge réussi

* Validation des tests et corrections du rapport mission

* chekpoint: Blowfish _Analyzer.identifier_algo()

* add: Intiialisation de Blowfish_Analyzer et implémentation de Blowfish_Analyzer.identifier_algo()

* Implémentation de Blowfish_Analyzer.filtrer_dictionnaire_par_indice()

* Correction de bug

* Implementer de Blowfish déchiffrer

* Integration de blowfish dans le detecteur crypto

* Gestion des bugs de chemin et d'import

* tests aes_gcm

---------

Co-authored-by: e-mandy <andymfrd02@gmail.com>
Co-authored-by: Seathiel <ogoudedjimonde@gmail.com>

Author: 3 people

main.py

@@ -1,2 +1,16 @@
 from src.detecteur_crypto import DetecteurCryptoOrchestrateur
-print(DetecteurCryptoOrchestrateur().analyser_fichier_specifique('data/mission1.enc'))
+from src.analyzers.blowfish_analyzer import Blowfish_Analyzer
+from src.analyzers.aes_cbc_analyzer import Aes_Cbc_Analyzer
+from src.interface_console import consoleInterface
+import os
+# print(DetecteurCryptoOrchestrateur().analyser_fichier_specifique('data/mission1.enc'))
+
+# try:
+#     resultat_dechiffrement: bytes = Blowfish_Analyzer().dechiffrer("data/mission3.enc", Blowfish_Analyzer().generer_cles_candidates('keys/wordlist.txt')[2])
+#     print(f"Résultat du déchiffrement : {resultat_dechiffrement.decode('utf-8')}")
+# except ValueError as ve:
+#     print(ve)
+# except FileNotFoundError:
+#     print("Erreur: Le fichier 'mission3.enc' est introuvable.")
+
+consoleInterface()

requirements.txt

@@ -1,5 +1,5 @@
 cffi==1.17.1
-cryptography==45.0.5
+cryptography==43.0.0
 pycparser==2.22
 pycryptodome==3.23.0
 rich==14.1.0

resultat.txt

@@ -85,4 +85,10 @@ def generer_cles_candidates(self, chemin_dictionnaire: str) -> list[bytes]:
       cle_derivee: bytes = kdf.derive(mot_de_passe_en_octets)
       clees_candidates.append(cle_derivee)
 
-    return clees_candidates
+    return clees_candidates
+
+  def identifier_algo(self, chemin_fichier_chiffre):
+     return super().identifier_algo(chemin_fichier_chiffre)
+   
+  def dechiffrer(self, chemin_fichier_chiffre, cle_donnee):
+      return super().dechiffrer(chemin_fichier_chiffre, cle_donnee)

src/analyzers/aes_gcm_analyzer.py

@@ -1,8 +1,11 @@
 from src.crypto_analyzer import CryptoAnalyzer
 from src.utils import calculer_entropie
 import hashlib
-from cryptography.hazmat.primitives.ciphers import algorithms, Cipher, modes
+import base64
+import re
+from cryptography.hazmat.primitives.ciphers import Cipher, modes
 from cryptography.hazmat.primitives.padding import PKCS7
+from cryptography.hazmat.decrepit.ciphers.algorithms import Blowfish
 class Blowfish_Analyzer(CryptoAnalyzer):
   '''Détermine si l'algo blowfish est utilisé, génère des clés et tente de de déchffrer un fichier chiffré en utilisant les clés générées.
   
@@ -17,7 +20,7 @@ class Blowfish_Analyzer(CryptoAnalyzer):
 
   '''
 
-  __BLOWFISH_TAILLE_BLOC = 8
+  __BLOWFISH_TAILLE_BLOC = 64
   __BLOWFISH_TAILLE_IV = 8
 
   def identifier_algo(self, chemin_fichier_chiffre: str) -> float:
@@ -132,6 +135,18 @@ def generer_cles_candidates(self, chemin_dictionnaire: str) -> list[bytes]:
 
     return cles_candidates
 
+  def decode_base64(self, encoded_bytes, altchars=b'+/'):
+    encoded_bytes = re.sub(
+        rb'[^a-zA-Z0-9%s]+' %
+        altchars, b'', encoded_bytes)
+
+    missing_padding_length = len(encoded_bytes) % 4
+
+    if missing_padding_length:
+        encoded_bytes += b'=' * (4 - missing_padding_length)
+
+    return base64.b64decode(encoded_bytes, altchars)
+  
   def dechiffrer(self, chemin_fichier_chiffre: str, cle_donnee: bytes) -> bytes:
     """
     Déchiffre le fichier supposé crypté par l'algorithme blowfish avec la clé donnée en respectant les critères de 
@@ -146,19 +161,22 @@ def dechiffrer(self, chemin_fichier_chiffre: str, cle_donnee: bytes) -> bytes:
     """
 
     #La taille de clé est dans l'intervalle 32-448bits et est multiple de 8
-    if len(cle_donnee) not in range(32, 448, 8):
+    print(cle_donnee)
+    if len(cle_donnee) not in range(4, 55, 8):
+      print(len(cle_donnee))
       raise ValueError('Taille de clé invalide.')
 
     try:
-      
-      algorithm_blowfish = algorithms.Blowfish(cle_donnee)
+    
+      algorithm_blowfish = Blowfish(self.decode_base64(cle_donnee))
       texte_chiffre = ''
 
-      #Récupération de l'IV et des texte chiffré das le fichier
+      #Récupération de l'IV et du texte chiffré dans le fichier
       with open(chemin_fichier_chiffre, 'rb') as f:
-        initialization_vector = f.read(self.__BLOWFISH_TAILLE_IV)
-        texte_chiffre = f.read()
+        donnees = f.read()
       f.close()
+      initialization_vector = donnees[:self.__BLOWFISH_TAILLE_IV]
+      texte_chiffre = donnees[self.__BLOWFISH_TAILLE_IV:]
 
       #Initialisation du cipher
       cipher = Cipher(algorithm_blowfish, modes.CBC(initialization_vector))
@@ -178,3 +196,11 @@ def dechiffrer(self, chemin_fichier_chiffre: str, cle_donnee: bytes) -> bytes:
       raise
 
 
+# if __name__ == "__main__":
+#     try:
+#         resultat_dechiffrement: bytes = Blowfish_Analyzer().dechiffrer("CryptoForensic-Python/data/mission3.enc", os.urandom(32))
+#         print(f"Résultat du déchiffrement : {resultat_dechiffrement.decode('utf-8')}")
+#     except ValueError as ve:
+#         print(ve)
+#     except FileNotFoundError:
+#         print("Erreur: Le fichier 'mission2.enc' est introuvable.")

src/analyzers/blowfish_analyzer.py

@@ -100,7 +100,10 @@ def filtrer_dictionnaire_par_indices(self, chemin_dictionnaire: str) -> List[byt
             Returns: 
                 list[bytes]: La liste de tous les mots susceptibles d'être des clés adéquates.
         """
-        return []
+        f = open('keys/wordlist.txt', 'rb')
+        cle = f.readlines()
+        f.close()
+        return cle
 
     def generer_cles_candidates(self, chemin_dictionnaire: str) -> List[bytes]:
         """
@@ -117,6 +120,7 @@ def generer_cles_candidates(self, chemin_dictionnaire: str) -> List[bytes]:
         cles_candidates: List[bytes] = []
         for cle in donnees_fichier_filtre:
             cles_candidates.append(hashlib.sha256(cle).digest())
+        print(cles_candidates)
         return cles_candidates
 
     def dechiffrer(self, chemin_fichier_chiffre: str, cle_donnee: bytes) -> bytes:
@@ -153,7 +157,7 @@ def dechiffrer(self, chemin_fichier_chiffre: str, cle_donnee: bytes) -> bytes:
 # L'appel direct a été déplacé dans un bloc if __name__ == "__main__" pour de bonnes pratiques (Mouwafic)
 if __name__ == "__main__":
     try:
-        resultat_dechiffrement: bytes = ChaCha20_Analyzer().dechiffrer("mission2.enc", os.urandom(32))
+        resultat_dechiffrement: bytes = ChaCha20_Analyzer().dechiffrer("data/mission2.enc", os.urandom(32))
         print(f"Résultat du déchiffrement : {resultat_dechiffrement.decode('utf-8')}")
     except ValueError as ve:
         print(ve)

src/analyzers/chacha20_analyzer.py

@@ -2,13 +2,15 @@
 import os
 import time
 from typing import List, Union
-
+from pathlib import Path
 # Import des modules d'analyse
 from src.analyzers.aes_cbc_analyzer import Aes_Cbc_Analyzer
 from src.crypto_analyzer import CryptoAnalyzer
 from src.analyzers.chacha20_analyzer import ChaCha20_Analyzer
 from src.analyzers.blowfish_analyzer import Blowfish_Analyzer
 from src.analyzers.aes_gcm_analyzer import Aes_Gcm_Analyzer
+from src.analyzers.fernet_analyzer import FernetAnalyzer
+from src.rapport_mission import generer_rapport_mission
 
 # Import des modules utilitaries
 from src.utils import est_dechiffre
@@ -41,7 +43,8 @@ def __init__(self):
             "AES-CBC": Aes_Cbc_Analyzer(),
             "ChaCha20": ChaCha20_Analyzer(),
             "Blowfish": Blowfish_Analyzer(),
-            "AES-GCM": Aes_Gcm_Analyzer()
+            "AES-GCM": Aes_Gcm_Analyzer(),
+            "Fernet": FernetAnalyzer(),
         }
         self.missions_completees: list[dict[str, Union[str, list[ResultatAnalyse], float]]]  = []
         self.statistiques_globales: dict[str, Union[int, float]] = {
@@ -68,7 +71,7 @@ def analyser_fichier_specifique(self, chemin_fichier_chiffre: str) -> ResultatAn
 
         try:
             # Vérification de l'existence du fichier
-            if not os.path.exists(f"data/{chemin_fichier_chiffre}"):
+            if not os.path.isfile(Path('data')/f"{chemin_fichier_chiffre}"):
                 print("Erreur: Fichier non trouvé")
                 return ResultatAnalyse("", b"", 0.0, b"", 0.0, 0)
 
@@ -156,7 +159,7 @@ def mission_complete_automatique(self, dossier_chiffres: str, chemin_dictionnair
                 chemin_fichier = os.path.join(dossier_chiffres, fichier)
 
                 # Analyse du fichier
-                resultat = self.analyser_fichier_specifique(chemin_fichier)
+                resultat = self.analyser_fichier_specifique(fichier)
 
                 # Tentative de déchiffrement si algorithme détecté
                 if resultat.algo:
@@ -181,7 +184,7 @@ def mission_complete_automatique(self, dossier_chiffres: str, chemin_dictionnair
                     print(f"{fichier}: Aucun algorithme détecté")
 
             # Rapport de synthèse final
-            self.generer_rapport_synthese(resultats, time.time() - debut_mission)
+            generer_rapport_mission().generer_rapport_synthese(resultats, time.time() - debut_mission)
 
             # Mise à jour des statistiques globales
             self.missions_completees.append({
@@ -251,4 +254,5 @@ def attaque_dictionnaire_manuelle(self, chemin_fichier: str, algorithme_choisi:
             print(f"Erreur lors de l'attaque: {str(e)}")
             temps_execution = time.time() - debut_attaque
             return ResultatAnalyse("", b"", 0.0, b"", temps_execution, 0)
-# print(DetecteurCryptoOrchestrateur().analyser_fichier_specifique('data/mission1.enc'))
+
+# print(DetecteurCryptoOrchestrateur().analyser_fichier_specifique(f"{os.path.abspath(os.curdir)}\\CryptoForensic-Python\\data\\mission2.enc"))

src/detecteur_crypto.py

@@ -94,7 +94,7 @@ def menu_1(self):
         print(f"\n[bold]Score de probabilité[/bold] : [green]{data.score_probabilite}[/green]")
         # print(data.texte_dechiffre)
         print(f"\n[bold]Temps d'éxécution[/bold] : [green]{round(data.temps_execution,4)}[/green] s")
-        esc=input("Veuillez appuyer sur la touche entrer pour retrouner au menu principal")
+        esc=input("Veuillez appuyer sur la touche entrer pour retourner au menu principal")
         if esc=="":
             self.default_menu()
         else : self.default_menu()
@@ -107,14 +107,24 @@ def menu_2(self):
         self.dynamiqueText("Mission complète automatique","green")
         self.dynamiqueText("Veuillez entrer le chemin du dossier :","white")
         time.sleep(0.02)
-        # chemin_dossier = self.prompt.ask("Veuillez entrer le chemin du dossier : ")
-        self.console.clear()
+        
+        chemin_dossier = self.prompt.ask("Veuillez entrer le chemin du dossier : ")
+        resultat = DetecteurCryptoOrchestrateur().mission_complete_automatique(chemin_dossier, "keys/wordlist.txt")
+        print(line for line in resultat)
+        # self.console.clear()
         self.dynamiqueText("Mission en cours...","green")
         time.sleep(0.02)
-        self.console.clear()
+        # self.console.clear()
         self.dynamiqueText("Mission terminée","green")
+        
+        esc=input("Veuillez appuyer sur la touche entrer pour retourner au menu principal")
         time.sleep(0.02)
-        self.default_menu()
+        
+        if esc=="":
+            self.default_menu()
+        else : self.default_menu()
+        
+        # self.default_menu()
 
     def menu_3(self):
         self.console.clear()

src/interface_console.py

@@ -56,15 +56,15 @@ def recuperer_ancien_rapport(self, base_date:str)->list|str:
         except FileNotFoundError:
             print('Fichier non trouvé')
 
-print(generer_rapport_mission().generer_rapport_synthese({
-    'algorithme':'CHACHA20', 
-    'fichier': 'mission1.enc',
-    'cle':'PK7',
-    'tentatives':'127',
-    'temps_execution':"368s",
-    'taux_succes': "97%",
-    'statut_succes':'Succès',
-    'texte_dechiffre':'Je suis là!'
-}))
+# print(generer_rapport_mission().generer_rapport_synthese({
+#     'algorithme':'CHACHA20', 
+#     'fichier': 'mission1.enc',
+#     'cle':'PK7',
+#     'tentatives':'127',
+#     'temps_execution':"368s",
+#     'taux_succes': "97%",
+#     'statut_succes':'Succès',
+#     'texte_dechiffre':'Je suis là!'
+# }))
 
-print(generer_rapport_mission().recuperer_ancien_rapport("05/08/25")[0])
+# print(generer_rapport_mission().recuperer_ancien_rapport("05/08/25")[0])

src/rapport_mission.py

@@ -1,4 +1,5 @@
 import math
+import re
 import string
 from pathlib import Path
 from typing import Any, Dict, List, TypedDict
@@ -55,10 +56,10 @@ def est_dechiffre(texte:str) -> bool:
         pourcent += 30
 
     # Le respect de la ponctuation, les 20% restants
-    if stats['ponctuation'] > 50 :
+    if stats['ponctuation_valide'] > 50 :
         pourcent += 20
 
-    return True if pourcent > 70 else False
+    return True if pourcent > 80 else False
 
 
 
@@ -100,7 +101,7 @@ def verifier_texte_dechiffre(texte: str) -> Dict[str, Any]:
     copy=texte
     for lettre in tab:
         copy=copy.replace(lettre, ' ')
-    mots = [mot for mot in copy.strip().split(' ') if mot]
+    mots = [mot.removesuffix('\n').removeprefix('\n') for mot in copy.strip().split(' ') if mot != '\n']
     stats['nombre_mots']=len(mots)
 
     # Verifier que le chaque mot du texte est un mot anglais/francais 
@@ -119,7 +120,7 @@ def verifier_texte_dechiffre(texte: str) -> Dict[str, Any]:
                 try:
                     with open(chemin, 'r', encoding='latin-1') as f: 
                         for ligne in f:
-                            if ligne.strip() == mot:
+                            if  re.match(ligne.strip().removesuffix('\n'), mot, re.I):
                                 mots_valides += 1
                                 trouve=True
                                 break