Correction de l'orchestrateur et ajustements correspondants

Author: seathiel-12

main.py

@@ -1,4 +1,4 @@
-from src.detecteur_crypto import DetecteurCryptoOrchestrateur
+from src.detecteur_crypto import DetecteurCryptoOrchestrateur, ResultatAnalyse
 from src.analyzers.blowfish_analyzer import Blowfish_Analyzer
 from src.analyzers.aes_cbc_analyzer import Aes_Cbc_Analyzer
 from src.interface_console import consoleInterface
@@ -13,4 +13,5 @@
 # except FileNotFoundError:
 #     print("Erreur: Le fichier 'mission3.enc' est introuvable.")
 
-consoleInterface()
+consoleInterface()
+# print(DetecteurCryptoOrchestrateur().mission_complete_automatique('data/', 'keys/wordlist.txt'))

rapport_mission.txt

@@ -1 +1 @@
-RAPPORT DE SYNTHESE DU 05/08/25 � 00:01:06~ Mission 2: CHACHA20 ~ I - Statistiques relatives � l'analyse du fichier~Fichier crypt� par cet algorithme: mission1.enc~Cl� de d�chiffrement identifi�e: PK7 ~Nombre de tentatives: 127 ~Temps d'ex�cution: 368s ~ II - R�sultats obtenusTaux r�ussite du d�chiffrement: 97%(Succ�s)~Texte d�chiffr�: Je suis l�! ~
+RAPPORT DE SYNTHESE DU 11/08/25 � 04:19:59~ Mission 1: AES-CBC-256 ~ I - Statistiques relatives � l'analyse du fichier~-Fichier crypt� par cet algorithme: ('mission1.enc',)~-Cl� de d�chiffrement identifi�e: b'\xf7@[\xc1\xb5\x83c\xd8g?\xda\xcbO\xbd\rcZ\xfc\xfe\x9b\x0f\x88\r\xf1\x80\x89\xa1R\x0f\xd1f\xd8' ~-Nombre de tentatives: 1 ~-Temps d'ex�cution: 0.013037919998168945 ~ II - R�sultats obtenus~-Taux r�ussite du d�chiffrement: 69.42(Succ�s)~-Texte d�chiffr�: F�licitations ! Vous avez d�chiffr� la mission 1.~Le secret de cette mission est : AES-256-CBC est toujours largement utilis� dans l'industrie.~Cl� utilis�e : paris2024~Algorithme : AES-256-CBC avec PBKDF2 ~~RAPPORT DE SYNTHESE DU 11/08/25 � 04:19:59~ Mission 3: BLOWFISH ~ I - Statistiques relatives � l'analyse du fichier~-Fichier crypt� par cet algorithme: ('mission3.enc',)~-Cl� de d�chiffrement identifi�e: b'' ~-Nombre de tentatives: 15 ~-Temps d'ex�cution: 0.010114669799804688 ~ II - R�sultats obtenus~-Taux r�ussite du d�chiffrement: 0(Echec)~-Texte d�chiffr�: b'' ~~RAPPORT DE SYNTHESE DU 11/08/25 � 04:19:59~ Mission 5: FERNET ~ I - Statistiques relatives � l'analyse du fichier~-Fichier crypt� par cet algorithme: ('mission5.enc',)~-Cl� de d�chiffrement identifi�e: b"i'\xaaf\x99\xdc\xa0A\xed\xc6\xce\xfe`\xcc\xb9/\xf8\xa1\x0e~\x18\xd3\xbb\xeb\xa1\x9f\xc0|\xc8\xf1_\xdd" ~-Nombre de tentatives: 2 ~-Temps d'ex�cution: 0.016638517379760742 ~ II - R�sultats obtenus~-Taux r�ussite du d�chiffrement: 66.0(Succ�s)~-Texte d�chiffr�: Magnifique ! Derni�re mission compl�t�e.~Message final : j'adore la cryptographie~Cette phrase �tait la cl� elle-m�me !~Algorithme : Fernet (bas� sur AES-128-CBC + HMAC) ~~

src/detecteur_crypto.py

@@ -10,23 +10,24 @@
 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
+from src.rapport_mission import rapport_mission
 
 # Import des modules utilitaries
-from src.utils import est_dechiffre
+from src.utils import verifier_texte_dechiffre
 
 class ResultatAnalyse:
     """
         Classe représentant un résultat d'analyse.
     """
-    def __init__(self, algo: str, cle: bytes, score_probabilite: float, texte_dechiffre: bytes, temps_execution: float = 0.0, nb_tentatives: int = 0):
+    def __init__(self, algo: str, cle: bytes, score_probabilite: float, texte_dechiffre: bytes, temps_execution: float = 0.0, nb_tentatives: int = 0, fichier: str ='', taux_succes: float = 0.0):
         self.algo = algo
         self.cle = cle
         self.score_probabilite = score_probabilite
         self.texte_dechiffre = texte_dechiffre
         self.temps_execution = temps_execution
         self.nb_tentatives = nb_tentatives
-
+        self.fichier = fichier,
+        self.taux_succes = taux_succes
 class DetecteurCryptoOrchestrateur:
     """
             Classe principale qui centralise tout:
@@ -40,7 +41,7 @@ def __init__(self):
         Initialisation de tous les modules d'analyse disponibles 
         """
         self.analyzers: dict[str, CryptoAnalyzer] = {
-            "AES-CBC": Aes_Cbc_Analyzer(),
+            "AES-CBC-256": Aes_Cbc_Analyzer(),
             "ChaCha20": ChaCha20_Analyzer(),
             "Blowfish": Blowfish_Analyzer(),
             "AES-GCM": Aes_Gcm_Analyzer(),
@@ -89,7 +90,7 @@ def analyser_fichier_specifique(self, chemin_fichier_chiffre: str) -> ResultatAn
                 scores_algorithmes[nom_algo] = score
                 # print(f"{nom_algo}: score {score:.2f}")
 
-                if score > 0.5:  # Seuil de confiance
+                if score > 0.9 :  # Seuil de confiance
                     algorithme_detecte = nom_algo
                     score_probabilite = score
                     # print(f"Algorithme détecté: {algorithme_detecte} (score: {score:.2f})")
@@ -98,32 +99,35 @@ def analyser_fichier_specifique(self, chemin_fichier_chiffre: str) -> ResultatAn
             if not algorithme_detecte:
                 print("Aucun algorithme correctement détecté ")
                 temps_execution = time.time() - debut_analyse
-                return ResultatAnalyse("", b"", 0.0, b"", temps_execution, nb_tentatives)
+                return ResultatAnalyse("", b"", 0.0, b"", temps_execution, nb_tentatives, chemin_fichier_chiffre, 0)
 
             temps_execution = time.time() - debut_analyse
 
-            return ResultatAnalyse(algorithme_detecte, cle, score_probabilite, texte_dechiffre, temps_execution, nb_tentatives)
+            return ResultatAnalyse(algorithme_detecte, cle, score_probabilite, texte_dechiffre, temps_execution, nb_tentatives, chemin_fichier_chiffre, 0)
 
         except Exception as e:
             print(f"Erreur lors de l'analyse: {str(e)}")
             temps_execution = time.time() - debut_analyse
-            return ResultatAnalyse("", b"", 0.0, b"", temps_execution, 0)
+            return ResultatAnalyse("", b"", 0.0, b"", temps_execution, 0, chemin_fichier_chiffre)
 
     def __tenter_dechiffrement_avec_dictionnaire(self, chemin_fichier: str, cles_candidates: list[bytes], analyzer: CryptoAnalyzer, resultat: ResultatAnalyse):
         for j, cle in enumerate(cles_candidates):
             resultat.nb_tentatives += 1
 
             if j % 100 == 0:  # retour visuel tous les 100 essais
-                print(f"   Tentative {j+1}/{len(cles_candidates)}...")
+                print(f"Tentative {j+1}/{len(cles_candidates)}...")
 
-            texte_dechiffre = analyzer.dechiffrer(chemin_fichier, cle)
-            if texte_dechiffre and est_dechiffre(texte_dechiffre.decode('utf-8')) and len(texte_dechiffre) > 0:
+            texte_dechiffre = analyzer.dechiffrer(chemin_fichier, cle).decode('utf-8')
+            succes =  verifier_texte_dechiffre(texte_dechiffre)['taux_succes']
+            
+            if texte_dechiffre and succes > 60 and len(texte_dechiffre) > 0:
                 resultat.cle = cle
                 resultat.texte_dechiffre = texte_dechiffre
-                print(f"   Clé trouvée après {j+1} tentatives!")
-                break
-        else:
-            print("Aucune clé valide trouvée")
+                resultat.taux_succes = succes
+                print(f"Clé trouvée après {j+1} tentatives!")
+                return 
+        
+        print("Aucune clé valide trouvée")
 
     def mission_complete_automatique(self, dossier_chiffres: str, chemin_dictionnaire: str) -> List[ResultatAnalyse]:
         """
@@ -153,8 +157,9 @@ def mission_complete_automatique(self, dossier_chiffres: str, chemin_dictionnair
             print(f"{len(fichiers_enc)} fichiers .enc détectés")
             print("\nANALYSE SÉQUENTIELLE DES FICHIERS")
 
-            for i, fichier in enumerate(fichiers_enc, 1):
-                print(f"\nFICHIER {i}/{len(fichiers_enc)}: {fichier}")
+            for i, fichier in enumerate(fichiers_enc, 0):
+                
+                print(f"\nFICHIER {i+1}/{len(fichiers_enc)}: {fichier}")
 
                 chemin_fichier = os.path.join(dossier_chiffres, fichier)
 
@@ -179,12 +184,23 @@ def mission_complete_automatique(self, dossier_chiffres: str, chemin_dictionnair
 
                 # retour visuel
                 if resultat.algo:
-                    print(f"{fichier}: {resultat.algo} (score: {resultat.score_probabilite:.2f})")
+                    print(f"{fichier}: {resultat.algo} (score: {resultat.score_probabilite:.2f}) \n\n")
                 else:
                     print(f"{fichier}: Aucun algorithme détecté")
 
             # Rapport de synthèse final
-            generer_rapport_mission().generer_rapport_synthese(resultats, time.time() - debut_mission)
+            for i in range(6) :
+                resultat = {
+                    'algorithme': resultats[i].algo,
+                    'fichier': resultats[i].fichier,
+                    'cle': resultats[i].cle,
+                    'tentatives': resultats[i].nb_tentatives,
+                    'temps_execution': resultats[i].temps_execution,
+                    'taux_succes': resultats[i].taux_succes,
+                    'statut_succes' : 'Succès' if resultats[i].taux_succes > 60 else 'Echec',
+                    'texte_dechiffre' : resultats[i].texte_dechiffre
+                }
+                rapport_mission().generer_rapport_synthese(resultat)
 
             # Mise à jour des statistiques globales
             self.missions_completees.append({
@@ -256,3 +272,4 @@ def attaque_dictionnaire_manuelle(self, chemin_fichier: str, algorithme_choisi:
             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"))
+

src/interface_console.py

@@ -1,3 +1,4 @@
+import re
 from rich.console import Console
 from rich.traceback import install
 from rich.markdown import Markdown
@@ -9,6 +10,7 @@
 # from detecteur_crypto import Analyser_fichier_uniquement
 # from detecteur_crypto import Analyser_fichier_sequentiels
 from .detecteur_crypto import DetecteurCryptoOrchestrateur
+from .rapport_mission import rapport_mission
 import time, os
 
 install()
@@ -144,15 +146,26 @@ def menu_4(self):
         self.console.clear()
         self.dynamiqueText("Affichage des rapports","green")
         time.sleep(0.02)
-        f = open("rapport_mission.txt",'r')
-        rapports = f.read()
-        for rapport in rapports:
-            print(f"\n{rapport}")
-        f.close()
+        date = input("Quel est la date du rapport que vous souhaitez? Entrez 'all' pour tous les rapports. (format: jj/mm/aa): ")
+        
+        rapports = []
+        if date == "all" :
+            with open("rapport_mission.txt",'r') as f :
+                rapports = f.readlines()
+            f.close()
+        elif re.match(r"\d+/\d+/\d+", date) :
+            rapports = rapport_mission().recuperer_ancien_rapport(date)
+            
+        if rapports :
+            for rapport in rapports:
+                print(f"\n{rapport.replace('~', '\n')}")
+        else :
+            self.console.print(Markdown('#### Aucun rapport trouvé.'))
+        
+        time.sleep(0.03)
         esc = input('Veuillez appuyez sur la touche entrer pour continuer')
-        if esc=='': 
+        if esc=="": 
             self.default_menu()
-        else: self.default_menu()
 
     def menu_5(self):
         self.console.clear()
@@ -217,4 +230,4 @@ def menu_6(self):
         time.sleep(2)
         self.console.clear()
 
-consoleInterface()
+# consoleInterface()

src/rapport_mission.py

@@ -1,7 +1,7 @@
 from datetime import date, datetime
 import os
 from pathlib import Path
-class generer_rapport_mission():
+class rapport_mission():
 
     def __init__(self):
         pass
@@ -18,19 +18,20 @@ def generer_rapport_synthese(self, resultats_de_mission:dict)->None:
         equivalence=['AES-CBC-256', 'CHACHA20', 'BLOWFISH', 'AES-GCM', 'FERNET']
 
         try :
-            rapport= f"RAPPORT DE SYNTHESE DU {date.today().strftime("%d/%m/%y")} à {str(datetime.now().time()).split('.')[0]}\n " f"Mission {equivalence.index(resultats_de_mission['algorithme'].upper()) + 1}: {resultats_de_mission['algorithme'].upper()} \n I - Statistiques relatives à l'analyse du fichier\n" f"Fichier crypté par cet algorithme: {resultats_de_mission['fichier']}\n" f"Clé de déchiffrement identifiée: {resultats_de_mission['cle']} \n" f"Nombre de tentatives: {resultats_de_mission['tentatives']} \n" f"Temps d'exécution: {resultats_de_mission["temps_execution"]} \n II - Résultats obtenus" f"Taux réussite du déchiffrement: {resultats_de_mission['taux_succes']}({resultats_de_mission['statut_succes']})\n" f"Texte déchiffré: {resultats_de_mission['texte_dechiffre']} \n"
+            rapport= f"RAPPORT DE SYNTHESE DU {date.today().strftime("%d/%m/%y")} à {str(datetime.now().time()).split('.')[0]}\n " f"Mission {equivalence.index(resultats_de_mission['algorithme'].upper()) + 1}: {resultats_de_mission['algorithme'].upper()} \n I - Statistiques relatives à l'analyse du fichier\n" f"-Fichier crypté par cet algorithme: {resultats_de_mission['fichier']}\n" f"-Clé de déchiffrement identifiée: {resultats_de_mission['cle']} \n" f"-Nombre de tentatives: {resultats_de_mission['tentatives']} \n" f"-Temps d'exécution: {resultats_de_mission["temps_execution"]} \n II - Résultats obtenus\n" f"-Taux réussite du déchiffrement: {resultats_de_mission['taux_succes']}({resultats_de_mission['statut_succes']})\n" f"-Texte déchiffré: {resultats_de_mission['texte_dechiffre']} \n\n"
 
             # Ecriture du rapport dans le fichier rapport.txt pour les affichage ultérieurs
             chemin = Path(f"rapport_mission.txt")
             with open(chemin, 'a') as f:
                 f.write(rapport.replace('\n', '~'))
-                f.close()
-                
-            return rapport
+            f.close()
+            print(rapport)
+            
+            return 
         except (KeyError, ValueError):
-            print("Une erreur s'est produite.")
+            print("Une erreur s'est produite.") 
+            return
 
-        return rapport
 
 
     def recuperer_ancien_rapport(self, base_date:str)->list|str:
@@ -44,15 +45,15 @@ def recuperer_ancien_rapport(self, base_date:str)->list|str:
 
 
         """
-        rapport=[]
+        rapports=[]
         try:
             chemin = Path(f"rapport_mission.txt")
             with open(chemin, 'r') as f:
                 for line in f:
                     if line.find(base_date) != -1:
-                        rapport.append(line.replace('~', '\n'))
+                        rapports.append(line.replace('~', '\n'))
                 f.close()
-                return rapport if rapport else 'Aucun rapport trouvé à cette date.'
+                return rapports if rapports else False
         except FileNotFoundError:
             print('Fichier non trouvé')
 

src/utils.py

@@ -32,35 +32,6 @@ def calculer_entropie(bytes: bytes) -> float:
         proba_byte = 1 / i
         entropie +=  (proba_byte) * math.log(1/proba_byte, 8)
     return entropie
-
-
-
-def est_dechiffre(texte:str) -> bool: 
-    """
-        Détermine si oui ou non une chaine a été déchiffrée
-        
-        Args: 
-            texte(str): la chaine en supposée déchiffrée
-        Returns: 
-            bool: déchiffrée ou non
-    """
-    stats:dict[str, Any] = verifier_texte_dechiffre(texte)
-    pourcent=0
-    
-    # Les caractères imprimables constituent 50% de la validation du déchiffrement
-    if stats['imprimable'] > 70 :
-        pourcent += 50
-    
-    # Le pourcentage de mots validés par les dictionnaires en constitue 30%
-    if stats['p_mots_valide'] > 50 :
-        pourcent += 30
-    
-    # Le respect de la ponctuation, les 20% restants
-    if stats['ponctuation_valide'] > 50 :
-        pourcent += 20
-    
-    return True if pourcent > 80 else False
-
 
 
 def verifier_texte_dechiffre(texte: str) -> Dict[str, Any]:
@@ -86,7 +57,8 @@ def verifier_texte_dechiffre(texte: str) -> Dict[str, Any]:
         'nombre_mots':0,
         'p_mots_valide':0,
         'non_mots':[],
-        'ponctuation_valide':0
+        'ponctuation_valide':0,
+        'taux_succes':0
     }
 
     if not texte:
@@ -139,7 +111,7 @@ def verifier_texte_dechiffre(texte: str) -> Dict[str, Any]:
             stats['p_mots_valide'] = round((mots_valides / len(mots)) * 100, 2)
         else:
             stats['p_mots_valide'] = 0.0
-                    
+                
     except Exception:
         raise
 
@@ -158,6 +130,8 @@ def verifier_texte_dechiffre(texte: str) -> Dict[str, Any]:
     if not nbr_points: nbr_points=1
     stats['ponctuation_valide'] = round(count*100/nbr_points, 2)
 
+    stats['taux_succes'] = round((stats['imprimable'] + stats['p_mots_valide'] + stats['ponctuation_valide']) / 3, 2)
+
     return stats