Зашифрованные сообщения с RSA и PYTHON

Question

Я новичок в разработке в php и я студент, моя цель - разработать зашифрованный чат с сервером на одной стороне, который шифрует параметры отправки сообщений через сокет, и на стороне клиента, которая дешифрует сообщение значениями.

Я уже выполнил алгоритм шифрования RSA. html, но не могу получить значение сокета на стороне клиента RSAde c. html.

На клиенте со стороны мы отправляем поля n и d и зашифрованное сообщение для серверной стороны.

И я знаю, как записать их значения на их расшифрованной стороне на стороне клиента, но я не сделал этого в своем коде.

Я сделал клиент только с PHP clientvxx. php В противном случае, в виде чата, это 2-й шаг. Я также нашел способ общаться в JavaScript, он работает, но вы должны получить сообщение, кодирующее и декодирующее его, я не могу этого сделать.

Я использовал: socket_send () для отправки пакета socket_recv I невозможно получить

Примечание: у вас есть право менять языки программирования, например, на JAVA или даже на JAVASCRIPT / PHP;)

Вот мои коды: RSA Код детали передатчика:

"" "

import math
from random import choice
#calcul le pgcd entre les nombres premiers
def private_gcd(a, b):
    while b != 0:
        c = a % b
        a = b
        b = c
    return a

#fonction Inverse modulaire : module inversé entre phi et l'argument m
def private_inversemodulaire(phi, m):
    for x in range(1, m):
        if (phi * x) % m == 1:
            return x
    return None

#de Javascript à Python
codageGroupSize = 0
codageTableChar = ""

# def private_tableComplete(): 
    # #définit la table de conversion
codageTableChar = "0123456789 abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ&~#|*+-\\/=%!:?,.<>'àâçéèêëïîöôüûù" + '"'
TableConv = codageTableChar
tdesblocs=3
    #fonction standard qui 
# def private_standard(entree):
#     alphabet= '0123456789'
#     longueur = len(entree)

#     entree_standard=''
#     for i in range(0, longueur) :
#         if (alphabet.indexOf(entree.[i!=-1])   :#charAt
#             entree_standard += entree.[i] #charAt  
#     return entree_standard
#focntion permettant le calcul de d grâce à n et e, n étant généré par le couple (q,p) original
# calcul les différentes clefs nécessaires
# def calculClef()  :
#     p = 1511
#     q = 907
#     n = p * q
#     N = float( n)
#     euler = n - p - q + 1 

#     e = (e== "") 
#     tmpNe = 1
#     d = 1
#     while(((d * e) % euler) != 1):
#         tmpNe += 1
#         d = math.ceil( tmpNe * euler / e)

#     # d = float(d) #sinon  ne déchiffre pas 
#     #
#     codageGroupSize = tdesblocs
#     if (len(codageTableChar)*math.pow(100, codageGroupSize - 1) > n) :
#         print("P ou Q risquent d'être trop petits pour un chiffrement valable !")

#utile pour récupérer les caractères
def private_valeurChar(lettre)  : 
    return (codageTableChar.indexOf(lettre, 0))

# Calcul le modulo "Modulo" de "base" a la puissance "exposant" INDISPENSABLE
def private_moduloExpo(base, exposant, Modulo)  :
    moduloBase2 = []

    # Niveau de puissance de 2 à considérer
    #max et non math.max
    moduloLevel = max(math.floor((math.log(exposant) / 0.6931471805599)), 1) #

    # Préparation du tableau de transcodage
  #  moduloBase2[ 0] = base % Modulo  #IndexError: list assignment index out of range
    level = 1 
    for  level in range(1,moduloLevel) :

        # moduloBase2[ level] = ( moduloBase2[ level - 1] * moduloBase2[ level - 1]) % Modulo  #IndexError: list assignment index out of range


    # Utilisation pour décomposition en utilisant le tableau
        expoDec = exposant
        valeur = 1
        level = moduloLevel
        while (expoDec > 0)     :
            if (expoDec >= math.pow(2,level)) :
                # valeur = (valeur * moduloBase2[ level]) % Modulo #IndexError: list assignment index out of range
                level=level-1 #level-=1
                expoDec -= math.pow(2, level)

            else:
                level=level-1
        return valeur

