def create_ticket(self, requested_user, requesting_user, shared_user_key): requesting_user_pub_key_str = self.get_user_pub_key(requesting_user).exportKey() requested_user_pub_key = self.get_user_pub_key(requested_user) requested_user_pub_key_str = requested_user_pub_key.exportKey() #requested_user_priv_key = self.get_user_priv_key(requested_user).exportKey() now = datetime.datetime.now() expiration_datetime = (now + datetime.timedelta(days=1)).strftime(fmt) # Create a signature iv = Random.new().read( 16 ) signature_msg = SHA256.new(str(iv)) signature = common.sign(signature_msg, server_priv_key) # Encrypt with public key of requested user encrypt_msg = common.encode_msg([iv, signature, shared_user_key, requesting_user, requesting_user_pub_key_str, expiration_datetime]) encrypted_keys, ciphertext = common.public_key_encrypt(encrypt_msg, requested_user_pub_key) return [encrypted_keys, ciphertext]
def login_to_server(self, password): try: self.sock.sendto("LOGIN", self.server_address) dos_cookie = self.sock.recv(1024) # compute diffie hellman value and encrypt with password hash iv1 = Random.new().read( 16 ) dh = diffie_hellman.DiffieHellman() dh_key = str(dh.genPublicKey()) dh_val = common.aes_encrypt(dh_key, password, iv1) # Sign the message signature_msg = SHA256.new(str(self.username) + str(iv1)) signature = common.sign(signature_msg, self.priv_key) # Encrypt plaintext using server public key encrypt_msg = common.encode_msg([self.username, iv1, signature, dh_val]) encrypted_keys, ciphertext = common.public_key_encrypt(encrypt_msg, server_pub_key) send_msg = "LOGIN," + dos_cookie + "," + encrypted_keys + "," + ciphertext self.sock.settimeout(3) data = common.send_and_receive(send_msg, self.server_address, self.sock, 8192, 2) if len(data) != 2 : return None rec_msg = common.public_key_decrypt(data[0], data[1], self.priv_key) decoded_msg = common.decode_msg(rec_msg) iv2 = decoded_msg[0] signature = decoded_msg[1] encrypted_serv_dh_val = decoded_msg[2] nonce1 = decoded_msg[3] # Verify the signature h = SHA256.new(str(iv2)) verifier = PKCS1_v1_5.new(server_pub_key) if verifier.verify(h, str(signature)): # Decrypt server dh val server_dh_val = long(common.aes_decrypt(encrypted_serv_dh_val, password, iv2)) # Generate shared key dh.genKey(server_dh_val) shared_key = dh.getKey() # Encrypt nonce1 with our shared key nonce2 = Random.new().read( 32 ) iv3 = Random.new().read( 16 ) encrypted_n1 = common.aes_encrypt(nonce1, shared_key, iv3) # Encrypt mesage with pub key of the server encrypt_msg = common.encode_msg([iv3, encrypted_n1, nonce2]) encrypted_keys, ciphertext = common.public_key_encrypt(encrypt_msg, server_pub_key) # Send message send_msg = encrypted_keys + ',' + ciphertext data = common.send_and_receive(send_msg, self.server_address, self.sock, 4096, 2) if len(data) != 2 : return None rec_msg = common.public_key_decrypt(data[0], data[1], self.priv_key) decoded_msg = common.decode_msg(rec_msg) iv4 = decoded_msg[0] encrypted_serv_nonce2 = decoded_msg[1] # Verify user nonce1 value matches the value we sent serv_nonce2 = common.aes_decrypt(encrypted_serv_nonce2, shared_key, iv4) if nonce2 == serv_nonce2: self.shared_key = shared_key self.shared_iv = iv4 print "Successfully logged in!" else: self.shared_key = None print "Login unsuccessful" sys.exit() else: print "Server could not be verified" sys.exit() except socket.timeout as e: print "Server is not responding" sys.exit()
def handle_request(self, data, addr): data = data.split(',', 4) if data[0] == 'AUTH': if len(data) != 3 : return # Decrypt message with our private key and break out message msg = common.public_key_decrypt(data[1], data[2], self.priv_key) decoded_msg = common.decode_msg(msg) connected_uname = decoded_msg[0] encr_ticket_key = decoded_msg[1] encr_ticket_ciphert = decoded_msg[2] iv2 = decoded_msg[3] signature = decoded_msg[4] encrypted_nonce = decoded_msg[5] # Decrypt ticket ticket = common.public_key_decrypt(encr_ticket_key, encr_ticket_ciphert, self.priv_key) ticket = common.decode_msg(ticket) if len(ticket) != 6 : return iv = ticket[0] serv_signature = ticket[1] shared_user_key = ticket[2] requesting_user = ticket[3] requesting_user_pub_key_str = ticket[4] expiration_datetime_str = ticket[5] # Verify ticket is not expired and username from ticket matches requesting username expiration_timestamp = '' try: expiration_timestamp = datetime.datetime.strptime(expiration_datetime_str, fmt) except ValueError: return # Check offset!!! if common.is_timestamp_current(expiration_timestamp + time_offset) != True : return if requesting_user != connected_uname: return # Verify server's signature h = SHA256.new(str(iv)) verifier = PKCS1_v1_5.new(server_pub_key) if verifier.verify(h, str(serv_signature)): # Now verify signature of initiating user requesting_user_pub_key = RSA.importKey(requesting_user_pub_key_str) h = SHA256.new(str(iv2)) verifier = PKCS1_v1_5.new(requesting_user_pub_key) if verifier.verify(h, str(signature)): # Create signature iv3 = Random.new().read( 16 ) signature_msg = SHA256.new(str(iv3)) signature = common.sign(signature_msg, self.priv_key) # Add user to authenticated users self.authenticated_users[requesting_user]['shared_key'] = shared_user_key self.authenticated_users[requesting_user]['shared_iv'] = iv3 self.authenticated_users[requesting_user]['sequence_n'] = int(iv3.encode('hex'), 16) self.authenticated_users[requesting_user]['address'] = addr # Now decrypt nonce, and encrypt back with kab + 1 nonce = common.aes_decrypt(encrypted_nonce, shared_user_key, iv2) incr_shared_key = SHA256.new(str( common.increment_key(shared_user_key) )).digest() our_encrypted_nonce = common.aes_encrypt(nonce, incr_shared_key, iv3) # Send final message back to initiating user, encrypted with their pub key encrypt_msg = common.encode_msg([iv3, signature, our_encrypted_nonce]) encrypted_keys, ciphertext = common.public_key_encrypt(encrypt_msg, requesting_user_pub_key) send_msg = encrypted_keys + "," + ciphertext self.sock.sendto(send_msg, addr) else: return return if data[0] == 'MESSAGE': if len(data) != 4 : return decoded_msg = common.decode_msg(data[1:]) if len(decoded_msg) != 3 : return connected_uname = decoded_msg[0] user_hmac_key = decoded_msg[1] encrypted_msg = decoded_msg[2] # Retrieve session info for user if self.authenticated_users.get(connected_uname) == None : return shared_key = self.authenticated_users[connected_uname]['shared_key'] shared_iv = self.authenticated_users[connected_uname]['shared_iv'] user_addr = self.authenticated_users[connected_uname]['address'] self.authenticated_users[connected_uname]['sequence_n'] += 1 sequence_n = self.authenticated_users[connected_uname]['sequence_n'] # Decrypt message msg = common.aes_decrypt(encrypted_msg, shared_key, shared_iv).split(',',1) if len(msg) != 2 : return user_seq_n = msg[0] user_msg = msg[1] # Verify sequence number matches our sequence number if user_seq_n != str(sequence_n) : return # Verify hmac key hmac_key = hmac.new(shared_key, str(user_seq_n) + ',' + user_msg).digest() if user_hmac_key != hmac_key : return print connected_uname + ': ' + user_msg return else: return
def get_ticket_from_server(self, user): try: self.sock.sendto("TICKET", self.server_address) dos_cookie = self.sock.recv(1024) # Request to talk to given user, sending current timestamp # Please not sure if adding the offset here is legal, please check!!! timestamp = (datetime.datetime.now() + time_offset).strftime(fmt) msg = user + "," + timestamp encrypted_msg = common.aes_encrypt(msg, self.shared_key, self.shared_iv) encoded_encrypted_msg = common.encode_msg([encrypted_msg]) # Send request to server send_msg = "TICKET," + dos_cookie + ',' + self.username + ',' + encoded_encrypted_msg self.sock.settimeout(5) data = common.send_and_receive(send_msg, self.server_address, self.sock, 16384, 1) if len(data) != 1 : return # Decrypt the message with shared key + 1 msg = base64.b64decode( data[0] ) incr_shared_key = SHA256.new(str( common.increment_key(self.shared_key) )).digest() msg = common.aes_decrypt(msg, incr_shared_key, self.shared_iv).split(',', 8) if len(msg) != 8 : return serv_timestamp = msg[0] serv_user_to_talk_to = msg[1] shared_key_ab = msg[2] encr_ticket_key = msg[3] encr_ticket_ciphert = msg[4] user_pk = msg[5] user_ip = msg[6] user_port = msg[7] # Not sure what to do with timestamp offset here!!! if serv_timestamp == timestamp and serv_user_to_talk_to == user: nonce = Random.new().read( 32 ) iv2 = Random.new().read( 16 ) signature_msg = SHA256.new(str(iv2)) signature = common.sign(signature_msg, self.priv_key) # Encrypt nonce with our shared key encrypted_nonce = common.aes_encrypt(nonce, shared_key_ab, iv2) # Encrypt mesage with pub key of the user user_pk = RSA.importKey(user_pk) encrypt_msg = common.encode_msg([self.username, encr_ticket_key, encr_ticket_ciphert, iv2, signature, encrypted_nonce]) encrypted_keys, ciphertext = common.public_key_encrypt(encrypt_msg, user_pk) user_address = (user_ip,int(user_port)) send_msg = "AUTH" + ',' + encrypted_keys + ',' + ciphertext data = common.send_and_receive(send_msg, user_address, self.sock, 2048, 2) if len(data) != 2 : return # Decrypt message with our private key and break out message msg = common.public_key_decrypt(data[0], data[1], self.priv_key) decoded_msg = common.decode_msg(msg) iv3 = decoded_msg[0] signature = decoded_msg[1] encrypted_nonce = decoded_msg[2] # Decrypt nonce with shared key + 1 incr_shared_key = SHA256.new(str( common.increment_key(shared_key_ab) )).digest() connected_nonce = common.aes_decrypt(encrypted_nonce, incr_shared_key, iv3) # Verify nonce is correct if connected_nonce == nonce: self.authenticated_users[serv_user_to_talk_to]['shared_key'] = shared_key_ab self.authenticated_users[serv_user_to_talk_to]['shared_iv'] = iv3 self.authenticated_users[serv_user_to_talk_to]['sequence_n'] = int(iv3.encode('hex'), 16) self.authenticated_users[serv_user_to_talk_to]['address'] = user_address return except socket.timeout as e: print "Server is not responding" sys.exit()
def login_protocol(self, data): if len(data) != 2 : return # Decrypt message with our private key and break out message msg = common.public_key_decrypt(data[0], data[1], server_priv_key) decoded_msg = common.decode_msg(msg) uname = decoded_msg[0] iv1 = decoded_msg[1] signature = decoded_msg[2] encrypted_dh_val = decoded_msg[3] if connected_clients.get(uname) is not None: return # Lookup public key of the user user_pub_key = self.get_user_pub_key(uname) # Verify the user's signature h = SHA256.new(str(uname) + str(iv1)) verifier = PKCS1_v1_5.new(user_pub_key) if verifier.verify(h, str(signature)): print "Signature Verified!" pass_hash = base64.b64decode( self.get_password_hash(uname) ) # Decrypt DH val diff_hell_val = long(common.aes_decrypt(encrypted_dh_val, pass_hash, iv1)) # Create random values nonce1 = Random.new().read( 32 ) iv2 = Random.new().read( 16 ) # Compute our diffie hellman value and encrypt with password hash dh = diffie_hellman.DiffieHellman() serv_dh_key = str(dh.genPublicKey()) serv_dh = common.aes_encrypt(serv_dh_key, pass_hash, iv2) # Establish shared key dh.genKey(diff_hell_val) shared_key = dh.getKey() # Sign the message signature_msg = SHA256.new(str(iv2)) signature = common.sign(signature_msg, server_priv_key ) # Encrypt with public key of user encrypt_msg = common.encode_msg([iv2, signature, serv_dh, nonce1]) encrypted_server_keys, ciphertext = common.public_key_encrypt(encrypt_msg, user_pub_key) # Send message send_msg = encrypted_server_keys + "," + ciphertext data = common.send_and_receive(send_msg, self.client_address, self.socket, 1024, 2) if len(data) != 2 : return rec_msg = common.public_key_decrypt(data[0], data[1], server_priv_key) decoded_msg = common.decode_msg(rec_msg) iv3 = decoded_msg[0] encrypted_user_nonce1 = decoded_msg[1] nonce2 = decoded_msg[2] # Verify user encrypted nonce1 with the shared key user_nonce1 = common.aes_decrypt(encrypted_user_nonce1, shared_key, iv3) if nonce1 == user_nonce1: print "Login Sucess for user: "******"Login Failure for user: "******"The signature is not authentic" return