def receive_message(): while True: data, address = sock.recvfrom(1024) if data.decode()[:5] == 'hello': hosts[data.decode()[6:]] = address[0] elif (data.decode()[:6] != 'update') and (address[0] != host_ip): w_time = calculate_mov_avg(address[0], float(data.decode()) + get_rtt(address[0])) # calcuate moving average of mec wait time => w_time = wait time + rtt if address[0] in mec_waiting_time: mec_waiting_time[address[0]].append(w_time) else: mec_waiting_time[address[0]] = [w_time]
async def echo_handler(reader, writer): data = await reader.readline() message = data.decode() addr = writer.get_extra_info('peername') msg = "Received %r from %r" % (message, addr) print(msg) table = message.replace("\n", "").split(".|.") for i in range(len(table)): table[i] = table[i].split("-|-") table_request = up.lookup(table, "table_request") if table_request == "new": result = await newTable(table) elif table_request == "update": result = await updateTable(table) elif table_request == "delete": result = await deleteTable(table) result = result.encode() print("Send: %r" % result) writer.write(result) await writer.drain() print("Close the client socket") writer.close()
def report_EP(self, username, api_key, status, pubkey): url = "http://cs302.kiwi.land/api/report" # Credentials use server to update #username = "******" #password = "******" # current public key #pubkey = "c852f14e5c063da1dbedb7fa0d6cc9e4d6f61e581140b4ae2f46cddd67556d48" # connections hostname = socket.gethostname() ip = socket.gethostbyname(hostname) connection_address = ip + ":10020" connection_location = "0" # create HTTP BASIC authorization header #credentials = ('%s:%s' % (username, password)) #b64_credentials = base64.b64encode(creden # tials.encode('ascii')) headers = { #'Authorization': 'Basic %s' % b64_credentials.decode('ascii'), 'X-username': username, 'X-apikey': api_key, 'Content-Type': 'application/json; charset=utf-8', } payload = { "connection_address": connection_address, "connection_location": connection_location, "incoming_pubkey": pubkey, "status": status, } # 1. convert the payload into json representation, payload_str = json.dumps(payload) # 2. ensure the payload is in bytes, not a string json_payload = payload_str.encode('utf-8') # 3. pass the payload bytes into this function try: req = urllib.request.Request(url, data=json_payload, headers=headers) response = urllib.request.urlopen(req) data = response.read() # read the received bytes # load encoding if possible (default to utf-8) encoding = response.info().get_content_charset('utf-8') response.close() except urllib.error.HTTPError as error: print(error.read()) exit() JSON_object = json.loads(data.decode(encoding)) print(status) print(JSON_object) return JSON_object["response"]
def tx_ping_check_EP(self, username, api_key, connection_address, connection_location, other_connections): url = "http://" + other_connections + "/api/ping_check" # Credentials use server to update #username = "******" #password = "******" # current public key #pubkey = "c852f14e5c063da1dbedb7fa0d6cc9e4d6f61e581140b4ae2f46cddd67556d48" # connections connection_address = connection_address connection_location = connection_location my_time = str(time.time()) # create HTTP BASIC authorization header #credentials = ('%s:%s' % (username, password)) #b64_credentials = base64.b64encode(creden # tials.encode('ascii')) headers = { #'Authorization': 'Basic %s' % b64_credentials.decode('ascii'), 'X-username': username, 'X-apikey': api_key, 'Content-Type': 'application/json; charset=utf-8', } payload = { "my_time": my_time, "connection_address": connection_address, "connection_location": connection_location, } # 1. convert the payload into json representation, payload_str = json.dumps(payload) # 2. ensure the payload is in bytes, not a string json_payload = payload_str.encode('utf-8') # 3. pass the payload bytes into this function try: req = urllib.request.Request(url, data=json_payload, headers=headers) response = urllib.request.urlopen(req, timeout=0.01) data = response.read() # read the received bytes # load encoding if possible (default to utf-8) encoding = response.info().get_content_charset('utf-8') response.close() except urllib.error.HTTPError as error: print(error.read()) exit() JSON_object = json.loads(data.decode(encoding)) #print(status) print(JSON_object)
def UDP_back_msg(self, host='0.0.0.0', port=4002): client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) client.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) client.bind((host, port)) while True: try: data, addr = client.recvfrom(10000) if data: print('GET:', data.decode()) client.sendto('UDP GET'.encode(), addr) except Exception as e: print(e) time.sleep(0.1)
def loginserver_pubkey_EP(self): url = "http://cs302.kiwi.land/api/loginserver_pubkey" try: req = urllib.request.Request(url) response = urllib.request.urlopen(req) data = response.read() # read the received bytes # load encoding if possible (default to utf-8) encoding = response.info().get_content_charset('utf-8') response.close() except urllib.error.HTTPError as error: print(error.read()) exit() JSON_object = json.loads(data.decode(encoding)) print(JSON_object) return JSON_object
def get_loginserver_record_EP(self, username, api_key): url = "http://cs302.kiwi.land/api/get_loginserver_record" # Credentials use server to update #username = "******" #password = "******" # create HTTP BASIC authorization header #credentials = ('%s:%s' % (username, password)) #b64_credentials = base64.b64encode(credentials.encode('ascii')) headers = { #'Authorization': 'Basic %s' % b64_credentials.decode('ascii'), 'X-username': username, 'X-apikey': api_key, 'Content-Type': 'application/json; charset=utf-8', } payload = {} # 1. convert the payload into json representation, payload_str = json.dumps(payload) # 2. ensure the payload is in bytes, not a string json_payload = payload_str.encode('utf-8') # 3. pass the payload bytes into this function try: req = urllib.request.Request(url, data=json_payload, headers=headers) response = urllib.request.urlopen(req) data = response.read() # read the received bytes # load encoding if possible (default to utf-8) encoding = response.info().get_content_charset('utf-8') response.close() except urllib.error.HTTPError as error: print(error.read()) exit() JSON_object = json.loads(data.decode(encoding)) return JSON_object["loginserver_record"]
def get_privatedata(self, username, api_key): """Use this API to load the saved symmetrically encrypted private data for a user """ #def authenticate(self,username,password): # Endpoint url = "http://cs302.kiwi.land/api/get_privatedata" # create HTTP BASIC authorization header #credentials = ('%s:%s' % (username, password)) #b64_credentials = base64.b64encode(credentials.encode('ascii')) headers = { 'X-username': username, 'X-apikey': api_key, 'Content-Type': 'application/json; charset=utf-8', } payload = {} # 1. convert the payload into json representation, payload_str = json.dumps(payload) # 2. ensure the payload is in bytes, not a string json_payload = payload_str.encode('utf-8') # 3. pass the payload bytes into this function try: req = urllib.request.Request(url, data=json_payload, headers=headers) response = urllib.request.urlopen(req) data = response.read() # read the received bytes # load encoding if possible (default to utf-8) encoding = response.info().get_content_charset('utf-8') response.close() except urllib.error.HTTPError as error: print(error.read()) exit() JSON_object = json.loads(data.decode(encoding)) return JSON_object["privatedata"]
def parse_links3(url): data = urllib.request.urlopen(url).read() root = xml.etree.ElementTree.fromstring(data.decode('utf-8')) txt_list = [] txt = '' for c in root: if len(root) == 1: txt += f'{c.tag}' for cc in c: if len(c) == 1: txt += f'/{cc.tag}' for ccc in cc: if len(cc) == 1: txt += f'/{ccc.tag}' if isinstance(ccc.attrib, dict): for k, v in ccc.attrib.items(): txt += f'\n - {k}: {v}' if len(txt) > settings.MAXIMUM_CHARACTERS: txt_list += [txt] txt = '' return txt_list + [txt]
def receive_message(): global hosts while True: data, address = sock.recvfrom(1024) if data.decode()[:5] == 'hello': hosts[data.decode()[6:]] = address[0] elif (data.decode()[:6] == 'update') and (discovering == 0): hosts = ast.literal_eval(data.decode()[7:]) # print('received: ', hosts) elif (data.decode()[:6] != 'update') and (address[0] != host_ip): w_time = calculate_mov_avg(address[0], float(data.decode()) + get_rtt(address[0])) # calcuate moving average of mec wait time => w_time = wait time + rtt if address[0] in mec_waiting_time: mec_waiting_time[address[0]].append(w_time) else: mec_waiting_time[address[0]] = [w_time] elif data.decode().strip() == 'user': send_message('update')
async def visual(ctx, v_type, country): if v_type in visual_types and country in countries: if v_type == 'pie': c_data = virus_data[country] labels = ['Active: %i'%(c_data[5]), 'Recovered: %i'%(c_data[1]), 'Dead: %i'%(c_data[2])] sizes = [c_data[5], c_data[1], c_data[2]] colors = ['yellowgreen', 'gold', 'lightskyblue'] fig = plt.figure(facecolor = 'dimgrey', edgecolor='k', linewidth= 2.0, frameon=True) pie = plt.pie(sizes,colors = colors , autopct='%1.1f%%', shadow = False, startangle=90) plt.legend(pie[0], labels, loc="best") plt.axis('equal') plt.tight_layout() plt.savefig('pie.png', facecolor=fig.get_facecolor()) await ctx.send(file=discord.File('pie.png')) elif v_type == 'line': http = urllib3.PoolManager() response = http.request('GET','https://api.thevirustracker.com/free-api?countryTimeline=%s'%(country)) data = response.data #byte data = data.decode('utf8') #converting byte to string data = json.loads(data) data = data['timelineitems'][0] dates = list(data.keys()) values = [] for x in data.keys(): if x != 'stat' : values.append(data[x]["total_cases"]) dates = dates[:len(dates) -1:] fig = plt.figure(figsize = (80,20)) plt.plot(dates,values, color="#ff0000", linewidth=3) plt.gcf().autofmt_xdate() plt.grid() plt.savefig('plt.png') await ctx.send(file=discord.File('plt.png')) else: await ctx.send("Invalid visual")
def list_users_EP(self, username, api_key): url = "http://cs302.kiwi.land/api/list_users" headers = { 'X-username': username, 'X-apikey': api_key, 'Content-Type': 'application/json; charset=utf-8', } payload = {} # 1. convert the payload into json representation, payload_str = json.dumps(payload) # 2. ensure the payload is in bytes, not a string json_payload = payload_str.encode('utf-8') # 3. pass the payload bytes into this function try: req = urllib.request.Request(url, data=json_payload, headers=headers) response = urllib.request.urlopen(req) data = response.read() # read the received bytes # load encoding if possible (default to utf-8) encoding = response.info().get_content_charset('utf-8') response.close() except urllib.error.HTTPError as error: print(error.read()) exit() JSON_object = json.loads(data.decode(encoding)) username = [] connection_address = [] connection_location = [] updated_time = [] publickey = [] status = [] online_records = [] users = JSON_object["users"] #print(users) for record in range(len(users)): #print(users[record]) username.append(users[record]["username"]) connection_address.append(users[record]["connection_address"]) connection_location.append(users[record]["connection_location"]) updated_time.append(users[record]["connection_updated_at"]) publickey.append(users[record]["incoming_pubkey"]) status.append(users[record]["status"]) online_users = { "username": username, "connection_address": connection_address, "connection_location": connection_location, "connection_updated_at": updated_time, "publickey": publickey, "status": status } print("******************************************") print(online_users) print("*******************************************") return online_users
def tx_groupinvite(self, username, apikey, loginserver_record, target_pubkey, target_username, privatekey, pubkey, connections): """ Use this API to transmit a secret message between users. Meta-information is public (the sender username/pubkey, and the destination username/pubkey, the timestamp). """ url = "http://" + connections + "/api/groupinvite" print("XXXXXXXXXXXXXXXXX") print(connections) print("XXXXXXXXXXXXXXXXX") ## LOGIN RECORD DONE #MAKE GROUPKEY HASH #TARGET PUBKEY DONE target_pubkey = target_pubkey #TARGET USERNAME DONE target_username = target_username #ENCRYPTED GROUPKEY # timestamp sender_created_at = str(time.time()) # target details key_password = "******" salt_password = bytes((key_password * 16).encode('utf-8')[:16]) key_password_b = bytes(key_password, encoding='utf-8') print(key_password_b) print(salt_password) ops = nacl.pwhash.argon2i.OPSLIMIT_SENSITIVE mems = nacl.pwhash.argon2i.MEMLIMIT_SENSITIVE #symmetric_key = nacl.pwhash.argon2i.kdf(32,key_password_b,salt_password,ops,mems, encoder=nacl.encoding.HexEncoder) symmetric_key = nacl.pwhash.argon2i.kdf(32, key_password_b, salt_password, ops, mems) print(key_password) print(key_password_b) print(salt_password) print(ops) print(mems) print(symmetric_key) #message = Api.get_privatedata(self,username,api_key) groupkey_hash = nacl.hash.sha256(symmetric_key, encoder=nacl.encoding.HexEncoder) print(groupkey_hash) # Generate encrypting public key target_key = nacl.signing.VerifyKey( target_pubkey, encoder=nacl.encoding.HexEncoder).to_curve25519_public_key() personal_key = nacl.signing.VerifyKey( pubkey, encoder=nacl.encoding.HexEncoder).to_curve25519_public_key() # Make sealed box using public key (can only be decoded by target) box = nacl.public.SealedBox(target_key) personal_box = nacl.public.SealedBox(personal_key) #target_key_str = target_key.encode(encoder=nacl.encoding.HexEncoder).decode('utf-8') # Private message that needs to be encrypted key = bytes(symmetric_key, encoding='utf-8') encrypted_groupkey = box.encrypt( key, encoder=nacl.encoding.HexEncoder).decode('utf-8') personal_encrypted_message = personal_box.encrypt( key, encoder=nacl.encoding.HexEncoder).decode('utf-8') # Create signing key from private key signing_key = nacl.signing.SigningKey(privatekey, encoder=nacl.encoding.HexEncoder) sender_created_at = str(time.time()) #publicKey,signaturePing_str,signature_str,signing_key,login = add_pubkey.PublicKey.add_key(self,username,password) # Sign message (login,targetkey,targetusernmae,encryptedmessage,sender_created_at) signatureMessage = bytes(loginserver_record + groupkey_hash + target_pubkey + target_username + encrypted_groupkey + sender_created_at, encoding='utf-8') signedMessage = signing_key.sign(signatureMessage, encoder=nacl.encoding.HexEncoder) signature_str = signedMessage.signature.decode('utf-8') # create HTTP BASIC authorization header #credentials = ('%s:%s' % (username, password)) #b64_credentials = base64.b64encode(credentials.encode('ascii')) headers = { 'X-username': username, 'X-apikey': apikey, 'Content-Type': 'application/json; charset=utf-8', } payload = { "loginserver_record": loginserver_record, "groupkey_hash": groupkey_hash, "target_pubkey": target_pubkey, "target_username": target_username, "encrypted_groupkey": encrypted_groupkey, "sender_created_at": sender_created_at, "signature": signature_str, } # 1. convert the payload into json representation, payload_str = json.dumps(payload) # 2. ensure the payload is in bytes, not a string json_payload = payload_str.encode('utf-8') # 3. pass the payload bytes into this function try: req = urllib.request.Request(url, data=json_payload, headers=headers) response = urllib.request.urlopen(req, timeout=2) data = response.read() # read the received bytes # load encoding if possible (default to utf-8) encoding = response.info().get_content_charset('utf-8') response.close() except urllib.error.HTTPError as error: print(error.read()) exit() JSON_object = json.loads(data.decode(encoding)) print(JSON_object)
def get_data_from_url(url): data = urllib.request.urlopen(url).read() return data.decode('utf-8')
def rx_privatemessage(self, username, apikey, pubkey, privkey, login_record, t_user, t_pubkey, t_message, t_connection_address): """ Use this API to transmit a secret message between users. Meta-information is public (the sender username/pubkey, and the destination username/pubkey, the timestamp). """ url = "http://" + t_connection_address + "/api/rx_privatemessage" print("XXXXXXXXXXXXXXXXX") print(t_connection_address) print("XXXXXXXXXXXXXXXXX") # timestamp sender_created_at = str(time.time()) # target details target_username = t_user target_pubkey = t_pubkey # Generate encrypting public key target_key = nacl.signing.VerifyKey( target_pubkey, encoder=nacl.encoding.HexEncoder).to_curve25519_public_key() personal_key = nacl.signing.VerifyKey( pubkey, encoder=nacl.encoding.HexEncoder).to_curve25519_public_key() # Make sealed box using public key (can only be decoded by target) box = nacl.public.SealedBox(target_key) personal_box = nacl.public.SealedBox(personal_key) target_key_str = target_key.encode( encoder=nacl.encoding.HexEncoder).decode('utf-8') # Private message that needs to be encrypted message = bytes(t_message, encoding='utf-8') encrypted_message = box.encrypt( message, encoder=nacl.encoding.HexEncoder).decode('utf-8') personal_encrypted_message = personal_box.encrypt( message, encoder=nacl.encoding.HexEncoder).decode('utf-8') # Create signing key from private key publickey = pubkey privatekey = privkey login = str(login_record) signing_key = nacl.signing.SigningKey(privatekey, encoder=nacl.encoding.HexEncoder) sender_created_at = str(time.time()) #publicKey,signaturePing_str,signature_str,signing_key,login = add_pubkey.PublicKey.add_key(self,username,password) # Sign message (login,targetkey,targetusernmae,encryptedmessage,sender_created_at) signatureMessage = bytes(login + target_pubkey + target_username + encrypted_message + sender_created_at, encoding='utf-8') signedMessage = signing_key.sign(signatureMessage, encoder=nacl.encoding.HexEncoder) signature_str = signedMessage.signature.decode('utf-8') # create HTTP BASIC authorization header #credentials = ('%s:%s' % (username, password)) #b64_credentials = base64.b64encode(credentials.encode('ascii')) headers = { 'X-username': username, 'X-apikey': apikey, 'Content-Type': 'application/json; charset=utf-8', } payload = { "loginserver_record": login, "target_pubkey": target_pubkey, "target_username": target_username, "encrypted_message": encrypted_message, "sender_created_at": sender_created_at, "signature": signature_str, } # 1. convert the payload into json representation, payload_str = json.dumps(payload) # 2. ensure the payload is in bytes, not a string json_payload = payload_str.encode('utf-8') # 3. pass the payload bytes into this function try: req = urllib.request.Request(url, data=json_payload, headers=headers) response = urllib.request.urlopen(req, timeout=2) data = response.read() # read the received bytes # load encoding if possible (default to utf-8) encoding = response.info().get_content_charset('utf-8') response.close() except urllib.error.HTTPError as error: print(error.read()) exit() JSON_object = json.loads(data.decode(encoding)) print(JSON_object) return payload, personal_encrypted_message
def rx_broadcast(self, username, api_key, privatekey, loginrecord, message, connection_address): """Use this API to transmit a signed broadcast between users. You need to be authenticated, and the broadcast public key must be known, but the broadcast public key need not be associated to your account.""" # replace URL with specific connection #url = "http://cs302.kiwi.land/api/rx_broadcast" print(connection_address) url = "http://" + connection_address + "/api/rx_broadcast" #username = "******" #password = "******" # Load public and private keys #publickey = "c852f14e5c063da1dbedb7fa0d6cc9e4d6f61e581140b4ae2f46cddd67556d48" # Load login record # get private key from private data to generate signing key signing_key = nacl.signing.SigningKey(privatekey, encoder=nacl.encoding.HexEncoder) verify_key = signing_key.verify_key verify_key_hex = verify_key.encode(encoder=nacl.encoding.HexEncoder) publicKey = verify_key_hex.decode('utf-8') # get timestamp sender_created_at = str(time.time()) # record broadcast message (tweet) #message = "Combination Test2" # Message signing signatureMessage = bytes(loginrecord + message + sender_created_at, encoding='utf-8') signedMessage = signing_key.sign(signatureMessage, encoder=nacl.encoding.HexEncoder) signature_str = signedMessage.signature.decode('utf-8') # create HTTP BASIC authorization header #credentials = ('%s:%s' % (username, password)) #b64_credentials = base64.b64encode(credentials.encode('ascii')) headers = { 'X-username': username, 'X-apikey': api_key, 'Content-Type': 'application/json; charset=utf-8', } payload = { "loginserver_record": loginrecord, "message": message, "sender_created_at": sender_created_at, "signature": signature_str, } # 1. convert the payload into json representation, payload_str = json.dumps(payload) # 2. ensure the payload is in bytes, not a string json_payload = payload_str.encode('utf-8') # 3. pass the payload bytes into this function try: req = urllib.request.Request(url, data=json_payload, headers=headers) response = urllib.request.urlopen(req, timeout=0.1) data = response.read() # read the received bytes # load encoding if possible (default to utf-8) encoding = response.info().get_content_charset('utf-8') response.close() except urllib.error.HTTPError as error: print(error.read()) exit() JSON_object = json.loads(data.decode(encoding)) print(JSON_object)
def add_pubkey_EP(self, username, api_key): #def add_key(self,username,password): """ Use this API to associate a public key (256-bit Ed25519 format, hex encoded) with your account. The public key that is added is the one provided for the purposes of the signature. """ url = "http://cs302.kiwi.land/api/add_pubkey" # Generate new private key signing_key = nacl.signing.SigningKey.generate() # Generate public key from private key verify_key = signing_key.verify_key # Make private key encoded private_key = signing_key.encode(encoder=nacl.encoding.HexEncoder) # Hex Encoded public key verify_key_hex = verify_key.encode(encoder=nacl.encoding.HexEncoder) publicKey = verify_key_hex.decode('utf-8') # Sign message with public key and username signatureMessage = bytes(publicKey + username, encoding='utf-8') signedMessage = signing_key.sign(signatureMessage, encoder=nacl.encoding.HexEncoder) signature_str = signedMessage.signature.decode('utf-8') # create HTTP BASIC authorization header #credentials = ('%s:%s' % (username, password)) #b64_credentials = base64.b64encode(credentials.encode('ascii')) headers = { 'X-username': username, 'X-apikey': api_key, 'X-signature': signature_str, 'Content-Type': 'application/json; charset=utf-8', } payload = { "pubkey": publicKey, "username": username, "signature": signature_str, "client_time": time.time() } # 1. convert the payload into json representation, payload_str = json.dumps(payload) # 2. ensure the payload is in bytes, not a string json_payload = payload_str.encode('utf-8') # 3. pass the payload bytes into this function try: req = urllib.request.Request(url, data=json_payload, headers=headers) response = urllib.request.urlopen(req) data = response.read() # read the received bytes # load encoding if possible (default to utf-8) encoding = response.info().get_content_charset('utf-8') response.close() except urllib.error.HTTPError as error: print(error.read()) exit() JSON_object = json.loads(data.decode(encoding)) print(JSON_object) return publicKey, private_key.decode('utf-8')
def add_privatedata(self, username, api_key, login_record, privatekey, password, friend_username="******", blocked_words=None, block_username="******", block_message=None, favourite_message=None, reset=None): """ Use this API to save symmetrically encrypted private data for a given user. It will automatically delete previously uploaded private data. """ url = "http://cs302.kiwi.land/api/add_privatedata" loginserver_record = str(login_record) client_saved_at = str(time.time()) print("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$") print("ADDING NEW PRIVATE DATA: " + privatekey) print("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$") #SecretBox generation #key = nacl.utils.random(nacl.secret.SecretBox.KEY_SIZE) #print(key) # Keep this key safe!!! # box = nacl.secret.SecretBox(key) # nonce = nacl.utils.random(nacl.secret.SecretBox.NONCE_SIZE) key_password = password salt_password = bytes(((key_password * 16).encode('utf-8')[:16])) key_password_b = bytes(key_password, encoding='utf-8') ops = nacl.pwhash.argon2i.OPSLIMIT_SENSITIVE mems = nacl.pwhash.argon2i.MEMLIMIT_SENSITIVE #symmetric_key = nacl.pwhash.argon2i.kdf(32,key_password_b,salt_password,ops,mems, encoder=nacl.encoding.HexEncoder) # implement key.size symmetric_key = nacl.pwhash.argon2i.kdf(nacl.secret.SecretBox.KEY_SIZE, key_password_b, salt_password, ops, mems) print(symmetric_key) box = nacl.secret.SecretBox(symmetric_key) nonce = nacl.utils.random(nacl.secret.SecretBox.NONCE_SIZE) prikeys = [str(privatekey)] blocked_pubkeys = [] blocked_usernames = [] blocked_text = [] blocked_message_signatures = [] favourite_message_signatures = [] friends_usernames = [] #keys, record = Api.decode_privatedata(self,username,api_key,password) print("CHECK1111111111111111111111111111111") keys, record = Api.decode_privatedata(self, username, api_key, password) print("CHECK2222222222222222222222222222222") blocked_pubkeys = record["blocked_pubkeys"] print("CHECK333333333333333333333333333333333") blocked_usernames = record["blocked_usernames"] print("CHECK4444444444444444444444444444444") blocked_text = record["blocked_words"] print("CHECK5555555555555555555555555555555") blocked_message_signatures = record["blocked_message_signatures"] print("CHECK6666666666666666666666666666666") favourite_message_signatures = record["favourite_message_signatures"] print("CHECK777777777777777777777777777777") friends_usernames = record["friends_usernames"] print("CHECK888888888888888888888888888888888") if (block_username != "none"): for i in range(len(friends_usernames)): if friends_usernames[i] == block_username: friends_usernames.remove(block_username) if friend_username != "none": for i in range(len(blocked_usernames)): if blocked_usernames[i] == friend_username: blocked_usernames.remove(friend_username) if friend_username != "none": try: friends_usernames.remove(friend_username) except ValueError: print("not yet added") friends_usernames.append(friend_username) if block_username != "none": try: blocked_usernames.remove(block_username) except ValueError: print("not yet added") blocked_usernames.append(block_username) if block_message != None: try: blocked_message_signatures.remove(block_message) except ValueError: print("Not yet added") blocked_message_signatures.append(block_message) if favourite_message != None: try: favourite_message_signatures.remove(favourite_message) except ValueError: print("not yet added") favourite_message_signatures.append(favourite_message) if blocked_words != None: try: blocked_text.remove(blocked_words) except ValueError: print("not yet added") blocked_text.append(blocked_words) # try: # for i in range(len(blocked_words)): # if blocked_words[i] != None: # blocked_text.append(blocked_words) # except: # print("IT DID NOT BLOCK") #friends_usernames = [] if (reset == 1): prikeys = [str(privatekey)] blocked_pubkeys = [] blocked_usernames = [] blocked_text = [] blocked_message_signatures = [] favourite_message_signatures = [] friends_usernames = [] privatedata = { "prikeys": prikeys, "blocked_pubkeys": blocked_pubkeys, "blocked_usernames": blocked_usernames, "blocked_words": blocked_text, "blocked_message_signatures": blocked_message_signatures, "favourite_message_signatures": favourite_message_signatures, "friends_usernames": friends_usernames } # Converts private data to string privatedata = json.dumps(privatedata) # Converts to bytes privatedata = bytes(privatedata, encoding='utf-8') #privatedata = base64.b64encode(privatedata # Encrypt the private data encrypted_privatedata = box.encrypt( privatedata, nonce, encoder=nacl.encoding.Base64Encoder).decode('utf-8') # Get private key #privatekey = "2a4ec0f5a1edeca10c344b9d3558fb4cb411be6006c086252f3042a92434cf29" # Make signing key signing_key = nacl.signing.SigningKey(privatekey, encoder=nacl.encoding.HexEncoder) # Signing message signatureMessage = bytes(encrypted_privatedata + loginserver_record + client_saved_at, encoding='utf-8') signedMessage = signing_key.sign(signatureMessage, encoder=nacl.encoding.HexEncoder) signature_str = signedMessage.signature.decode('utf-8') # create HTTP BASIC authorization header #credentials = ('%s:%s' % (username, password)) #b64_credentials = base64.b64encode(credentials.encode('ascii')) headers = { #'Authorization': 'Basic %s' % b64_credentials.decode('ascii'), #'X-signature': signature_str, 'X-username': username, 'X-apikey': api_key, 'Content-Type': 'application/json; charset=utf-8', } payload = { "privatedata": encrypted_privatedata, "loginserver_record": loginserver_record, "client_saved_at": client_saved_at, "signature": signature_str, } # 1. convert the payload into json representation, payload_str = json.dumps(payload) # 2. ensure the payload is in bytes, not a string json_payload = payload_str.encode('utf-8') # 3. pass the payload bytes into this function try: req = urllib.request.Request(url, data=json_payload, headers=headers) response = urllib.request.urlopen(req) data = response.read() # read the received bytes # load encoding if possible (default to utf-8) encoding = response.info().get_content_charset('utf-8') response.close() except urllib.error.HTTPError as error: print(error.read()) exit() JSON_object = json.loads(data.decode(encoding)) print(JSON_object)
def ping_EP(self, username, api_key, publickey, privatekey): url = "http://cs302.kiwi.land/api/ping" error = [] # Need to check with Hammond #self = "name" # Should be inputed from personal web api #username = "******" #password = "******" #publickey = "c852f14e5c063da1dbedb7fa0d6cc9e4d6f61e581140b4ae2f46cddd67556d48" # Utilise get private data endpoint #privatekey = "2a4ec0f5a1edeca10c344b9d3558fb4cb411be6006c086252f3042a92434cf29" # Creates a signing key from encoded private key try: signing_key = nacl.signing.SigningKey( privatekey, encoder=nacl.encoding.HexEncoder) except: error.append("invalid_privkey") try: # Creates a message to be signed (pubkey) signatureMessage = bytes(publickey, encoding='utf-8') # Signs message using signing key and encodes it signedMessage = signing_key.sign(signatureMessage, encoder=nacl.encoding.HexEncoder) # Decodes it into string signature_str = signedMessage.signature.decode('utf-8') except: publickey = "None" signature_str = "None" error.append("incorrect_pubkey_sign") # create HTTP BASIC authorization header #credentials = ('%s:%s' % (username, password)) #b64_credentials = base64.b64encode(credentials.encode('ascii')) headers = { #'Authorization': 'Basic %s' % b64_credentials.decode('ascii'), 'X-username': username, 'X-apikey': api_key, 'Content-Type': 'application/json; charset=utf-8', #'X-signature': signature_str, } payload = { "pubkey": publickey, "signature": signature_str, } # converts the payload into json representation, payload_str = json.dumps(payload) # ensures the payload is in bytes, not a string json_payload = payload_str.encode('utf-8') # passes the payload bytes into this function try: req = urllib.request.Request(url, data=json_payload, headers=headers) response = urllib.request.urlopen(req) data = response.read() # read the received bytes # load encoding if possible (default to utf-8) encoding = response.info().get_content_charset('utf-8') response.close() except urllib.error.HTTPError as error: exit() JSON_object = json.loads(data.decode(encoding)) print(JSON_object)
def tx_groupmessage(self, username, apikey, loginserver_record, privatekey, group_message, connections): url = "http://" + connections + "/api/rx_groupmessage" #url = "http://" + connections + "/api/groupinvite" print("XXXXXXXXXXXXXXXXX") print(connections) print("XXXXXXXXXXXXXXXXX") ## LOGIN RECORD DONE #MAKE GROUPKEY HASH #ENCRYPTED GROUPKEY # timestamp sender_created_at = str(time.time()) # target details key_password = "******" salt_password = bytes((key_password * 16).encode('utf-8')[:16]) key_password_b = bytes(key_password, encoding='utf-8') print(key_password_b) print(salt_password) ops = nacl.pwhash.argon2i.OPSLIMIT_SENSITIVE mems = nacl.pwhash.argon2i.MEMLIMIT_SENSITIVE #symmetric_key = nacl.pwhash.argon2i.kdf(32,key_password_b,salt_password,ops,mems, encoder=nacl.encoding.HexEncoder) symmetric_key = nacl.pwhash.argon2i.kdf(32, key_password_b, salt_password, ops, mems) print(key_password) print(key_password_b) print(salt_password) print(ops) print(mems) print(symmetric_key) box = nacl.secret.SecretBox(symmetric_key) nonce = nacl.utils.random(nacl.secret.SecretBox.NONCE_SIZE) #message = Api.get_privatedata(self,username,api_key) groupkey_hash = nacl.hash.sha256( symmetric_key, encoder=nacl.encoding.HexEncoder).decode('utf-8') print(groupkey_hash) # Create signing key from private key signing_key = nacl.signing.SigningKey(privatekey, encoder=nacl.encoding.HexEncoder) sender_created_at = str(time.time()) #publicKey,signaturePing_str,signature_str,signing_key,login = add_pubkey.PublicKey.add_key(self,username,password) # Sign message (login,targetkey,targetusernmae,encryptedmessage,sender_created_at) group_msg = bytes(group_message, encoding='utf-8') #privatedata = base64.b64encode(privatedata # Encrypt the private data encrypted_groupmessage = box.encrypt( group_msg, nonce, encoder=nacl.encoding.Base64Encoder).decode('utf-8') # Make signing key signing_key = nacl.signing.SigningKey(privatekey, encoder=nacl.encoding.HexEncoder) # Signing message signatureMessage = bytes(loginserver_record + encrypted_groupmessage + sender_created_at, encoding='utf-8') signedMessage = signing_key.sign(signatureMessage, encoder=nacl.encoding.HexEncoder) signature_str = signedMessage.signature.decode('utf-8') # create HTTP BASIC authorization header #credentials = ('%s:%s' % (username, password)) #b64_credentials = base64.b64encode(credentials.encode('ascii')) headers = { 'X-username': username, 'X-apikey': apikey, 'Content-Type': 'application/json; charset=utf-8', } payload = { "loginserver_record": loginserver_record, "groupkey_hash": groupkey_hash, "group_message": encrypted_groupmessage, "sender_created_at": sender_created_at, "signature": signature_str, } print("HHHHHHHHHHHHHHHHHHHHHHHHHHH") print(payload) print("HHHHHHHHHHHHHHHHHHHHHHHHHHH") # 1. convert the payload into json representation, payload_str = json.dumps(payload) # 2. ensure the payload is in bytes, not a string json_payload = payload_str.encode('utf-8') # 3. pass the payload bytes into this function try: req = urllib.request.Request(url, data=json_payload, headers=headers) response = urllib.request.urlopen(req) data = response.read() # read the received bytes # load encoding if possible (default to utf-8) encoding = response.info().get_content_charset('utf-8') response.close() except urllib.error.HTTPError as error: print(error.read()) exit() JSON_object = json.loads(data.decode(encoding)) print(JSON_object)