#fonction pour chiffrer le bloc
def private_encodage(message, e, N)  :
    messageNum=""
    # preSize = math.ceil(math.log(N) / math.log10(1)) # error division by zero
    print('type de message est : ', type(message))
    tailleGroupe = int(tdesblocs)
    codageTableChar = TableConv
    GroupeValue=0 #initiialiser sinon GroupeValue not declarec
    k=0
    for k in range(0,len(str(message))) :
        # charAt message.charAt(k) transformer en str  'int' object is not subscriptable
        # chiffre=private_valeurChar(message[k]) # PR commenter car error int is not subscriptable
        chiffre='101010'
        if(int(chiffre)<10) :
            chiffre="0"+chiffre
            messageNum+=chiffre
            while(len(messageNum)%tailleGroupe>0):
                messageNum="0"+messageNum
                messageCode=""
                k=0
        for k in range(0,len(messageNum)) :
            k=k+tailleGroupe
            GroupeValue=int(messageNum.substring(k,k+tailleGroupe),10)
        # chiffre le groupe
        groupePreCode = private_moduloExpo(GroupeValue, e, N)
        xx=str(groupePreCode)
        while(len(xx)<preSize) :
            groupePreCode="0"+groupePreCode
            xx=str(groupePreCode)
            messageCode += groupePreCode
            messageCode += " "
        return messageCode

#fonction pour déchiffer le bloc
def private_decodage(messageCode, d, N)  :
    continu=standard(messageCode)
    tailleGroupe = tdesblocs
    codageTableChar = TableConv
    #PR error division by zero !!
    # preSize = math.ceil(math.log(N) / math.log10(1))
    nombre = ""
    n=0
    while(len(continu) > 0)   :
        groupeCode = int(continu.substring(0, preSize), 10)
        continu = continu.substring(preSize, len(continu))
        # déchiffre le groupe
        groupelettre = private_moduloExpo(groupeCode, d, N)
    if (n>0) :
        xx=str(groupelettre)
        while(len(xx)<tailleGroupe):
            groupelettre="0"+groupelettre
            xx=str(groupelettre)
            n=n+1
            nombre += groupelettre

    message=""
    k=0
    for k in range(0,k<len(nombre), 2) :

        lettre=int(nombre.substring(k,k+2),10)
        message += codageTableChar+[lettre]

    return message

#adaptation python javascript
#fonction pour générer les clés utilisées
def GENERATEUR_DE_CLE():
    e=377    
    p=1511
    q=907
    n=p*q
    phi = (p-1) * (q-1)#ajout de phi
    print ('p=',p)
    print('q=',q)
    print ('phi=',phi)
    euler = n - p - q + 1 
    tmpNe = 1
    d = 1
    while(((d * e) % euler) != 1):
        tmpNe += 1
        d = math.ceil( tmpNe * euler / e)

    # d = float(d) #sert à rien

    public_key = [e, n]
    private_key = [d, n]
    return [public_key, private_key]

#retour du python

def private_chiffre_block(m, e, n):
    c = (m**e) % n
    return c

def private_dechiffre_block(c, d, n):
    m = (c**d) % n
    return m

# méthode pour chiffrer le message
def chiffre_string(s, public_key):
    e, n = public_key
    return ''.join([chr(private_chiffre_block(ord(x), e, n)) for x in list(s)])

# méthode pour déchiffrer le message
def dechiffre_string(s, private_key):
    d, n = private_key
    return ''.join([chr(private_dechiffre_block(ord(x), d, n)) for x in list(s)])

" "" Мой передатчик и декодер RSA, которые я хочу использовать javascript в моем python или перенастроить его, чтобы использовать al go для шифрования и дешифрования моих сообщений: "" "

<!DOCTYPE html>
<html>
 <body>         
<div  id="rsa_titre">
Chiffrement par RSA
</div>
Ici le couple <b>n,e</b> est la clé publique et <b>d</b> la clé privée .<br><br>


