163 lines
5.5 KiB
Python
163 lines
5.5 KiB
Python
import unittest
|
|
|
|
from ca_core.crypto.zenroom_service_client import ZenroomServiceClient
|
|
|
|
|
|
class TestZenroomServiceClient(unittest.TestCase):
|
|
def setUp(self):
|
|
self.client = ZenroomServiceClient()
|
|
|
|
def test_1_generate_keypair(self):
|
|
result = self.client.generate_keypair("Alice")
|
|
|
|
self.assertEqual(result["my_name"], "Alice")
|
|
self.assertIn("keyring", result)
|
|
self.assertIsInstance(result["keyring"], dict)
|
|
self.assertIn("ecdh", result["keyring"])
|
|
self.assertIsInstance(result["keyring"]["ecdh"], str)
|
|
self.assertTrue(result["keyring"]["ecdh"])
|
|
self.assertEqual(result["private_key"], result["keyring"]["ecdh"])
|
|
|
|
def test_2_generate_public_key(self):
|
|
keypair = self.client.generate_keypair("Alice")
|
|
public_key = self.client.generate_public_key(keypair["keyring"])
|
|
|
|
self.assertIsInstance(public_key, str)
|
|
self.assertTrue(public_key)
|
|
|
|
def test_3_symmetric_encrypt(self):
|
|
result = self.client.symmetric_encrypt(
|
|
header="test-header",
|
|
message="hello symmetric crypto",
|
|
shared_key="correct horse battery staple",
|
|
)
|
|
|
|
self.assertIsInstance(result, dict)
|
|
self.assertIn("checksum", result)
|
|
self.assertIn("header", result)
|
|
self.assertIn("iv", result)
|
|
self.assertIn("text", result)
|
|
|
|
self.assertIsInstance(result["checksum"], str)
|
|
self.assertIsInstance(result["header"], str)
|
|
self.assertIsInstance(result["iv"], str)
|
|
self.assertIsInstance(result["text"], str)
|
|
|
|
self.assertTrue(result["checksum"])
|
|
self.assertTrue(result["header"])
|
|
self.assertTrue(result["iv"])
|
|
self.assertTrue(result["text"])
|
|
|
|
def test_4_symmetric_decrypt(self):
|
|
plaintext = "hello symmetric crypto"
|
|
password = "correct horse battery staple"
|
|
|
|
encrypted = self.client.symmetric_encrypt(
|
|
header="test-header",
|
|
message=plaintext,
|
|
shared_key=password,
|
|
)
|
|
|
|
decrypted = self.client.symmetric_decrypt(
|
|
secret_message=encrypted,
|
|
shared_key=password,
|
|
)
|
|
|
|
self.assertEqual(decrypted, plaintext)
|
|
|
|
def test_5_asymmetric_encrypt(self):
|
|
alice = self.client.generate_keypair("Alice")
|
|
bob = self.client.generate_keypair("Bob")
|
|
bob_public_key = self.client.generate_public_key(bob["keyring"])
|
|
|
|
result = self.client.asymmetric_encrypt(
|
|
receiver_public_key=bob_public_key,
|
|
sender_keyring=alice["keyring"],
|
|
header="asym-header",
|
|
message="hello bob",
|
|
)
|
|
|
|
self.assertIsInstance(result, dict)
|
|
self.assertIn("checksum", result)
|
|
self.assertIn("header", result)
|
|
self.assertIn("iv", result)
|
|
self.assertIn("text", result)
|
|
|
|
self.assertIsInstance(result["checksum"], str)
|
|
self.assertIsInstance(result["header"], str)
|
|
self.assertIsInstance(result["iv"], str)
|
|
self.assertIsInstance(result["text"], str)
|
|
|
|
self.assertTrue(result["checksum"])
|
|
self.assertTrue(result["header"])
|
|
self.assertTrue(result["iv"])
|
|
self.assertTrue(result["text"])
|
|
|
|
def test_6_asymmetric_decrypt(self):
|
|
alice = self.client.generate_keypair("Alice")
|
|
bob = self.client.generate_keypair("Bob")
|
|
|
|
alice_public_key = self.client.generate_public_key(alice["keyring"])
|
|
bob_public_key = self.client.generate_public_key(bob["keyring"])
|
|
|
|
encrypted = self.client.asymmetric_encrypt(
|
|
receiver_public_key=bob_public_key,
|
|
sender_keyring=alice["keyring"],
|
|
header="asym-header",
|
|
message="hello bob",
|
|
)
|
|
|
|
decrypted = self.client.asymmetric_decrypt(
|
|
sender_public_key=alice_public_key,
|
|
receiver_keyring=bob["keyring"],
|
|
secret=encrypted,
|
|
)
|
|
|
|
self.assertIsInstance(decrypted, dict)
|
|
self.assertEqual(decrypted["header"], "asym-header")
|
|
self.assertEqual(decrypted["text"], "hello bob")
|
|
|
|
def test_7_sign_objects(self):
|
|
alice = self.client.generate_keypair("Alice")
|
|
|
|
result = self.client.sign_objects(
|
|
objects={"myMessage": "hello signed world"},
|
|
signer_keyring=alice["keyring"],
|
|
)
|
|
|
|
self.assertIsInstance(result, dict)
|
|
self.assertIn("myMessage", result)
|
|
self.assertIn("myMessage.signature", result)
|
|
self.assertEqual(result["myMessage"], "hello signed world")
|
|
|
|
signature = result["myMessage.signature"]
|
|
self.assertIsInstance(signature, dict)
|
|
self.assertIn("r", signature)
|
|
self.assertIn("s", signature)
|
|
self.assertIsInstance(signature["r"], str)
|
|
self.assertIsInstance(signature["s"], str)
|
|
self.assertTrue(signature["r"])
|
|
self.assertTrue(signature["s"])
|
|
|
|
def test_8_verify_signature(self):
|
|
alice = self.client.generate_keypair("Alice")
|
|
alice_public_key = self.client.generate_public_key(alice["keyring"])
|
|
|
|
signed = self.client.sign_objects(
|
|
objects={"myMessage": "hello signed world"},
|
|
signer_keyring=alice["keyring"],
|
|
)
|
|
|
|
verified = self.client.verify_signature(
|
|
message_field="myMessage",
|
|
message_value=signed["myMessage"],
|
|
signature=signed["myMessage.signature"],
|
|
signer_public_key=alice_public_key,
|
|
)
|
|
|
|
self.assertTrue(verified)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|