Merge branch 'main' into add/Initialisation_Blowfish_Analyzer

Author: mouwaficbdr

src/analyzers/chacha20_analyzer.py

@@ -0,0 +1,185 @@
+# Import des modules
+import hashlib
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+from rich import print
+import os, struct
+import math
+import sys
+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):
+    """
+    Détermine si l'algo ChaCha20 est utilisé, génère des clés et tente de de déchffrer un fichier chiffré en utilisant les clés générées.
+    
+    Cette classe a trois méthodes:
+    - identifier_algo: Détermine si l'algo de chiffrement utilisé sur le fichier chiffré qui lui est passé en paramètre est l'ChaCha20.
+    - generer_cles_candidates: Génère une liste de clés candidates pour le déchiffrement du fichier chiffré
+    - dechiffrer: fait le déchiffrement proprement dit sur la base de la liste des clés générées
+    
+    Attributes:
+    _CHACHA20_LONGUEUR_CLE: la taille de la clé de chiffrement (32 octets)
+    _CHACHA20_LONGUEUR_NONCE: la taille du vecteur d'initialisation (12 octets)
+    _CHACHA20_LONGUEUR_TAG: la taille de l'empreinte de chiffrement (16 octets)
+    _CHACHA20_LONGUEUR_BLOC: la taille du bloc de chiffrement (64 bits)
+    """
+
+    _CHACHA20_LONGUEUR_CLE = 32
+    _CHACHA20_LONGUEUR_NONCE = 12 #fourni
+    _CHACHA20_LONGUEUR_TAG = 16
+    _CHACHA20_LONGUEUR_BLOC = 64
+
+
+
+    def identifier_algo(self, chemin_fichier_chiffre: str) -> float:
+        """
+        Détermine la probabilité que l'algo de chiffrement utilisé soit l'ChaCha20 en:
+        - vérifiant la présence d'un nonce de 12 bytes en début de fichier
+        - vérifiant l'entropie très élevée sur l'ensemble des données
+        - vérifiant l'absence de padding (pas de contrainte de taille)
+        - vérifiant que la taille du fichier est suffisante pour contenir un nonce
+        
+        Retourne une probabilité entre 0 et 1(Pour connaitre la probabilité que l'algo de chiffrement utilisé soit l'ChaCha20).
+        
+        Args:
+            chemin_fichier_chiffre(str): le chemin du fichier chiffré à traiter .
+            
+        Returns:
+            float: La probabilité que l'algo de chiffrement utilisé soit l'ChaCha20 apres le calcul.
+        """
+        try:
+            with open(chemin_fichier_chiffre, 'rb') as f:
+                donnees = f.read()
+            
+            if len(donnees) < self._CHACHA20_LONGUEUR_NONCE:
+                return 0.0  # Fichier trop petit pour contenir un nonce
+            
+            # Extraire le nonce présumé (12 premiers bytes)
+            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 
+            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 = calculer_entropie(donnees_chiffrees)
+            # L'entropie d'un chiffrement ChaCha20 devrait être proche de 8 bits/octet
+            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)
+            if taille_donnees % 16 == 0 or taille_donnees % 8 == 0:
+                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 = 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 = (taille_min * 0.1 + 
+                          entropie_max * 0.4 + 
+                          padding_max * 0.3 + 
+                          nonce_max * 0.2)
+            
+            return min(probabilite, 1.0)
+            
+        except Exception as e:
+            print(f"Erreur lors de l'identification de l'algorithme: {e}")
+            return 0.0
+
+
+    def filtrer_dictionnaire_par_indices(self, chemin_fichier_chiffre):
+        pass
+
+    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.               
+                            
+
+            Args: 
+                chemin_fichier_chiffre(str) : Le chemin vers le fichier chiffré
+        
+            Returns:
+                cles_candidates (list[bytes]) : Un tableau de clés, chaque clé étant une séquence d'octets  
+        '''
+        
+        donnees_fichier_filtre = self.filtrer_dictionnaire_par_indices(chemin_fichier_chiffre)
+
+        cle_candidates: list[bytes] = []
+        for cle in donnees_fichier_filtre:
+            cle_candidates.append(hashlib.sha256(cle).digest())
+
+        return cle_candidates
+    
+    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:
+                # 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(cle_donnee, nonce)
+                cipher = Cipher(algorithm_chacha20, mode=None)
+                decrypteur = cipher.decryptor()
+                resultat = decrypteur.update(texte_chiffre)
+                
+                # Retourner les bytes bruts comme attendu par l'interface
+                return resultat
+
+            except Exception as e:
+                print(f"Une erreur est survenue : {e}")
+                return b""
+            cle_candidates.append(hashlib.sha256(cle).encode(encoding="utf-8"))
+
+        return cle_candidates
+    
+    def dechiffrer(self,chemin_fichier_chiffer : str ,clef :bytes)->str:
+        if len(clef) != 32 : return ValueError("Erreur : La clé a pas la taille correcte ")
+        else: 
+            try:
+                with open(f"data/{chemin_fichier_chiffer}",'rb') as f:
+                    nonce = f.read(16)
+                    texte_chiffrer = f.read()
+
+                counter=0
+                algorithm_chacha20 = algorithms.ChaCha20(clef,nonce)
+                cipher = Cipher(algorithm_chacha20,mode=None)
+                decrypteur = cipher.decryptor()
+                return decrypteur.update(texte_chiffrer)
+                
+                
+
+            except Exception as e:
+                print(f"Une erreur est survenu : {e}")
+
+
+
+# print(ChaCha20_Analyzer().dechiffrer("mission2.enc",os.urandom(32)))