Hotfix/problèmes globaux

scripts/show_decrypted_texts.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+"""
+Affiche les textes déchiffrés pour chaque mission en utilisant l'analyzer correspondant.
+"""
+import sys
+from pathlib import Path
+from typing import Dict, Tuple, Type
+
+sys.path.append('.')
+
+from src.analyzers.aes_cbc_analyzer import Aes_Cbc_Analyzer
+from src.analyzers.chacha20_analyzer import ChaCha20_Analyzer
+from src.analyzers.blowfish_analyzer import Blowfish_Analyzer
+from src.analyzers.aes_gcm_analyzer import Aes_Gcm_Analyzer
+from src.analyzers.fernet_analyzer import FernetAnalyzer
+from src.utils import verifier_texte_dechiffre
+
+MISSIONS: Dict[str, Tuple[str, Type]] = {
+    'AES-CBC': ('data/mission1.enc', Aes_Cbc_Analyzer),
+    'ChaCha20': ('data/mission2.enc', ChaCha20_Analyzer),
+    'Blowfish': ('data/mission3.enc', Blowfish_Analyzer),
+    'AES-GCM': ('data/mission4.enc', Aes_Gcm_Analyzer),
+    'Fernet': ('data/mission5.enc', FernetAnalyzer),
+}
+
+WORDLIST = 'keys/wordlist.txt'
+
+
+def main() -> None:
+    if not Path(WORDLIST).exists():
+        print(f"Wordlist manquante: {WORDLIST}")
+        sys.exit(1)
+
+    for algo, (mission_path, AnalyzerCls) in MISSIONS.items():
+        print("=" * 70)
+        print(f"{algo} -> {mission_path}")
+        if not Path(mission_path).exists():
+            print(f"Fichier introuvable: {mission_path}")
+            continue
+
+        analyzer = AnalyzerCls()
+        try:
+            cles = analyzer.generer_cles_candidates(WORDLIST)
+        except Exception as e:
+            print(f"Erreur génération clés: {e}")
+            cles = []
+
+        meilleure_stat = -1.0
+        meilleur_texte_b = b''
+        meilleure_cle = None
+
+        for cle in cles:
+            try:
+                res = analyzer.dechiffrer(mission_path, cle)
+            except Exception:
+                continue
+            if not res:
+                continue
+            # Sanitize and score
+            texte = res.decode('utf-8', errors='ignore').replace('\x00', ' ')
+            try:
+                taux = float(verifier_texte_dechiffre(texte).get('taux_succes', 0.0))
+            except Exception:
+                taux = 0.0
+            if taux > meilleure_stat:
+                meilleure_stat = taux
+                meilleur_texte_b = res
+                meilleure_cle = cle
+            # Early stop on good plaintext
+            if taux >= 60.0:
+                break
+
+        if meilleure_cle is None:
+            print("❌ Aucun texte déchiffré trouvé")
+        else:
+            texte = meilleur_texte_b.decode('utf-8', errors='ignore')
+            print(f"✅ Meilleur taux: {meilleure_stat:.2f}%")
+            print("--- TEXTE DÉCHIFFRÉ ---")
+            print(texte.strip())
+            print("------------------------")
+
+if __name__ == '__main__':
+    main()

src/analyzers/aes_gcm_analyzer.py

@@ -1,6 +1,7 @@
 from src.crypto_analyzer import CryptoAnalyzer
 from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
 from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
 from typing import List
 import re
 
@@ -23,43 +24,30 @@ class Aes_Gcm_Analyzer(CryptoAnalyzer):
   _PBKDF2_ITERATIONS: int = 10000             #Fourni
   _PBKDF2_LONGUEUR_CLE: int = 32              #Longueur de la clé
 
-  def __filtrer_dictionnaire_par_indice(self, chemin_dictionnaire: str) -> List[str]:
+  def __filtrer_dictionnaire_par_indices(self, chemin_dictionnaire: str) -> List[str]:
     """
     Filtre le dictionnaire en se basant sur les indices de la mission 4.
     L'indice pointe vers le format de clé "Acronyme en majuscules + 4 chiffres".
-
-    Args:
-      chemin_dictionnaire(str): Le chemin vers le fichier de dictionnaire.
-
-    Returns:
-      list[str]: Une liste de mots de passe filtrés.
     """
     mots_filtres: List[str] = []
