Feature/detecteur crypto orchestrateur

guideUtilisation.txt

@@ -0,0 +1,15 @@
+## **Algorithmes déployés lors des mission**
+**AES-256** :
+###### 1. **Hello Word** : Ceci est un exemple veuillez suivre ce format pour la documentation de vos algorithmes
+
+**Chacha20** :
+###### 1. **Hello Word** : Ceci est un exemple veuillez suivre ce format pour la documentation de vos algorithmes
+
+**Blowfish** :
+###### 1. **Hello Word** : Ceci est un exemple veuillez suivre ce format pour la documentation de vos algorithmes
+
+**AES-GCM** :
+###### 1. **Hello Word** : Ceci est un exemple veuillez suivre ce format pour la documentation de vos algorithmes
+
+**Fernet** :
+###### 1. **Hello Word** : Ceci est un exemple veuillez suivre ce format pour la documentation de vos algorithmes

src/detecteur_crypto.py

@@ -1,15 +1,251 @@
-from analyzers.aes_cbc_analyzer import Aes_Cbc_Analyzer
-from crypto_analyzer import identifier_algo
-
-"""
-        Classe principale qui centralise tout:
-            -Lance l’analyse des fichiers et identifie l'algorithme probable,
-            -Lance les attaquespar dictionnaire,
-            -Lance et coordonnes le processus de dechiffrement 
-"""
+# Import des modules
+import os
+import time
+from typing import List
+
+# Import des modules d'analyse
+from .analyzers.aes_cbc_analyzer import Aes_Cbc_Analyzer
+
+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):
+        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
+
 class DetecteurCryptoOrchestrateur:
     """
-        Initialisation de l'analyseur AES-CBC     
+            Classe principale qui centralise tout:
+                -Lance l'analyse des fichiers et identifie l'algorithme probable,
+                -Lance les attaques par dictionnaire,
+                -Lance et coordonnes le processus de dechiffrement 
     """
+
     def __init__(self):
