def test_decrypt_ballot_valid_input_missing_nonce_fails(
self, keypair: ElGamalKeyPair
):
# Arrange
election = election_factory.get_simple_election_from_file()
metadata, context = election_factory.get_fake_ciphertext_election(
election, keypair.public_key
)
data = ballot_factory.get_simple_ballot_from_file()
device = EncryptionDevice("Location")
operator = EncryptionMediator(metadata, context, device)
# Act
subject = operator.encrypt(data)
self.assertIsNotNone(subject)
subject.nonce = None
missing_nonce_value = None
result_from_nonce = decrypt_ballot_with_nonce(
subject, metadata, context.crypto_extended_base_hash, keypair.public_key,
)
result_from_nonce_seed = decrypt_ballot_with_nonce(
subject,
metadata,
context.crypto_extended_base_hash,
keypair.public_key,
missing_nonce_value,
)
# Assert
self.assertIsNone(result_from_nonce)
self.assertIsNone(result_from_nonce_seed)
def test_decrypt_ballot_valid_input_missing_nonce_fails(
self, keypair: ElGamalKeyPair
):
# Arrange
election = election_factory.get_simple_manifest_from_file()
internal_manifest, context = election_factory.get_fake_ciphertext_election(
election, keypair.public_key
)
data = ballot_factory.get_simple_ballot_from_file()
device = election_factory.get_encryption_device()
operator = EncryptionMediator(internal_manifest, context, device)
# Act
subject = operator.encrypt(data)
self.assertIsNotNone(subject)
subject.nonce = None
missing_nonce_value = None
result_from_nonce = decrypt_ballot_with_nonce(
subject,
internal_manifest,
context.crypto_extended_base_hash,
keypair.public_key,
)
# SUGGEST this test is the same as the one above
result_from_nonce_seed = decrypt_ballot_with_nonce(
subject,
internal_manifest,
context.crypto_extended_base_hash,
keypair.public_key,
missing_nonce_value,
)
# Assert
self.assertIsNone(result_from_nonce)
self.assertIsNone(result_from_nonce_seed)
def test_decrypt_ballot_valid_input_succeeds(self, keypair: ElGamalKeyPair):
"""
Check that decryption works as expected by encrypting a ballot using the stateful `EncryptionMediator`
and then calling the various decrypt functions.
"""
# TODO: Hypothesis test instead
# Arrange
election = election_factory.get_simple_election_from_file()
metadata, context = election_factory.get_fake_ciphertext_election(
election, keypair.public_key
)
data = ballot_factory.get_simple_ballot_from_file()
device = EncryptionDevice("Location")
operator = EncryptionMediator(metadata, context, device)
# Act
subject = operator.encrypt(data)
self.assertIsNotNone(subject)
result_from_key = decrypt_ballot_with_secret(
subject,
metadata,
context.crypto_extended_base_hash,
keypair.public_key,
keypair.secret_key,
remove_placeholders=False,
)
result_from_nonce = decrypt_ballot_with_nonce(
subject,
metadata,
context.crypto_extended_base_hash,
keypair.public_key,
remove_placeholders=False,
)
result_from_nonce_seed = decrypt_ballot_with_nonce(
subject,
metadata,
context.crypto_extended_base_hash,
keypair.public_key,
subject.nonce,
remove_placeholders=False,
)
# Assert
self.assertIsNotNone(result_from_key)
self.assertIsNotNone(result_from_nonce)
self.assertIsNotNone(result_from_nonce_seed)
self.assertEqual(data.object_id, subject.object_id)
self.assertEqual(data.object_id, result_from_key.object_id)
self.assertEqual(data.object_id, result_from_nonce.object_id)
self.assertEqual(data.object_id, result_from_nonce_seed.object_id)
for description in metadata.get_contests_for(data.ballot_style):
expected_entries = (
len(description.ballot_selections) + description.number_elected
)
key_contest = [
contest
for contest in result_from_key.contests
if contest.object_id == description.object_id
][0]
nonce_contest = [
contest
for contest in result_from_nonce.contests
if contest.object_id == description.object_id
][0]
seed_contest = [
contest
for contest in result_from_nonce_seed.contests
if contest.object_id == description.object_id
][0]
# Contests may not be voted on the ballot
data_contest_exists = [
contest
for contest in data.contests
if contest.object_id == description.object_id
]
if any(data_contest_exists):
data_contest = data_contest_exists[0]
else:
data_contest = None
self.assertTrue(
key_contest.is_valid(
description.object_id,
expected_entries,
description.number_elected,
description.votes_allowed,
)
)
self.assertTrue(
nonce_contest.is_valid(
description.object_id,
expected_entries,
description.number_elected,
description.votes_allowed,
)
)
self.assertTrue(
seed_contest.is_valid(
description.object_id,
expected_entries,
description.number_elected,
description.votes_allowed,
)
)
for selection_description in description.ballot_selections:
key_selection = [
selection
for selection in key_contest.ballot_selections
if selection.object_id == selection_description.object_id
][0]
nonce_selection = [
selection
for selection in nonce_contest.ballot_selections
if selection.object_id == selection_description.object_id
][0]
seed_selection = [
selection
for selection in seed_contest.ballot_selections
if selection.object_id == selection_description.object_id
][0]
# Selections may be undervoted for a specific contest
if any(data_contest_exists):
data_selection_exists = [
selection
for selection in data_contest.ballot_selections
if selection.object_id == selection_description.object_id
]
else:
data_selection_exists = []
if any(data_selection_exists):
data_selection = data_selection_exists[0]
self.assertTrue(data_selection.to_int() == key_selection.to_int())
self.assertTrue(data_selection.to_int() == nonce_selection.to_int())
self.assertTrue(data_selection.to_int() == seed_selection.to_int())
else:
data_selection = None
# TODO: also check edge cases such as:
# - placeholder selections are true for under votes
self.assertTrue(key_selection.is_valid(selection_description.object_id))
self.assertTrue(
nonce_selection.is_valid(selection_description.object_id)
)
self.assertTrue(
seed_selection.is_valid(selection_description.object_id)
)