def test_generate_auxiliary_key_pair(self):
# Arrange
guardian = Guardian(SENDER_GUARDIAN_ID, SENDER_SEQUENCE_ORDER,
NUMBER_OF_GUARDIANS, QUORUM)
first_public_key = guardian.share_auxiliary_public_key()
# Act
guardian.generate_auxiliary_key_pair()
second_public_key = guardian.share_auxiliary_public_key()
# Assert
self.assertIsNotNone(second_public_key)
self.assertIsNotNone(second_public_key.key)
self.assertNotEqual(first_public_key.key, second_public_key.key)
def test_publish_election_backup_challenge(self):
# Arrange
guardian = Guardian(
SENDER_GUARDIAN_ID, SENDER_SEQUENCE_ORDER, NUMBER_OF_GUARDIANS, QUORUM
)
recipient_guardian = Guardian(
RECIPIENT_GUARDIAN_ID,
RECIPIENT_SEQUENCE_ORDER,
NUMBER_OF_GUARDIANS,
QUORUM,
)
guardian.save_auxiliary_public_key(
recipient_guardian.share_auxiliary_public_key()
)
guardian.generate_election_partial_key_backups(identity_auxiliary_encrypt)
# Act
challenge = guardian.publish_election_backup_challenge(RECIPIENT_GUARDIAN_ID)
# Assert
self.assertIsNotNone(challenge)
self.assertIsNotNone(challenge.value)
self.assertEqual(challenge.owner_id, SENDER_GUARDIAN_ID)
self.assertEqual(challenge.designated_id, RECIPIENT_GUARDIAN_ID)
self.assertEqual(len(challenge.coefficient_commitments), QUORUM)
self.assertEqual(len(challenge.coefficient_proofs), QUORUM)
for proof in challenge.coefficient_proofs:
proof.is_valid()
def test_verify_election_partial_key_challenge(self):
# Arrange
guardian = Guardian(
SENDER_GUARDIAN_ID, SENDER_SEQUENCE_ORDER, NUMBER_OF_GUARDIANS, QUORUM
)
recipient_guardian = Guardian(
RECIPIENT_GUARDIAN_ID,
RECIPIENT_SEQUENCE_ORDER,
NUMBER_OF_GUARDIANS,
QUORUM,
)
alternate_guardian = Guardian(
ALTERNATE_VERIFIER_GUARDIAN_ID,
ALTERNATE_VERIFIER_SEQUENCE_ORDER,
NUMBER_OF_GUARDIANS,
QUORUM,
)
guardian.save_auxiliary_public_key(
recipient_guardian.share_auxiliary_public_key()
)
guardian.generate_election_partial_key_backups(identity_auxiliary_encrypt)
challenge = guardian.publish_election_backup_challenge(RECIPIENT_GUARDIAN_ID)
# Act
verification = alternate_guardian.verify_election_partial_key_challenge(
challenge
)
# Assert
self.assertIsNotNone(verification)
self.assertEqual(verification.owner_id, SENDER_GUARDIAN_ID)
self.assertEqual(verification.designated_id, RECIPIENT_GUARDIAN_ID)
self.assertEqual(verification.verifier_id, ALTERNATE_VERIFIER_GUARDIAN_ID)
self.assertTrue(verification.verified)
def test_generate_election_partial_key_backups(self):
# Arrange
guardian = Guardian(
SENDER_GUARDIAN_ID, SENDER_SEQUENCE_ORDER, NUMBER_OF_GUARDIANS, QUORUM
)
other_guardian = Guardian(
RECIPIENT_GUARDIAN_ID, RECIPIENT_SEQUENCE_ORDER, NUMBER_OF_GUARDIANS, QUORUM
)
# Act
empty_key_backup = guardian.share_election_partial_key_backup(
RECIPIENT_GUARDIAN_ID
)
# Assert
self.assertIsNone(empty_key_backup)
# Act
guardian.save_auxiliary_public_key(other_guardian.share_auxiliary_public_key())
guardian.generate_election_partial_key_backups(identity_auxiliary_encrypt)
key_backup = guardian.share_election_partial_key_backup(RECIPIENT_GUARDIAN_ID)
# Assert
self.assertIsNotNone(key_backup)
self.assertIsNotNone(key_backup.encrypted_value)
self.assertEqual(key_backup.owner_id, SENDER_GUARDIAN_ID)
self.assertEqual(key_backup.designated_id, RECIPIENT_GUARDIAN_ID)
self.assertEqual(len(key_backup.coefficient_commitments), QUORUM)
self.assertEqual(len(key_backup.coefficient_proofs), QUORUM)
for proof in key_backup.coefficient_proofs:
proof.is_valid()
def test_share_auxiliary_public_key(self):
# Arrange
guardian = Guardian(SENDER_GUARDIAN_ID, SENDER_SEQUENCE_ORDER,
NUMBER_OF_GUARDIANS, QUORUM)
# Act
public_key = guardian.share_auxiliary_public_key()
# Assert
self.assertIsNotNone(public_key)
self.assertIsNotNone(public_key.key)
self.assertEqual(public_key.owner_id, SENDER_GUARDIAN_ID)
self.assertEqual(public_key.sequence_order, SENDER_SEQUENCE_ORDER)
def test_save_auxiliary_public_key(self):
# Arrange
guardian = Guardian(SENDER_GUARDIAN_ID, SENDER_SEQUENCE_ORDER,
NUMBER_OF_GUARDIANS, QUORUM)
other_guardian = Guardian(RECIPIENT_GUARDIAN_ID,
RECIPIENT_SEQUENCE_ORDER,
NUMBER_OF_GUARDIANS, QUORUM)
public_key = other_guardian.share_auxiliary_public_key()
# Act
guardian.save_auxiliary_public_key(public_key)
# Assert
self.assertTrue(guardian.all_auxiliary_public_keys_received())
def test_all_election_partial_key_backups_received(self):
# Arrange
guardian = Guardian(
SENDER_GUARDIAN_ID, SENDER_SEQUENCE_ORDER, NUMBER_OF_GUARDIANS, QUORUM
)
other_guardian = Guardian(
RECIPIENT_GUARDIAN_ID, RECIPIENT_SEQUENCE_ORDER, NUMBER_OF_GUARDIANS, QUORUM
)
guardian.save_auxiliary_public_key(other_guardian.share_auxiliary_public_key())
guardian.generate_election_partial_key_backups(identity_auxiliary_encrypt)
key_backup = guardian.share_election_partial_key_backup(RECIPIENT_GUARDIAN_ID)
# Assert
self.assertFalse(other_guardian.all_election_partial_key_backups_received())
other_guardian.save_election_partial_key_backup(key_backup)
self.assertTrue(other_guardian.all_election_partial_key_backups_received())
def test_share_election_partial_key_backup(self):
# Arrange
guardian = Guardian(
SENDER_GUARDIAN_ID, SENDER_SEQUENCE_ORDER, NUMBER_OF_GUARDIANS, QUORUM
)
other_guardian = Guardian(
RECIPIENT_GUARDIAN_ID, RECIPIENT_SEQUENCE_ORDER, NUMBER_OF_GUARDIANS, QUORUM
)
# Act
guardian.save_auxiliary_public_key(other_guardian.share_auxiliary_public_key())
guardian.generate_election_partial_key_backups(identity_auxiliary_encrypt)
key_backup = guardian.share_election_partial_key_backup(RECIPIENT_GUARDIAN_ID)
# Assert
self.assertIsNotNone(key_backup)
self.assertIsNotNone(key_backup.encrypted_value)
self.assertEqual(key_backup.owner_id, SENDER_GUARDIAN_ID)
self.assertEqual(key_backup.designated_id, RECIPIENT_GUARDIAN_ID)
def test_save_election_partial_key_verification(self):
# Arrange
guardian = Guardian(
SENDER_GUARDIAN_ID, SENDER_SEQUENCE_ORDER, NUMBER_OF_GUARDIANS, QUORUM
)
other_guardian = Guardian(
RECIPIENT_GUARDIAN_ID, RECIPIENT_SEQUENCE_ORDER, NUMBER_OF_GUARDIANS, QUORUM
)
guardian.save_auxiliary_public_key(other_guardian.share_auxiliary_public_key())
guardian.generate_election_partial_key_backups(identity_auxiliary_encrypt)
key_backup = guardian.share_election_partial_key_backup(RECIPIENT_GUARDIAN_ID)
other_guardian.save_election_partial_key_backup(key_backup)
verification = other_guardian.verify_election_partial_key_backup(
SENDER_GUARDIAN_ID, identity_auxiliary_decrypt
)
# Act
guardian.save_election_partial_key_verification(verification)
# Assert
self.assertTrue(guardian.all_election_partial_key_backups_verified)
def test_publish_joint_key(self):
# Arrange
guardian = Guardian(SENDER_GUARDIAN_ID, SENDER_SEQUENCE_ORDER,
NUMBER_OF_GUARDIANS, QUORUM)
other_guardian = Guardian(RECIPIENT_GUARDIAN_ID,
RECIPIENT_SEQUENCE_ORDER,
NUMBER_OF_GUARDIANS, QUORUM)
guardian.save_auxiliary_public_key(
other_guardian.share_auxiliary_public_key())
guardian.generate_election_partial_key_backups()
key_backup = guardian.share_election_partial_key_backup(
RECIPIENT_GUARDIAN_ID)
other_guardian.save_election_partial_key_backup(key_backup)
verification = other_guardian.verify_election_partial_key_backup(
SENDER_GUARDIAN_ID)
# Act
joint_key = guardian.publish_joint_key()
# Assert
self.assertIsNone(joint_key)
# Act
guardian.save_election_public_key(
other_guardian.share_election_public_key())
joint_key = guardian.publish_joint_key()
# Assert
self.assertIsNone(joint_key)
# Act
guardian.save_election_partial_key_verification(verification)
joint_key = guardian.publish_joint_key()
# Assert
self.assertIsNotNone(joint_key)
self.assertNotEqual(joint_key,
guardian.share_election_public_key().key)
def test_verify_election_partial_key_backup(self):
# Arrange
guardian = Guardian(
SENDER_GUARDIAN_ID, SENDER_SEQUENCE_ORDER, NUMBER_OF_GUARDIANS, QUORUM
)
other_guardian = Guardian(
RECIPIENT_GUARDIAN_ID, RECIPIENT_SEQUENCE_ORDER, NUMBER_OF_GUARDIANS, QUORUM
)
guardian.save_auxiliary_public_key(other_guardian.share_auxiliary_public_key())
guardian.generate_election_partial_key_backups(identity_auxiliary_encrypt)
key_backup = guardian.share_election_partial_key_backup(RECIPIENT_GUARDIAN_ID)
other_guardian.save_election_partial_key_backup(key_backup)
# Act
verification = other_guardian.verify_election_partial_key_backup(
SENDER_GUARDIAN_ID, identity_auxiliary_decrypt
)
# Assert
self.assertIsNotNone(verification)
self.assertEqual(verification.owner_id, SENDER_GUARDIAN_ID)
self.assertEqual(verification.designated_id, RECIPIENT_GUARDIAN_ID)
self.assertEqual(verification.verifier_id, RECIPIENT_GUARDIAN_ID)
self.assertTrue(verification.verified)