-
-    # L'année courante
-    annee_courante: str = "2024" #Normalement 2025 mais on considère 2024 pour se conformer à la wordlist
-
-    # Définition du motif d'acronyme de 4 lettres en majuscules
-    # On utilise une expression régulière pour plus de robustesse
+    annee_courante: str = "2024"  # Normalement 2025 mais on considère 2024 pour se conformer à la wordlist
     motif_acronyme = re.compile(r"^[A-Z]{4}$")
-    
+
     try:
         with open(chemin_dictionnaire, "r", encoding="utf-8") as f:
             for ligne in f:
                 mot: str = ligne.strip()
-
-                # Vérifie si le mot de passe correspond au format de l'indice
-                # ex: NATO2024, UN2024, etc.
                 if mot.endswith(annee_courante):
-                    acronyme: str = mot[:-4] # Extrait la partie acronyme
+                    acronyme: str = mot[:-4]
                     if motif_acronyme.match(acronyme):
                         mots_filtres.append(mot)
-
     except FileNotFoundError:
         print(f"Erreur : Le fichier de dictionnaire '{chemin_dictionnaire}' est introuvable.")
         return []
-    
+
     return mots_filtres
+
+
 
   def generer_cles_candidates(self, chemin_dictionnaire: str) -> List[bytes]:
     '''
@@ -72,7 +60,7 @@ def generer_cles_candidates(self, chemin_dictionnaire: str) -> List[bytes]:
         list[bytes]: liste des clés candidates. 
     '''
 
-    mots_de_passe_cible: List[str] = self.__filtrer_dictionnaire_par_indice(chemin_dictionnaire)
+    mots_de_passe_cible: List[str] = self.__filtrer_dictionnaire_par_indices(chemin_dictionnaire)
 
     clees_candidates: List[bytes] = []
 
@@ -151,6 +139,11 @@ def identifier_algo(self, chemin_fichier_chiffre: str) -> float:
         if probabilite >= 0.5:
             probabilite += 0.1
 
+        # Normalisation du score dans [0.0, 1.0]
+        if probabilite > 1.0:
+            probabilite = 1.0
+        if probabilite < 0.0:
+            probabilite = 0.0
         return probabilite
 
     except FileNotFoundError:
@@ -172,8 +165,41 @@ def dechiffrer(self, chemin_fichier_chiffre: str, cle_donnee: bytes) -> bytes:
         bytes: Le contenu déchiffré ou une chaîne vide en cas d'échec.
     """
     try:
-        # TODO: Implémenter la logique de déchiffrement AES GCM
+        # Validation taille de clé: AES-256 => 32 octets
+        if len(cle_donnee) != self._PBKDF2_LONGUEUR_CLE:
+            raise ValueError("Erreur : La clé AES-256 doit faire 32 bytes")
+
+        # Lecture du fichier: nonce (12B) + données + tag (16B)
+        with open(chemin_fichier_chiffre, "rb") as f:
+            donnees = f.read()
+
+        if len(donnees) < 12 + 16:
+            return b""
+
+        nonce = donnees[:12]
+        ciphertext_tag = donnees[12:]
+        if len(ciphertext_tag) < 16:
+            return b""
+        ciphertext = ciphertext_tag[:-16]
+        tag = ciphertext_tag[-16:]
+
+        # Déchiffrement AES-GCM
+        cipher = Cipher(algorithms.AES(cle_donnee), modes.GCM(nonce, tag))
+        decryptor = cipher.decryptor()
+        try:
+            plaintext = decryptor.update(ciphertext) + decryptor.finalize()
+            return plaintext
+        except Exception:
+            # Tag invalide / clé incorrecte
+            return b""
+
+    except FileNotFoundError:
+        raise
+    except ValueError as e:
+        # Erreur de validation de clé
+        if "doit faire 32 bytes" in str(e):
+            raise
         return b""
     except Exception as e:
-        print(f"Erreur lors du déchiffrement: {e}")
+        # Erreur générique
         return b""

src/analyzers/blowfish_analyzer.py

@@ -3,9 +3,8 @@
 import hashlib
 import base64
 import re
-from cryptography.hazmat.primitives.ciphers import Cipher, modes
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
 from cryptography.hazmat.primitives.padding import PKCS7
-from cryptography.hazmat.decrepit.ciphers.algorithms import Blowfish
 class Blowfish_Analyzer(CryptoAnalyzer):
   '''Détermine si l'algo blowfish 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.
 
@@ -72,36 +71,25 @@ def identifier_algo(self, chemin_fichier_chiffre: str) -> float:
     return score
 
 
-  def __filtrer_dictionnaire_par_indice(self, chemin_dictionnaire: str) -> list[str]:
+  def __filtrer_dictionnaire_par_indices(self, chemin_dictionnaire: str) -> list[str]:
     """
     Filtre le dictionnaire en se basant sur les indices de la mission 3.
     L'indice pointe vers un format de clé "sha + nombre + chiffres simples".