<b>Pour chiffrer:</b> Il suffit d'entrer <b>e</b>, <b>n</b> et la taille des blocs (c'est la 
clef publique donnée par 
la personne qui déchiffrera) ainsi que le message dans le champ "Message clair". Appuyez ensuite
 sur "Chiffrer".<br><br>
 <b>Pour déchiffrer:</b> Entrez, en plus de <b>e</b>, <b>n</b> 
  et la taille des blocs, la valeur de <b>d</b> (ou simplement entrez les trois 
  nombres originaux de p, q et e puis appuyez sur le bouton calcul).  <br><br>

<b>Utilisation:</b> La personne voulant déchiffrer le message 
  doit posséder la clef privée, alors que les autres ne connaissent que les 
  clefs publiques.<br> Ici, les clefs privées sont <b>p</b>, <b>q</b>, <b>d</b>, 
  les clefs publiques sont <b>e</b> et <b>n</b>.
  indique comment regrouper les chiffres avant le chiffrement proprement dit.  <br><br>


<b>Création des clefs de (dé)chiffrement:</b> Entrez des nombres premiers dans les champs 
p et q, puis e satisfaisant les conditions suivantes :<br> Il faut 
que les 3 nombres soient différents et premiers.<br>
Que p et q soient sufisament grands .<br>
Et e premier avec (p-1).(q-1).<br>  Appuyez ensuite sur le bouton "Calcul" pour trouver <b>n</b> 
et <b>d</b>. Plus les nombres sont grands, plus de décryptement sera difficile, mais le temps de 
déchiffrement augmentera aussi.<br><br>

<table border="0">
<tbody><tr>
<td>
<form method="POST" name="FormClef">
<table cellspacing="2" border="0">
<tbody><tr>
<td align="CENTER">p : <input type="TEXT" size="6" name="P" value="1511"></td>
<td align="CENTER">q : <input type="TEXT" size="6" name="Q" value="907"></td>
<td align="CENTER">e : <input type="TEXT" size="6" name="E" value="377"></td>
<td align="CENTER">Taille des blocs : <input type="TEXT" size="2" name="Groupage" value="3"></td>
</tr>
<tr>
<td align="CENTER"><input type="BUTTON" value="Calculs" onclick="CalculClef()"></td>
<td colspan="2" align="CENTER">n = p·q : <input type="TEXT" size="12" name="N"></td>
<td align="CENTER">d : <input type="TEXT" size="12" name="D"></td>
</tr>
<tr>
<td></td>
<td colspan="4" align="CENTER">
 <input type="BUTTON" name="Table1" value="Table de conversion simple" onclick="TableConv.value=' ABCDEFGHIJKLMNOPQRSTUVWXYZ'">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 <input type="BUTTON" name="Table2" value="Table de conversion étendue" onclick="tableComplete()">
</td>
</tr>
<tr>
<td>Table de conversion</td>
<td colspan="4">
<input type="TEXT" size="70" name="TableConv"><br>
</td>
</tr>
</tbody></table>
</form>
<form method="POST" name="FormCodage">
<table>
<tbody><tr>
<td >Message clair<br>
<br>
<td colspan="4" >
<textarea name="Texte" rows="6" cols="70" wrap="HARD">texte clair</textarea>
</td>
</tr>
<tr>
<td></td>
              <td colspan="4" align="CENTER"> 
                <table width="80%" cellspacing="1" cellpadding="1" border="0">
                  <tbody><tr>
                    <td>
                      <input type="BUTTON" name="Code" value="Chiffrer" onclick="Encode()">
                    </td>
                    <td>
                      <input type="BUTTON" name="Decode" value="Déchiffrer" onclick="Decoder()">
                    </td>
                    <td>
                      <input type="BUTTON" value="Effacer" onclick="FormCodage.Texte.value=''; FormCodage.Crypte.value=''" name="BUTTON">
                    </td>
                  </tr>
                </tbody></table>
              </td>
</tr>
<tr>
<td>Message chiffré<br>
<br>
<td colspan="4">
<textarea name="Crypte" rows="6" cols="70" wrap="SOFT"></textarea>
</td>
</tr>
</tbody></table>
</form>
</td></tr></tbody></table>


<script>

