Légères modifications des commentaires

code/functions.py

@@ -12,8 +12,10 @@
 """ L'objectif de ce Travail Pratique est de déchiffrer un message codé via l'algorythme RSA """
 # ---------------------------------------------------------------------------
 # Imports
+from email.policy import strict
 import math
 import time
+import struct
 # ---------------------------------------------------------------------------
 
 # Fonction qui calcule le PGCD d'un entier a et d'un entier b selon la méthode d'Euclide
@@ -48,11 +50,13 @@ def PGCD(a, b):
 # Résultat sous la forme 𝑃𝐺𝐶𝐷 𝑎, 𝑏 = 𝑥 × 𝑎 + 𝑦 × 𝑏
 def Euclide_Etendu(a, b):
     if (a != b):
-        # Si a est plus petit que b, échange leurs valeurs (a = b, b = a)
-        if (a < b):
-            tmp = a
-            a = b
-            b = tmp
+        
+        # # Si a est plus petit que b, échange leurs valeurs (a = b, b = a)
+        # if (a < b):
+        #     tmp = a
+        #     a = b
+        #     b = tmp
+        # Cette partie a été retirée car si a < b, nous effecturons simplement une itération de plus pour placer b en numérateur, et a en dénominateur
 
         # Initialisation du des résultats (r), x, y, reste (q) sous forme de tableaux d'entiers
         # Initialisation d'une variable d'indice i
@@ -87,7 +91,6 @@ def Euclide_Etendu(a, b):
             pgcd = r[i-1]
             X = x[i-1]
             Y = y[i-1]
-            print("%d x %d + %d x %d = %d" % (a, X, b, Y, pgcd))
 
             if (X * a + Y * b != pgcd):
                 print("Une erreur s'est produite")
@@ -111,7 +114,10 @@ def Exponentiation_Rapide(a, X, n):
 
     while (e > 0):
         y = e % 2
-        r = (r * (b ** y)) % n
+        
+        if (y == 1):
+            r = (r * b) % n
+            
         b = (b * b) % n
 
         # Si e est impair, on lui soustrait 1 afin d'effectuer une division entière
@@ -142,7 +148,11 @@ def Calculer_Phi(p, q):
 # Fonction servant à decoder un caractère à l'aide de l'exponentiation rapide
 def Decode_Char(charADecoder, d, n):
     charDecode = Exponentiation_Rapide(charADecoder, d, n)
-    print("Char à decoder : %d\n D : %d\n n : %d\n\n\n result : %d" %
-          (charADecoder, d, n, charDecode))
-    print("result = (CharADecoder ^ d) mod n")
+    # print("Char à decoder : %d\n D : %d\n n : %d\n\n\n result : %d" % --> Débogage
+    #       (charADecoder, d, n, charDecode)) --> Débogage
+    # print("result = (CharADecoder ^ d) mod n") --> Débogage
     return charDecode
+
+def DecodeMessage(M):
+    temp = struct.pack("<i",M).rstrip(b'\x00')
+    return temp.decode('utf-8')

code/main.py

@@ -16,34 +16,39 @@ from functions import *
 # ---------------------------------------------------------------------------
 
 # Initialisation et calcul des variables nécessaires au décodage du message
+print("------ Valeurs des variables nécessaires au déchiffrement du message ------")
+
 
 # Constante n à utiliser pour le déchiffrement
 N = 1882929457
+print("N = %d" % N)
 
 # Constante e à utiliser pour le déchiffrement
 E = 9719
+print("E = %d" % E)
 
 # Génération de p, en enregistrant le nombre d'itérations qui ont été nécessaires
 nbIterations, P = Calculer_P(N)
-print("P = %d" % P)
+# Affichage de la variable P, ainsi que le nombre d'itérations
+print("P = %d (Calculée en %d itérations)" % (P, nbIterations))
 
 # Calcul de la valeur Q
 Q = N / P
+# Affichage de la variable Q
 print("Q = %d" % Q)
 
 # Calcul de Phi
 Phi = Calculer_Phi(P, Q)
+# Affichage de la variable Phi
 print("Phi = %d" % Phi)
 
 # Calcule des coéfficients de Bézout entre E et Phi, et de leurs pgcd (même si nous l'utilisons pas dans ce cas précis)
 pgcd, D, B = Euclide_Etendu(E, Phi)
-
-print("D x E + B x Phi = %d x %d + %d x %d = %d" % (D, E, B, Phi, pgcd))
-print("D = %d" % D)
 D = D % Phi
-print("D mod Phi = %d" % D)
+# Affichage de la variable D
+print("D = %d" % D)
 
-# Message chiffré
+# Message chiffré, séparé block par block sous la forme d'entiers
 message = [
     1794310518,
     519597008,
@@ -87,26 +92,28 @@ message = [
     656966934
 ]
 
+# On affiche le message chiffré d'origine
+print("\nLes blocks du message chiffré sont :\n---------------------------\n")
+for i in message:
+    print(i)
+print("\n---------------------------\n")
 
+# Initialisation de la variable qui contiendra le résultat (message complètement déchiffré)
 result = ""
 
+# Boucle parcourant tous les blocs contenu dans le message chiffré
 for i in message:
-    print(i)
-    decodedChar = Decode_Char(i, D, N)
-    print(decodedChar)
-    print(chr(int(decodedChar)))
-    print("---------------------------")
-    # b = bin(decodedChar)
-    # b = str(b)
-    # b = b[2:]
     
-    # if len(b) % 8 != 0:
-    #     add_0 = 8 - (len(b) % 8)
-    #     b = ("0" * add_0) + b
-    # binary = bytearray()
-    # for i in range(0, len(b), 8):
-    #     binary.append(int(b[i:i + 8], 2))
-    # binary = binary[::-1]
-    # result += binary.decode("utf-8")
+    #print(i) --> Débogage
+    # Décode la valeurs numérique du block grâce à l'exponentiation rapide ainsi que les valeurs calculées précédemment
+    decodedBlock = int(Decode_Char(i, D, N))
+    #print(decodedChar) --> Débogage
+    # Transforme le block déchiffré en une chaine de caractère UTF-8
+    decodedString = DecodeMessage(int(decodedBlock))
+    #print(decodedString) --> Débogage
+    result += decodedString
+    #print("---------------------------") --> Débogage
+
 
-print(result)
+# On affiche le message déchiffré
\ No newline at end of file
+print("\nLe message déchiffré est :\n---------------------------\n %s \n ---------------------------" % result)
\ No newline at end of file