detecteur_crypto.py

# 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:
    """
            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):
        """
        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)