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 __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
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_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_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_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_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 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 __context(self):
# type: () -> VirgilContext
"""Gets context for further use in api"""
if not self._context:
self._context = VirgilContext(self.__access_token)
return self._context
def __context(self):
return VirgilContext()
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())