def open_new_private_chat():
continue_listening.clear()
time.sleep(0.05)
swear_protected = is_swear_protected.get()
packets = protocol.PacketMaker(CREATE_CHAT,
content=int_to_bytes(swear_protected))
for packet in packets:
server.send(packet)
packet = server.recv(PACKET_SIZE)
msg = b""
request, request_id, packet_amount, packet_number, flag = buffer_extractor(
packet[:HEADER_SIZE])
msg += packet[HEADER_SIZE:]
if packet_amount - packet_number > 1:
for _ in range(packet_amount - 1):
packet = server.recv(PACKET_SIZE)
msg += packet[HEADER_SIZE:]
server_response = decrypt(msg, key).decode("utf-8")
chat_name, chat_id = server_response.split("~~~")
user_values.group_key = get_random_bytes(32)
user_values.rsa_group_key = RSA.generate(2048)
user_values.pin_code = chat_id
user_values.chat_name = chat_name
user_values.is_safe_chat = bool(swear_protected)
user_values.on_chat_raise()
stop_listening.set()
chat_frame.tkraise()
def run(self):
while self.user_values.pin_code or self.user_values.chat_name:
if self.request_queue:
if self.request_queue[0][0] == GET_GROUP_KEY:
client_public_key = RSA.import_key(
self.request_queue[0][1].strip(b"\x00"))
content = AES_crypto.rsa_encrypt(
self.user_values.rsa_group_key.export_key(),
client_public_key)
content += b"end_private_key"
encrypted_group_key = int_to_bytes(
pow(bytes_to_int(self.user_values.group_key),
self.user_values.rsa_group_key.e,
self.user_values.rsa_group_key.n))
content += encrypted_group_key
packets = protocol.PacketMaker(SEND_GROUP_KEYS,
content=content)
for packet in packets:
self.server.send(packet)
del self.request_queue[0]
elif self.request_queue[0][0] in [SEND_FILE, SEND_IMG]:
file_content = protocol_digest.decrypt(
self.request_queue[0][1][1],
self.user_values.group_key)
file_name = protocol_digest.decrypt(
self.request_queue[0][1][0],
self.user_values.group_key)
with open(".\\files\\" + file_name.decode("utf-8"),
"wb") as file_:
file_.write(file_content)
del self.request_queue[0]
elif self.request_queue[0][0] == GET_GROUP_INFO:
top = tkinter.Toplevel()
self.top = top
top.title("group info")
top.minsize(250, 250)
group_users = decrypt(self.request_queue[0][1],
self.key).decode("utf-8")
content = f"{self.user_values.chat_name}\n"
if self.user_values.pin_code:
pyperclip.copy(self.user_values.pin_code)
content += f"\nGroup code - {self.user_values.pin_code}\n"
content += "\nusers\n"
content += group_users
about_label = tkinter.Label(top, text=content)
about_label.pack()
del self.request_queue[0]
else:
print("no requestes")
print("request - " +
bytes_to_requst[self.request_queue[0]])
time.sleep(0.05)
def encrypt(data, bytes_key):
header = get_random_bytes(8)
key = hashlib.sha256(int_to_bytes(bytes_key)).hexdigest().encode("utf-8")
nonce = get_random_bytes(16)
cipher = AES.new(key, AES.MODE_SIV, nonce=nonce)
cipher.update(header)
ciphertext, tag = cipher.encrypt_and_digest(data)
json_k = ['nonce', 'header', 'ciphertext', 'tag']
json_v = [
b64encode(x).decode('utf-8') for x in (nonce, header, ciphertext, tag)
]
result = json.dumps(dict(zip(json_k, json_v)))
return result
def on_submit(*args):
date_error.grid_forget()
email_error.grid_forget()
re_password_error.grid_forget()
username_error.grid_forget()
password_error.grid_forget()
server_error.grid_forget()
username = username_entry.get()
password = password_entry.get()
re_password = re_password_entry.get()
birthday = birthday_picker.get_date()
today = datetime.date.today()
email = email_entry.get()
send = True
if birthday > today:
send = False
date_error.grid(row=6, column=0, columnspan=2)
if not is_valid_email(email):
send = False
email_error.grid(row=8, column=0, columnspan=2)
if password != re_password:
send = False
re_password_error.grid(row=4, column=0, columnspan=2)
if len(username) < USERNAME_MIN_LEN or len(
username) > USERNAME_MAX_LEN:
send = False
username_error.grid(row=10, column=0, columnspan=2)
if len(password) < PASSWORD_MIN_LEN or len(
password) > PASSWORD_MAX_LEN:
send = False
password_error.grid(row=9, column=0, columnspan=2)
if send:
content = to_json(username.encode("utf-8"),
hash_password(password).encode("utf-8"),
email.encode("utf-8"), bytes([birthday.day]),
bytes([birthday.month]),
int_to_bytes(birthday.year))
packets = protocol.PacketMaker(REGISTER, key, content=content)
for packet in packets:
server.send(packet)
server_response = server.recv(PACKET_SIZE)
can_auth, reason = protocol_digest.can_auth_email(server_response)
if can_auth:
user_values.username = username
email_validate_frame.tkraise()
else:
server_error_var.set(error_msgs[reason])
server_error.grid(row=11, column=0, columnspan=2)
def join_chat(*args):
continue_listening.clear()
pin_error.grid_forget()
pin_code = pin_code_entry.get()
if not pin_code:
pin_error.grid(row=3, column=0, sticky="N")
else:
rsa_key = RSA.generate(2048)
content = {
"chat_name": value,
"pin_code": pin_code,
"rsa_key": rsa_key.export_key("PEM").decode("utf-8")
}
content = json.dumps(content).encode("utf-8")
packets = protocol.PacketMaker(JOIN_CHAT,
shared_secret=key,
content=content)
for packet in packets:
server.send(packet)
request, server_response = get_server_response(server)
if request == SEND_GROUP_KEYS:
group_private_key, group_dh_key = server_response.strip(
b'\x00').split(b"end_private_key")
user_values.rsa_group_key = AES_crypto.rsa_decrypt(
group_private_key, rsa_key)
group_private_key = RSA.import_key(
user_values.rsa_group_key)
group_dh_key = pow(bytes_to_int(group_dh_key),
group_private_key.d,
group_private_key.n)
user_values.group_key = int_to_bytes(group_dh_key)
top.withdraw()
pin_code_entry.delete(0, "end")
user_values.pin_code = pin_code
user_values.chat_name = value
stop_listening.set()
chat_frame.tkraise()
user_values.on_chat_raise()
elif request == CANT_JOIN_CHAT:
pin_error.grid(row=3, column=0, sticky="N")
def __init__(self, client, addr, shared_secret, db_obj, chat_id_cli,
chat_id_name, user_list, chat_name_chat_id: dict,
server_values, public_chat_key):
self.chat_name = None
self.server_values = server_values
self.password = ""
self.auth_for_change_password = False
self.client = client
self.addr = addr
self.key = hashlib.sha256(
int_to_bytes(shared_secret)).hexdigest().encode("utf-8")
self.db_obj = db_obj
self.queue_requests = []
self.user_list = user_list
self.current_details = []
self.chat_name_chat_id = chat_name_chat_id # {chat_name: chat_id e.g. chat_password}
self.public_chat_key = public_chat_key # {chat_name: key} only for public chats
self.chat_id_cli = chat_id_cli # {chatId: [client,client...], ...}
self.chat_id_name = chat_id_name # {chatId: [username,username...], ...}
self.chat_id = None
self.username = None
self.keep_running = True
self.id_check = None
threading.Thread.__init__(self)
chat_name = "public chat number " + str(server_values.public_chat_numbers)
server_values.public_chat_numbers += 1
chat_name_chat_id[chat_name] = None
chat_id_cli[chat_name] = []
chat_id_name[chat_name] = []
key = get_random_bytes(32)
public_chat_key[chat_name] = key
user_list = []
create_password_less_chat()
while True:
client, addr = server.accept()
DH_parameters = pyDH.DiffieHellman()
DH_pub_key = DH_parameters.gen_public_key()
s = int_to_bytes(DH_pub_key) # sing the key with the rsa private key
client.send(s)
client_public_key = bytes_to_int(
client.recv(8192)) # gets the other contributor to the DH key exchange
shared_secrete = DH_parameters.gen_shared_key(client_public_key)
thread = client_thread.RequestHandler(client, addr, shared_secrete,
database, chat_id_cli, chat_id_name,
user_list, chat_name_chat_id,
server_values, public_chat_key)
thread.start()
def check(Ip):
# pass the regular expression
# and the string in search() method
if re.search(regex, Ip):
return True
else:
return False
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
IP = input(
"please enter the server's IP (if the server is in this computer just hit enter): "
)
if not check(IP):
IP = "127.0.0.1"
server.connect((IP, global_values.PORT))
# key exchange
parameters = pyDH.DiffieHellman()
my_pub_key = parameters.gen_public_key()
# getting server keys
pub_DH_KEY = bytes_to_int(server.recv(8192))
server_pub_key = pub_DH_KEY
shared_secret = parameters.gen_shared_key(server_pub_key)
server.send(int_to_bytes(my_pub_key))
key = hashlib.sha256(int_to_bytes(shared_secret)).hexdigest().encode("utf-8")
gui_manager.main(server, key)
