Recherche de site Web

Déchiffrer le chiffre de César en utilisant une attaque par force brute avec Python

Table des matières :

  1. Vulnérabilités du chiffre de César
  2. Écriture du programme Python de force brute pour le chiffre de César
  3. Flux de travail du programme
  4. Casser le code du chiffre de César en Python
  5. Preuve de concept
  6. Conclusion
  7. Questions Fréquemment Posées (FAQ)

Vulnérabilités du chiffre de César

Le chiffre de César était efficace à l'époque de Jules César, mais il présente des faiblesses significatives selon les normes modernes. L'un des problèmes les plus flagrants est son manque de sécurité en raison de sa simplicité. Il n'y a que 25 clés possibles (puisqu'une clé de 0 ou 26 donnerait le même texte en clair), ce qui le rend vulnérable aux attaques par force brute. Avec la puissance de calcul moderne, essayer toutes les clés possibles est une tâche triviale.

De plus, le chiffre de César ne tient pas compte des fréquences des lettres. En anglais, certaines lettres apparaissent plus fréquemment que d'autres, comme « E » et « T ». Un cryptanalyste compétent peut utiliser cette connaissance pour réduire le nombre de clés possibles, ce qui rend encore plus facile le déchiffrement de ce chiffre.

Écriture du programme Python de force brute pour le chiffre de César

Flux de programme :

  1. Tout d'abord, vous devez avoir un fichier texte contenant le message secret (chiffré) que vous souhaitez décoder.
  2. Ensuite, vous exécutez le programme depuis la ligne de commande, en lui indiquant quel fichier utiliser comme entrée. Par exemple, vous pourriez dire « brute_caesar.py secret_message.txt ».
  3. Le programme itérera le processus de décryption en utilisant la clé de décalage de 1 à 25 car les clés 0 et 26 renvoient au même résultat.
  4. Une fois qu'il a fini de déchiffrer avec toutes les clés possibles, enregistrez le résultat pour une enquête ultérieure. Par défaut, nous définissons le nom du fichier pour le texte de sortie comme « cracked_message.txt ».
  5. Enfin, ouvrez le "cracked_message.txt" et examinez quelle valeur clé a donné un sens au texte.

Déchiffrer le code Python du chiffre de César

1. Importer la bibliothèque requise

import argparse

Le code commence par importer la bibliothèque "argparse" qui sera utilisée pour gérer les arguments de la ligne de commande.

2. Définir la fonction de déchiffrement du chiffre de César

def caesar_decrypt(ciphertext, key):
    decrypted_text = ""
    for char in ciphertext:
        if char.isalpha():
            is_upper = char.isupper()
            char = char.lower()
            decrypted_char = chr(((ord(char) - ord('a') - key) % 26) + ord('a'))
            if is_upper:
                decrypted_char = decrypted_char.upper()
            decrypted_text += decrypted_char
        else:
            decryp

La fonction "caesar_decrypt" prend deux arguments : "ciphertext" (le texte chiffré) et "key" (la clé du chiffre de César à utiliser pour le déchiffrement). Nous initialisons une chaîne vide appelée "decrypted_text" pour stocker le résultat plus tard. Ensuite, nous commençons à itérer sur chaque caractère du ciphertext. Elle effectue les étapes de déchiffrement suivantes pour chaque caractère alphabétique du ciphertext :

  • Vérifiez si le caractère est en majuscule ou en minuscule et convertissez le caractère en minuscule pour faciliter la manipulation.
  • Ensuite, déchiffrez le caractère en utilisant la formule du chiffre de César : (char - clé) % 26.
  • Après cela, reconvertissez le caractère déchiffré en majuscule s'il était à l'origine en majuscule.
  • Enfin, ajoutez le caractère décrypté à la variable "decrypted_text" puisque les caractères non-alphabétiques (par exemple, la ponctuation ou les espaces) sont ajoutés à la "decrypted_text" sans aucune modification.

Enfin, la fonction renvoie le « texte_décrypté ».

3. Définir la fonction de déchiffrement par force brute

def brute_force_caesar(input_file, output_file):
    with open(input_file, 'r') as file:
        ciphertext = file.read()

    with open(output_file, 'w') as out_file:
        for key in range(26):
            decrypted_text = caesar_decrypt(ciphertext, key)
            out_file.write(f"Key {key}:\n")
            out_file.write("#" * 80 + "\n")
            out_file.write(f"{decrypted_text}\n")
            out_file.write("#" * 80 + "\n")