-        self.aes_cbc_analyzer = Aes_Cbc_Analyzer()
+        """
+        Initialisation de tous les modules d'analyse disponibles (AES-CBC) pour le moment
+        """
+        self.analyzers = {
+            "AES-CBC": Aes_Cbc_Analyzer(),
+        }
+        self.missions_completees = []
+        self.statistiques_globales = {
+            "total_fichiers": 0,
+            "fichiers_dechiffres": 0,
+            "temps_total": 0.0,
+            "tentatives_total": 0
+        }
+
+    def analyser_fichier_specifique(self, chemin_fichier_chiffre: str) -> ResultatAnalyse:
+        """
+        ANALYSE D'UN FICHIER SPÉCIFIQUE
+        - Sélection du fichier à analyser
+        - Identification automatique de l'algorithme
+        - Affichage des scores de probabilité
+
+        Args:
+            chemin_fichier_chiffre(str): chemin du fichier chiffré à analyser
+
+        Returns:
+            ResultatAnalyse: résultat de l'analyse
+        """
+        debut_analyse = time.time()
+
+        try:
+            # Vérification de l'existence du fichier
+            if not os.path.exists(chemin_fichier_chiffre):
+                print("Erreur: Fichier non trouvé")
+                return ResultatAnalyse("", b"", 0.0, b"", 0.0, 0)
+
+            # Initialisation des variables
+            algorithme_detecte = ""
+            cle = b""
+            score_probabilite = 0.0
+            texte_dechiffre = b""
+            nb_tentatives = 0
+
+            # Parcours des algorithmes disponibles
+            scores_algorithmes = {}
+            for nom_algo, analyzer in self.analyzers.items():
+                score = analyzer.identifier_algo(chemin_fichier_chiffre)
+                scores_algorithmes[nom_algo] = score
+                print(f"{nom_algo}: score {score:.2f}")
+
+                if score > 0.5:  # Seuil de confiance
+                    algorithme_detecte = nom_algo
+                    score_probabilite = score
+                    print(f"Algorithme détecté: {algorithme_detecte} (score: {score:.2f})")
+                    break
+
+            if not algorithme_detecte:
+                print("Aucun algorithme coréctement détecté ")
+                temps_execution = time.time() - debut_analyse
+                return ResultatAnalyse("", b"", 0.0, b"", temps_execution, nb_tentatives)
+
+            temps_execution = time.time() - debut_analyse
+
+            return ResultatAnalyse(algorithme_detecte, cle, score_probabilite, texte_dechiffre, temps_execution, nb_tentatives)
+
+        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)
+
+    def mission_complete_automatique(self, dossier_chiffres: str) -> List[ResultatAnalyse]:
+        """
+        MISSION COMPLÈTE AUTOMATIQUE
+        - Analyse des 5 fichiers séquentiellement
+        - Tentatives de déchiffrement avec retour visuel
+        - Rapport de synthèse final
+
+        Args:
+            dossier_chiffres(str): dossier contenant les fichiers chiffrés
+
+        Returns:
+            list[ResultatAnalyse]: liste des résultats d'analyse
+        """
+
+        debut_mission = time.time()
+        resultats = []
+
+        try:
+            # Récupération des fichiers .enc
+            fichiers_enc = [f for f in os.listdir(dossier_chiffres) if f.endswith(".enc")]
+
+            if not fichiers_enc:
+                print("Aucun fichier .enc trouvé dans le dossier")
+                return []
+
+            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}")
+
+                chemin_fichier = os.path.join(dossier_chiffres, fichier)
+
+                # Analyse du fichier
+                resultat = self.analyser_fichier_specifique(chemin_fichier)
+
+                # Tentative de déchiffrement si algorithme détecté
+                if resultat.algo:
+                    print(f"\nTENTATIVE DE DÉCHIFFREMENT")
+
+                    analyzer = self.analyzers[resultat.algo]
+                    cles_candidates = analyzer.generer_cles_candidates("dicoEn")
+
+                    if cles_candidates:
+                        print(f"Test de {len(cles_candidates)} clés candidates...")
+
+                        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)}...")
+
+                            texte_dechiffre = analyzer.dechiffrer(chemin_fichier, cle)
+                            if texte_dechiffre 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")
+                    else:
+                        print("   Aucune clé candidate générée")
+
+                resultats.append(resultat)
+
+                # retour visuel
+                if resultat.algo:
+                    print(f"{fichier}: {resultat.algo} (score: {resultat.score_probabilite:.2f})")
+                else:
+                    print(f"{fichier}: Aucun algorithme détecté")
+
+            # Rapport de synthèse final
+            self.generer_rapport_synthese(resultats, time.time() - debut_mission)
+
+            # Mise à jour des statistiques globales
+            self.missions_completees.append({
+                "dossier": dossier_chiffres,
+                "resultats": resultats,
+                "temps_total": time.time() - debut_mission
+            })
+
+            return resultats
+
+        except Exception as e:
+            print(f"Erreur lors de la mission complète: {str(e)}")
+            return []
+
+    def attaque_dictionnaire_manuelle(self, chemin_fichier: str, algorithme_choisi: str) -> ResultatAnalyse:
+        """
+            ATTAQUE PAR DICTIONNAIRE MANUELLE
+        - Choix du fichier et de l'algorithme
+        - Suivi en temps réel des tentatives
+        - Affichage des résultats intermédiaires
+
+        Args:
+            chemin_fichier(str): chemin du fichier à attaquer
+            algorithme_choisi(str): algorithme à utiliser
+
+        Returns:
+            ResultatAnalyse: résultat de l'attaque
+        """
+
+
+        debut_attaque = time.time()
+
+        try:
+            if algorithme_choisi not in self.analyzers:
+                print(f"Algorithme {algorithme_choisi} non disponible")
+                return ResultatAnalyse("", b"", 0.0, b"", 0.0, 0)
+
+            analyzer = self.analyzers[algorithme_choisi]
+
+            # Vérification de l'algorithme
+            score = analyzer.identifier_algo(chemin_fichier)
+            print(f"Score de confirmation: {score:.2f}")
+
+            if score < 0.3:
+                print("Score de confiance faible pour cet algorithme")
+
+            # Génération des clés candidates
+            print(f"Génération des clés candidates")
+            cles_candidates = analyzer.generer_cles_candidates("dicoEn")
+            print(f"{len(cles_candidates)} clés candidates générées")
+
+            # Attaque par dictionnaire
+
+            cle_trouvee = b""
+            texte_dechiffre = b""
+            nb_tentatives = 0
+
+            for i, cle in enumerate(cles_candidates):
+                nb_tentatives += 1
+
+                # retour visuel en temps réel
+                if i % 50 == 0:
+                    print(f"Tentative {i+1}/{len(cles_candidates)}... ({(i+1)/len(cles_candidates)*100:.1f}%)")
+                texte_dechiffre = analyzer.dechiffrer(chemin_fichier, cle)
+                if texte_dechiffre and len(texte_dechiffre) > 0:
+                    cle_trouvee = cle
+                    break
+            else:
+                print(f"Aucune clé valide trouvée après {len(cles_candidates)} tentatives")
+
+            temps_execution = time.time() - debut_attaque
+            print(f"Temps d'exécution: {temps_execution:.2f} secondes")
+
+            return ResultatAnalyse(algorithme_choisi, cle_trouvee, score, texte_dechiffre, temps_execution, nb_tentatives)
+
+        except Exception as e:
+            print(f"Erreur lors de l'attaque: {str(e)}")
+            temps_execution = time.time() - debut_attaque
+            return ResultatAnalyse("", b"", 0.0, b"", temps_execution, 0)
+