Implémentation de la méthode déchiffrer et intégration dans le détecteur crypto (#31)

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

* 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

* 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

---------

Co-authored-by: Let Me Cook <badaroumouwafic@gmail.com>

Author: seathiel-12

src/analyzers/aes_cbc_analyzer.py

@@ -1,5 +1,5 @@
-from ..crypto_analyzer import CryptoAnalyzer
-from ..utils import calculer_entropie
+from crypto_analyzer import CryptoAnalyzer
+from utils import calculer_entropie
 from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
 from cryptography.hazmat.primitives import hashes
 from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
@@ -10,7 +10,7 @@ class Aes_Cbc_Analyzer(CryptoAnalyzer):
   
     Cette classe a trois méthodes:
     - identifier_algo: Détermine si l'algo de chiffrement utilsé sur le fichier chiffré qui lui est passé en paramètre est l'aes_cbc.
-    - generer_cles_candidates: Génère une liste de clés candidates pour le déchiffrement du fichier chiffré
+     - generer_cles_candidates: Génère une liste de clés candidates pour le déchiffrement du fichier chiffré
     - dechiffrer: fait le déchiffrement proprement dit sur la base de la liste des clés générées
     
     Attributes:

src/analyzers/blowfish_analyzer.py

@@ -1,7 +1,8 @@
 from ..detecteur_crypto import CryptoAnalyzer
 from ..utils import calculer_entropie
 import hashlib
-
+from cryptography.hazmat.primitives.ciphers import algorithms, Cipher, modes
+from cryptography.hazmat.primitives.padding import PKCS7
 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.
   
@@ -11,9 +12,14 @@ class Blowfish_Analyzer(CryptoAnalyzer):
     - dechiffrer: fait le déchiffrement proprement dit sur la base de la liste des clés générées
     
     Attributes:
-    
+    __BLOWFISH_TAILLE_BLOC : taille à considérer pour les blocs de données chiffrés que le PKCS7 doit prendre en compte (8 bits)
+    __BLOWFISH_TAILLE_IV : taille du vecteur d'initialisation en début de fichier (8 bits)
 
   '''
+  
+  __BLOWFISH_TAILLE_BLOC = 8
+  __BLOWFISH_TAILLE_IV = 8
+  
   def identifier_algo(self, chemin_fichier_chiffre: str) -> float:
     '''
       Détermine la probabilité que l'algo de chiffrement utilisé soit blowfish en:
@@ -96,32 +102,79 @@ def __filtrer_dictionnaire_par_indice(self, chemin_dictionnaire: str) -> list[st
     return mots_filtres
 
   def generer_cles_candidates(self, chemin_dictionnaire: str) -> list[bytes]:
-          """
-          Génère une liste de clés candidates pour le déchiffrement.
-          Les candidats incluent les mots de passe directs, leur hash MD5 et leur hash SHA1.
-          
-          Args:
-              chemin_dictionnaire(str): Le chemin vers le fichier de dictionnaire.
-          
-          Returns:
-              list[bytes]: Une liste des clés candidates sous forme d'octets.
-          """
-          cles_candidates: list[bytes] = []
-          # Utilisation de la méthode privée pour filtrer les mots
-          mots_de_passe_cible = self.__filtrer_dictionnaire_par_indice(chemin_dictionnaire)
-          
-          for mot in mots_de_passe_cible:
-              mot_en_bytes = mot.encode("utf-8")
-              
-              # 1. Ajouter le mot de passe direct comme clé candidate
-              cles_candidates.append(mot_en_bytes)
-              
-              # 2. Hachage MD5 et ajout à la liste (en bytes)
-              hash_md5 = hashlib.md5(mot_en_bytes).digest()
-              cles_candidates.append(hash_md5)
-              
-              # 3. Hachage SHA1 et ajout à la liste (en bytes)
-              hash_sha1 = hashlib.sha1(mot_en_bytes).digest()
-              cles_candidates.append(hash_sha1)
-          
-          return cles_candidates
+    """
+    Génère une liste de clés candidates pour le déchiffrement.
+    Les candidats incluent les mots de passe directs, leur hash MD5 et leur hash SHA1.
+    
+    Args:
+        chemin_dictionnaire(str): Le chemin vers le fichier de dictionnaire.
+    
+    Returns:
+        list[bytes]: Une liste des clés candidates sous forme d'octets.
+    """
+    cles_candidates: list[bytes] = []
+    # Utilisation de la méthode privée pour filtrer les mots
+    mots_de_passe_cible = self.__filtrer_dictionnaire_par_indice(chemin_dictionnaire)
+    
+    for mot in mots_de_passe_cible:
+        mot_en_bytes = mot.encode("utf-8")
+        
+        # 1. Ajouter le mot de passe direct comme clé candidate
+        cles_candidates.append(mot_en_bytes)
+        
+        # 2. Hachage MD5 et ajout à la liste (en bytes)
+        hash_md5 = hashlib.md5(mot_en_bytes).digest()
+        cles_candidates.append(hash_md5)
+        
+        # 3. Hachage SHA1 et ajout à la liste (en bytes)
+        hash_sha1 = hashlib.sha1(mot_en_bytes).digest()
+        cles_candidates.append(hash_sha1)
+    
+    return cles_candidates
+    
+  def dechiffrer(self, chemin_fichier_chiffre: str, cle_donnee: bytes):
+    """
+    Déchiffre le fichier supposé crypté par l'algorithme blowfish avec la clé donnée en respectant les critères de 
+      - récupération de l'IV
+      - suppression de padding
+    
+    Args: 
+      chemin_fichier_chiffre (str): le chemin vers le fichier chiffré
+      clee_donnee (bytes): La clé à utiliser pour le déchiffrement
+    Returns:
+      bytes: les données originales 
+    """
+    
+    #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):
+      return ValueError('Taille de clé invalide.')
+     
+    try:
+      
+      algorithm_blowfish = algorithms.Blowfish(cle_donnee)
+      texte_chiffre = ''
+
+      #Récupération de l'IV et des texte chiffré das le fichier
+      with open(chemin_fichier_chiffre, 'rb') as f:
+        initialization_vector = f.read(self.__BLOWFISH_TAILLE_IV)
+        texte_chiffre = f.read()
+      f.close()
+      
+      #Initialisation du cipher
+      cipher = Cipher(algorithm_blowfish, modes.CBC(initialization_vector))
+      decrypteur = cipher.decryptor()
+
+      #Suppresseur de padding
+      supresseur_padding = PKCS7(self.__BLOWFISH_TAILLE_BLOC).unpadder()
+      
+      #Décriptage des données avec le padding(remplissage aléatoire)
+      donnees_chiffrees_avec_padding = decrypteur.update(texte_chiffre) + decrypteur.finalize()
+      
+      #Suppression du padding et récupération de la donnée finale
+      donnees_originales = supresseur_padding.update(donnees_chiffrees_avec_padding) + supresseur_padding.finalize() 
+      return donnees_originales
+      
+    except (FileNotFoundError):
+      raise
+    
+

src/analyzers/chacha20_analyzer.py

@@ -174,12 +174,9 @@ def dechiffrer(self,chemin_fichier_chiffer : str ,clef :bytes)->str:
                 cipher = Cipher(algorithm_chacha20,mode=None)
                 decrypteur = cipher.decryptor()
                 return decrypteur.update(texte_chiffrer)
-                
-                
-
             except Exception as e:
                 print(f"Une erreur est survenu : {e}")
 
 
 
-# print(ChaCha20_Analyzer().dechiffrer("mission2.enc",os.urandom(32)))
+print(ChaCha20_Analyzer().dechiffrer("mission2.enc",os.urandom(32)))

src/detecteur_crypto.py

@@ -4,14 +4,13 @@
 from typing import List, Union
 
 # Import des modules d'analyse
-from .analyzers.aes_cbc_analyzer import Aes_Cbc_Analyzer
-from .crypto_analyzer import CryptoAnalyzer
-
-# Import de la classe abstraite
-from .analyzers.chacha20_analyzer import ChaCha20_Analyzer
+from analyzers.aes_cbc_analyzer import Aes_Cbc_Analyzer
+from crypto_analyzer import CryptoAnalyzer
+from analyzers.chacha20_analyzer import ChaCha20_Analyzer
+from analyzers.blowfish_analyzer import Blowfish_Analyzer
 
 # Import des modules utilitaries
-from .utils import est_dechiffre
+from utils import est_dechiffre
 
 class ResultatAnalyse:
     """
@@ -35,11 +34,12 @@ class DetecteurCryptoOrchestrateur:
 
     def __init__(self):
         """
-        Initialisation de tous les modules d'analyse disponibles (AES-CBC pour le moment)
+        Initialisation de tous les modules d'analyse disponibles 
         """
         self.analyzers: dict[str, CryptoAnalyzer] = {
             "AES-CBC": Aes_Cbc_Analyzer(),
             "ChaCha20": ChaCha20_Analyzer(),
+            "Blowfish": Blowfish_Analyzer()
         }
         self.missions_completees: list[dict[str, Union[str, list[ResultatAnalyse], float]]]  = []
         self.statistiques_globales: dict[str, Union[int, float]] = {
@@ -118,7 +118,7 @@ def __tenter_dechiffrement_avec_dictionnaire(self, chemin_fichier: str, cles_can
                 print(f"   Clé trouvée après {j+1} tentatives!")
                 break
         else:
-            print("   Aucune clé valide trouvée")
+            print("Aucune clé valide trouvée")
 
     def mission_complete_automatique(self, dossier_chiffres: str, chemin_dictionnaire: str) -> List[ResultatAnalyse]:
         """
@@ -250,4 +250,4 @@ def attaque_dictionnaire_manuelle(self, chemin_fichier: str, algorithme_choisi:
             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/interface_console.py

@@ -5,6 +5,7 @@
 from rich.text import Text
 from rich.prompt import Prompt
 from rich.table import Table
+from pathlib import Path
 # from detecteur_crypto import Analyser_fichier_uniquement
 # from detecteur_crypto import Analyser_fichier_sequentiels
 from .detecteur_crypto import DetecteurCryptoOrchestrateur
@@ -55,7 +56,7 @@ def default_menu(self):
         self.console.print(menuTag,menuOption)
         time.sleep(0.04)
 
-        choix = self.prompt.ask("Veuillez choisir une option ",choices=["1","2","3","4","5","6"])
+        choix = self.prompt.ask("Veuillez choisir une option ", choices=["1","2","3","4","5","6"])
         try:    
             if choix == "1":
                 self.menu_1()
@@ -145,7 +146,8 @@ def menu_5(self):
         mission_table.add_row("AES-256-GCM","mission4.enc","Acronyme d'une organisation internationale + année courante","Identifier le mode authentifié GCM et gérer l'authentification")
         mission_table.add_row("Fernet","mission5.enc","Phrase française simple encodée, liée à notre domaine d'étude","Reconnaître le format Fernet et sa structure particulière")
 
-        f = open("guideUtilisation.txt",'r')
+        chemin = Path().cwd()/'guideUtilisation.txt'
+        f = open(chemin,'r')
         algo_docs = Markdown(f.read())
         f.close()
 
@@ -175,7 +177,7 @@ def menu_5(self):
 
         for guide in guides:
             print(guide)
-            print("\n")
+            print("\n") 
 
         escape= input('')
         if escape != None:
@@ -187,4 +189,4 @@ def menu_6(self):
         time.sleep(2)
         self.console.clear()
 
-consoleInterface()
+consoleInterface()