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)
