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
