Merge branch 'main' of https://github.com/mouwaficbdr/CryptoForensic-Python into feature/DetecteurCryptoOrchestrateur

Author: wesley-kami

dicoEn/i.txt

@@ -0,0 +1 @@
+RAPPORT DE SYNTHESE DU 05/08/25 � 00:01:06~ Mission 2: CHACHA20 ~ I - Statistiques relatives � l'analyse du fichier~Fichier crypt� par cet algorithme: mission1.enc~Cl� de d�chiffrement identifi�e: PK7 ~Nombre de tentatives: 127 ~Temps d'ex�cution: 368s ~ II - R�sultats obtenusTaux r�ussite du d�chiffrement: 97%(Succ�s)~Texte d�chiffr�: Je suis l�! ~

dicoEn/y.txt

@@ -99,7 +99,7 @@ def generer_cles_candidates(self, chemin_dictionnaire: str) -> list[bytes]:
         chemin_dictionnaire(str): le chemin du dictionnaire de mots de passes pour l'attaque par dictionnaire.
         
       Returns:
-        list[bytes]: liste des clés candidates.
+        list[bytes]: liste des clés candidates. 
     '''
 
     mots_de_passe_cible = self.filtrer_dictionnaire_par_indices(chemin_dictionnaire)
@@ -155,4 +155,4 @@ def dechiffrer(self, chemin_fichier_chiffre: str, cle_donnee: bytes) -> bytes:
           return b""
 
     except FileNotFoundError:
-      return b""
+      raise

rapport_mission.txt

@@ -1,6 +1,6 @@
 from datetime import date, datetime
 import os
-
+from pathlib import Path
 class generer_rapport_mission():
 
     def __init__(self):
@@ -10,27 +10,19 @@ def generer_rapport_synthese(self, resultats_de_mission:dict)->None:
         """
             Retourne le rapport de mission effectué.
             Args: 
-                resultats_de_mission(dict): les résultats de l'opération de déchiffrement du fichier
+                resultats_de_mission(dict{algorithme, fichier, cle, tentatives, temps_execution, taux_succes, texte_dechiffre}): les résultats de l'opération de déchiffrement du fichier
             Returns:
                 str: le rapport
         """
 
         equivalence=['AES-CBC-256', 'CHACHA20', 'BLOWFISH', 'AES-GCM', 'FERNET']
 
         try :
-            rapport= f"RAPPORT DE SYNTHESE DU {date.today().strftime("%d/%m/%y")} à {str(datetime.now().time()).split('.')[0]}\n " 
-            +  f"Mission {equivalence.index(resultats_de_mission['algorithme'].toupper()) + 1}: {resultats_de_mission['algorithme'].toupper()} \n" 
-            +  "I - Statistiques relatives à l'analyse du fichier\n"
-            + f"Fichier crypté par cet algorithme: {resultats_de_mission['fichier']}\n"
-            + f"Clé de déchiffrement identifiée: {resultats_de_mission['cle']} \n"
-            + f"Nombre de tentatives: {resultats_de_mission['tentatives']} \n"
-            + f"Temps d'exécution: {resultats_de_mission["temps_execution"]} \n"
-            +  "II - Résultats obtenus"
-            + f"Taux réussite du déchiffrement: {resultats_de_mission['taux_succes']}({resultats_de_mission['statut_succes']})\n"
-            + f"Texte déchiffré: {resultats_de_mission['texte_dechiffre']} \n"
+            rapport= f"RAPPORT DE SYNTHESE DU {date.today().strftime("%d/%m/%y")} à {str(datetime.now().time()).split('.')[0]}\n " f"Mission {equivalence.index(resultats_de_mission['algorithme'].upper()) + 1}: {resultats_de_mission['algorithme'].upper()} \n I - Statistiques relatives à l'analyse du fichier\n" f"Fichier crypté par cet algorithme: {resultats_de_mission['fichier']}\n" f"Clé de déchiffrement identifiée: {resultats_de_mission['cle']} \n" f"Nombre de tentatives: {resultats_de_mission['tentatives']} \n" f"Temps d'exécution: {resultats_de_mission["temps_execution"]} \n II - Résultats obtenus" f"Taux réussite du déchiffrement: {resultats_de_mission['taux_succes']}({resultats_de_mission['statut_succes']})\n" f"Texte déchiffré: {resultats_de_mission['texte_dechiffre']} \n"
 
             # Ecriture du rapport dans le fichier rapport.txt pour les affichage ultérieurs
-            with open(f"{os.path.abspath(os.curdir)}\\CryptoForensic-Python\\rapport_mission.txt", 'a') as f:
+            chemin = Path(f"rapport_mission.txt")
+            with open(chemin, 'a') as f:
                 f.write(rapport.replace('\n', '~'))
                 f.close()
 
@@ -54,13 +46,25 @@ def recuperer_ancien_rapport(self, base_date:str)->list|str:
         """
         rapport=[]
         try:
-            with open(f"{os.path.abspath(os.curdir)}\\rapport.txt", 'r') as f:
-                line=f.readline()
-                while line != "" :
+            chemin = Path(f"rapport_mission.txt")
+            with open(chemin, 'r') as f:
+                for line in f:
                     if line.find(base_date) != -1:
-                        rapport.append(line)
+                        rapport.append(line.replace('~', '\n'))
                 f.close()
-                return rapport if rapport.count() > 0 else 'Aucun rapport trouvé à cette date.'
+                return rapport if rapport else 'Aucun rapport trouvé à cette date.'
         except FileNotFoundError:
             print('Fichier non trouvé')
 
+print(generer_rapport_mission().generer_rapport_synthese({
+    'algorithme':'CHACHA20', 
+    'fichier': 'mission1.enc',
+    'cle':'PK7',
+    'tentatives':'127',
+    'temps_execution':"368s",
+    'taux_succes': "97%",
+    'statut_succes':'Succès',
+    'texte_dechiffre':'Je suis là!'
+}))
+
+print(generer_rapport_mission().recuperer_ancien_rapport("05/08/25")[0])

src/analyzers/aes_cbc_analyzer.py

@@ -1,21 +1,39 @@
 import math
 import string
-import sys
-import os
+from pathlib import Path
+from typing import Any, Dict, List, TypedDict
+
+class StatsDict(TypedDict):
+    imprimable: float
+    nombre_mots: int
+    p_mots_valide: float
+    non_mots: List[str]
+    ponctuation_valide: int
 
 def calculer_entropie(bytes: bytes) -> float:
+    '''
+        Calcul l'entropie (le désordre dans une suite de données) afin de déterminer le degré d'improbabilité d'une chaine de données.
+
+        Args:
+            bytes(bytes): La donnée brute contenue dans le fichier crypté.
+
+        Returns:
+            float: l'entropie calculée.
+    '''
     entropie = 0
     proba_byte = 0
     for specifique_byte in bytes:
         i = 1
         for chaque_byte in bytes:
-            if(chaque_byte == specifique_byte):
-                i += 1
+                if(chaque_byte == specifique_byte):
+                    i += 1
+
         proba_byte = 1 / i
         entropie +=  (proba_byte) * math.log(1/proba_byte, 8)
     return entropie
 
 
+
 def est_dechiffre(texte:str) -> bool: 
     """
         Détermine si oui ou non une chaine a été déchiffrée
@@ -25,7 +43,7 @@ def est_dechiffre(texte:str) -> bool:
         Returns: 
             bool: déchiffrée ou non
     """
-    stats:dict=verifier_texte_dechiffre(texte)
+    stats:dict[str, Any] = verifier_texte_dechiffre(texte)
     pourcent=0
 
     # Les caractères imprimables constituent 50% de la validation du déchiffrement
@@ -41,11 +59,10 @@ def est_dechiffre(texte:str) -> bool:
         pourcent += 20
 
     return True if pourcent > 70 else False
-           
-           
-           
 
-def verifier_texte_dechiffre(texte: str) -> dict[int, int, int, list, int]:
+        
+
+def verifier_texte_dechiffre(texte: str) -> Dict[str, Any]:
     """
         Verifie que le dechiffrement d'un message a bien été effectué sur la base de certains critères.
 
@@ -63,86 +80,83 @@ def verifier_texte_dechiffre(texte: str) -> dict[int, int, int, list, int]:
 
     #Statistiques sur le texte 
 
-    stats: dict = {
+    stats: dict[str, Any] = {
         'imprimable':0,
         'nombre_mots':0,
         'p_mots_valide':0,
         'non_mots':[],
         'ponctuation_valide':0
     }
 
+    if not texte:
+        return stats
+
     #Verifier le pourcentage de caractères imprimables.
-    
-    for lettre in texte:
-        if lettre.isprintable():
-            stats['imprimable']+= 100/len(texte)
-    
+    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, ' ')
-    copy=copy.strip().split(' ')
-    stats['nombre_mots']=len(copy)
+    mots = [mot for mot in copy.strip().split(' ') if mot]
+    stats['nombre_mots']=len(mots)
 
     # Verifier que le chaque mot du texte est un mot anglais/francais 
 
     try:
-        for mot in copy:
+        mots_valides = 0
+        for mot in mots:
             trouve=False
-            if mot == '': continue
+            if not mot: continue
+            
+            first_char = mot[0].lower()
+            
             for syl in ['Fr', 'En']:
-                chemin=f"{os.curdir}\\CryptoForensic-Python\\dico{syl}\\{mot[0]}.txt"
-                
-                with open(chemin, 'r') as f:
-                    ligne=f.readline()
-                    ligne=ligne.removesuffix('\n')
-                    
-                    while not trouve and ligne != "":
-                        
-                        if ligne == mot:
-                            stats['p_mots_valide']+=100/len(copy)
-                            print(stats['p_mots_valide'], mot)
-                            trouve=True
-                            break
-                        
-                        ligne=f.readline()
-                        ligne=ligne.removesuffix('\n')
-                        
-                f.close()
+
+                chemin = Path(f"dico{syl}")/f"{first_char}.txt"
+                try:
+                    with open(chemin, 'r', encoding='latin-1') as f: 
+                        for ligne in f:
+                            if ligne.strip() == mot:
+                                mots_valides += 1
+                                trouve=True
+                                break
+                except FileNotFoundError:
+                    continue
 
                 if trouve : break
 
             if not trouve : 
                 stats['non_mots'].append(mot)
+        if mots:
+            stats['p_mots_valide'] = round((mots_valides / len(mots)) * 100, 2)
+        else:
+            stats['p_mots_valide'] = 0.0
 
     except Exception:
-        tb=sys.exception().__traceback__
-        raise Exception().with_traceback(tb)
+        raise
 
 
     #Verifier la structure de ponctuation.
 
     points='.?!;,'
-    nbr_ponct=0
-    for point in points :
-        nbr_ponct+=texte.count(point)
-    for point in points :
-        partition= texte.partition(point)
-        if partition[2].startswith(' ') :
-            if (point in '?!.' and partition[2].lstrip()[0].isupper()) or (point in ';,' and partition[2].lstrip()[0].islower()):
-                stats['ponctuation_valide']+=100/nbr_ponct
-        
-    for key in stats:
-        print(key)
-        if isinstance(stats[key], float):
-            stats[key]=round(stats[key], 2)
+    count = 0
+    nbr_points = 0
+    for i, char in enumerate(texte):
+        if char in points:
+            nbr_points += 1
+            if (i == len(texte) - 1) or (texte[i+1] == ' '):
+                count += 1
+                
+    if not nbr_points: nbr_points=1
+    stats['ponctuation_valide'] = round(count*100/nbr_points, 2)
 
     return stats
 
 
-def rangerDico():
+def rangerDico() -> None:
     """
         Fonction utilitaire de rangement du dictionnaire anglais téléchargé
         Pour effectuer des tests
@@ -151,11 +165,13 @@ def rangerDico():
     compte = 0
     # Ouverture du grand dictionnaire.
     try :
-        with open(f"{os.path.abspath(os.curdir)}\\words_alpha.txt",'r') as f:
+        # Utilisation de Path pour un chemin portable
+        words_path = Path.cwd() / "words_alpha.txt"
+        with open(words_path,'r') as f:
             while i<26:
                 # Définition du chemin vers le fichier de chaque mot en fonction de l'alphabet.
-                chemin=f"{os.curdir}\\dicoEn\\{string.ascii_lowercase[i]}.txt"
-                with open(chemin, 'a') as fichier:
+                dico_path = Path.cwd() / "dicoEn" / f"{string.ascii_lowercase[i]}.txt"
+                with open(dico_path, 'a') as fichier:
                     #Ecriture dans le fichier.
                     fichier.write(string.ascii_lowercase[i]+'\n')
                     while 1 :
@@ -172,5 +188,3 @@ def rangerDico():
     except FileNotFoundError: 
         print('Fichier non trouvé.')
 # rangerDico()         
-
-print(verifier_texte_dechiffre('neither#nor avec, ded_caractère a'))

src/rapport_mission.py

@@ -0,0 +1,45 @@
+from unittest import TestCase, main
+import sys
+sys.path.append('.')
+sys.path.append('..')
+from src.analyzers.aes_cbc_analyzer import Aes_Cbc_Analyzer
+
+class AnalyzersTester(TestCase):
+
+    """
+        Cette classe est principalement destinée à recueillir toutes les fonctions de test des analyseurs d'algorithme
+        de chiffrement.
+    """
+    
+    def setUp(self):
+        self.chemin_fichier_chiffre = "data/mission1.enc"
+        self.chemin_fichier_chiffre_invalide = "tests/fichiers_pour_tests/mission1_invalide.enc"
+        self.wordlist = "keys/wordlist.txt"
+        self.analyser = Aes_Cbc_Analyzer()
+
+    
+    def test_aes_cbc_identifier_algo(self):
+        self.assertAlmostEqual(self.analyser.identifier_algo(self.chemin_fichier_chiffre), 1)
+        self.assertAlmostEqual(self.analyser.identifier_algo(self.chemin_fichier_chiffre_invalide), 0)
+
+    def test_aes_cbc_filtrage_dict(self):
+        self.assertIsInstance(self.analyser.filtrer_dictionnaire_par_indices(self.wordlist), list)
+        self.assertEqual(self.analyser.filtrer_dictionnaire_par_indices(self.wordlist), ["paris2024"])
+        self.assertEqual(self.analyser.filtrer_dictionnaire_par_indices("chemin_dohi.txt"), [])
+
+    def test_generation_cles_candidate(self):
+        self.assertIsInstance(self.analyser.generer_cles_candidates(self.wordlist), list)
+
+    def test_exception_dechiffrer(self):
+        cles_candidates = self.analyser.generer_cles_candidates(self.wordlist)
+        
+        if not cles_candidates:
+            self.fail("La liste des clés candidates ne devrait pas être vide.")
+        
+        premiere_cle = cles_candidates[0]
+        
+        with self.assertRaises(FileNotFoundError):
+            self.analyser.dechiffrer("no_file_dohi.txt", premiere_cle)
+
+if __name__ == '__main__':
+    main()