var CodageGroupSize = 0;




    CodageTableChar = "0123456789 abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ&~#|*+-\\/=%!:;?,.<>'àâçéèêëïîöôüûù" + '"';
    FormClef.TableConv.value = CodageTableChar;


function standard(entree)
{
  alphabet= '0123456789';
  longueur = entree.length;

  entree_standard='';
  for (i=0; i<longueur; i++)
  {
    if (alphabet.indexOf(entree.charAt(i))!=-1)
    {
      entree_standard += entree.charAt(i)
    }
  }
  // document.write('lentreestandardest' + entree_standard);
  // console.log('lentreestandardest' + entree_standard);
  return entree_standard;
}

function CalculClef()
  {
  p = (FormClef.P.value == "") ? 0 : FormClef.P.value;
  q = (FormClef.Q.value == "") ? 0 : FormClef.Q.value;
  n = p * q;
  FormClef.N.value = parseFloat( n);
  Euler = n - p - q + 1;

  // Recherche au coup par coup
  e = (FormClef.E.value == "") ? 0 : FormClef.E.value;
  TmpNe = 1;
  d = 1;
  while
   (((d * e) % Euler) != 1)
    {
    TmpNe += 1;
    d = Math.ceil( TmpNe * Euler / e);
    };
  FormClef.D.value = parseFloat(d);

  CodageGroupSize = FormClef.Groupage.value;
  if (CodageTableChar.length*Math.pow(100, CodageGroupSize - 1) > n)
    {
    alert("P ou Q risquent d'être trop petits !");
    };
  }


function ValeurChar(Lettre){
  return (CodageTableChar.indexOf(Lettre, 0));
  };

  function ModuloDexpo(Base, Exposant, Modulo)  {
  var ModuloBase2 = new Array();

  ModuloLevel = Math.max(Math.floor((Math.log(Exposant) / 0.6931471805599)), 1);

  ModuloBase2[ 0] = Base % Modulo;
  console.log('ModuloBase2:',ModuloBase2[0])
  for
   ( Level = 1; Level <= ModuloLevel; Level++)
     {
     ModuloBase2[ Level] = ( ModuloBase2[ Level - 1] * ModuloBase2[ Level - 1]) % Modulo;
     };

  ExpoDec = Exposant;
  Valeur = 1;
  Level = ModuloLevel;
  while
   (ExpoDec > 0)
     {
     if
      (ExpoDec >= Math.pow(2, Level))
       {
       Valeur = (Valeur * ModuloBase2[ Level]) % Modulo;
       ExpoDec -= Math.pow(2, Level--);
       }
      else
       {
       Level--
       };
     }
  return Valeur
  };


function Encodage(Message, E, N)
  {
  messageNum="";
  PreSize = Math.ceil(Math.log(N) / Math.LN10);
  TailleGroupe = parseInt(FormClef.Groupage.value)
  CodageTableChar = FormClef.TableConv.value;
  for(k=0; k<Message.length; k++) {
    chiffre=ValeurChar(Message.charAt(k))
  // document.write('chiffre='+chiffre);
    if(parseInt(chiffre)<10) {chiffre="0"+chiffre};
    messageNum+=chiffre
    }
    while(messageNum.length%TailleGroupe>0){messageNum="0"+messageNum}
    MessageCode="";
    // console.log('1erGroupeValue', GroupeValue);//groupevalue not defined
    for(k=0; k<messageNum.length; k=k+TailleGroupe) {
        GroupeValue=parseInt(messageNum.substring(k,k+TailleGroupe),10)
    // document.write('2emeGroupeValue', GroupeValue);
        // chiffre le groupe
        GroupePreCode = ModuloDexpo(GroupeValue, E, N);
    xx=GroupePreCode.toString()
    while(xx.length<PreSize) {GroupePreCode="0"+GroupePreCode;xx=GroupePreCode.toString()}
        MessageCode += GroupePreCode
        MessageCode += " "
      };
  return MessageCode;
  };


