chiffrement RSA ; send/receive ; message 'Finished'

Interface.py

@@ -24,6 +24,7 @@ class Interface(tk.Tk):
 
     def send(self):
         """Envoie le message chiffré."""
+        print("self.entree.get() dans Interface.py : ", self.entree.get())
         message = self.entree.get().encode("utf8")
         # à compléter pour chiffrer le message
         if self._cleSymetrique != None:
@@ -37,7 +38,7 @@ class Interface(tk.Tk):
         # à compléter pour déchiffrer le message
         if self._cleSymetrique != None:
             message = chiffre_xor(message, self._cleSymetrique)
-        self.message.set(message_dechiffre.decode("utf8"))
+        self.message.set(message.decode("utf8"))
     
     def set_cleSymetrique(self, val):
         """Définit/met à jour la clé symétrique"""
@@ -57,3 +58,13 @@ def chiffre_xor(message, cle):
         res += lettre
     return res
 
+def puissance_mod_rapide(a, b, n):
+        """renvoie a**b mod n"""
+        if b == 1:
+            return a
+        elif b == 2:
+            return (a**2)%n
+        elif b % 2 == 0:
+            return puissance_mod_rapide((a**2)%n, b // 2, n)
+        else:
+            return (a * puissance_mod_rapide((a**2)%n, b // 2, n)) % n

InterfaceClient.py

@@ -1,13 +1,53 @@
 # -*- coding: utf-8 -*-
 
 import tkinter as tk
-from Interface import Interface
+from random import SystemRandom
+from Interface import Interface, puissance_mod_rapide
 
 
 class InterfaceClient(Interface):
     def __init__(self):
         Interface.__init__(self, "client")
         # à compléter
+        self.sendHelloButton = tk.Button(self, text="Hello", command=self.hello)
+        self.sendHelloButton.pack()
+        self.keyExchangeButton = tk.Button(self, text="KeyExchange", command=self.keyExchange)
+        self.keyExchangeButton.pack()
+        
+    def hello(self):
+        """envoie en clair le message HELLO"""
+        self.entree.set("HELLO")
+        self.send()
+        
+    def keyExchange(self):
+        """attend la clé publique du serveur
+        choisit une clé symétrique aléatoire de 7 caractères
+        la transmet en la chiffrant avec la clé publique du serveur
+        attend le message Finished du serveur chiffré avec cette clé"""
+        self.receive()
+        clePubliqueServeur = int(self.message.get())
+        #
+        cleSymetriqueClair = symKeyGen()
+        #
+        cleSymetriqueClair_bytes = int.from_bytes(cleSymetriqueClair, "big")
+        cleSymetrique_chifree = self.chiffre_RSA(cleSymetriqueClair_bytes, clePubliqueServeur)
+        self.entree.set(str(cleSymetrique_chifree))
+        self.send()
+        #
+        self.set_cleSymetrique(cleSymetriqueClair)
+        self.receive()
+        if self.message.get() == "Finished":
+            print("Connection sécurisée établie ☺")
+        
+    def chiffre_RSA(self, msg, cle):
+        """chiffre un message avec une clé publique"""
+        #suppose qu'on sait que n = 870567544966633301
+        return puissance_mod_rapide(msg, cle, 870567544966633301)
+        
+        
+def symKeyGen():
+    """renvoie une clé symétrique aléatoire de 7 caractères"""
+    return bytes([SystemRandom().randint(0, 255) for _ in range(7)])
 
 
 It = InterfaceClient()

InterfaceServeur.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 import tkinter as tk
-from Interface import Interface
+from Interface import Interface, puissance_mod_rapide
 
 
 class InterfaceServeur(Interface):
@@ -11,40 +11,34 @@ class InterfaceServeur(Interface):
         self.e = 42205
         self.d = 769020235650503533
         # à compléter
-        self.btn_hello = tk.Button("Serveur Hello", command=self.hello)
+        self.waitForHelloButton = tk.Button(self, text="Serveur Hello", command=self.hello)
-        self.btn_finished = tk.Button("Finished", command=self.finish)
+        self.waitForHelloButton.pack()
+        self.finishedButton = tk.Button(self, text="Finished", command=self.finish)
+        self.finishedButton.pack()
         
     def hello(self):
         """attend la réception du message HELLO depuis le client, puis envoie en
         clair sa clé publique"""
-        msg_recu = self.receive()
+        self.receive()
-        if msg_recu == "HELLO":
+        if self.message.get() == "HELLO":
-            self.entree.set(self.n)
+            self.entree.set(self.e)
             self.send()
+        else:
+            print("HELLO n'a pas été reçu.")
             
     def finish(self):
         """attend la réception de la clé symétrique, la déchiffre avec sa clé privée, la
         mémorise et envoie le message Finished chiffré avec cette clé"""
-        msg_recu = self.receive()
+        self.receive()
-        self.set_cleSymetrique(self.dechiffre_RSA(msg))
+        cleSym = int(self.message.get())
-        self.send("Finished")
+        cleSym_dechiffree = self.dechiffre_RSA(cleSym).to_bytes(7, "big")
+        self.set_cleSymetrique(cleSym_dechiffree) 
+        self.entree.set("Finished")
+        self.send()
         
     def dechiffre_RSA(self, msg):
         """déchiffre un message avec sa clé privée"""
-        return self.puissance_mod_rapide(msg , self.d, self.n)
+        return puissance_mod_rapide(msg, self.d, self.n)
-        
-    def puissance_mod_rapide(self, a, b, n):
-        """renvoie a**b mod n"""
-        if b == 1:
-            return a
-        elif b == 2:
-            a2 = (a**2)%n
-        elif b % 2 == 0:
-            return self.puissance_mod_rapide(a2, b // 2, n)
-        else:
-            return (a * self.puissance_mod_rapide(a2, b // 2, n)) % n
-            
-