def prepare_nested_message_for_trusted(self):
self.nonce = str(generate_random_key())
return prepare_inner_message(self.server_key,
self.nonce,
self.client_random_value,
self.client_client_id,
self.client_server_id)
def test_generated_key_is_not_none(self):
generated_key = generate_random_key()
self.assertIsNotNone(generated_key)
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_each_time_is_different(self):
first_key = generate_random_key()
second_key = generate_random_key()
self.assertNotEqual(first_key, second_key)
def generate_and_save_nonce(self):
self.nonce = str(generate_random_key())
def generate_and_save_random_value(self):
self.random_value = generate_random_key()
from Utils import generate_random_key
from TrustedServer import TrustedServer
from Server import Server
from Client import Client
from threading import active_count, enumerate, current_thread, Thread
import sys
id_for_alice = 'alice'
id_for_bob = 'bob'
key_for_alice = generate_random_key()
key_for_bob = generate_random_key()
trusted_server = TrustedServer(keys={id_for_alice: key_for_alice, id_for_bob: key_for_bob},max_connections=10)
trusted_server.start()
server = Server(server_id=id_for_bob, server_key=key_for_bob, max_connections=10, trusted_server=trusted_server)
server.start()
client = Client(client_id=id_for_alice, client_key=key_for_alice, server=server, server_id=id_for_bob)
client.start()
def clean():
client.join(120)
server.finish()
trusted_server.finish()
server.join(120)
trusted_server.join(120)
t = Thread(target=clean)
t.start()
t.join(360)
def generate_nested_response_to_server(self):
message = '{0}:{1}'.format(self.server_nonce, generate_random_key())
return self.encrypt_with_id(message, self.main_server_id)