La fonction « brute_force_caesar » prend un argument requis : « input_file » (le chemin vers le fichier d'entrée contenant le texte chiffré). Elle ouvre et lit le contenu du fichier d'entrée et le stocke dans la variable ciphertext.

Le code entre ensuite dans une boucle qui itère à travers toutes les clés possibles du chiffre de César, de 0 à 25. Pour chaque clé, il appelle la fonction "caesar_decrypt" avec le texte chiffré et la valeur de clé actuelle.
Une fois qu'il a fini d'écrire chaque résultat de déchiffrement, il imprimera où le résultat de sortie est sauvegardé.

4. La fonction principale

def main():
    parser = argparse.ArgumentParser(description="Brute force Caesar cipher decryption")
    parser.add_argument("input_file", help="Path to the input file containing the encrypted text")
    parser.add_argument("output_file", nargs='?', default="cracked_message.txt", help="Path to the output file to save the decryption results (default: cracked_message.txt)")
    args = parser.parse_args()

    brute_force_caesar(args.input_file, args.output_file)

La fonction principale est l'endroit où l'exécution du script commence. Elle configure un parseur d'arguments en utilisant « argparse ».

Ici, nous définissons un argument de ligne de commande requis nommé "input_file" qui est le chemin vers le fichier d'entrée contenant le texte crypté. Il analyse les arguments de ligne de commande fournis lors de l'exécution du script. Par exemple, "brute_caesar.py secret_message.txt".

5. Exécution du script

if __name__ == "__main__":
    main()

Ce bloc conditionnel garantit que le code à l'intérieur ne s'exécute que lorsque le script est exécuté directement, et non lorsqu'il est importé en tant que module. Il appelle la fonction principale pour démarrer l'exécution du script.

Fait. Ici, nous enregistrons le programme sous “brute_caesar.py ”. Exécutez le programme avec l'argument d'aide pour afficher les options requises :

python brute_caesar.py -h

Image alternative & légende : Programme Python de Brute Force pour le Chiffre de César

Preuve de concept

Maintenant, nous avons le message secret entrant comme l'image suivante :

Image alternative & légende : Message chiffré

Nous savons avec certitude qu'il s'agissait du chiffre de César, mais malheureusement, nous ne connaissons pas la clé. La seule façon de déchiffrer ce message est par une attaque par force brute. En utilisant le programme Python que nous avons créé précédemment, nous déchiffrons ensuite le message. Le résultat est montré comme suit :

Image alternative & légende : Preuve de concept – Programme Python de bruteforce du chiffre de César

D'après le POC précédent, nous savons maintenant que ce chiffre utilise une clé de décalage de 24.

Essayez-le vous-même

Téléchargez le code source de ce programme sur notre page GitHub à l'adresse https://github.com/bimando/Caesar-Cipher-Toolkit.

Conclusion

En résumé, bien que le chiffre de César ait été efficace à l'époque de Jules César, sa simplicité présente de grandes vulnérabilités dans les temps modernes. Avec seulement 25 clés possibles et aucune considération des fréquences des lettres, il est susceptible aux attaques par force brute. Notre programme Python illustre cela en décodant systématiquement un message secret, mettant en évidence les faiblesses du chiffre. Découvrez les points clés et le code téléchargeable sur notre page GitHub pour une compréhension plus approfondie de cette méthode de cryptage classique.

Questions Fréquemment Posées (FAQ)

Q1 : Qu'est-ce qu'une attaque par force brute dans le contexte du déchiffrement du chiffre de César ?
A1 : Une attaque par force brute consiste à essayer systématiquement toutes les valeurs de clé possibles (1 – 25) pour déchiffrer le chiffre de César jusqu'à ce que la clé correcte soit trouvée.

Q2 : Comment l'analyse de la fréquence des lettres aide-t-elle à déchiffrer le chiffre de César ?
A2 : L'analyse de la fréquence des lettres exploite la distribution non uniforme des lettres dans la langue anglaise pour réduire les clés possibles lors du déchiffrement.

Q3 : Existe-t-il des contre-mesures efficaces contre les attaques par force brute sur le chiffre de César ?
A3 : L'utilisation de techniques de cryptage plus sophistiquées, telles que celles avec des espaces de clés plus grands et des algorithmes complexes, peut atténuer efficacement les vulnérabilités associées aux attaques par force brute sur le chiffre de César.