function Decodage(MessageCode, D, E, N)
  {
  continu=standard(MessageCode)
  TailleGroupe = FormClef.Groupage.value;
  CodageTableChar = FormClef.TableConv.value;
  PreSize = Math.ceil(Math.log(N) / Math.LN10);
  nombre = "";
  n=0;
  while(continu.length > 0)
    {
    GroupeCode = parseInt(continu.substring(0, PreSize), 10);
    continu = continu.substring(PreSize, continu.length); //peutetre commenté
    // déchiffre le groupe
    GroupeLettre = ModuloDexpo(GroupeCode, D, N);
    if (n>0) {
       xx=GroupeLettre.toString()
       while(xx.length<TailleGroupe){
        GroupeLettre="0"+GroupeLettre;
        xx=GroupeLettre.toString()
        }
     }
    n++
    nombre += GroupeLettre;
    }
  Message="";
  for(k=0; k<nombre.length; k=k+2) {
    lettre=parseInt(nombre.substring(k,k+2),10)
    Message += CodageTableChar.charAt(lettre)
    };
  return Message;
  };


function Encode(){
  FormCodage.Crypte.value = Encodage( FormCodage.Texte.value, FormClef.E.value, FormClef.N.value);
  }; 


function Decoder(){
  FormCodage.Texte.value = Decodage( FormCodage.Crypte.value, FormClef.D.value, FormClef.E.value, FormClef.N.value);
  }; 

</script>    
</html>

" "" Мой клиент 1: "" "

from socket import *
from threading import Thread
import sys,tkinter, time
import RSA

def recevoir():
    #Reçoit les messages.
    message_list.insert(tkinter.END, "Bonjour! %s" % NOM)
    message_list.insert(tkinter.END, " Vous êtes en ligne!")
    while True:
        try:
            message = CLIENT.recv(BUFFER_SIZE).decode("utf8")
            print('message non décodé',message)
            message = RSA.dechiffre_string(message, private_key_1)
            print('message décodé: ', message)
            print ('voici la clé privé du client 1', private_key_1)
            message_list.insert(tkinter.END, message)
        except OSError:  # Si l'utilisateur se déconnecte
            print('OSERROR')
            break

def send(event = None):  # évènement passé par le binders.
    #Pour send des messages.
    message = my_message.get()    
    my_message.set("")  # Vide le champ de saisie
    message = NOM + ": " + message
    message_list.insert(tkinter.END, message)
    message = RSA.chiffre_string(message, public_key_2)
    CLIENT.send(bytes(message, "utf8"))


def fermeture(event = None):
   #Quand on clique fermer la fenêtre
    message_list.insert(tkinter.END, "déconnexion...")
    time.sleep(2)
    CLIENT.close()
    top.quit()
    sys.exit()


#****INTERFACE GRAPHIQUE tkinter****
top = tkinter.Tk()
top.title("Projet tutoré S4 client1")

messages_frame = tkinter.Frame(top)
my_message = tkinter.StringVar()  # Pour les messages à être send.
my_message.set("Saissisez votre message...")
scrollbar = tkinter.Scrollbar(messages_frame)  # Pour naviguer entre les messages.
# Conteneur du message
message_list = tkinter.Listbox(messages_frame, height=25, width=100, yscrollcommand=scrollbar.set)
scrollbar.pack(side=tkinter.RIGHT, fill=tkinter.Y)
message_list.pack(side=tkinter.LEFT, fill=tkinter.BOTH)
message_list.pack()
messages_frame.pack()

entry_field = tkinter.Entry(top, textvariable=my_message)
entry_field.bind("<Return>", send)
entry_field.pack()
send_button = tkinter.Button(top, text = "Envoyer", command = send)
send_button.pack()

top.protocol("WM_DELETE_WINDOW", fermeture)



#****Partie SOCKET****
#IP = input('IP: ')
#PORT = int(input('port: '))
#NOM = input(NOM: ')

IP = "192.168.56.1"
PORT = 42000
NOM= "ALICE au pays des bisounours"

BUFFER_SIZE = 1024
ADRESSE = (IP, PORT)

CLIENT = socket(AF_INET, SOCK_STREAM)    # client socket object
CLIENT.connect(ADRESSE) # Pour se connecter au socket du serveur socket grâce à l'adresse

