Correction des erreurs dans la fonction identifier_algo

Author: Eunock-web

src/analyzers/chacha20_analyzer.py

@@ -5,8 +5,12 @@
 import os, struct
 import math
 
-# Import de la classe CryptoAnalyzer
-from ..crypto_analyzer import CryptoAnalyzer
+# Import de la classe CryptoAnalyzer et utils
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+from crypto_analyzer import CryptoAnalyzer
+from utils import calculer_entropie
 
 # Définition de la classe ChaCha20_Analyzer
 class ChaCha20_Analyzer(CryptoAnalyzer):
@@ -30,34 +34,7 @@ class ChaCha20_Analyzer(CryptoAnalyzer):
     _CHACHA20_LONGUEUR_TAG = 16
     _CHACHA20_LONGUEUR_BLOC = 64
 
-    def calculer_entropie(self, data: bytes) -> float:
-        """
-        Calcule l'entropie de Shannon d'une séquence d'octets.
-        
-        Args:
-            data (bytes): Les données à analyser
-            
-        Returns:
-            float: L'entropie calculée (0-8 bits par octet)
-        """
-        if not data:
-            return 0.0
-        
-        # Compter les occurrences de chaque octet
-        compteur = [0] * 256
-        for byte in data:
-            compteur[byte] += 1
-        
-        # Calculer l'entropie
-        entropie = 0.0
-        longueur = len(data)
-        
-        for count in compteur:
-            if count > 0:
-                probabilite = count / longueur
-                entropie -= probabilite * math.log2(probabilite)
-        
-        return entropie
+
 
     def identifier_algo(self, chemin_fichier_chiffre: str) -> float:
         """
@@ -83,39 +60,47 @@ def identifier_algo(self, chemin_fichier_chiffre: str) -> float:
                 return 0.0  # Fichier trop petit pour contenir un nonce
 
             # Extraire le nonce présumé (12 premiers bytes)
-            nonce_presume = donnees[:self._CHACHA20_LONGUEUR_NONCE]
+            nonce = donnees[:self._CHACHA20_LONGUEUR_NONCE]
             donnees_chiffrees = donnees[self._CHACHA20_LONGUEUR_NONCE:]
 
             if len(donnees_chiffrees) == 0:
                 return 0.0  # Pas de données chiffrées
 
-            # Critère 1: Vérifier la taille minimale (nonce + au moins quelques bytes de données)
-            score_taille = 1.0 if len(donnees) >= self._CHACHA20_LONGUEUR_NONCE + 16 else 0.0
+            # Critère 1: Vérifier la taille minimale 
+            if len(donnees) >= self._CHACHA20_LONGUEUR_NONCE + 16:
+                taille_min = 1.0
+            else:
+                taille_min = 0.0
 
             # Critère 2: Vérifier l'entropie des données chiffrées (doit être très élevée)
-            entropie = self.calculer_entropie(donnees_chiffrees)
+            entropie = calculer_entropie(donnees_chiffrees)
             # L'entropie d'un chiffrement ChaCha20 devrait être proche de 8 bits/octet
-            score_entropie = min(entropie / 8.0, 1.0)
+            if entropie / 8.0 > 1.0:
+                entropie_max = 1.0
+            else:
+                entropie_max = entropie / 8.0
 
             # Critère 3: Vérifier l'absence de padding (pas de contrainte de taille)
             # ChaCha20 est un chiffrement de flux, donc pas de padding
             # On vérifie que la taille des données chiffrées n'est pas un multiple d'une taille de bloc commune
             taille_donnees = len(donnees_chiffrees)
-            score_padding = 1.0  # Par défaut, on suppose pas de padding
-            
-            # Vérifier si la taille est un multiple de tailles de bloc communes (AES = 16, DES = 8)
             if taille_donnees % 16 == 0 or taille_donnees % 8 == 0:
-                score_padding = 0.5  # Réduire le score si c'est un multiple de tailles de bloc communes
+                padding_max = 0.5
+            else:
+                padding_max = 1.0
 
             # Critère 4: Vérifier l'entropie du nonce (doit être élevée aussi)
-            entropie_nonce = self.calculer_entropie(nonce_presume)
-            score_nonce = min(entropie_nonce / 8.0, 1.0)
+            entropie_nonce = calculer_entropie(nonce)
+            if entropie_nonce / 8.0 > 1.0:
+                nonce_max = 1.0
+            else:
+                nonce_max = entropie_nonce / 8.0
 
             # Calcul de la probabilité finale (moyenne pondérée des scores)
-            probabilite = (score_taille * 0.1 + 
-                          score_entropie * 0.4 + 
-                          score_padding * 0.3 + 
-                          score_nonce * 0.2)
+            probabilite = (taille_min * 0.1 + 
+                          entropie_max * 0.4 + 
+                          padding_max * 0.3 + 
+                          nonce_max * 0.2)
 
             return min(probabilite, 1.0)
 
@@ -126,7 +111,7 @@ def identifier_algo(self, chemin_fichier_chiffre: str) -> float:
     def filtrer_dictionnaire_par_indices(self, chemin_fichier_chiffre):
         pass
 
-    def generer_cle_candidates(self, chemin_fichier_chiffre):
+    def generer_cles_candidates(self, chemin_fichier_chiffre):
         '''
             Cette fonction se charge de générer les clés candidates pour le déchiffremment du fichier chiffré en utilisant
             la dérivation sha256 pour renforcer les clées de chiffrement.               
@@ -146,29 +131,32 @@ def generer_cle_candidates(self, chemin_fichier_chiffre):
 
         return cle_candidates
 
-    def dechiffrer(self, chemin_fichier_chiffre: str, clef: bytes) -> str:
-        if len(clef) != 32: 
+    def dechiffrer(self, chemin_fichier_chiffre: str, cle_donnee: bytes) -> bytes:
+        if len(cle_donnee) != 32: 
             raise ValueError("Erreur : La clé n'a pas la taille correcte")
         else: 
             try:
-                with open(f"data/{chemin_fichier_chiffre}", 'rb') as f:
+                # Utiliser le chemin complet si c'est un chemin absolu, sinon ajouter le préfixe data/
+                if os.path.isabs(chemin_fichier_chiffre):
+                    fichier_path = chemin_fichier_chiffre
+                else:
+                    fichier_path = f"data/{chemin_fichier_chiffre}"
+                
+                with open(fichier_path, 'rb') as f:
                     nonce = f.read(self._CHACHA20_LONGUEUR_NONCE)
                     texte_chiffre = f.read()
 
-                algorithm_chacha20 = algorithms.ChaCha20(clef, nonce)
+                algorithm_chacha20 = algorithms.ChaCha20(cle_donnee, nonce)
                 cipher = Cipher(algorithm_chacha20, mode=None)
                 decrypteur = cipher.decryptor()
                 resultat = decrypteur.update(texte_chiffre)
 
-                # Essayer de décoder en UTF-8 avec gestion d'erreurs
-                try:
-                    return resultat.decode('utf-8')
-                except UnicodeDecodeError:
-                    return resultat.decode('utf-8', errors='ignore')
+                # Retourner les bytes bruts comme attendu par l'interface
+                return resultat
 
             except Exception as e:
                 print(f"Une erreur est survenue : {e}")
-                return None
+                return b""
 
 
 # print(ChaCha20_Analyzer().dechiffrer("mission2.enc",os.urandom(32)))