def test_process_message_from_server_returns_error_when_random_message_does_not_match(self):
random_value_from_server = 312789
self.client.random_value = 41279412
self.client.nonce = 'one-nonce'
encrypted_message = encrypt('{0}:{1}'.format(self.client.nonce, 'session-key'), self.client_key)
response = self.client.process_message_from_server((random_value_from_server, encrypted_message))
self.assertEqual(response, self.client.error_signal)
def test_connect_from_server_if_encrypted_message_cannot_be_decrypted_to_two_elements_will_return_error_signal(
self):
client = Client(client_id=None, client_key=3197, server=None, server_id=None)
random_value_from_server = 11
encrypted_message = encrypt('{0}:{1}'.format('nonce', 'session-key'), self.client_key)
response = client.process_message_from_server((random_value_from_server, encrypted_message))
self.assertEqual(response, client.error_signal)
def test_connect_from_server_if_nested_message_matches_returns_own_ok_signal(self):
random_value_from_server = 12312
self.client.random_value = random_value_from_server
generated_nonce = 'generated-nonce'
self.client.nonce = generated_nonce
encrypted_message = encrypt('{0}:{1}'.format('%s' % generated_nonce, 'session-key'), self.client_key)
response = self.client.process_message_from_server((random_value_from_server, encrypted_message))
self.assertEqual(response, self.client.ok_signal)
def test_if_nonce_does_not_match_returns_error_signal(self):
server_key = 178
self.worker = ServerWorker(server_id='server_id_123', server_key=server_key, trusted_server=None)
nested = encrypt('{0}:{1}'.format('wrong_nonce', 'session_key'), server_key)
self.worker.nonce = 'server_nonce'
output = self.worker.create_response_for_client_from_message_from_trusted(
(self.random_value, 'encrypted_client_message', nested))
self.assertEqual(output, self.worker.error_signal)
def test_connect_from_trusted_server_unpacks_message_from_trusted(self):
server_key = 178
self.worker = ServerWorker(server_id='server_id_123', server_key=server_key, trusted_server=None)
nested = encrypt('{0}:{1}'.format('server_nonce', 'session_key'), server_key)
self.worker.nonce = 'server_nonce'
self.worker.create_response_for_client_from_message_from_trusted(
(self.random_value, 'encrypted_client_message', nested))
self.assertEqual(self.worker.session_key, 'session_key')
self.assertEqual(self.worker.trusted_nonce, 'server_nonce')
def test_connect_from_trusted_returns_one_element_shorter_tuple_on_correct_data(self):
server_key = 178
self.worker = ServerWorker(server_id='server_id_123', server_key=server_key, trusted_server=None)
nested = encrypt('{0}:{1}'.format('server_nonce', 'session_key'), server_key)
self.worker.nonce = 'server_nonce'
self.worker.client_random_value = self.random_value
output = self.worker.create_response_for_client_from_message_from_trusted(
(self.random_value, 'encrypted_client_message', nested))
self.assertEqual(isinstance(output, tuple), True)
self.assertEqual(len(output), 2)
def test_encrypted_message_can_be_encrypted(self):
original_message = 'original message'
key = generate_random_key()
encrypted_message = encrypt(original_message, key)
decrypted_message = decrypt(encrypted_message, key)
self.assertEquals(original_message, decrypted_message)
def test_encrypted_message_is_different_for_different_keys(self):
original_message = 'message text'
encrypted_first = encrypt(original_message, 123)
encrypted_second = encrypt(original_message, 321)
self.assertNotEqual(encrypted_first, encrypted_second)
def test_encrypted_message_is_different_than_original(self):
original_message = 'message text'
encrypted_message = encrypt(original_message, 123)
self.assertNotEqual(original_message, encrypted_message)
def test_produces_an_encrypted_message(self):
encrypted_message = encrypt('message text', 123)
self.assertIsNotNone(encrypted_message)
def prepare_inner_message(self, encryption_key, nonce, random_value, client_id, server_id):
return encrypt('{0}:{1}:{2}:{3}'.format(nonce, random_value, client_id, server_id), encryption_key)
def test_connect_from_server_unpacks_encrypted_message(self):
random_value_from_server = 41280
encrypted_message = encrypt('{0}:{1}'.format('nonce', 'session-key'), self.client_key)
self.client.process_message_from_server((random_value_from_server, encrypted_message))
self.assertEqual(self.client.trusted_nonce, 'nonce')
self.assertEqual(self.client.session_key, 'session-key')
def encrypt_with_id(self, message, id_key):
return encrypt(message, self.keys[id_key])
