def get_messages(partner):
# Check for new info
check_db()
all_messages = get_mail_db(current_user.name, partner)
message_js = []
groupnames = names_n_group(current_user.name)[1]
members = []
partner_id = ""
if partner in groupnames:
members = get_members(partner)
partner_id = get_id(partner)
for mess in all_messages:
direction = "sent" if mess.sender == current_user.name else "replies"
sender_id = get_id(mess.sender, string=True)
message = {"sender": sender_id,
"recipient": mess.recipient,
"content": mess.content,
"time": mess.time.time().strftime("%H:%M:%S"),
"direction": direction,
"imgURL": url_for('tree_bp.static',
filename='/imag/' + mess.sender + '.png')}
message_js += [message]
return {'messages': message_js, 'members': members, 'id': partner_id}
def sendmessage():
data = request.json # Get the data (sender, recipient, message)
check_db()
names, groupnames = names_n_group(current_user.name)
sender, recipient = data['sender'], secure_filename(data['recipient'])
data['destination'] = recipient
# We make a copy for ourself
new_message = Message(owner=sender,
sender=sender,
content=data['content'],
time=datetime.now(),
recipient=recipient)
add_db(new_message, 'Message')
# Key is different if it's a group message
# or 2-party message
if recipient in groupnames:
key = get_key_aes(sender, recipient)
elif recipient in names:
key, dico = P2Psecret(sender, recipient, 'sender')
data['info_otk'] = repr(dico)
else:
raise Exception("Problem : the recipient name : {}".format(recipient))
# Ciphertext
encrypted_data = encrypt_aes(data['content'], str(key))
data['content'] = repr(encrypted_data)
headers = {'x-access-tokens': get_token(current_user.name)}
requests.post(server_address + "/mailbox", json=data, headers=headers)
return jsonify(answer="Génial")
def new_conversation():
check_db()
lastmails = get_last_messages(current_user.name)
partners = list(lastmails.keys())
names, groupnames = names_n_group(current_user.name)
names.remove(current_user.name)
print('names = ', names)
other_partners = [name for name in names if name not in partners]
partners_id = [Party.query.filter_by(target=partner)
.first().user_id for partner in other_partners]
others = dict(zip(partners_id, other_partners))
return render_template('new_conversation.html',
others=others, partners_id=partners_id)
def settings(partner):
members_id, not_members_id = {}, {}
names, groupnames = names_n_group(current_user.name)
check_db()
if partner in groupnames:
members = get_members(partner)
not_members = [name for name in names if name not in members]
for not_member in not_members:
not_members_id[not_member] = get_id(not_member, string=True)
for member in members:
members_id[member] = get_id(member, string=True)
return render_template('settings.html',
partner=partner,
notmembersid=not_members_id,
members=members,
notmembers=not_members,
membersid=members_id)
def remove_member():
# It is important to be up to date before removing a member
# in order to be sure we get the correct keys
check_db()
data = request.json
# Intels for the already existing members, so that they
# get the tree into the server, and adapt theirs
groupname = data['groupname']
members = get_members(groupname)
headers = {'x-access-tokens': get_token(current_user.name)}
group = get_group(groupname)
for member in members:
dico = {'groupname': groupname, 'member': data['member']}
intel = {
'sender': current_user.name,
'content': json.dumps(dico),
'recipient': member,
'type': 'remove_member',
'groupname': groupname
}
requests.post(server_address + "/intels/" + member,
json=intel,
headers=headers)
members = get_members(groupname)
if data['member'] in members:
members.remove(data['member'])
group.members = ','.join(members)
db.session.commit()
return "User removed !", 200
def messenger():
check_db()
groupnames = names_n_group(current_user.name)[1]
lastmails = get_last_messages(current_user.name)
print('lastmails = ', lastmails)
my_id = 'user_' + str(get_id(current_user.name))
message_js = []
for partner in lastmails:
mail = lastmails[partner]
partner_id = get_id(partner, string=True)
try:
if mail.sender == current_user.name:
direction = "sent"
else:
direction = "received"
message = {"sender": mail.sender,
"recipient": mail.recipient,
"content": mail.content,
"time": mail.time.time().strftime("%H:%M:%S"),
"direction": direction,
"imgURL": url_for('tree_bp.static',
filename='imag/' + partner_id
+ '.png'),
"partner": partner}
partner_id = get_id(partner, string=True)
message_js += [message]
except Exception:
raise ValueError("Error")
return render_template('messenger.html', lastmails=message_js,
current=my_id, groupnames=groupnames)
def add_member():
check_db()
data = request.json
groupname, new_member = data['groupname'], data['newmember']
# Get the tree, add a node and get the node
tree = read_tree(groupname)
add_node(tree, new_member)
newnode = get_node(tree, new_member)
# We take a random OTK private key, with the corresponding index
private_otk = get_otk(current_user.name)
ind_private_otk = private_otk.serverID
# Creation of the shared key (leaf key) and we put it in the leaf attribute
headers = {'x-access-tokens': get_token(current_user.name)}
public_otk = requests.get(server_address + "/getOTK/" + new_member + "/" +
str(-1),
headers=headers).json()
otkeys = {
'privateOTK': str(ind_private_otk),
'publicOTK': public_otk['publOTK']
}
compute_leaf_keys(newnode, current_user.name, newnode.value, otkeys,
'initiator')
# Update the key pairs
fill_nodes(tree, newnode.path)
members = get_members(groupname)
pks = get_pk_path(tree, newnode)
publicKeys = get_all_pk(tree)
dico = {'groupname': groupname, 'publicKeys': pks, 'newmember': new_member}
# Intels for the already existing members
headers = {'x-access-tokens': get_token(current_user.name)}
for member in members:
intel = {
'sender': current_user.name,
'content': repr(dico),
'recipient': member,
'type': data['type'],
'groupname': groupname
}
requests.post(server_address + "/intels/" + member,
json=intel,
headers=headers)
# We make a copy not to erase our tree
central_tree = deepcopy(tree)
clear_leaves(central_tree, get_all_value(central_tree))
# Intel for the new member only,
# so that they create its tree
dico = {
'info_otk': {
'creatorOTK': SIKE_compute_pk(private_otk.privateOTK, 'initiator'),
'partnerOTK': public_otk['indexOTK']
},
'groupname': groupname,
'members': ','.join(get_value_leaves(tree)),
'publicKeys': repr(publicKeys)
}
intel = {
'sender': current_user.name,
'content': repr(dico),
'recipient': new_member,
'type': 'creation',
'groupname': groupname
}
headers = {'x-access-tokens': get_token(current_user.name)}
requests.post(server_address + "/intels/" + new_member,
json=intel,
headers=headers)
# Add the new member to the list of members
group = get_group(groupname)
group.members = group.members + "," + new_member
db.session.commit()
return "Done", 200