-
-    Args:
-      chemin_dictionnaire(str): Le chemin vers le fichier de dictionnaire.
-
-    Returns:
-      list[str]: Une liste de mots de passe filtrés.
     """
     mots_filtres: list[str] = []
-
-    # Indices pour le préfixe et le suffixe
-    prefixes = ("sha256", "sha384", "sha512", "sha1") 
+    prefixes = ("sha256", "sha384", "sha512", "sha1")
     suffixes = ("123", "456", "789")
-    
+
     try:
       with open(chemin_dictionnaire, "r", encoding="utf-8") as f:
         for ligne in f:
           mot = ligne.strip()
-
-          # Vérifie si le mot commence par un préfixe et se termine par un suffixe
           if mot.startswith(prefixes) and mot.endswith(suffixes):
             mots_filtres.append(mot)
-
     except FileNotFoundError:
       print(f"Erreur : Le fichier de dictionnaire '{chemin_dictionnaire}' est introuvable.")
       return []
-    
+
     return mots_filtres
 
   def generer_cles_candidates(self, chemin_dictionnaire: str) -> list[bytes]:
@@ -117,7 +105,7 @@ def generer_cles_candidates(self, chemin_dictionnaire: str) -> list[bytes]:
     """
     cles_candidates: list[bytes] = []
     # Utilisation de la méthode privée pour filtrer les mots
-    mots_de_passe_cible = self.__filtrer_dictionnaire_par_indice(chemin_dictionnaire)
+    mots_de_passe_cible = self.__filtrer_dictionnaire_par_indices(chemin_dictionnaire)
 
     for mot in mots_de_passe_cible:
         mot_en_bytes = mot.encode("utf-8")
@@ -165,23 +153,22 @@ def dechiffrer(self, chemin_fichier_chiffre: str, cle_donnee: bytes) -> bytes:
       raise ValueError('Taille de clé invalide.')
 
     try:
-
-      algorithm_blowfish = Blowfish(self.decode_base64(cle_donnee))
-      texte_chiffre = ''
+      # Use the key directly, not base64 decoded
+      algorithm_blowfish = algorithms.Blowfish(cle_donnee)
 
       #Récupération de l'IV et du texte chiffré dans le fichier
       with open(chemin_fichier_chiffre, 'rb') as f:
         donnees = f.read()
-      f.close()
+
       initialization_vector = donnees[:self.__BLOWFISH_TAILLE_IV]
       texte_chiffre = donnees[self.__BLOWFISH_TAILLE_IV:]
 
       #Initialisation du cipher
       cipher = Cipher(algorithm_blowfish, modes.CBC(initialization_vector))
       decrypteur = cipher.decryptor()
 
-      #Suppresseur de padding
-      supresseur_padding = PKCS7(self.__BLOWFISH_TAILLE_BLOC).unpadder()
+      #Suppresseur de padding - PKCS7 uses bits, not bytes
+      supresseur_padding = PKCS7(64).unpadder()  # 64 bits = 8 bytes
 
       #Décriptage des données avec le padding(remplissage aléatoire)
       donnees_chiffrees_avec_padding = decrypteur.update(texte_chiffre) + decrypteur.finalize()