def setUp(self): self.keydir = "tests/data/keys" self.alt = "tests/data/altkeys" self.mal = { 'type': 'pub', 'trust': 'u', 'length': '2048', 'algo': '1', 'keyid': '190DB52959AC3560', 'date': '1523719389', 'expires': '1838174400', 'dummy': '', 'ownertrust': 'u', 'sig': '', 'uids': ['alice (in wonderland) <*****@*****.**>'], 'sigs': [], 'subkeys': [[ 'A58D508E0BE72B6D', 'e', 'AD7C46A3E9C993F2F174120CA58D508E0BE72B6D' ]], 'fingerprint': 'AA74BBFE8A31ADBC0E9ED26B190DB52959AC3560' } self.k = keyring.KeyRing(self.keydir)
def setUp(self): self.keydir = "tests/data/keys" self.key_fingerprint = 'C227D0EC9289CB9D1F06A9A85933EB9BDA9B62BB' self.key_ring = keyring.KeyRing(self.keydir) self.key_finder = keyfinder.KeyFinder(self.key_ring) self.message = "Hello world." self.e = encrypter.Encrypter(self.keydir)
def test_result_import_method_not_valid(self): pub_key = 'xxx666' import tempfile with tempfile.TemporaryDirectory() as temp_home_dir: k = keyring.KeyRing(temp_home_dir) result = k.import_key(pub_key) self.assertTrue(result.count == 0)
def test_result_import_method_valid(self): pub_key = self.k.export_key(self.mal['fingerprint']) import tempfile with tempfile.TemporaryDirectory() as temp_home_dir: k = keyring.KeyRing(temp_home_dir) result = k.import_key(pub_key) self.assertTrue(result.count > 0)
def is_key_valid(self, key_dir): key_ring_agent = keyring.KeyRing(key_dir) result = key_ring_agent.import_key(self.pub_key) if result.count == 0: self.error = result.stderr self.valid = False return False else: self.key_dict = key_ring_agent.get_raw_key_list()[0]
def __init__(self, gpg_pub_key): self.target_pubkey = gpg_pub_key self.temp_dir = self.create_temp_dir() self.temp_dir_name = self.temp_dir.name self.key_ring = keyring.KeyRing(self.temp_dir_name) self.result = None self.valid = None self.key_dict = None self.validate()
def setUp(self): self.message = "Hello world" self.key_dir = 'tests/data/keys' self.key_ring = keyring.KeyRing(self.key_dir) self.encrypt_agent = encrypter.Encrypter(self.key_dir) self.encrypted_msg = str( self.encrypt_agent.execute(self.message, '55A45A99FE45E540')) self.mock_valid_payload = dict(ciphertext=self.encrypted_msg, request_nonce='req_nonce_string', response_nonce='resp_nonce_string') self.mock_database_table = MagicMock() self.passphrase = 'passphrase' self.x = contactresponsevalidator.ContactResponseValidator( self.mock_valid_payload, self.key_dir, self.mock_database_table, self.passphrase)
def __init__(self, message_server_host_address, key_home_dir, request_data_record, passphrase): self.request_data_record = request_data_record self.message_server_address = message_server_host_address self.message_server_port = settings.port_message_server self.key_home_dir = key_home_dir self.passphrase = passphrase self.gpgsigner = signer.Signer(self.key_home_dir) self.temp_dir = self.create_temp_dir() self.temp_dir_name = self.temp_dir.name self.key_ring = keyring.KeyRing(self.temp_dir_name) self.encrypt_agent = encrypter.Encrypter(self.temp_dir_name) self.target_fingerprint = None self.request_nonce = None self.response_nonce = None self.data_dict = None self.encoded_data_dict = None self.sig = None self.error = None self.valid = None self.sig_dict = None self.encoded_sig_dict = None
def setUp(self): self.target = ['alice, <*****@*****.**>, 190DB52959AC3560'] self.home = 'tests/data/keys' self.keyring = keyring.KeyRing(self.home) self.formatter = keylistformatter.KeyListFormatter() self.x = hostkeyobservable.HostKeyObservable(self.keyring)
class TestGPGControllerHandleQueuePayloadMethodAndRelated( gpgcontrollersetupclass.TestGPGControllerSetupClass): bad_result_mock = NewKeyResultMockBad() good_result_mock = NewKeyResultMockGood() new_key_payload_bad = dict(desc=constants.command_list.Create_New_Key, result=bad_result_mock) new_key_payload_good = dict(desc=constants.command_list.Create_New_Key, result=good_result_mock) home = 'tests/data/keys' althome = 'tests/data/altkeys' key_ring = keyring.KeyRing(home) key_dir = 'tests/data/keys' def test_handle_queue_payload_method_attribute(self): name = 'handle_queue_payload' check = hasattr(self.x, name) self.assertTrue(check) def test_handle_create_new_key_result_method_attribute(self): name = 'handle_create_new_key_result' check = hasattr(self.x, name) self.assertTrue(check) def test_handle_queue_payload_create_new_key_calls_create_new_key_callback( self): sub = self.x.handle_create_new_key_result = MagicMock() self.x.handle_queue_payload(self.new_key_payload_bad) sub.assert_called_with(self.new_key_payload_bad) def test_handle_create_new_key_result_sets_creating_new_key_attribute( self): self.x.creating_new_key = True self.x.handle_create_new_key_result(self.new_key_payload_bad) self.assertFalse(self.x.creating_new_key) def test_handle_create_new_key_result_prints_and_appends_on_bad_result( self): sub1 = self.x.print_notification = MagicMock() sub2 = self.x.append_notification = MagicMock() self.x.handle_create_new_key_result(self.new_key_payload_bad) self.assertTrue(sub1.called) sub2.assert_called_with(self.bad_result_mock.stderr) def test_handle_create_new_key_result_prints_and_appends_on_good_result( self): sub1 = self.x.print_notification = MagicMock() sub2 = self.x.append_notification = MagicMock() self.x.handle_create_new_key_result(self.new_key_payload_good) self.assertTrue(sub1.called) sub2.assert_called_with(self.good_result_mock.stderr) def test_handle_create_new_key_result_sets_key_list_on_good_result(self): sub1 = self.x.key_list_observable = MagicMock() sub = self.x.gpg_data_context.set_key_list = MagicMock() self.x.handle_create_new_key_result(self.new_key_payload_good) self.assertTrue(sub.called) def test_handle_create_new_key_result_sets_host_key_on_good_result(self): sub1 = self.x.key_list_observable = MagicMock() sub = self.x.gpg_data_context.set_key_list = MagicMock() target = self.x.gpg_data_context.set_host_key = MagicMock() self.x.handle_create_new_key_result(self.new_key_payload_good) self.assertTrue(target.called)
class TestClassBasics(unittest.TestCase): """ Set everything up as class attributes, then copy the class instance in setup, this is much faster to run. """ message = "Hello world" key_dir = 'tests/data/keys' key_ring = keyring.KeyRing(key_dir) encrypt_agent = encrypter.Encrypter(key_dir) encrypted_msg = str(encrypt_agent.execute(message, '190DB52959AC3560')) mock_valid_payload = dict(ciphertext=encrypted_msg, nonce='nonce_string') gpg_signer = signer.Signer(key_dir) valid_sig = gpg_signer.execute(message, None, 'passphrase', detach=True) valid_sig_dict = dict(sig=str(valid_sig), data=message) passphrase = 'passphrase' valid_obj = messagevalidator.MessageValidator(mock_valid_payload, key_dir, passphrase) def setUp(self): self.x = copy.deepcopy(self.valid_obj) def test_instance(self): self.assertIsInstance(self.x, messagevalidator.MessageValidator) def test_target_payload_attribute_set(self): self.assertEqual(self.x.message_payload, self.mock_valid_payload) def test_key_dir_attribute_set(self): self.assertEqual(self.x.key_dir, self.key_dir) def test_passphrase_attr_set(self): self.assertEqual(self.x.passphrase, self.passphrase) def test_error_attribute_set_none(self): self.assertIsNone(self.x.error) def test_valid_attribute_set_none(self): self.assertIsNone(self.x.valid) def test_data_dict_attribute_set_none(self): self.assertIsNone(self.x.data_dict) def test_verify_result_attribute_set_none(self): self.assertIsNone(self.x.verify_result) def test_gpg_verifier_attribute_is_verifier_home_set(self): self.assertIsInstance(self.x.gpg_verifier, detachedverifier.DetachedVerifier) self.assertEqual(self.x.key_dir, self.x.gpg_verifier.home) def test_set_error_method_sets_error_and_valid(self): msg = 'Error Message' self.x.set_error(msg) self.assertEqual(self.x.error, msg) self.assertIs(self.x.valid, False) def test_check_payload_keys_method_checks_payload_keys_sets_attributes( self): result = self.x.check_payload_keys(self.x.message_payload) self.assertIs(result, True) def test_check_payload_keys_method_returns_false_on_invalid_dict(self): bad_dict = dict() result = self.x.check_payload_keys(bad_dict) self.assertIs(result, False) def test_check_payload_keys_method_returns_false_on_bad_data(self): bad_data = 'xxx' result = self.x.check_payload_keys(bad_data) self.assertIs(result, False) @patch('net.message.messagevalidator.decrypter.Decrypter') def test_decrypt_ciphertext_method_calls_decrypter_with_key_dir( self, target): mock_ciphertext = 'xxx' self.x.decrypt_ciphertext(mock_ciphertext) target.assert_called_with(self.x.key_dir) @patch.object(messagevalidator.decrypter.Decrypter, 'execute') def test_decrypt_ciphertext_calls_execute_with_args(self, target): passphrase = 'passphrase' self.x.decrypt_ciphertext(self.encrypted_msg) target.assert_called_with(self.encrypted_msg, self.passphrase) @patch.object(messagevalidator.decrypter.Decrypter, 'execute') def test_decrypt_ciphertext_sets_error_returns_false_if_bad_response( self, sub): class MockBadResult: ok = False status = 'status_message' sub.return_value = MockBadResult() passphrase = 'passphrase' target = self.x.set_error = MagicMock() result = self.x.decrypt_ciphertext(self.encrypted_msg) target.assert_called_with(MockBadResult.status) self.assertIs(result, False) @patch.object(messagevalidator.decrypter.Decrypter, 'execute') def test_decrypt_ciphertext_returns_plaintext_on_valid_result(self, sub): class MockBadResult: ok = True status = 'status_message' sub.return_value = MockBadResult() passphrase = 'passphrase' result = self.x.decrypt_ciphertext(self.encrypted_msg) self.assertEqual(result, str(sub.return_value)) def test_decode_json_decodes_returns_valid_json(self): msg_dict = dict(msg='hello world') encoded = json.dumps(msg_dict) result = self.x.decode_json_string(encoded) self.assertEqual(result, msg_dict) def test_decode_json_returns_false_on_invalid(self): msg_dict = dict(msg='hello world') result = self.x.decode_json_string(msg_dict) self.assertIs(result, False) def test_check_sig_dict_keys_returns_true_on_valid(self): sig_dict = dict(sig='sig', data='data') result = self.x.check_sig_dict_keys(sig_dict) self.assertIs(result, True) def test_check_sig_dict_keys_returns_false_on_invalid(self): sig_dict = dict(xxx='sig', data='data') result = self.x.check_sig_dict_keys(sig_dict) self.assertIs(result, False) def test_check_sig_dict_keys_returns_false_on_bad_input(self): bad = 123 result = self.x.check_sig_dict_keys(bad) self.assertIs(result, False) def test_verify_sig_dict_verifies_valid_sig_dict_returns_true(self): result = self.x.verify_sig_dict(self.valid_sig_dict) self.assertIs(result, True) def test_verify_sig_dict_sets_error_returns_false_on_invalid(self): sig_dict = dict(sig='sig', data='data') target = self.x.set_error = MagicMock() result = self.x.verify_sig_dict(sig_dict) self.assertIs(result, False) self.assertTrue(target.called) def test_verify_sig_dict_sets_verify_result_attribute(self): result = self.x.verify_sig_dict(self.valid_sig_dict) self.assertIsNotNone(self.x.verify_result) def test_check_data_dict_keys_returns_true_on_valid(self): data_dict = dict(address_host='host-string', address_port='port_string', nonce='nonce_string', message='message_string') result = self.x.check_data_dict_keys(data_dict) self.assertTrue(result) def test_check_data_dict_keys_returns_false_on_not_valid(self): data_dict = dict(xxxx='host-string', address_port='port_string', nonce='nonce_string', message='message_string') result = self.x.check_data_dict_keys(data_dict) self.assertIs(result, False) def test_validate_calls_check_payload_keys_returns_false_if_false_and_sets_error( self): target_1 = self.x.check_payload_keys = MagicMock(return_value=False) target_2 = self.x.set_error = MagicMock() result = self.x.validate() target_1.assert_called_with(self.x.message_payload) self.assertTrue(target_2.called) self.assertIs(result, False) def test_validate_calls_decrypt_ciphertext_returns_false_if_false(self): check_payload_key_mock = self.x.check_payload_keys = MagicMock( return_value=True) set_error_mock = self.x.set_error = MagicMock() decrypt_method_mock = self.x.decrypt_ciphertext = MagicMock( return_value=False) result = self.x.validate() decrypt_method_mock.assert_called_with( self.x.message_payload['ciphertext']) self.assertIs(result, False) def test_validate_calls_json_decode_if_decrypt_not_false(self): check_payload_key_mock = self.x.check_payload_keys = MagicMock( return_value=True) set_error_mock = self.x.set_error = MagicMock() decrypt_method_mock = self.x.decrypt_ciphertext = MagicMock( return_value='xxxxx') json_decode_mock = self.x.decode_json_string = MagicMock() result = self.x.validate() json_decode_mock.assert_any_call(decrypt_method_mock.return_value) def test_validate_sets_error_returns_false_if_json_decode_of_decrypt_is_false( self): check_payload_key_mock = self.x.check_payload_keys = MagicMock( return_value=True) set_error_mock = self.x.set_error = MagicMock() decrypt_method_mock = self.x.decrypt_ciphertext = MagicMock( return_value='xxxxx') json_decode_mock = self.x.decode_json_string = MagicMock( return_value=False) result = self.x.validate() self.assertTrue(set_error_mock.called) self.assertIs(result, False) def test_validate_calls_check_sig_dict_keys_if_json_decode_of_decrypt_not_false( self): check_payload_key_mock = self.x.check_payload_keys = MagicMock( return_value=True) set_error_mock = self.x.set_error = MagicMock() decrypt_method_mock = self.x.decrypt_ciphertext = MagicMock( return_value='xxxxx') json_decode_mock = self.x.decode_json_string = MagicMock( return_value=self.valid_sig_dict) verify_sig_mock = self.x.verify_sig_dict = MagicMock() check_sig_dict_keys_mock = self.x.check_sig_dict_keys = MagicMock() result = self.x.validate() self.assertTrue(check_sig_dict_keys_mock.called) def test_validate_sets_error_returns_false_if_sig_dict_key_check_returns_false( self): check_payload_key_mock = self.x.check_payload_keys = MagicMock( return_value=True) set_error_mock = self.x.set_error = MagicMock() decrypt_method_mock = self.x.decrypt_ciphertext = MagicMock( return_value='xxxxx') json_decode_mock = self.x.decode_json_string = MagicMock( return_value='xxxx') check_sig_dict_keys_mock = self.x.check_sig_dict_keys = MagicMock( return_value=False) result = self.x.validate() self.assertTrue(set_error_mock.called) self.assertIs(result, False) def test_validate_calls_verify_sig_dict_with_sig_dict_if_sig_dict_keys_valid( self): check_payload_key_mock = self.x.check_payload_keys = MagicMock( return_value=True) set_error_mock = self.x.set_error = MagicMock() decrypt_method_mock = self.x.decrypt_ciphertext = MagicMock( return_value='xxxxx') json_decode_mock = self.x.decode_json_string = MagicMock( return_value=self.valid_sig_dict) check_sig_dict_keys_mock = self.x.check_sig_dict_keys = MagicMock( return_value=True) verify_sig_mock = self.x.verify_sig_dict = MagicMock() result = self.x.validate() self.assertTrue(verify_sig_mock.called) def test_validate_returns_false_if_verify_sig_dict_is_false(self): check_payload_key_mock = self.x.check_payload_keys = MagicMock( return_value=True) set_error_mock = self.x.set_error = MagicMock() decrypt_method_mock = self.x.decrypt_ciphertext = MagicMock( return_value='xxxxx') json_decode_mock = self.x.decode_json_string = MagicMock( return_value='xxxx') check_sig_dict_keys_mock = self.x.check_sig_dict_keys = MagicMock( return_value=True) verify_sig_mock = self.x.verify_sig_dict = MagicMock( return_value=False) result = self.x.validate() self.assertIs(result, False) def test_validate_decodes_data_dict_string(self): check_payload_key_mock = self.x.check_payload_keys = MagicMock( return_value=True) set_error_mock = self.x.set_error = MagicMock() decrypt_method_mock = self.x.decrypt_ciphertext = MagicMock( return_value='xxxxx') json_decode_mock = self.x.decode_json_string = MagicMock( return_value=self.valid_sig_dict) check_sig_dict_keys_mock = self.x.check_sig_dict_keys = MagicMock( return_value=True) verify_sig_mock = self.x.verify_sig_dict = MagicMock(return_value=True) result = self.x.validate() json_decode_mock.assert_any_call(json_decode_mock.return_value['data']) def test_validate_calls_check_data_keys_if_verify_sig_is_true(self): check_payload_key_mock = self.x.check_payload_keys = MagicMock( return_value=True) set_error_mock = self.x.set_error = MagicMock() decrypt_method_mock = self.x.decrypt_ciphertext = MagicMock( return_value='xxxxx') json_decode_mock = self.x.decode_json_string = MagicMock( return_value=self.valid_sig_dict) check_sig_dict_keys_mock = self.x.check_sig_dict_keys = MagicMock( return_value=True) verify_sig_mock = self.x.verify_sig_dict = MagicMock(return_value=True) check_data_keys_mock = self.x.check_data_dict_keys = MagicMock() result = self.x.validate() self.assertTrue(check_data_keys_mock.called) def test_validate_sets_error_returns_false_if_data_dict_check_is_false( self): check_payload_key_mock = self.x.check_payload_keys = MagicMock( return_value=True) set_error_mock = self.x.set_error = MagicMock() decrypt_method_mock = self.x.decrypt_ciphertext = MagicMock( return_value='xxxxx') json_decode_mock = self.x.decode_json_string = MagicMock( return_value=self.valid_sig_dict) check_sig_dict_keys_mock = self.x.check_sig_dict_keys = MagicMock( return_value=True) verify_sig_mock = self.x.verify_sig_dict = MagicMock(return_value=True) check_data_keys_mock = self.x.check_data_dict_keys = MagicMock( return_value=False) result = self.x.validate() self.assertTrue(set_error_mock.called) self.assertIs(result, False) def test_validate_sets_valid_true_sets_data_dict_attribute_if_data_dict_check_true( self): check_payload_key_mock = self.x.check_payload_keys = MagicMock( return_value=True) set_error_mock = self.x.set_error = MagicMock() decrypt_method_mock = self.x.decrypt_ciphertext = MagicMock( return_value='xxxxx') json_decode_mock = self.x.decode_json_string = MagicMock( return_value=self.valid_sig_dict) check_sig_dict_keys_mock = self.x.check_sig_dict_keys = MagicMock( return_value=True) verify_sig_mock = self.x.verify_sig_dict = MagicMock(return_value=True) check_data_keys_mock = self.x.check_data_dict_keys = MagicMock( return_value=True) result = self.x.validate() self.assertTrue(self.x.valid) self.assertIs(result, True) self.assertIsNotNone(self.x.data_dict) def test_with_valid_message_from_factory(self): msg_dict = build_valid_message_payload_with_factory() validator = messagevalidator.MessageValidator(msg_dict, self.key_dir, self.passphrase) result = validator.validate() self.assertIs(result, True)
def __init__(self): self.temp_dir = self.create_temp_dir() self.temp_dir_name = self.temp_dir.name self.key_ring = keyring.KeyRing(self.temp_dir_name)
Copyright (C) 2018 Disappeer Labs License: GPLv3 """ import unittest from disappeer.gpg.helpers import keylistformatter from disappeer.gpg.agents import keyring key_dir = 'tests/data/keys' user_name = 'alice' user_email = '<*****@*****.**>' user_keyid = '190DB52959AC3560' user_key_uid_string = 'alice (in wonderland) <*****@*****.**>' key_ring = keyring.KeyRing(key_dir) raw_key_list = key_ring.get_raw_key_list() class TestKeyListFormatterBasics(unittest.TestCase): def setUp(self): self.key_list = raw_key_list self.key_uid_string = self.key_list[0]['uids'][0] self.x = keylistformatter.KeyListFormatter() def test_instance(self): self.assertIsInstance(self.x, keylistformatter.KeyListFormatter) def test_format_method_attribute(self): name = 'format' check = hasattr(self.x, name)
def __init__(self, key_dir): self.key_dir = key_dir self.key_ring = keyring.KeyRing(self.key_dir) self.key_finder = keyfinder.KeyFinder(self.key_ring)
def setUp(self): self.keydir = "tests/data/keys" self.k = keyring.KeyRing(self.keydir)