def test_Alice_Bob_Same_Key(self):
for i in range(100):
# 100 iterations should test well despite randomness?
alice = pyDHE.new()
bob = pyDHE.new()
alice.update(bob.getPublicKey())
bob.update(alice.getPublicKey())
self.assertEqual(bob.getFinalKey(), alice.getFinalKey(),
"Alice and Bob have different keys")
def test_negotiate(self, group=14):
server = socket.socket()
server.bind(('', 0))
server.listen(1)
port = server.getsockname()[1]
pid = os.fork()
# child process - aka, the server
if pid == 0:
sock, _ = server.accept()
server.close()
# parent - aka, the client
else:
sock = socket.socket()
sock.connect(('', port))
server.close()
alice = pyDHE.new(group)
local_key = alice.negotiate(sock)
#sock.close()
if pid == 0:
sock.send(long_to_bytes(local_key))
sock.close()
else:
os.wait()
remote_key = bytes_to_long(sock.recv(1024))
sock.close()
self.assertEqual(local_key, remote_key, "keys do not match")
def debug_handshake(userlist, connection, passwd_db):
truth_value = False
alice = pyDHE.new()
value = alice.negotiate(connection)
e = encr(value)
print(1)
username_recv = e.decrypt(connection.recv(1024))
time.sleep(0.13)
print(2)
passwd_recv = e.decrypt(connection.recv(1024))
print(3)
#print(username_recv)
username_parts = username_recv.decode().split(":")
passwd_parts = passwd_recv.decode()
print(passwd_parts)
if passwd_db.add_user(username_parts[1], passwd_parts) == True:
truth_value = True
print(1)
elif passwd_db.check_password(username_parts[1], passwd_parts) == True:
truth_value = True
print(2)
if username_parts[0] == "Username" and truth_value == True:
userlist.append(username_parts[1])
connection.send("1:Username Accepted".encode())
passwd_parts = []
return e
else:
connection.send("0:Authentification failed".encode())
debug_handshake(userlist, connection, password_db)
def negotiate(self):
self.dh = pyDHE.new(14)
self.sock.send(long_to_bytes(self.dh.getPublicKey()))
data = self.sock.recv(1024)
self.dh.update(bytes_to_long(data))
fullKey = self.dh.getFinalKey()
self.key = hashlib.sha256((str(fullKey)).encode()).hexdigest()[:32]
return self.dh.getFinalKey()
def send_public_key(self, dst):
User = pyDHE.new()
msg = str(User.getPublicKey())
self.NETIF.send_msg(dst, msg.encode('utf-8'))
return User
def get_DH(self,data, conn):
dh = pyDHE.new(14)
client_public_key = bytes_to_long(data)
final_key_dh = dh.update(client_public_key)
my_public_key = dh.getPublicKey()
conn.send(long_to_bytes(my_public_key))
self.key = hashlib.sha256((str(final_key_dh)).encode()).hexdigest()[:32]
def negotiate(self):
"""
Negotiates a Diffie-Hellman key with the server
"""
self.secret = pyDHE.new()
self.sharedSecret = self.secret.negotiate(self.sock)
salt = str(self.sock.getsockname()).encode()
self.key = hashlib.pbkdf2_hmac('sha256', str(self.sharedSecret).encode(), salt, 100000)
def on_connect():
global Alice, pkey, Alice_server, pkey_server, credentials
Alice = pyDHE.new()
pkey = Alice.getPublicKey()
while not mem_client.get('username') or not mem_client.get('password'):
time.sleep(5)
#continue
print(' connection established ')
credentials['username'] = mem_client.get('username').decode('utf-8')
credentials['password'] = mem_client.get('password').decode('utf-8')
sio.emit('authenticate', credentials)
mem_client.set('connection',"Connection Successfully Established")
def DH_Original(group):
# 根据int型group自动选择素数和本原根并生成DHE对象及公私钥对
DH_Object = pyDHE.new(group)
print("正在生成本机DH公私钥...")
DH_PublicKey = DH_Object.getPublicKey()
# 生成公钥
DH_PrivateKey = DH_Object.a
# 生成私钥
print("本机DH公钥：", str(DH_PublicKey)[0:20])
print("本机DH私钥：", str(DH_PrivateKey)[0:20])
return DH_Object, DH_PrivateKey, DH_PublicKey
def debug_handshake(username, passw, socket):
bob = pyDHE.new()
value = bob.negotiate(socket)
e = encr(value)
socket.send(e.encrypt(("Username:"******""
response = socket.recv(1024).decode()
print("test")
if response.split(":")[0] == "0":
debug_handshake(username, passw, socket)
else:
return e
def on_connect():
global dhe_helper, x, credentials
#diffie hellman keys between each pair of participating clients
#more info on pyDHE module - https://github.com/deadPix3l/pyDHE
dhe_helper = pyDHE.new()
# x = G^a mod P
x = dhe_helper.getPublicKey(
) #public key - generated using common public key and own private key
#keep on waiting till login credentials are received
while not mem_client.get('username') or not mem_client.get('password'):
time.sleep(5)
#continue
print(' connection established ')
credentials['username'] = mem_client.get('username').decode('utf-8')
credentials['password'] = mem_client.get('password').decode('utf-8')
#only authorized clients are able to access the main model
sio.emit('authenticate', credentials)
mem_client.set('connection', "Connection Successfully Established")
def generate_dh():
"""Generates a DHE object (private)."""
private_key = pyDHE.new()
return private_key
def test_Forgot_update_fail(self):
self.assertRaises(ValueError, pyDHE.new().getFinalKey)
import pyDHE
alice = pyDHE.new(group=14)
alicePubkey = alice.getPublicKey()
print('Alice pub key:', alicePubkey)
bob = pyDHE.new(group=14)
bobPubkey = bob.getPublicKey()
print('Bob pub key:', bobPubkey)
print('Exchange over Internet...done')
aliceSharedkey = alice.update(bobPubkey)
print('Alice shared key:', hex(aliceSharedkey))
bobSharedKey = bob.update(alicePubkey)
print('Bob shared key:', hex(bobSharedKey))
from datetime import datetime
from message import Message
from streaming import createMsg, streamData, initializeAES
import pyDHE
import eel
# this is temporary, just for debuggining when you want to open two clients on one computer
# Note that there is a small chance the random port numbers will be the same and crash anyway.
import random
# [GLOBAL VARIABLES]
client = None # so we can use it in exposed functions
eel.init('./GUI/web') # initializing eel
eelPort = 42069 # default GUI port
clientDH = pyDHE.new() # diffiehellman object
# contains names only of all the clients connected
client_list = []
class Client:
def __init__(self, server_ip, port, client_ip):
self.SERVER_IP = server_ip
self.PORT = port
self.CLIENT_IP = client_ip
self.finalDecryptionKey = None
print(f"[*] Host: {self.CLIENT_IP} | Port: {self.PORT}")
self.client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#!/usr/bin/env python
import pyDHE
alice = pyDHE.new((2, 541))
bob = pyDHE.new((2, 541))
A = alice.getPublicKey()
B = bob.getPublicKey()
K = alice.update(B)
assert K == bob.update(A)
p, g = alice.p, alice.g
a, b = alice.a, bob.a
print('''
Welcome to DiffieCrack!
-----------------------
The goal is to mathematically discover just one of the
three numbers in the private section, using only public
and inferred (i.e Only what Eve can see). Feel free to
add more equations to the inferred, but remember:
Don't use any private values. Good Luck!
''')
print('''
Private
--------
a: {}
from datetime import datetime
from message import Message
from streaming import streamData, initializeAES
import pyDHE
import eel
# Importing Random just for Debugging when we want to open two clients on one computer
# there is a very small chance the random port numbers will be the same and crash anyway.
import random
# [GLOBAL VARIABLES]
client = None # so we can use it in exposed functions
eel.init('./GUI/web') # Initializing eel
eelPort = 42069 # default GUI port
clientDH = pyDHE.new() # Diffie-Hellman object
# contains names only of all the clients connected
client_list = []
class Client:
def __init__(self, server_ip, port, client_ip):
self.SERVER_IP = server_ip
self.PORT = port
self.CLIENT_IP = client_ip
self.finalDecryptionKey = None
print(f"[*] Host: {self.SERVER_IP} | Port: {self.PORT}")
self.client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
import socketio
import time
import json
import numpy as np
import pyDHE
import retry
from flserver import FLServer
import pandas as pd
from keras.models import model_from_json
NO_OF_ROUNDS = 2
sio = socketio.Server(async_mode='eventlet')
app = socketio.Middleware(sio)
Bob = pyDHE.new(18)
pkey = Bob.getPublicKey()
count_clients = 0
count_rounds = 0
count_auth_clients = 0
conn_threshold = 3
update_threshold = 3
updates_received = 0
client_updates = {}
server_wait_time = 5
suv_dictionary = {}
count_train_done = 0
count_shared_done = 0
fin_weights_str = retry.model_weights_json
fin_struct = retry.model_json
def exchange_key(connection, pub_key):
"""
Get RSA key from server
:param connection: Connection to server
:param pub_key: Client's public key
:return: server_pub_key, server_pub_key_bytes, max_message_size
"""
if main.diffe_key_exchange is False:
# Get the server's public key
server_pub_key_bytes = connection.recv(1024)
# Send public key
connection.sendall(rsa.PublicKey.save_pkcs1(pub_key))
else:
# Rounds of bit-shifting and XOR
rounds = 64
while True:
# Generate 4096-bit keys (RFC 3526 Group 16)
client_diffe_key = pyDHE.new(16)
shared_secret = client_diffe_key.negotiate(connection)
# Encrypt
encrypted = int(
binascii.hexlify(rsa.PublicKey.save_pkcs1(pub_key)).decode(),
16)
for x in range(0, rounds):
encrypted = encrypted ^ (shared_secret**rounds)
encrypted = encrypted << rounds
encrypted = int(str(encrypted)[::-1])
# Decrypt
decrypted = encrypted
decrypted = int(str(decrypted)[::-1])
for x in range(rounds, 0, -1):
decrypted = decrypted >> rounds
decrypted = decrypted ^ (shared_secret**rounds)
# Check if able to decrypt
try:
binascii.unhexlify(hex(decrypted)[2:]).decode()
client_success = True
# Generate new keys upon failure and try again
except UnicodeDecodeError:
client_success = False
pass
except binascii.Error:
client_success = False
pass
# Notify client about encryption status
server_success = connection.recv(1024)
if client_success is False:
connection.send(b'DHE')
else:
connection.send(b'CONTINUE')
# Get encryption status from client
if client_success is False or server_success == b'DHE':
pass
elif server_success == b'CONTINUE':
break
# Hold encrypted server key
server_encrypted = b''
# Receive encrypted key from the server
while True:
data = connection.recv(8192)
if data == b'ENDED':
break
elif data[-5:] == b'ENDED':
server_encrypted += data[:-5]
break
server_encrypted += data
# Send the encrypted key to the server
connection.sendall(bytes(hex(encrypted).encode()))
connection.send(b'ENDED')
# Decrypt the client's public key
decrypted = int(server_encrypted, 16)
decrypted = int(str(int(decrypted))[::-1])
for x in range(rounds, 0, -1):
decrypted = decrypted >> rounds
decrypted = decrypted ^ (shared_secret**rounds)
server_pub_key_bytes = binascii.unhexlify(hex(decrypted)[2:]).decode()
server_pub_key = rsa.PublicKey.load_pkcs1(server_pub_key_bytes)
# Determine max message size
max_message_size = common.byte_size(server_pub_key.n) - 11
# Return crypto key information
return server_pub_key, server_pub_key_bytes, max_message_size
import socket
import threading
import argparse
import os
from datetime import datetime
from message import Message
from streaming import createMsg, streamData, initializeAES, decryptMsg, returnVector
from clientConnectionObj import ClientConnection
import pyDHE
import time
serverDH = pyDHE.new() # DiffieHellman object
class Server:
def __init__(self, ip, port):
self.IP = ip
self.PORT = port
self.USERNAME = "******"
self.temp_f = False # flag for loop logic
# holds a list of client connection objects (eventually we should have just this)
self.clientConnections = []
self.current_chat = "./logs/currentchat.txt"
self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)