public_key_1, private_key_1 = RSA.GENERATEUR_DE_CLE()
print("Cle privée personnelle client1", private_key_1)
message = str(public_key_1[0]) + '*' + str(public_key_1[1])
print("Clé publique personnelle (à send)", public_key_1)

CLIENT.send(bytes(message, "utf8"))
m = CLIENT.recv(BUFFER_SIZE).decode('utf8')
public_key_2 = [int(x) for x in m.split('*')]
print("Cle publique reçue", public_key_2)

recevoir_thread = Thread(target = recevoir)   # Thread créée pour pouvoir recevoir simultanément avec cette méthode
recevoir_thread.start()
tkinter.mainloop()  # Démarre l'interface graphique Tkinter.

" "" Мой клиент 2: " ""

from socket import *
from threading import Thread
import tkinter, sys, time
import RSA

def recevoir():
    #Reçoit les messages.
    message_list.insert(tkinter.END, "Bonjour! %s" % NOM)
    message_list.insert(tkinter.END, " Vous êtes en ligne!")
    while True:
        try:
            message = CLIENT.recv(BUFFER_SIZE).decode("utf8")
            print("decrypte message", message, " avec ma cle privee", private_key_2)
            message = original_RSA.decrypt_string(message, private_key_2)
            print("le message decrypte est", message)
            message_list.insert(tkinter.END, message)
        except OSError:  # Si l'utilisateur se déconnecte
            print('OSERROR')
            break
def send(event = None):  # évènement passé par le binders.
    #Pour send des messages.
    message = my_message.get()    
    my_message.set("")  # Vide le champ de saisie
    message = NOM + ": " + message
    message_list.insert(tkinter.END, message)
    print("chiffre le message", message, " avec la cle publique de l'autre", public_key_1)
    message = original_RSA.chiffre_string(message, public_key_1)
    print("le message cryptee est ", message)
    CLIENT.send(bytes(message, "utf8"))

def fermeture(event = None):
   #Quand on clique fermer la fenêtre
    message_list.insert(tkinter.END, "déconnexion...")
    time.sleep(2)
    CLIENT.close()
    top.quit()
    sys.exit()

#----INTERFACE GRAPHIQUE tkinter GUI----
top = tkinter.Tk()
top.title("Projet tutoré S4 client2")

messages_frame = tkinter.Frame(top)
my_message = tkinter.StringVar()  # Pour les messages à être send.
my_message.set("Saissisez votre message...")
scrollbar = tkinter.Scrollbar(messages_frame)  # Pour naviguer entre les messages.
# Conteneur du message
message_list = tkinter.Listbox(messages_frame, height=25, width=100, yscrollcommand=scrollbar.set)
scrollbar.pack(side=tkinter.RIGHT, fill=tkinter.Y)
message_list.pack(side=tkinter.LEFT, fill=tkinter.BOTH)
message_list.pack()
messages_frame.pack()

entry_field = tkinter.Entry(top, textvariable=my_message)
entry_field.bind("<Return>", send)
entry_field.pack()
send_button = tkinter.Button(top, text = "Envoyer", command = send)
send_button.pack()

top.protocol("WM_DELETE_WINDOW", fermeture)


#****Partie SOCKET****
#IP = input('IP: ')
#PORT = int(input('port: '))
#NOM = input(NOM: ')

HOST = "192.168.56.1"
PORT = 42000
NOM= "Bob"
BUFFER_SIZE = 1024
ADRESSE = (HOST, PORT)

CLIENT = socket(AF_INET, SOCK_STREAM)    # client socket object
CLIENT.connect(ADRESSE) # Pour se connecter au socket du serveur socket grâce à l'adresse

public_key_2, private_key_2 = RSA.GENERATEUR_DE_CLE()
print("Cle privée personnelle client2", private_key_2)

message = str(public_key_2[0]) + '*' + str(public_key_2[1])
print("Cle publique personnelle (à send)", public_key_2)

CLIENT.send(bytes(message, "utf8"))
m = CLIENT.recv(BUFFER_SIZE).decode('utf8')
public_key_1 = [int(x) for x in m.split('*')]
print("cle publique recue", public_key_1)

recevoir_thread = Thread(target = recevoir)   # Thread créée pour pouvoir recevoir simultanément avec cette méthode
recevoir_thread.start()
tkinter.mainloop() 

