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)
