def runClient(port, dest):
print("Trying " + str(dest) + ":" + str(port) + " ...")
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_address = (dest, port)
try:
sock.connect(server_address)
except socket.error as e:
WriteErrorLog(str(e))
try:
modulo = recv_msg(sock)
print ("Reception du modulo " + modulo)
base = recv_msg(sock)
print("Reception de la base " + base)
b = entierAleatoire(int(modulo))
print("Generation de la cle privee " + str(b))
B = exponentiationModulaire(int(base), b, int(modulo))
A = recv_msg(sock)
print("Reception de la cle publique serveur " + A)
send_msg(sock, str(B))
print("Envoi de la cle publique " + str(B))
k = exponentiationModulaire(int(A), b, int(modulo))
print("Obtention de la cle partagee " + str(k))
finally:
sock.close()
def runServer(port):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_address = ("0.0.0.0", port)
print('starting up on {} port {}'.format(*server_address))
try:
sock.bind(server_address)
sock.listen(1)
except socket.error as e:
WriteErrorLog(str(e))
while True:
print('waiting for a connection')
m = trouverNombrePremier()
n = entierAleatoire(m)
a = entierAleatoire(m)
connection, client_address = sock.accept()
try:
print('connection from', client_address)
while True:
print ("Envoi du modulo " + str(m))
print ("Envoi de la base " + str(n))
send_msg(connection, str(m))
send_msg(connection, str(n))
print("Generation de la cle privee " + str(a))
A = exponentiationModulaire(n, a, m)
send_msg(connection, str(A))
print("Envoi de la cle publique " + str(A))
B = recv_msg(connection)
print("Reception de la cle publique client " + B)
k = exponentiationModulaire(int(B), a, m)
print("Obtention de la cle partagee " + str(k))
data = connection.recv(1024)
print (data)
if not data:
break
finally:
connection.close()
while True:
(s, address) = serversocket.accept()
i += 1
print(str(i) + "e connexion au serveur")
print("----------")
m = trouverNombrePremier()
n = entierAleatoire(m)
print("Envoi du modulo: " + str(m))
print("Envoi de la base: " + str(n))
print("----------")
send_msg(s, str(m))
send_msg(s, str(n))
serSecretKey = entierAleatoire(m)
serPublicKey = exponentiationModulaire(n, serSecretKey, m)
print("Cle privée: " + str(serSecretKey))
print("Cle publique a envoyer: " + str(serPublicKey))
send_msg(s, str(serPublicKey))
pubKeyCli = int(recv_msg(s))
print("Cle publique recu: " + str(pubKeyCli))
servSharedKey = exponentiationModulaire(pubKeyCli, serSecretKey, m)
print("Cle partagee: " + str(servSharedKey))
print("----------")
s.close()
else: #mode client
destination = (opts.dest, opts.port)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(destination)
i = 0
while True:
(s, address) = serversocket.accept()
i += 1
print(str(i) + " connexion to server")
modulo = trouverNombrePremier()
base = entierAleatoire(modulo)
send_msg(s, str(modulo))
print("Send modulo: " + str(modulo))
send_msg(s, str(base))
print("Send base: " + str(base))
privateKey = entierAleatoire(modulo)
publicKey = exponentiationModulaire(base, privateKey, modulo)
send_msg(s, str(publicKey))
publicKeyRcv = int(recv_msg(s))
sharedKey = exponentiationModulaire(publicKeyRcv, privateKey, modulo)
print("Private key: " + str(privateKey))
print("Public key: " + str(publicKey))
print("Public key received: " + str(publicKeyRcv))
print("Shared key: " + str(sharedKey))
s.close()
else:
adress_destination = "localhost"
# Le serveur prépare et envoie le modulo et la base encodé en UTF-8
a = trouverNombrePremier()
b = entierAleatoire(a)
print(f'Envoi du modulo: {a}')
print(f'Envoi de la base: {b}')
print("--------------------------------------------------------")
send_msg(clientSocket, str(a))
send_msg(clientSocket, str(b))
# Le serveur génère une clé privée
cle_privee_serveur = entierAleatoire(a)
print(f'Clé privée : {cle_privee_serveur}')
# Le serveur calcule la clé publique
cle_publique_serveur = exponentiationModulaire(
b, cle_privee_serveur, a)
print(f'Clé publique à envoyer : {cle_publique_serveur}')
# Le serveur envoie la clé publique au client
send_msg(clientSocket, str(cle_publique_serveur))
# Le serveur recoit la clé publique du client
cle_publique_recue = int(recv_msg(clientSocket))
print(f'Clé publique recue: {cle_publique_recue}')
# Le serveur calcule la clé partagée
cle_partagee_serveur = exponentiationModulaire(
cle_publique_recue, cle_privee_serveur, a)
print(f'Clé partagée: {cle_partagee_serveur}')
clientSocket.close()
def main():
if opts.destination and opts.serveur:
write_exception(
Exception(
"L'application ne peut pas utiliser -d et -s simultanément."))
if opts.port == -1:
write_exception(Exception("L'option -p est obligatoire."))
#TODO: retourner un message d'erreur significatif s'il y a une erreur
#TODO: chaque message d'erreur (et sa date et heure) doit être écrit dans le fichier Error.log
try:
if opts.serveur: # mode serveur
print(
"###############################################################"
)
print("Demarrage du serveur ...")
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
serversocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
serversocket.bind(("localhost", opts.port))
serversocket.listen(5)
print(f"Ecoute sur le port : {opts.port}")
while True:
(s, address) = serversocket.accept()
print('1e connexion au serveur')
print(
'----------------------------------------------------------'
)
#create a,b p
a = trouverNombrePremier()
b = entierAleatoire(a)
p = entierAleatoire(a)
#create public key
server_public_key = exponentiationModulaire(b, p, a)
print(f"Envoi du modulo : {a}")
print(f"Envoi de la base : {b}")
print(
'----------------------------------------------------------'
)
print(f'Cle privee : {p}')
print(f'Cle publique a envoyer : {server_public_key}')
send_msg(s, str(a)) # send a
send_msg(s, str(b)) # send b
send_msg(s, str(server_public_key)) # send public key
# receive client public key
client_public_key = int(recv_msg(s))
print(f'Cle publique recue : {client_public_key}')
#calculate shared key
shared_key = exponentiationModulaire(client_public_key, p, a)
print(f"Cle partagee : {shared_key}")
print("au serveur")
print(
"###############################################################"
)
s.close()
else: # mode client
if not opts.destination:
write_exception(
Exception(
"Le client doit spécifier une destination en utilisant -d."
))
print(
"###############################################################"
)
destination = (opts.destination, opts.port)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(destination)
a = int(recv_msg(s)) # receive a
print(f"Reception du modulo : {a}")
b = int(recv_msg(s)) # receive b
print(f'Reception de la base : {b}')
print('----------------------------------------------------------')
#create q
q = entierAleatoire(a)
print(f'Cle privee : {q}')
#Create public key
client_public_key = exponentiationModulaire(b, q, a)
print(f'Cle publique a envoyer : {client_public_key}')
# receive server public key
server_public_key = int(recv_msg(s))
print(f'Cle publique recue : {server_public_key}')
#send public key
send_msg(s, str(client_public_key))
#calculate shared key
shared_key = exponentiationModulaire(server_public_key, q, a)
print(f"Cle partagee : {shared_key}")
print(
"###############################################################"
)
s.close()
except Exception as e:
write_exception(e)