Gestion des bugs de chemin et d'import

Author: seathiel-12

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

@@ -1,4 +1,4 @@
-from ..crypto_analyzer import CryptoAnalyzer
+from crypto_analyzer import CryptoAnalyzer
 from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
 from cryptography.hazmat.primitives import hashes
 import re
@@ -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,12 @@
+import base64
+import os
 from ..detecteur_crypto import CryptoAnalyzer
 from ..utils import calculer_entropie
 import hashlib
-from cryptography.hazmat.primitives.ciphers import algorithms, Cipher, modes
+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 +21,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 +136,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 +162,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 +197,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

@@ -8,8 +8,8 @@
 from typing import List
 
 sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-from crypto_analyzer import CryptoAnalyzer
-from utils import calculer_entropie
+from ..crypto_analyzer import CryptoAnalyzer
+from ..utils import calculer_entropie
 
 # Définition de la classe ChaCha20_Analyzer
 class ChaCha20_Analyzer(CryptoAnalyzer):
@@ -101,7 +101,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]:
         """
@@ -118,6 +121,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:
@@ -154,7 +158,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,14 @@
 import os
 import time
 from typing import List, Union
-
+from pathlib import Path
 # Import des modules d'analyse
-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
-from analyzers.aes_gcm_analyzer import Aes_Gcm_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
+from .analyzers.aes_gcm_analyzer import Aes_Gcm_Analyzer
+from .rapport_mission import generer_rapport_mission
 
 # Import des modules utilitaries
 from utils import est_dechiffre
@@ -68,7 +69,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 +157,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 +182,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({
@@ -252,4 +253,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(f"{os.path.abspath(os.curdir)}\\CryptoForensic-Python\\data\\mission2.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

@@ -55,7 +55,7 @@ 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
@@ -100,7 +100,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