def test_combine_election_public_keys(self):
# Arrange
random_keypair = generate_election_key_pair(QUORUM)
random_keypair_two = generate_election_key_pair(QUORUM)
public_keys = DataStore[GUARDIAN_ID, ElectionPublicKey]()
public_keys.set(
RECIPIENT_GUARDIAN_ID,
ElectionPublicKey(
RECIPIENT_GUARDIAN_ID,
random_keypair.proof,
random_keypair.key_pair.public_key,
),
)
public_keys.set(
SENDER_GUARDIAN_ID,
ElectionPublicKey(
SENDER_GUARDIAN_ID,
random_keypair_two.proof,
random_keypair_two.key_pair.public_key,
),
)
# Act
joint_key = combine_election_public_keys(
{
SENDER_GUARDIAN_ID: ONE_MOD_Q,
RECIPIENT_GUARDIAN_ID: TWO_MOD_Q
},
public_keys,
)
# Assert
self.assertIsNotNone(joint_key)
self.assertNotEqual(joint_key, random_keypair.key_pair.public_key)
self.assertNotEqual(joint_key, random_keypair_two.key_pair.public_key)
def test_verify_election_partial_key_backup(self):
# Arrange
recipient_auxiliary_key_pair = generate_rsa_auxiliary_key_pair(
RECIPIENT_GUARDIAN_ID, RECIPIENT_SEQUENCE_ORDER)
sender_election_key_pair = generate_election_key_pair(
SENDER_GUARDIAN_ID, SENDER_SEQUENCE_ORDER, QUORUM)
recipient_auxiliary_public_key = AuxiliaryPublicKey(
RECIPIENT_GUARDIAN_ID,
RECIPIENT_SEQUENCE_ORDER,
recipient_auxiliary_key_pair.public_key,
)
partial_key_backup = generate_election_partial_key_backup(
SENDER_GUARDIAN_ID,
sender_election_key_pair.polynomial,
recipient_auxiliary_public_key,
identity_auxiliary_encrypt,
)
# Act
verification = verify_election_partial_key_backup(
RECIPIENT_GUARDIAN_ID,
partial_key_backup,
sender_election_key_pair.share(),
recipient_auxiliary_key_pair,
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)
def test_generate_election_partial_key_backup(self):
# Arrange
election_key_pair = generate_election_key_pair(SENDER_GUARDIAN_ID,
SENDER_SEQUENCE_ORDER,
QUORUM)
auxiliary_key_pair = generate_rsa_auxiliary_key_pair(
RECIPIENT_GUARDIAN_ID, RECIPIENT_SEQUENCE_ORDER)
auxiliary_public_key = AuxiliaryPublicKey(
RECIPIENT_GUARDIAN_ID,
RECIPIENT_SEQUENCE_ORDER,
auxiliary_key_pair.public_key,
)
# Act
backup = generate_election_partial_key_backup(
SENDER_GUARDIAN_ID,
election_key_pair.polynomial,
auxiliary_public_key,
identity_auxiliary_encrypt,
)
# Assert
self.assertIsNotNone(backup)
self.assertEqual(backup.designated_id, RECIPIENT_GUARDIAN_ID)
self.assertEqual(backup.designated_sequence_order,
RECIPIENT_SEQUENCE_ORDER)
self.assertIsNotNone(backup.encrypted_value)
def test_combine_election_public_keys(self):
# Arrange
random_key = generate_election_key_pair(RECIPIENT_GUARDIAN_ID,
SENDER_SEQUENCE_ORDER,
QUORUM).share()
random_key_two = generate_election_key_pair(SENDER_GUARDIAN_ID,
RECIPIENT_SEQUENCE_ORDER,
QUORUM).share()
# Act
joint_key = combine_election_public_keys([random_key, random_key_two])
# Assert
self.assertIsNotNone(joint_key)
self.assertNotEqual(joint_key, random_key.key)
self.assertNotEqual(joint_key, random_key_two.key)
def test_generate_election_partial_key_challenge(self):
# Arrange
recipient_auxiliary_key_pair = generate_rsa_auxiliary_key_pair(
RECIPIENT_GUARDIAN_ID, RECIPIENT_SEQUENCE_ORDER)
sender_election_key_pair = generate_election_key_pair(
SENDER_GUARDIAN_ID, SENDER_SEQUENCE_ORDER, QUORUM)
recipient_auxiliary_public_key = AuxiliaryPublicKey(
RECIPIENT_GUARDIAN_ID,
RECIPIENT_SEQUENCE_ORDER,
recipient_auxiliary_key_pair.public_key,
)
partial_key_backup = generate_election_partial_key_backup(
SENDER_GUARDIAN_ID,
sender_election_key_pair.polynomial,
recipient_auxiliary_public_key,
identity_auxiliary_encrypt,
)
# Act
challenge = generate_election_partial_key_challenge(
partial_key_backup, sender_election_key_pair.polynomial)
# Assert
self.assertIsNotNone(challenge)
self.assertEqual(challenge.designated_id, RECIPIENT_GUARDIAN_ID)
self.assertEqual(challenge.designated_sequence_order,
RECIPIENT_SEQUENCE_ORDER)
self.assertIsNotNone(challenge.value)
self.assertEqual(len(challenge.coefficient_commitments), QUORUM)
self.assertEqual(len(challenge.coefficient_proofs), QUORUM)
for proof in challenge.coefficient_proofs:
self.assertTrue(proof.is_valid())
def test_generate_election_partial_key_backup(self):
# Arrange
election_key_pair = generate_election_key_pair(QUORUM)
auxiliary_key_pair = generate_rsa_auxiliary_key_pair()
auxiliary_public_key = AuxiliaryPublicKey(
RECIPIENT_GUARDIAN_ID,
RECIPIENT_SEQUENCE_ORDER,
auxiliary_key_pair.public_key,
)
# Act
backup = generate_election_partial_key_backup(
SENDER_GUARDIAN_ID,
election_key_pair.polynomial,
auxiliary_public_key,
identity_auxiliary_encrypt,
)
# Assert
self.assertIsNotNone(backup)
self.assertEqual(backup.designated_id, RECIPIENT_GUARDIAN_ID)
self.assertEqual(backup.designated_sequence_order,
RECIPIENT_SEQUENCE_ORDER)
self.assertIsNotNone(backup.encrypted_value)
self.assertEqual(len(backup.coefficient_commitments), QUORUM)
self.assertEqual(len(backup.coefficient_proofs), QUORUM)
for proof in backup.coefficient_proofs:
self.assertTrue(proof.is_valid())
def test_verify_election_partial_key_challenge(self):
# Arrange
recipient_auxiliary_key_pair = generate_elgamal_auxiliary_key_pair()
sender_election_key_pair = generate_election_key_pair(QUORUM)
recipient_auxiliary_public_key = AuxiliaryPublicKey(
RECIPIENT_GUARDIAN_ID,
RECIPIENT_SEQUENCE_ORDER,
recipient_auxiliary_key_pair.public_key,
)
partial_key_backup = generate_election_partial_key_backup(
SENDER_GUARDIAN_ID,
sender_election_key_pair.polynomial,
recipient_auxiliary_public_key,
)
challenge = generate_election_partial_key_challenge(
partial_key_backup, sender_election_key_pair.polynomial)
# Act
verification = verify_election_partial_key_challenge(
ALTERNATE_VERIFIER_GUARDIAN_ID, 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_key_pair(self):
# Act
election_key_pair = generate_election_key_pair(NUMBER_OF_GUARDIANS)
# Assert
self.assertIsNotNone(election_key_pair)
self.assertIsNotNone(election_key_pair.key_pair.public_key)
self.assertIsNotNone(election_key_pair.key_pair.secret_key)
self.assertIsNotNone(election_key_pair.polynomial)
self.assertTrue(election_key_pair.proof.is_valid())
for proof in election_key_pair.polynomial.coefficient_proofs:
self.assertTrue(proof.is_valid())
def test_generate_election_key_pair(self):
# Act
election_key_pair = generate_election_key_pair(SENDER_GUARDIAN_ID,
SENDER_SEQUENCE_ORDER,
QUORUM)
# Assert
self.assertIsNotNone(election_key_pair)
self.assertIsNotNone(election_key_pair.key_pair.public_key)
self.assertIsNotNone(election_key_pair.key_pair.secret_key)
self.assertIsNotNone(election_key_pair.polynomial)
self.assertEqual(
len(election_key_pair.polynomial.coefficient_commitments), QUORUM)
self.assertEqual(len(election_key_pair.polynomial.coefficient_proofs),
QUORUM)
for proof in election_key_pair.polynomial.coefficient_proofs:
self.assertTrue(proof.is_valid())
def _guardian_generates_keys(
self, guardian_id: GUARDIAN_ID, sequence_order: int
) -> None:
"""Guardian generates their keys"""
# Create Election Key Pair
election_key_pair = generate_election_key_pair(
guardian_id, sequence_order, self.QUORUM
)
self.assertIsNotNone(election_key_pair)
self.election_key_pairs[guardian_id] = election_key_pair
# Create Auxiliary Key Pair
auxiliary_key_pair = generate_rsa_auxiliary_key_pair(
guardian_id, sequence_order
)
self.assertIsNotNone(auxiliary_key_pair)
self.auxiliary_key_pairs[guardian_id] = auxiliary_key_pair
def generate_election_keys(request: ElectionKeyPairRequest) -> ElectionKeyPair:
"""
Generate election key pairs for use in election process
:param request: Election key pair request
:return: Election key pair
"""
keys = generate_election_key_pair(
request.quorum,
int_to_q_unchecked(request.nonce)
if request.nonce is not None else None,
)
if not keys:
raise HTTPException(
status_code=500,
detail="Election keys failed to be generated",
)
return ElectionKeyPair(
public_key=str(keys.key_pair.public_key),
secret_key=str(keys.key_pair.secret_key),
proof=write_json_object(keys.proof),
polynomial=write_json_object(keys.polynomial),
)
def create_guardian(request: GuardianRequest) -> Guardian:
"""
Create a guardian for the election process with the associated keys
"""
election_keys = generate_election_key_pair(
request.quorum,
int_to_q_unchecked(request.nonce) if request.nonce is not None else None,
)
if request.auxiliary_key_pair is None:
auxiliary_keys = generate_rsa_auxiliary_key_pair()
else:
auxiliary_keys = request.auxiliary_key_pair
if not election_keys:
raise HTTPException(
status_code=500,
detail="Election keys failed to be generated",
)
if not auxiliary_keys:
raise HTTPException(
status_code=500, detail="Auxiliary keys failed to be generated"
)
return Guardian(
id=request.id,
sequence_order=request.sequence_order,
number_of_guardians=request.number_of_guardians,
quorum=request.quorum,
election_key_pair=ElectionKeyPair(
public_key=str(election_keys.key_pair.public_key),
secret_key=str(election_keys.key_pair.secret_key),
proof=write_json_object(election_keys.proof),
polynomial=write_json_object(election_keys.polynomial),
),
auxiliary_key_pair=AuxiliaryKeyPair(
public_key=auxiliary_keys.public_key, secret_key=auxiliary_keys.secret_key
),
)