"" "Мой сервер:" ""

#Pour lancer le serveur qui fait transiter les messsages
from socket import *
from threading import Thread


client_sock = []    # stcoke les sockets client 
client_addresses = {}   # stocke les adresses {key: client socket, values: client address}
public_key = []     # stocke les clés publiques des clients


def communication_entrante_acceptée():
    #ACCAPETE les communications entrantes et les maintient pour les clients
    client, client_address = SERVER.accept()
    client_sock.append(client)
    print("%s:%s has connected." % client_address)
    public_key.append(client.recv(BUFFER_SIZE))
    client_addresses[client] = client_address


def conteneur_client1(client_sock, client_addresses):
    #Contient le premier client (connexion)
    client_sock[0].send(public_key[1])

    while True:
        msg0 = client_sock[0].recv(BUFFER_SIZE)
        client_sock[1].send(msg0)
        print(" Client 1: %s" % msg0.decode('utf8'))


def conteneur_client2(client_sock, client_addresses):
    #Contient le deuxième client (connexion)
    client_sock[1].send(public_key[0])

    while True:
        msg1 = client_sock[1].recv(BUFFER_SIZE)
        client_sock[0].send(msg1)
        print(" Client 2: %s" % msg1.decode('utf8'))



#****Partie SOCKET****
IP = gethostbyname(gethostname())     # récupère l'adresse IP
PORT = 42000
BUFFER_SIZE = 1024   # taille en mémoire tampon du récepteur
ADDRESSE = (IP, PORT)  # servers socket address

SERVER = socket(AF_INET, SOCK_STREAM)   # create socket object
SERVER.bind(ADDRESSE)    # Association de l'IP du socket et le numéro du port.

SERVER.listen(2)
print('IP du serveur: ', IP)
print('Port du serveur: ', PORT)
print("En attente de connexion...")
communication_entrante_acceptée()
communication_entrante_acceptée()

Thread(target = conteneur_client1, args = (client_sock, client_addresses)).start()
Thread(target = conteneur_client2, args = (client_sock, client_addresses)).start()
print('Conversation chiffré: ')
SERVER.close()

"" "

ОРИГИНАЛЬНЫЕ РАБОЧИЕ КОДЫ: original_rsa.py:" "" import original_premier из случайного выбора импорта def private_gcd (a, b): в то время как b! = 0: c = a% ba = bb = c вернуть def private_inversemodulaire (phi, m): для x в диапазоне (1, m ): if (phi * x)% m == 1: r eturn x return None def private_nbprementreux (phi): l = [] для x в диапазоне (2, phi): если private_gcd (phi, x) == 1 и private_inversemodulaire (x, phi)! = Нет: l.append (x) ) если len (l)> 5: разбить x на l: if x == private_inversemodulaire (x, phi): l.remove (x) вернуть l

def GENERATEUR_DE_CLE():
    p, q = original_premier.nombre_different_premier()
    n = p * q
    phi = (p-1) * (q-1)  # Fonction eulérienne (totient)
    print ('p=',p)
    print('q=',q)
    print ('phi=',phi)
    e = choice(private_nbprementreux(phi))
    d = private_inversemodulaire(e, phi)

    public_key = [e, n]
    private_key = [d, n]
    return [public_key, private_key]


def private_chiffre_block(m, e, n):
    c = (m**e) % n
    return c

def private_dechiffre_block(c, d, n):
    m = (c**d) % n
    return m

# méthode pour chiffrer le message
def chiffre_string(s, public_key):
    e, n = public_key
    return ''.join([chr(private_chiffre_block(ord(x), e, n)) for x in list(s)])

def dechiffre_string(s, private_key):
    d, n = private_key
    return ''.join([chr(private_dechiffre_block(ord(x), d, n)) for x in list(s)])

"" "original_premier.py: "" "

from random import choice

premier = [967, 971, 977, 983, 991, 997]

def nombre_different_premier():
    while True:
        p = choice(premier)
        q = choice(premier)
        if p != q:
            return [p, q]

" ""

Спасибо за все и за чтение и ответы!