From f40bb5916365fd5459b8293ca627d506c85d3c14 Mon Sep 17 00:00:00 2001 From: e-mandy Date: Sat, 2 Aug 2025 15:40:23 +0100 Subject: [PATCH 01/11] Documentation de la fonction d'entropie --- src/utils.py | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/src/utils.py b/src/utils.py index 62ab214..92f5308 100644 --- a/src/utils.py +++ b/src/utils.py @@ -3,7 +3,16 @@ def valider_texte_dechiffre(texte): pass -def calculer_entropie(bytes): +def calculer_entropie(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: From 8f0dbfce701e060940317e458cb7a3e353c3da4d Mon Sep 17 00:00:00 2001 From: e-mandy Date: Sat, 2 Aug 2025 16:04:26 +0100 Subject: [PATCH 02/11] Essai de fusion (1/2) --- src/utils.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/utils.py b/src/utils.py index 997098b..3d2bfdb 100644 --- a/src/utils.py +++ b/src/utils.py @@ -45,7 +45,7 @@ def verifier_texte_dechiffre(texte: str): #Statistiques sur le texte - stats={ + stats={ 'imprimable':0, 'nombre_mots':0, 'p_mots_valide':0, @@ -55,9 +55,9 @@ def verifier_texte_dechiffre(texte: str): #Verifier le pourcentage de caractères imprimables. - for lettre in texte: - if lettre.isprintable(): - stats['imprimable']+= 100/len(texte) + for lettre in texte: + if lettre.isprintab:le(): + stats['imprimable']+= 100/len(texte) # Traitement du texte brut pour obtenir une séquence distinct de pseudo-mot à cette étape séparé par des espaces @@ -126,9 +126,9 @@ def verifier_texte_dechiffre(texte: str): def rangerDico(): - """ - Fonction utilitaire de rangement du dictionnaire anglais téléchargé - """ + """ + Fonction utilitaire de rangement du dictionnaire anglais téléchargé + """ i=0 compte = 0 # Ouverture du grand dictionnaire. From b638a494081c7c90f6a181e936b3f81cc7476416 Mon Sep 17 00:00:00 2001 From: e-mandy Date: Sun, 3 Aug 2025 17:55:15 +0100 Subject: [PATCH 03/11] =?UTF-8?q?R=C3=A9cup=C3=A9ration=20du=20main=20(1/2?= =?UTF-8?q?)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/detecteur_crypto.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/src/detecteur_crypto.py b/src/detecteur_crypto.py index 45c6775..153e418 100644 --- a/src/detecteur_crypto.py +++ b/src/detecteur_crypto.py @@ -12,6 +12,4 @@ class DetecteurCryptoOrchestrateur: Initialisation de l'analyseur AES-CBC """ def __init__(self): - self.aes_cbc_analyzer = AesCbcAnalyzer() - - + self.aes_cbc_analyzer = AesCbcAnalyzer() \ No newline at end of file From e96580101f4ddcd0030487efcd4cc0b081672910 Mon Sep 17 00:00:00 2001 From: e-mandy Date: Sun, 3 Aug 2025 21:37:00 +0100 Subject: [PATCH 04/11] Mise en place des tests unitaires (1/4) --- src/utils.py | 29 +++++++---------------------- tests/test_global.py | 13 +++++++++++++ 2 files changed, 20 insertions(+), 22 deletions(-) diff --git a/src/utils.py b/src/utils.py index 0804109..5919cf4 100644 --- a/src/utils.py +++ b/src/utils.py @@ -21,15 +21,11 @@ def calculer_entropie(bytes) -> float: for chaque_byte in bytes: if(chaque_byte == specifique_byte): i += 1 -<<<<<<< HEAD + proba_byte = 1 / i entropie += (proba_byte) * math.log(1/proba_byte, 8) return entropie -======= - proba_byte = 1 / i - entropie += (proba_byte) * math.log(1/proba_byte, 8) - return entropie ->>>>>>> 267a282fa6e0765b0437b0aa3ef6139dc3453987 + def est_dechiffre(texte:str) -> bool: @@ -79,15 +75,6 @@ def verifier_texte_dechiffre(texte: str) -> dict[int, int, int, list, int]: #Statistiques sur le texte -<<<<<<< HEAD - stats={ - 'imprimable':0, - 'nombre_mots':0, - 'p_mots_valide':0, - 'non_mots':[], - 'ponctuation_valide':0 - } -======= stats: dict = { 'imprimable':0, 'nombre_mots':0, @@ -95,7 +82,6 @@ def verifier_texte_dechiffre(texte: str) -> dict[int, int, int, list, int]: 'non_mots':[], 'ponctuation_valide':0 } ->>>>>>> 267a282fa6e0765b0437b0aa3ef6139dc3453987 #Verifier le pourcentage de caractères imprimables. @@ -105,7 +91,7 @@ def verifier_texte_dechiffre(texte: str) -> dict[int, int, int, list, int]: # Traitement du texte brut pour obtenir une séquence distinct de pseudo-mot à cette étape séparé par des espaces - tab='./:!\\}{_%*$£&#;,~"()[]=§|`^@' + tab='./:!\\}{_%*$£&#;,~"()[]=§|`^@?' copy=texte for lettre in tab: copy=copy.replace(lettre, ' ') @@ -119,9 +105,9 @@ def verifier_texte_dechiffre(texte: str) -> dict[int, int, int, list, int]: trouve=False if mot == '': continue for syl in ['Fr', 'En']: - chemin=f"{os.curdir}\\CryptoForensic-Python\\dico{syl}\\{mot[0]}.txt" - - with open(chemin, 'r') as f: + chemin=f"{os.curdir}.\\CryptoForensic-Python\\dico{syl}\\{mot[0]}.txt" + exit + with open(chemin, 'r') as f: ligne=f.readline() ligne=ligne.removesuffix('\n') @@ -129,7 +115,7 @@ def verifier_texte_dechiffre(texte: str) -> dict[int, int, int, list, int]: if ligne == mot: stats['p_mots_valide']+=100/len(copy) - print(stats['p_mots_valide'], mot) + print('\n', stats['p_mots_valide'], mot,) trouve=True break @@ -196,4 +182,3 @@ def rangerDico(): # rangerDico() -print(verifier_texte_dechiffre('neither#nor avec, ded_caractère a')) diff --git a/tests/test_global.py b/tests/test_global.py index e5e65e5..19dcc5a 100644 --- a/tests/test_global.py +++ b/tests/test_global.py @@ -1,5 +1,9 @@ # import de la library pour les tests from unittest import TestCase, main +import sys +sys.path.append('.') +sys.path.append('..') +from src.utils import verifier_texte_dechiffre, calculer_entropie """ Ici le TestCase pour le regroupement des Cas de figures de Tests et le main pour l'exécution automatique des tests définis dans la classe ci-dessous @@ -16,6 +20,15 @@ def test_addition(self): self.assertEqual(add(5,5),10) + def test_verification_texte_dechiffre(self): + self.assertDictEqual(verifier_texte_dechiffre("je talk !a mamamia:?"), {"imprimable": 100, "nombre_mots": 4, "p_mots_valide": 3, "nom_mots": ["mamamia"], "ponctuation_valide": 1}) + + def test_calcul_entropie(self): + self.assertGreater(calculer_entropie("aaaaaaaa"), 0) + + + + """ # La fonction doit être préfixé du mot test pour que le TestCase puisse le l'identifier en tant que méthode à tester (le snake_case ici devra être appliqué ici) From e119f5dc57f198d6c8978647a8b907ce0656ce73 Mon Sep 17 00:00:00 2001 From: e-mandy Date: Sun, 3 Aug 2025 21:41:06 +0100 Subject: [PATCH 05/11] Revert "Mise en place des tests unitaires (1/4)" This reverts commit e96580101f4ddcd0030487efcd4cc0b081672910. --- src/utils.py | 29 ++++++++++++++++++++++------- tests/test_global.py | 13 ------------- 2 files changed, 22 insertions(+), 20 deletions(-) diff --git a/src/utils.py b/src/utils.py index 5919cf4..0804109 100644 --- a/src/utils.py +++ b/src/utils.py @@ -21,11 +21,15 @@ def calculer_entropie(bytes) -> float: for chaque_byte in bytes: if(chaque_byte == specifique_byte): i += 1 - +<<<<<<< HEAD proba_byte = 1 / i entropie += (proba_byte) * math.log(1/proba_byte, 8) return entropie - +======= + proba_byte = 1 / i + entropie += (proba_byte) * math.log(1/proba_byte, 8) + return entropie +>>>>>>> 267a282fa6e0765b0437b0aa3ef6139dc3453987 def est_dechiffre(texte:str) -> bool: @@ -75,6 +79,15 @@ def verifier_texte_dechiffre(texte: str) -> dict[int, int, int, list, int]: #Statistiques sur le texte +<<<<<<< HEAD + stats={ + 'imprimable':0, + 'nombre_mots':0, + 'p_mots_valide':0, + 'non_mots':[], + 'ponctuation_valide':0 + } +======= stats: dict = { 'imprimable':0, 'nombre_mots':0, @@ -82,6 +95,7 @@ def verifier_texte_dechiffre(texte: str) -> dict[int, int, int, list, int]: 'non_mots':[], 'ponctuation_valide':0 } +>>>>>>> 267a282fa6e0765b0437b0aa3ef6139dc3453987 #Verifier le pourcentage de caractères imprimables. @@ -91,7 +105,7 @@ def verifier_texte_dechiffre(texte: str) -> dict[int, int, int, list, int]: # Traitement du texte brut pour obtenir une séquence distinct de pseudo-mot à cette étape séparé par des espaces - tab='./:!\\}{_%*$£&#;,~"()[]=§|`^@?' + tab='./:!\\}{_%*$£&#;,~"()[]=§|`^@' copy=texte for lettre in tab: copy=copy.replace(lettre, ' ') @@ -105,9 +119,9 @@ def verifier_texte_dechiffre(texte: str) -> dict[int, int, int, list, int]: trouve=False if mot == '': continue for syl in ['Fr', 'En']: - chemin=f"{os.curdir}.\\CryptoForensic-Python\\dico{syl}\\{mot[0]}.txt" - exit - with open(chemin, 'r') as f: + chemin=f"{os.curdir}\\CryptoForensic-Python\\dico{syl}\\{mot[0]}.txt" + + with open(chemin, 'r') as f: ligne=f.readline() ligne=ligne.removesuffix('\n') @@ -115,7 +129,7 @@ def verifier_texte_dechiffre(texte: str) -> dict[int, int, int, list, int]: if ligne == mot: stats['p_mots_valide']+=100/len(copy) - print('\n', stats['p_mots_valide'], mot,) + print(stats['p_mots_valide'], mot) trouve=True break @@ -182,3 +196,4 @@ def rangerDico(): # rangerDico() +print(verifier_texte_dechiffre('neither#nor avec, ded_caractère a')) diff --git a/tests/test_global.py b/tests/test_global.py index 19dcc5a..e5e65e5 100644 --- a/tests/test_global.py +++ b/tests/test_global.py @@ -1,9 +1,5 @@ # import de la library pour les tests from unittest import TestCase, main -import sys -sys.path.append('.') -sys.path.append('..') -from src.utils import verifier_texte_dechiffre, calculer_entropie """ Ici le TestCase pour le regroupement des Cas de figures de Tests et le main pour l'exécution automatique des tests définis dans la classe ci-dessous @@ -20,15 +16,6 @@ def test_addition(self): self.assertEqual(add(5,5),10) - def test_verification_texte_dechiffre(self): - self.assertDictEqual(verifier_texte_dechiffre("je talk !a mamamia:?"), {"imprimable": 100, "nombre_mots": 4, "p_mots_valide": 3, "nom_mots": ["mamamia"], "ponctuation_valide": 1}) - - def test_calcul_entropie(self): - self.assertGreater(calculer_entropie("aaaaaaaa"), 0) - - - - """ # La fonction doit être préfixé du mot test pour que le TestCase puisse le l'identifier en tant que méthode à tester (le snake_case ici devra être appliqué ici) From 14e759db98c3a4dbf914719981fb1e327b7dee03 Mon Sep 17 00:00:00 2001 From: e-mandy Date: Sun, 3 Aug 2025 21:54:35 +0100 Subject: [PATCH 06/11] Mise en place des tests unitaires (1/4) --- src/utils.py | 29 +++++++---------------------- tests/test_global.py | 13 +++++++++++++ 2 files changed, 20 insertions(+), 22 deletions(-) diff --git a/src/utils.py b/src/utils.py index 0804109..5919cf4 100644 --- a/src/utils.py +++ b/src/utils.py @@ -21,15 +21,11 @@ def calculer_entropie(bytes) -> float: for chaque_byte in bytes: if(chaque_byte == specifique_byte): i += 1 -<<<<<<< HEAD + proba_byte = 1 / i entropie += (proba_byte) * math.log(1/proba_byte, 8) return entropie -======= - proba_byte = 1 / i - entropie += (proba_byte) * math.log(1/proba_byte, 8) - return entropie ->>>>>>> 267a282fa6e0765b0437b0aa3ef6139dc3453987 + def est_dechiffre(texte:str) -> bool: @@ -79,15 +75,6 @@ def verifier_texte_dechiffre(texte: str) -> dict[int, int, int, list, int]: #Statistiques sur le texte -<<<<<<< HEAD - stats={ - 'imprimable':0, - 'nombre_mots':0, - 'p_mots_valide':0, - 'non_mots':[], - 'ponctuation_valide':0 - } -======= stats: dict = { 'imprimable':0, 'nombre_mots':0, @@ -95,7 +82,6 @@ def verifier_texte_dechiffre(texte: str) -> dict[int, int, int, list, int]: 'non_mots':[], 'ponctuation_valide':0 } ->>>>>>> 267a282fa6e0765b0437b0aa3ef6139dc3453987 #Verifier le pourcentage de caractères imprimables. @@ -105,7 +91,7 @@ def verifier_texte_dechiffre(texte: str) -> dict[int, int, int, list, int]: # Traitement du texte brut pour obtenir une séquence distinct de pseudo-mot à cette étape séparé par des espaces - tab='./:!\\}{_%*$£&#;,~"()[]=§|`^@' + tab='./:!\\}{_%*$£&#;,~"()[]=§|`^@?' copy=texte for lettre in tab: copy=copy.replace(lettre, ' ') @@ -119,9 +105,9 @@ def verifier_texte_dechiffre(texte: str) -> dict[int, int, int, list, int]: trouve=False if mot == '': continue for syl in ['Fr', 'En']: - chemin=f"{os.curdir}\\CryptoForensic-Python\\dico{syl}\\{mot[0]}.txt" - - with open(chemin, 'r') as f: + chemin=f"{os.curdir}.\\CryptoForensic-Python\\dico{syl}\\{mot[0]}.txt" + exit + with open(chemin, 'r') as f: ligne=f.readline() ligne=ligne.removesuffix('\n') @@ -129,7 +115,7 @@ def verifier_texte_dechiffre(texte: str) -> dict[int, int, int, list, int]: if ligne == mot: stats['p_mots_valide']+=100/len(copy) - print(stats['p_mots_valide'], mot) + print('\n', stats['p_mots_valide'], mot,) trouve=True break @@ -196,4 +182,3 @@ def rangerDico(): # rangerDico() -print(verifier_texte_dechiffre('neither#nor avec, ded_caractère a')) diff --git a/tests/test_global.py b/tests/test_global.py index e5e65e5..19dcc5a 100644 --- a/tests/test_global.py +++ b/tests/test_global.py @@ -1,5 +1,9 @@ # import de la library pour les tests from unittest import TestCase, main +import sys +sys.path.append('.') +sys.path.append('..') +from src.utils import verifier_texte_dechiffre, calculer_entropie """ Ici le TestCase pour le regroupement des Cas de figures de Tests et le main pour l'exécution automatique des tests définis dans la classe ci-dessous @@ -16,6 +20,15 @@ def test_addition(self): self.assertEqual(add(5,5),10) + def test_verification_texte_dechiffre(self): + self.assertDictEqual(verifier_texte_dechiffre("je talk !a mamamia:?"), {"imprimable": 100, "nombre_mots": 4, "p_mots_valide": 3, "nom_mots": ["mamamia"], "ponctuation_valide": 1}) + + def test_calcul_entropie(self): + self.assertGreater(calculer_entropie("aaaaaaaa"), 0) + + + + """ # La fonction doit être préfixé du mot test pour que le TestCase puisse le l'identifier en tant que méthode à tester (le snake_case ici devra être appliqué ici) From 52433f75af6b71f7fcf1ff444b64437e2c8da27f Mon Sep 17 00:00:00 2001 From: e-mandy Date: Mon, 4 Aug 2025 17:12:44 +0100 Subject: [PATCH 07/11] =?UTF-8?q?Mise=20en=20place=20des=20tests=20li?= =?UTF-8?q?=C3=A9s=20=C3=A0=20l'analyzer=20aes=20cbc?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/analyzers/aes_cbc_analyzer.py | 2 +- src/utils.py | 1 - tests/test_analyzers.py | 33 +++++++++++++++++++++++++++++++ tests/test_global.py | 30 +++++++++++++--------------- 4 files changed, 48 insertions(+), 18 deletions(-) diff --git a/src/analyzers/aes_cbc_analyzer.py b/src/analyzers/aes_cbc_analyzer.py index d1b07f5..c11b365 100644 --- a/src/analyzers/aes_cbc_analyzer.py +++ b/src/analyzers/aes_cbc_analyzer.py @@ -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) diff --git a/src/utils.py b/src/utils.py index ede0a54..280a45d 100644 --- a/src/utils.py +++ b/src/utils.py @@ -3,7 +3,6 @@ import sys import os - def calculer_entropie(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. diff --git a/tests/test_analyzers.py b/tests/test_analyzers.py index e69de29..28a22ce 100644 --- a/tests/test_analyzers.py +++ b/tests/test_analyzers.py @@ -0,0 +1,33 @@ +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.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) + + def test_aes_cbc_filtrage_dict(self): + self.assertIsInstance(self.analyser.filtrer_dictionnaire_par_indices(self.wordlist), list) + + def test_generation_cles_candidate(self): + self.assertIsInstance(self.analyser.generer_cles_candidates(self.wordlist), list) + + def test_exception_dechiffrer(self): + with self.assertRaises(FileNotFoundError): + self.analyser.dechiffrer("no_file_dohi.txt", self.analyser.generer_cles_candidates(self.wordlist)) + +main() \ No newline at end of file diff --git a/tests/test_global.py b/tests/test_global.py index 19dcc5a..67d0c42 100644 --- a/tests/test_global.py +++ b/tests/test_global.py @@ -15,6 +15,20 @@ def add(a,b): class BetaTester(TestCase): #Définition de la méthode de test + """ + # La fonction doit être préfixé du mot test pour que le TestCase puisse le l'identifier en tant que méthode à tester (le snake_case ici devra être appliqué ici) + + # En fonction du type de vérification que vous souhaitez effectué par rapport aux test les méthodes assert devront variés. + ex : * assertEqual() pour vérifier l'égalité. Dans le cas utilisé cette fonction vérifie si le retour de la fonction add correspond à la valeur 10 + * assertIn() pour vérifier si une variable est dans une iterable + * assertIsInstance() pour vérifier le type de retour d'une variable ou fonction etc... (description des méthodes à l'appui) + + NB : Pour tester sa fonction chacun devra faire un import pour éviter la redondance. + Chaque fonction à tester devra se retrouver dans la class BetaTester avec un nom clair et propre à sa fonctionnalité précédé du mot "test" + + command : pyhton test_global.py [-v (-- verbose)] (verbose pour un test avec plus de précision) + + """ def test_addition(self): self.assertEqual(add(5,5),10) @@ -27,20 +41,4 @@ def test_calcul_entropie(self): self.assertGreater(calculer_entropie("aaaaaaaa"), 0) - - -""" - # La fonction doit être préfixé du mot test pour que le TestCase puisse le l'identifier en tant que méthode à tester (le snake_case ici devra être appliqué ici) - - # En fonction du type de vérification que vous souhaitez effectué par rapport aux test les méthodes assert devront variés. - ex : * assertEqual() pour vérifier l'égalité. Dans le cas utilisé cette fonction vérifie si le retour de la fonction add correspond à la valeur 10 - * assertIn() pour vérifier si une variable est dans une iterable - * assertIsInstance() pour vérifier le type de retour d'une variable ou fonction etc... (description des méthodes à l'appui) - - NB : Pour tester sa fonction chacun devra faire un import pour éviter la redondance. - Chaque fonction à tester devra se retrouver dans la class BetaTester avec un nom clair et propre à sa fonctionnalité précédé du mot "test" - - command : pyhton test_global.py [-v (-- verbose)] (verbose pour un test avec plus de précision) - -""" main() \ No newline at end of file From af85ee29c6e700e3b6d6e5ae2c9498a397f043ad Mon Sep 17 00:00:00 2001 From: mouwaficbdr Date: Mon, 4 Aug 2025 21:55:10 +0100 Subject: [PATCH 08/11] Corrections de typage et de logique --- src/utils.py | 133 ++++++++++++++++++++++++++------------------------- 1 file changed, 67 insertions(+), 66 deletions(-) diff --git a/src/utils.py b/src/utils.py index 280a45d..e49fb1a 100644 --- a/src/utils.py +++ b/src/utils.py @@ -1,29 +1,36 @@ import math import string import sys -import os +from typing import Any, Dict, List, TypedDict -def calculer_entropie(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. +class StatsDict(TypedDict): + imprimable: float + nombre_mots: int + p_mots_valide: float + non_mots: List[str] + ponctuation_valide: int - Args: - bytes(bytes): La donnée brute contenue dans le fichier crypté. +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. + 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 + entropie = 0 + proba_byte = 0 + for specifique_byte in bytes: + i = 1 + for chaque_byte in bytes: + if(chaque_byte == specifique_byte): + i += 1 - proba_byte = 1 / i - entropie += (proba_byte) * math.log(1/proba_byte, 8) - return entropie + proba_byte = 1 / i + entropie += (proba_byte) * math.log(1/proba_byte, 8) + return entropie @@ -52,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. @@ -82,51 +88,51 @@ def verifier_texte_dechiffre(texte: str) -> dict[int, int, int, list, int]: '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='./:!\\}{_%*$£&#;,~"()[]=§|`^@?' 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" - exit - 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('\n', stats['p_mots_valide'], mot,) - trouve=True - break - - ligne=f.readline() - ligne=ligne.removesuffix('\n') - - f.close() + chemin=f"dico{syl}/{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__ @@ -136,24 +142,17 @@ def verifier_texte_dechiffre(texte: str) -> dict[int, int, int, list, int]: #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 + for i, char in enumerate(texte): + if char in points: + if (i == len(texte) - 1) or (texte[i+1] == ' '): + count += 1 + stats['ponctuation_valide'] = count return stats -def rangerDico(): +def rangerDico() -> None: """ Fonction utilitaire de rangement du dictionnaire anglais téléchargé Pour effectuer des tests @@ -162,11 +161,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 : From 896696aac1ce9f707ac3bb7b66dc54182a010b12 Mon Sep 17 00:00:00 2001 From: mouwaficbdr Date: Mon, 4 Aug 2025 21:55:32 +0100 Subject: [PATCH 09/11] =?UTF-8?q?Correction=20du=20comportement=20=C3=A0?= =?UTF-8?q?=20la=20lev=C3=A9e=20de=20l'exception?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/analyzers/aes_cbc_analyzer.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/analyzers/aes_cbc_analyzer.py b/src/analyzers/aes_cbc_analyzer.py index c11b365..719381e 100644 --- a/src/analyzers/aes_cbc_analyzer.py +++ b/src/analyzers/aes_cbc_analyzer.py @@ -155,4 +155,4 @@ def dechiffrer(self, chemin_fichier_chiffre: str, cle_donnee: bytes) -> bytes: return b"" except FileNotFoundError: - return b"" \ No newline at end of file + raise \ No newline at end of file From 339140377e7d4e921e35558ffc8e024f751f202f Mon Sep 17 00:00:00 2001 From: mouwaficbdr Date: Mon, 4 Aug 2025 21:56:28 +0100 Subject: [PATCH 10/11] =?UTF-8?q?Correction=20de=20la=20lgoque=20de=20test?= =?UTF-8?q?=20de=20test=5Fexception=5Fd=C3=A9chiffrer?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- tests/test_analyzers.py | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/tests/test_analyzers.py b/tests/test_analyzers.py index 28a22ce..8129c39 100644 --- a/tests/test_analyzers.py +++ b/tests/test_analyzers.py @@ -27,7 +27,15 @@ 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", self.analyser.generer_cles_candidates(self.wordlist)) + self.analyser.dechiffrer("no_file_dohi.txt", premiere_cle) -main() \ No newline at end of file +if __name__ == '__main__': + main() \ No newline at end of file From 9b38d2763331de5def4a5b6db0e6dde9ac98f1cf Mon Sep 17 00:00:00 2001 From: mouwaficbdr Date: Mon, 4 Aug 2025 21:57:36 +0100 Subject: [PATCH 11/11] Corection de la logique de test_verification_texte_dechiffre --- tests/test_global.py | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/tests/test_global.py b/tests/test_global.py index 67d0c42..f59e2cd 100644 --- a/tests/test_global.py +++ b/tests/test_global.py @@ -35,10 +35,16 @@ def test_addition(self): def test_verification_texte_dechiffre(self): - self.assertDictEqual(verifier_texte_dechiffre("je talk !a mamamia:?"), {"imprimable": 100, "nombre_mots": 4, "p_mots_valide": 3, "nom_mots": ["mamamia"], "ponctuation_valide": 1}) - - def test_calcul_entropie(self): + resultat = verifier_texte_dechiffre("je talk !a mamamia:?") + self.assertAlmostEqual(resultat['imprimable'], 100.0) + self.assertEqual(resultat['nombre_mots'], 4) + self.assertAlmostEqual(resultat['p_mots_valide'], 75.0) + self.assertEqual(resultat['non_mots'], ["mamamia"]) + self.assertEqual(resultat['ponctuation_valide'], 1) + + def test_calcul_entropie(self) -> None: self.assertGreater(calculer_entropie("aaaaaaaa"), 0) -main() \ No newline at end of file +if __name__ == '__main__': + main() \ No newline at end of file