fix des problemes

Author: seathiel-12

main.py

@@ -3,6 +3,8 @@
 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.analyzers.chacha20_analyzer import ChaCha20_Analyzer
+
 from src.interface_console import consoleInterface
 import os
 from rich.progress import track
@@ -18,4 +20,10 @@
 
 consoleInterface()
 # print(DetecteurCryptoOrchestrateur().mission_complete_automatique('data/', 'keys/wordlist.txt'))
-
+# try:
+#         resultat_dechiffrement: bytes = ChaCha20_Analyzer().dechiffrer("data/mission2.enc", os.urandom(32))
+#         print(f"Résultat du déchiffrement : {resultat_dechiffrement}")
+# except ValueError as ve:
+#         print(ve)
+# except FileNotFoundError:
+#         print("Erreur: Le fichier 'mission2.enc' est introuvable.")

rapport_mission.txt

@@ -88,7 +88,7 @@ def test_dechiffrement_missions() -> None:
                 continue
 
             try:
-                texte = res.decode('utf-8', errors='ignore')
+                texte = res.decode('utf-8')
             except Exception:
                 texte = ''
 

scripts/test_dechiffrement_missions.py

@@ -65,7 +65,7 @@ def maj_progress_bar(self, sleep_avant: float, progress: Progress, task: TaskID,
         progress.update(task_id=task, description=message, advance=avance)
         time.sleep(sleep_apres)
 
-    def analyser_fichier_specifique(self, chemin_fichier_chiffre: str, progress : Progress, task, error:bool, nbr_opr_mission: int) -> ResultatAnalyse:
+    def analyser_fichier_specifique(self, chemin_fichier_chiffre: str, progress : Progress, task, error:bool, nbr_opr_mission: int) -> List[ResultatAnalyse] :
         """
         ANALYSE D'UN FICHIER SPÉCIFIQUE
         - Sélection du fichier à analyser
@@ -80,6 +80,7 @@ def analyser_fichier_specifique(self, chemin_fichier_chiffre: str, progress : Pr
             ResultatAnalyse: résultat de l'analyse
         """
         debut_analyse = time.time()
+        algorithme_potenciel = []
         try:
             # Vérification de l'existence du fichier
             avance = (100/(self._NBR_OPERATION_ANALYSE * nbr_opr_mission))
@@ -92,15 +93,13 @@ def analyser_fichier_specifique(self, chemin_fichier_chiffre: str, progress : Pr
                 self.maj_progress_bar(0.3, progress, task, "Fichier non trouvé ❌ (Aborting...)", ((avance * self._NBR_OPERATION_ANALYSE) - avance * 0.3), 1) 
 
                 error = True
-                return ResultatAnalyse("", b"", 0.0, b"", 0.0, 0)
+                return [ResultatAnalyse("", b"", 0.0, b"", 0.0, 0)]
 
             # Initialisation des variables
             # TODO : Mise à jour de la progress bar -> step : Initialisation des utilitaires pour l'identification (Done)
             self.maj_progress_bar(0.5, progress, task, "Initialisation des utilitaires pour l'identification", avance*0.2, 1)
 
-            algorithme_detecte = ""
             cle = b""
-            score_probabilite = 0.0
             texte_dechiffre = b""
             nb_tentatives = 0
 
@@ -125,32 +124,39 @@ def analyser_fichier_specifique(self, chemin_fichier_chiffre: str, progress : Pr
                 cumul_progress_avance += 2 * avance_algo
 
                 if score >= 0.6 :  # Seuil de confiance
+                    
+                    algorithme_potenciel.append({
+                        'algo': nom_algo,
+                        'score': score
+                    })
+                    
                     # TODO : Mise à jour de la progress bar -> step : Détection réussie pour {algorithme} et préparation du rapport d'analyse (Done)
-                    self.maj_progress_bar(1, progress, task, f"Détection réussie pour {nom_algo} et préparation du rapport d'analyse", ((100/nbr_opr_mission) - cumul_progress_avance), 1)
+                    self.maj_progress_bar(1, progress, task, f"Elligibilité détectée pour {nom_algo}", avance_algo, 1)
 
-                    algorithme_detecte = nom_algo
-                    score_probabilite = score
-                    break
                 else :
                     # TODO : Intégrer la progress bar -> step : Echec d'identification pour {algorithme} (Done)
                     self.maj_progress_bar(1, progress, task, f"Echec d'identification pour {nom_algo}", avance_algo, 1)
 
                     cumul_progress_avance += avance_algo
 
-            if not algorithme_detecte:
+            if not algorithme_potenciel:
                 print("Aucun algorithme correctement détecté ")
                 temps_execution = time.time() - debut_analyse
-                return ResultatAnalyse("", b"", 0.0, b"", temps_execution, nb_tentatives, chemin_fichier_chiffre, 0)
+                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, chemin_fichier_chiffre, 0)
+            resultat : List[ResultatAnalyse]= []
+            for item in algorithme_potenciel:
+                resultat.append(ResultatAnalyse(item['algo'], cle, item['score'], texte_dechiffre, temps_execution, nb_tentatives, chemin_fichier_chiffre, 0))
 
+            return resultat
+        
         except Exception as e:
             print(f"Erreur lors de l'analyse: {str(e)}")
             temps_execution = time.time() - debut_analyse
             error = True
-            return ResultatAnalyse("", b"", 0.0, b"", temps_execution, 0, chemin_fichier_chiffre)
+            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):
         """
@@ -222,42 +228,55 @@ def mission_complete_automatique(self, dossier_chiffres: str, chemin_dictionnair
 
                     # Analyse du fichier
                     error = False
-                    resultat = self.analyser_fichier_specifique(fichier, progress, task, error, self._NBR_OPERATION_MISSION)
-                    
-                    # Tentative de déchiffrement si algorithme détecté
-                    if resultat.algo:
-                        # TODO: MAJ de la progress bar -> step: Amorçage de la phase de déchiffrement (Done)
-                        self.maj_progress_bar(0, progress, task, "Amorçage de la phase de déchiffrement...", (100/self._NBR_OPERATION_MISSION) * 0.5, 1)
-                                                
-                        analyzer = self.analyzers[resultat.algo]
-                        
-                        # TODO: MAJ de la progress bar -> step: Récupération des clés candidates (Done)
-                        self.maj_progress_bar(0, progress, task, "Récupération des clés candidates...", (100/self._NBR_OPERATION_MISSION)*0.5, 1)
+                    resultats_analyse = self.analyser_fichier_specifique(fichier, progress, task, error, self._NBR_OPERATION_MISSION)
+                    cumul_avance : float = 0
 
-                        cles_candidates = analyzer.generer_cles_candidates(chemin_dictionnaire)
-                        
-                        if cles_candidates:
-                            print(f"Test de {len(cles_candidates)} clés candidates...")
-                            # TODO: MAJ de la progress bar -> step: Test de déchiffrement (Done)
-                            self.maj_progress_bar(0, progress, task, "Test de déchiffrement", (100/self._NBR_OPERATION_MISSION), 3)
-                        
-                            error = self.__tenter_dechiffrement_avec_dictionnaire(chemin_fichier, cles_candidates, analyzer, resultat) 
+                    print('analyzed')
+                    # Tentative de déchiffrement si algorithme détecté
+                    for resultat in resultats_analyse :
+                        if resultat.algo:
+                            avancement = (100/(self._NBR_OPERATION_MISSION * len(resultats_analyse)))
+                            # TODO: MAJ de la progress bar -> step: Amorçage de la phase de déchiffrement (Done)
+                            self.maj_progress_bar(0, progress, task, f"Amorçage de la phase de déchiffrement avec {resultat.algo}...", avancement * 0.5, 1)
+                                                    
+                            analyzer = self.analyzers[resultat.algo]
 
-                        else:
-                            # TODO: MAJ de la progress bar -> step: Abort et récupération des résultats d'analyse (Done)
-                            self.maj_progress_bar(0, progress, task, "Aucune clé candidate générée ❌ (Aborting ...)", (100/self._NBR_OPERATION_MISSION), 3)
-
-                            error = True
+                            # TODO: MAJ de la progress bar -> step: Récupération des clés candidates (Done)
+                            self.maj_progress_bar(0, progress, task, f"Récupération des clés candidates pour {resultat.algo}...", avancement*0.5, 1)
 
+                            cles_candidates = analyzer.generer_cles_candidates(chemin_dictionnaire)
+                            cumul_avance += avancement
+                            
+                            if cles_candidates:
+                                print(f"Test de {len(cles_candidates)} clés candidates...")
+                                
+                                # TODO: MAJ de la progress bar -> step: Test de déchiffrement (Done)
+                                self.maj_progress_bar(0, progress, task, f"Test de déchiffrement pour {resultat.algo}...", avancement * 0.5, 3)
+                            
+                                error = self.__tenter_dechiffrement_avec_dictionnaire(chemin_fichier, cles_candidates, analyzer, resultat) 
+                                
+                                #Cas de déchiffrement réussi
+                                if not error : 
+                                    # TODO: MAJ de la progress bar -> step: Déchiffrement réussi pour {algorithme}
+                                    self.maj_progress_bar(0.5, progress, task, f"Déchiffrement réussi pour {resultat.algo}", (100/self._NBR_OPERATION_MISSION) - cumul_avance , 2)
+                                    
+                                    resultat_final : ResultatAnalyse = resultat
+                                    break
+                                else : 
+                                    self.maj_progress_bar(0.5, progress, task, f"Echec de déchiffrement pour {resultat.algo} ❌", avancement * 0.5, 2)
+                            else :
+                                # TODO: MAJ de la progress bar -> step: Abort et récupération des résultats d'analyse (Done)
+                                self.maj_progress_bar(0, progress, task, "Aucune clé candidate générée ❌ (Aborting ...)", avancement, 3)
+                                error = True
 
-                    resultats.append(resultat)
+                    resultats.append(resultat_final)
 
                     # retour visuel
-                    if resultat.algo:
+                    if resultat_final.algo:
                         # TODO: MAJ de la progress bar -> step: Finalsation et retour de résultats (Done)
-                        self.maj_progress_bar(0, progress, task, "Finalisation et retour des résultats", (100/self._NBR_OPERATION_MISSION), 3)
+                        self.maj_progress_bar(0, progress, task, "Finalisation et retour des résultats", 100, 3)
 
-                        print(f"{fichier}: {resultat.algo} (score: {resultat.score_probabilite:.2f})")
+                        print(f"{fichier}: {resultat_final.algo} (score: {resultat_final.score_probabilite:.2f})")
 
                         message = "[bold green] Mission terminée. ✅[/bold green]\n\n" if not error else "[bold red] Mission terminée: Déchiffrement non concluant. ❌ [/bold red]\n\n"
                         Console().print(message)

src/detecteur_crypto.py

@@ -1,4 +1,4 @@
-import math, re, string, time
+import math, re, string, time, os
 from pathlib import Path
 from typing import Any, Dict, List, TypedDict
 from rich.console import Console
@@ -53,7 +53,6 @@ def verifier_texte_dechiffre(texte: str) -> Dict[str, Any]:
     """
 
     #Statistiques sur le texte 
-    
     stats: dict[str, Any] = {
         'imprimable':0,
         'nombre_mots':0,
@@ -70,16 +69,15 @@ def verifier_texte_dechiffre(texte: str) -> Dict[str, Any]:
     stats['imprimable'] = int(sum(1 for char in texte if char.isprintable()) / len(texte) * 100)
 
     # Traitement du texte brut pour obtenir une séquence distincte de pseudo-mot à cette étape séparé par des espaces
-    
-    tab='./:!\\}{_%*$£&#;,~"()[]=§|`^@?'
+
+    tab='.\\/:!}{_%*$£&#;,~"()[]=§|`^@?'
     copy=texte
     for lettre in tab:
         copy=copy.replace(lettre, ' ')
 
     # Diviser par espaces et filtrer les mots vides
     mots = [mot.strip() for mot in copy.split(' ') if mot.strip()]
     stats['nombre_mots']=len(mots)
-    
     # Verifier que le chaque mot du texte est un mot anglais/francais 
 
     try:
@@ -88,11 +86,12 @@ def verifier_texte_dechiffre(texte: str) -> Dict[str, Any]:
             trouve=False
             if not mot: continue
 
-            first_char = mot[0].lower()
-            
+            first_char = mot[0].lower() 
+                        
             for syl in ['Fr', 'En']:
 
-                chemin = Path(f"dico{syl}")/f"{first_char}.txt"
+                chemin = Path(f"dico{syl}")/f"{first_char}.txt" 
+                if not os.path.isfile(chemin) : continue
                 try:
                     with open(chemin, 'r', encoding='latin-1') as f: 
                         for ligne in f: