def __init__(self, *args, **kwargs): super(VirgilCardTest, self).__init__(*args, **kwargs) self._context = None self._app_private_key = None self.__crypto = VirgilCrypto() self.__client = VirgilClient(access_token=config.VIRGIL_ACCESS_TOKEN) self.__request_signer = RequestSigner(self.__crypto) self.__key_pair = self.__crypto.generate_keys()
def __init__(self, *args, **kwargs): super(CardManagerTest, self).__init__(*args, **kwargs) self._context = None self.__key_pair_alice = self.__context.crypto.generate_keys() self.__key_pair_bob = self.__context.crypto.generate_keys() self.__global_card_config = { "identity": "bob", "identity_type": "email", "owner_key": VirgilKey(self.__context, self.__key_pair_bob.private_key) } self._app_private_key = None self.__crypto = VirgilCrypto() self.__client = VirgilClient(access_token=config.VIRGIL_ACCESS_TOKEN) self.__request_signer = RequestSigner(self.__crypto) self._compatibility_data = None self._compatibility_data_path = None self._decode_data = None
def _client(self): if self.__client: return self.__client self.__client = VirgilClient( access_token=config.VIRGIL_ACCESS_TOKEN, ) self.__client.card_validator = (CardValidator(VirgilCrypto())) return self.__client
class VirgilCardTest(unittest.TestCase): def __init__(self, *args, **kwargs): super(VirgilCardTest, self).__init__(*args, **kwargs) self._context = None self._app_private_key = None self.__crypto = VirgilCrypto() self.__client = VirgilClient(access_token=config.VIRGIL_ACCESS_TOKEN) self.__request_signer = RequestSigner(self.__crypto) self.__key_pair = self.__crypto.generate_keys() def test_encrypt(self): card_model = self.__get_card_model(Card.Scope.APPLICATION) data_string = "hello world" data = VirgilBuffer.from_string(data_string) vc = VirgilCard(self.__context, card_model) cipher_data = vc.encrypt(data) self.assertEqual( bytearray( self.__crypto.decrypt(cipher_data.get_bytearray(), self.__key_pair.private_key)), data.get_bytearray()) def test_verify(self): card_model = self.__get_card_model(Card.Scope.APPLICATION) data_string = "hello world" data = VirgilBuffer.from_string(data_string) vc = VirgilCard(self.__context, card_model) signature = self.__crypto.sign(data.get_bytearray(), self.__key_pair.private_key) self.assertTrue(vc.verify(data, VirgilBuffer(signature))) def test_publish(self): card_model = self.__get_card_model(scope=Card.Scope.APPLICATION) creds = Credentials(config.VIRGIL_APP_ID, open(config.VIRGIL_APP_KEY_PATH, "rb").read(), config.VIRGIL_APP_KEY_PASSWORD) context = VirgilContext(access_token=config.VIRGIL_ACCESS_TOKEN, credentials=creds) vc = VirgilCard(context, card_model) try: vc.publish() self.assertIsNotNone(self.__client.get_card(card_model.id)) finally: try: self.__cleanup_cards(card_model) except Exception: pass def __build_card_model(self, identity, identity_type, scope, owner_key, custom_fields=None): card_config = { 'identity': identity, 'identity_type': identity_type, 'public_key': tuple(owner_key.export_public_key().get_bytearray()), 'data': custom_fields, } card = Card(**card_config) if scope == Card.Scope.APPLICATION: card_request = CreateCardRequest(**card_config) elif scope == Card.Scope.GLOBAL: card_request = CreateGlobalCardRequest(**card_config) else: raise ValueError("Unknown scope value") card.snapshot = card_request.snapshot snapshot_fingerprint = self.__crypto.calculate_fingerprint( card.snapshot) card.scope = scope card.id = snapshot_fingerprint.to_hex self_signature = owner_key.sign( VirgilBuffer(snapshot_fingerprint.value)) card.signatures = {card.id: self_signature.to_string("base64")} return card def __cleanup_cards(self, *cards): for card in cards: request = RevokeCardRequest(card_id=card.id, ) self.__request_signer.authority_sign(request, config.VIRGIL_APP_ID, self.__app_private_key) self.__client.revoke_card_from_request(request) def __get_card_model(self, scope): identity = "alice" identity_type = "username" scope = scope owner_key = VirgilKey(self.__context, self.__key_pair.private_key) self._card_model = self.__build_card_model(identity, identity_type, scope, owner_key) return self._card_model @property def __context(self): return VirgilContext() @property def __app_private_key(self): if self._app_private_key: return self._app_private_key with open(config.VIRGIL_APP_KEY_PATH, "r") as key_file: raw_private_key = self.__crypto.strtobytes(key_file.read()) self._app_private_key = self.__crypto.import_private_key( key_data=raw_private_key, password=config.VIRGIL_APP_KEY_PASSWORD) return self._app_private_key
def _crypto(self): if self.__crypto: return self.__crypto self.__crypto = VirgilCrypto() return self.__crypto
def crypto(self): """Gets a cryptographic keys storage.""" if not self._crypto: self._crypto = VirgilCrypto() return self._crypto
def _request_signer(self): if self.__request_signer: return self.__request_signer self.__request_signer = RequestSigner(VirgilCrypto()) return self.__request_signer
def _crypto(self): return VirgilCrypto()
class CardManagerTest(unittest.TestCase): def __init__(self, *args, **kwargs): super(CardManagerTest, self).__init__(*args, **kwargs) self._context = None self.__key_pair_alice = self.__context.crypto.generate_keys() self.__key_pair_bob = self.__context.crypto.generate_keys() self.__global_card_config = { "identity": "bob", "identity_type": "email", "owner_key": VirgilKey(self.__context, self.__key_pair_bob.private_key) } self._app_private_key = None self.__crypto = VirgilCrypto() self.__client = VirgilClient(access_token=config.VIRGIL_ACCESS_TOKEN) self.__request_signer = RequestSigner(self.__crypto) self._compatibility_data = None self._compatibility_data_path = None self._decode_data = None def test_create_user(self): identity = IdentitiesManager().create_user("alice", "username") owner_key = VirgilKey(self.__context, self.__key_pair_alice.private_key) cm = CardManager(self.__context) card = cm.create(identity, owner_key) self.assertIsInstance(card, VirgilCard) def test_create_email(self): identity = IdentitiesManager().create_email("bob@localhost") identity._validation_token = "test_token" owner_key = VirgilKey(self.__context, self.__key_pair_alice.private_key) cm = CardManager(self.__context) card = cm.create(identity, owner_key) self.assertIsInstance(card, VirgilCard) def test_create_app(self): identity = IdentitiesManager().create_app("someapp") owner_key = VirgilKey(self.__context, self.__key_pair_alice.private_key) cm = CardManager(self.__context) card = cm.create(identity, owner_key) self.assertIsInstance(card, VirgilCard) def test_find(self): cm = CardManager(self.__context) identity = IdentitiesManager().create_user("alice", "username") owner_key = VirgilKey(self.__context, self.__key_pair_alice.private_key) card = cm.create(identity, owner_key) try: cm.publish(card) finded = cm.find("alice") self.assertIn(card, finded) finally: try: self.__cleanup_cards(card) except Exception: pass def test_find_multiply(self): cm = CardManager(self.__context) identity_alice = IdentitiesManager().create_user("alice", "username") identity_bob = IdentitiesManager().create_user("bob", "username") alice_key = VirgilKey(self.__context, self.__key_pair_alice.private_key) bob_key = VirgilKey(self.__context, self.__key_pair_bob.private_key) alice_card = cm.create(identity_alice, alice_key) bob_card = cm.create(identity_bob, bob_key) try: cm.publish(alice_card) cm.publish(bob_card) finded = cm.find(["alice", "bob"]) self.assertIn(alice_card, finded) and self.assertIn(bob_card, finded) finally: try: self.__cleanup_cards(alice_card) except Exception: pass def test_import_card_unpublished_local(self): data = self.__compatibility_data["export_unpublished_local_virgil_card"] cm = CardManager(self.__context) imported_card = cm.import_card(data["exported_card"]) self.assertEqual(imported_card.id, data["card_id"]) def test_import_card_unpublished_local_without_id(self): data = self.__compatibility_data["export_unpublished_local_virgil_card_without_id"] cm = CardManager(self.__context) imported_card = cm.import_card(data["exported_card"]) imported_card_id = self.__crypto.calculate_fingerprint(bytearray(imported_card._VirgilCard__card.snapshot)).to_hex self.assertEqual(imported_card_id, data["card_id"]) def test_import_card_published_global(self): data = self.__compatibility_data["export_published_global_virgil_card"] cm = CardManager(self.__context) imported_card = cm.import_card(data["exported_card"]) self.assertEqual(imported_card, cm.get(data["card_id"])) def test_publish(self): cm = CardManager(self.__context) identity = IdentitiesManager().create_user("alice", "username") owner_key = VirgilKey(self.__context, self.__key_pair_alice.private_key) card = cm.create(identity, owner_key) try: card.publish() self.assertIsInstance(cm.get(card.id), VirgilCard) self.assertEqual(cm.get(card.id).identity, card.identity) finally: try: self.__cleanup_cards(card) except Exception: pass def test_publish_imported_card(self): identity = IdentitiesManager().create_user("alice", "username") owner_key = VirgilKey(self.__context, self.__key_pair_alice.private_key) cm = CardManager(self.__context) original_card = cm.create(identity, owner_key) exported_card = original_card.export() card = cm.import_card(exported_card) try: card.publish() self.assertIsInstance(cm.get(original_card.id), VirgilCard) self.assertEqual(cm.get(original_card.id).identity, card.identity) finally: try: self.__cleanup_cards(card) except Exception: pass def test_revoke(self): cm = CardManager(self.__context) identity = IdentitiesManager().create_user("alice", "username") owner_key = VirgilKey(self.__context, self.__key_pair_alice.private_key) card = cm.create(identity, owner_key) try: card.publish() self.assertIsInstance(cm.get(card.id), VirgilCard) self.assertEqual(cm.get(card.id).identity, card.identity) cm.revoke(card) with self.assertRaises(Exception) as context: cm.get(card.id) self.assertTrue("" in str(context.exception)) finally: try: self.__cleanup_cards(card) except Exception: pass def __cleanup_cards(self, *cards): for card in cards: request = RevokeCardRequest( card_id=card.id, ) self.__request_signer.authority_sign(request, config.VIRGIL_APP_ID, self.__app_private_key) self.__client.revoke_card_from_request(request) @property def __context(self): if not self._context: creds = Credentials( config.VIRGIL_APP_ID, open(config.VIRGIL_APP_KEY_PATH, "rb").read(), config.VIRGIL_APP_KEY_PASSWORD ) self._context = VirgilContext( config.VIRGIL_ACCESS_TOKEN, creds ) return self._context @property def __app_private_key(self): if self._app_private_key: return self._app_private_key with open(config.VIRGIL_APP_KEY_PATH, "r") as key_file: raw_private_key = self.__crypto.strtobytes(key_file.read()) self._app_private_key = self.__crypto.import_private_key( key_data=raw_private_key, password=config.VIRGIL_APP_KEY_PASSWORD ) return self._app_private_key @property def __compatibility_data(self): if self._compatibility_data: return self._compatibility_data with open(self.__compatibility_data_path, "r") as data_file: raw_data = data_file.read() json_data = json.loads(raw_data) return json_data @property def __compatibility_data_path(self): if self._compatibility_data_path: return self._compatibility_data_path this_file_path = os.path.abspath(__file__) cwd = os.path.dirname(this_file_path) data_file_path = os.path.join( cwd, "..", "data", "sdk_compatibility_data.json" ) self._compatibility_data_path = data_file_path return data_file_path
def __init__(self, *args, **kwargs): super(VirgilKeyTest, self).__init__(*args, **kwargs) self.__crypto = VirgilCrypto()
class VirgilKeyTest(unittest.TestCase): def __init__(self, *args, **kwargs): super(VirgilKeyTest, self).__init__(*args, **kwargs) self.__crypto = VirgilCrypto() def test_export(self): private_key = self.__crypto.generate_keys().private_key context = VirgilContext() vk = VirgilKey(context, private_key) self.assertEqual( vk.export().get_bytearray(), bytearray(self.__crypto.export_private_key(private_key))) def test_sign(self): private_key = self.__crypto.generate_keys().private_key context = VirgilContext() vk = VirgilKey(context, private_key) data_string = "hello world" data = VirgilBuffer.from_string(data_string) self.assertEqual( vk.sign(data).get_bytearray(), bytearray( self.__crypto.sign(bytearray(data_string, "utf-8"), private_key))) def test_decrypt(self): key_pair = self.__crypto.generate_keys() private_key = key_pair.private_key context = VirgilContext() vk = VirgilKey(context, private_key) data_string = "hello world" data = VirgilBuffer.from_string(data_string) encrypted_data = VirgilBuffer( self.__crypto.encrypt(data.get_bytearray(), key_pair.public_key)) self.assertEqual(data.get_bytearray(), vk.decrypt(encrypted_data).get_bytearray()) def test_save(self): private_key = self.__crypto.generate_keys().private_key context = VirgilContext() vk = VirgilKey(context, private_key) alias = "virgil_key_test_save" km = DefaultKeyStorage() try: vk.save(alias) self.assertEqual(bytearray(private_key.value), km.load(alias)) finally: try: km.delete(alias) except IOError: pass def test_save_with_passwd(self): private_key = self.__crypto.generate_keys().private_key context = VirgilContext() vk = VirgilKey(context, private_key) alias = "virgil_key_test_save" km = DefaultKeyStorage() try: vk.save(alias, "SomeCoolPass") self.assertEqual( private_key.value, self.__crypto.import_private_key(bytearray(km.load(alias)), "SomeCoolPass").value) finally: try: km.delete(alias) except IOError: pass def test_sign_then_encrypt(self): alice_keys = self.__crypto.generate_keys() bob_keys = self.__crypto.generate_keys() test_keys = self.__crypto.generate_keys() context = VirgilContext() data_string = "hello world" data = VirgilBuffer.from_string(data_string) recipients = [alice_keys, bob_keys] vk = VirgilKey(context, test_keys.private_key) cipher_data = vk.sign_then_encrypt(data, recipients) self.assertEqual( data.get_bytearray(), bytearray( self.__crypto.decrypt_then_verify(cipher_data.get_bytearray(), alice_keys.private_key, test_keys.public_key))) self.assertEqual( data.get_bytearray(), bytearray( self.__crypto.decrypt_then_verify(cipher_data.get_bytearray(), bob_keys.private_key, test_keys.public_key))) def test_decrypt_then_verify(self): alice_keys = self.__crypto.generate_keys() test_keys = self.__crypto.generate_keys() data_string = "hello world" data = VirgilBuffer.from_string(data_string) context = VirgilContext() vk = VirgilKey(context, test_keys.private_key) cipher_data = self.__crypto.sign_then_encrypt(data.get_bytearray(), alice_keys.private_key, test_keys.public_key) self.assertEqual( data.get_bytearray(), vk.decrypt_then_verify(VirgilBuffer(cipher_data), alice_keys).get_bytearray()) def test_export_public_key(self): test_keys = self.__crypto.generate_keys() context = VirgilContext() vk = VirgilKey(context, test_keys.private_key) self.assertEqual(bytearray(test_keys.public_key.value), vk.export_public_key().get_bytearray())