def generate(self, number_of_ballots: int = DEFAULT_NUMBER_OF_BALLOTS):
"""
Generate the sample data set
"""
rmtree(RESULTS_DIR, ignore_errors=True)
(
public_data,
private_data,
) = self.election_factory.get_hamilton_election_with_encryption_context()
plaintext_ballots = self.ballot_factory.generate_fake_plaintext_ballots_for_election(
public_data.metadata, number_of_ballots
)
self.encrypter = EncryptionMediator(
public_data.metadata, public_data.context, self.encryption_device
)
ciphertext_ballots: List[CiphertextBallot] = []
for plaintext_ballot in plaintext_ballots:
ciphertext_ballots.append(
get_optional(self.encrypter.encrypt(plaintext_ballot))
)
ballot_store = BallotStore()
ballot_box = BallotBox(public_data.metadata, public_data.context, ballot_store)
accepted_ballots: List[CiphertextAcceptedBallot] = []
for ballot in ciphertext_ballots:
if randint(0, 100) % 10 == 0:
accepted_ballots.append(ballot_box.spoil(ballot))
else:
accepted_ballots.append(ballot_box.cast(ballot))
ciphertext_tally = get_optional(
tally_ballots(ballot_store, public_data.metadata, public_data.context)
)
decrypter = DecryptionMediator(
public_data.metadata, public_data.context, ciphertext_tally
)
for guardian in private_data.guardians:
decrypter.announce(guardian)
plaintext_tally = get_optional(decrypter.get_plaintext_tally())
publish(
public_data.description,
public_data.context,
public_data.constants,
accepted_ballots,
ciphertext_tally,
plaintext_tally,
public_data.guardians,
)
publish_private_data(
plaintext_ballots, ciphertext_ballots, private_data.guardians
)
def test_tally_cast_ballots_accumulates_valid_tally(
self, everything: ELECTIONS_AND_BALLOTS_TUPLE_TYPE):
# Arrange
(
_election_description,
internal_manifest,
ballots,
secret_key,
context,
) = everything
# Tally the plaintext ballots for comparison later
plaintext_tallies = accumulate_plaintext_ballots(ballots)
# encrypt each ballot
store = DataStore()
encryption_seed = ElectionFactory.get_encryption_device().get_hash()
for ballot in ballots:
encrypted_ballot = encrypt_ballot(ballot, internal_manifest,
context, encryption_seed)
encryption_seed = encrypted_ballot.code
self.assertIsNotNone(encrypted_ballot)
# add to the ballot store
store.set(
encrypted_ballot.object_id,
from_ciphertext_ballot(encrypted_ballot, BallotBoxState.CAST),
)
# act
result = tally_ballots(store, internal_manifest, context)
self.assertIsNotNone(result)
# Assert
decrypted_tallies = self._decrypt_with_secret(result, secret_key)
self.assertEqual(plaintext_tallies, decrypted_tallies)
def test_tally_spoiled_ballots_accumulates_valid_tally(
self, everything: ELECTIONS_AND_BALLOTS_TUPLE_TYPE):
# Arrange
metadata, ballots, secret_key, context = everything
# Tally the plaintext ballots for comparison later
plaintext_tallies = accumulate_plaintext_ballots(ballots)
# encrypt each ballot
store = BallotStore()
seed_hash = EncryptionDevice("Location").get_hash()
for ballot in ballots:
encrypted_ballot = encrypt_ballot(ballot, metadata, context,
seed_hash)
seed_hash = encrypted_ballot.tracking_hash
self.assertIsNotNone(encrypted_ballot)
# add to the ballot store
store.set(
encrypted_ballot.object_id,
from_ciphertext_ballot(encrypted_ballot,
BallotBoxState.SPOILED),
)
# act
result = tally_ballots(store, metadata, context)
self.assertIsNotNone(result)
# Assert
decrypted_tallies = self._decrypt_with_secret(result, secret_key)
self.assertCountEqual(plaintext_tallies, decrypted_tallies)
for value in decrypted_tallies.values():
self.assertEqual(0, value)
self.assertEqual(len(ballots), len(result.spoiled_ballots))
def test_eg_conversion(self, state: DominionBallotsAndContext,
seed: ElementModQ) -> None:
ied = InternalElectionDescription(state.ed)
ballot_box = BallotBox(ied, state.cec)
seed_hash = EncryptionDevice("Location").get_hash()
nonces = Nonces(seed)[0:len(state.ballots)]
for b, n in zip(state.ballots, nonces):
eb = encrypt_ballot(b, ied, state.cec, seed_hash, n)
self.assertIsNotNone(eb)
pb = decrypt_ballot_with_secret(
eb,
ied,
state.cec.crypto_extended_base_hash,
state.cec.elgamal_public_key,
state.secret_key,
)
self.assertEqual(b, pb)
self.assertGreater(len(eb.contests), 0)
cast_result = ballot_box.cast(eb)
self.assertIsNotNone(cast_result)
tally = tally_ballots(ballot_box._store, ied, state.cec)
self.assertIsNotNone(tally)
results = decrypt_tally_with_secret(tally, state.secret_key)
self.assertEqual(len(results.keys()), len(state.id_map.keys()))
for obj_id in results.keys():
self.assertIn(obj_id, state.id_map)
cvr_sum = int(state.dominion_cvrs.data[state.id_map[obj_id]].sum())
decryption = results[obj_id]
self.assertEqual(cvr_sum, decryption)
def tally(store: BallotStore, metadata: InternalElectionDescription,
context: CiphertextElectionContext,
keypair: ElGamalKeyPair) -> Dict[str, int]:
"""
Should later be replaced with the proper tallying done by multiple trustees
:return: Election results
"""
tally = tally_ballots(store, metadata, context)
decrypted_tallies = _decrypt_with_secret(tally, keypair.secret_key)
return decrypted_tallies
def step_4_decrypt_tally(self) -> None:
"""
Homomorphically combine the selections made on all of the cast ballots
and use the Available Guardians to decrypt the combined tally.
In this way, no individual voter's cast ballot is ever decrypted drectly.
"""
# Generate a Homomorphically Accumulated Tally of the ballots
self.ciphertext_tally = get_optional(
tally_ballots(self.ballot_store, self.metadata, self.context)
)
self._assert_message(
tally_ballots.__qualname__,
f"""
- cast: {self.ciphertext_tally.count()}
- spoiled: {len(self.ciphertext_tally.spoiled_ballots)}
Total: {len(self.ciphertext_tally)}
""",
self.ciphertext_tally is not None,
)
# Configure the Decryption
self.decrypter = DecryptionMediator(
self.metadata, self.context, self.ciphertext_tally
)
# Announce each guardian as present
for guardian in self.guardians:
decryption_share = self.decrypter.announce(guardian)
self._assert_message(
DecryptionMediator.announce.__qualname__,
f"Guardian Present: {guardian.object_id}",
decryption_share is not None,
)
# Get the Plain Text Tally
self.plaintext_tally = get_optional(self.decrypter.get_plaintext_tally())
self._assert_message(
DecryptionMediator.get_plaintext_tally.__qualname__,
"Tally Decrypted",
self.plaintext_tally is not None,
)
# Now, compare the results
self.compare_results()
def _generate_encrypted_tally(
self,
metadata: InternalElectionDescription,
context: CiphertextElectionContext,
ballots: List[PlaintextBallot],
) -> CiphertextTally:
# encrypt each ballot
store = BallotStore()
for ballot in ballots:
encrypted_ballot = encrypt_ballot(ballot, metadata, context,
int_to_q_unchecked(1))
self.assertIsNotNone(encrypted_ballot)
# add to the ballot store
store.set(
encrypted_ballot.object_id,
from_ciphertext_ballot(encrypted_ballot, BallotBoxState.CAST),
)
tally = tally_ballots(store, metadata, context)
self.assertIsNotNone(tally)
return get_optional(tally)
def setUp(self):
self.key_ceremony = KeyCeremonyMediator(self.CEREMONY_DETAILS)
self.guardians: List[Guardian] = []
# Setup Guardians
for i in range(self.NUMBER_OF_GUARDIANS):
sequence = i + 2
self.guardians.append(
Guardian(
"guardian_" + str(sequence),
sequence,
self.NUMBER_OF_GUARDIANS,
self.QUORUM,
))
# Attendance (Public Key Share)
for guardian in self.guardians:
self.key_ceremony.announce(guardian)
self.key_ceremony.orchestrate(identity_auxiliary_encrypt)
self.key_ceremony.verify(identity_auxiliary_decrypt)
self.joint_public_key = self.key_ceremony.publish_joint_key()
self.assertIsNotNone(self.joint_public_key)
# setup the election
self.election = election_factory.get_fake_election()
builder = ElectionBuilder(self.NUMBER_OF_GUARDIANS, self.QUORUM,
self.election)
self.assertIsNone(
builder.build()) # Can't build without the public key
builder.set_public_key(self.joint_public_key)
self.metadata, self.context = get_optional(builder.build())
self.encryption_device = EncryptionDevice("location")
self.ballot_marking_device = EncryptionMediator(
self.metadata, self.context, self.encryption_device)
# get some fake ballots
self.fake_cast_ballot = ballot_factory.get_fake_ballot(
self.metadata, "some-unique-ballot-id-cast")
self.more_fake_ballots = []
for i in range(10):
self.more_fake_ballots.append(
ballot_factory.get_fake_ballot(
self.metadata, f"some-unique-ballot-id-cast{i}"))
self.fake_spoiled_ballot = ballot_factory.get_fake_ballot(
self.metadata, "some-unique-ballot-id-spoiled")
self.assertTrue(
self.fake_cast_ballot.is_valid(
self.metadata.ballot_styles[0].object_id))
self.assertTrue(
self.fake_spoiled_ballot.is_valid(
self.metadata.ballot_styles[0].object_id))
self.expected_plaintext_tally = accumulate_plaintext_ballots(
[self.fake_cast_ballot] + self.more_fake_ballots)
# Fill in the expected values with any missing selections
# that were not made on any ballots
selection_ids = set([
selection.object_id for contest in self.metadata.contests
for selection in contest.ballot_selections
])
missing_selection_ids = selection_ids.difference(
set(self.expected_plaintext_tally))
for id in missing_selection_ids:
self.expected_plaintext_tally[id] = 0
# Encrypt
encrypted_fake_cast_ballot = self.ballot_marking_device.encrypt(
self.fake_cast_ballot)
encrypted_fake_spoiled_ballot = self.ballot_marking_device.encrypt(
self.fake_spoiled_ballot)
self.assertIsNotNone(encrypted_fake_cast_ballot)
self.assertIsNotNone(encrypted_fake_spoiled_ballot)
self.assertTrue(
encrypted_fake_cast_ballot.is_valid_encryption(
self.context.crypto_extended_base_hash, self.joint_public_key))
# encrypt some more fake ballots
self.more_fake_encrypted_ballots = []
for fake_ballot in self.more_fake_ballots:
self.more_fake_encrypted_ballots.append(
self.ballot_marking_device.encrypt(fake_ballot))
# configure the ballot box
ballot_store = BallotStore()
ballot_box = BallotBox(self.metadata, self.context, ballot_store)
ballot_box.cast(encrypted_fake_cast_ballot)
ballot_box.spoil(encrypted_fake_spoiled_ballot)
# Cast some more fake ballots
for fake_ballot in self.more_fake_encrypted_ballots:
ballot_box.cast(fake_ballot)
# generate encrypted tally
self.ciphertext_tally = tally_ballots(ballot_store, self.metadata,
self.context)
def setUp(self):
# Key Ceremony
self.key_ceremony_mediator = KeyCeremonyMediator(
"key_ceremony_mediator_mediator", self.CEREMONY_DETAILS)
self.guardians: List[Guardian] = KeyCeremonyHelper.create_guardians(
self.CEREMONY_DETAILS)
KeyCeremonyHelper.perform_full_ceremony(self.guardians,
self.key_ceremony_mediator)
self.joint_public_key = self.key_ceremony_mediator.publish_joint_key()
# Setup the election
manifest = election_factory.get_fake_manifest()
builder = ElectionBuilder(self.NUMBER_OF_GUARDIANS, self.QUORUM,
manifest)
builder.set_public_key(self.joint_public_key.joint_public_key)
builder.set_commitment_hash(self.joint_public_key.commitment_hash)
self.internal_manifest, self.context = get_optional(builder.build())
self.encryption_device = election_factory.get_encryption_device()
self.ballot_marking_device = EncryptionMediator(
self.internal_manifest, self.context, self.encryption_device)
# get some fake ballots
self.fake_cast_ballot = ballot_factory.get_fake_ballot(
self.internal_manifest, "some-unique-ballot-id-cast")
self.more_fake_ballots = []
for i in range(10):
self.more_fake_ballots.append(
ballot_factory.get_fake_ballot(
self.internal_manifest, f"some-unique-ballot-id-cast{i}"))
self.fake_spoiled_ballot = ballot_factory.get_fake_ballot(
self.internal_manifest, "some-unique-ballot-id-spoiled")
self.more_fake_spoiled_ballots = []
for i in range(2):
self.more_fake_spoiled_ballots.append(
ballot_factory.get_fake_ballot(
self.internal_manifest,
f"some-unique-ballot-id-spoiled{i}"))
self.assertTrue(
self.fake_cast_ballot.is_valid(
self.internal_manifest.ballot_styles[0].object_id))
self.assertTrue(
self.fake_spoiled_ballot.is_valid(
self.internal_manifest.ballot_styles[0].object_id))
self.expected_plaintext_tally = accumulate_plaintext_ballots(
[self.fake_cast_ballot] + self.more_fake_ballots)
# Fill in the expected values with any missing selections
# that were not made on any ballots
selection_ids = {
selection.object_id
for contest in self.internal_manifest.contests
for selection in contest.ballot_selections
}
missing_selection_ids = selection_ids.difference(
set(self.expected_plaintext_tally))
for id in missing_selection_ids:
self.expected_plaintext_tally[id] = 0
# Encrypt
self.encrypted_fake_cast_ballot = self.ballot_marking_device.encrypt(
self.fake_cast_ballot)
self.encrypted_fake_spoiled_ballot = self.ballot_marking_device.encrypt(
self.fake_spoiled_ballot)
# encrypt some more fake ballots
self.more_fake_encrypted_ballots = []
for fake_ballot in self.more_fake_ballots:
self.more_fake_encrypted_ballots.append(
self.ballot_marking_device.encrypt(fake_ballot))
# encrypt some more fake ballots
self.more_fake_encrypted_spoiled_ballots = []
for fake_ballot in self.more_fake_spoiled_ballots:
self.more_fake_encrypted_spoiled_ballots.append(
self.ballot_marking_device.encrypt(fake_ballot))
# configure the ballot box
ballot_store = DataStore()
ballot_box = BallotBox(self.internal_manifest, self.context,
ballot_store)
ballot_box.cast(self.encrypted_fake_cast_ballot)
ballot_box.spoil(self.encrypted_fake_spoiled_ballot)
# Cast some more fake ballots
for fake_ballot in self.more_fake_encrypted_ballots:
ballot_box.cast(fake_ballot)
# Spoil some more fake ballots
for fake_ballot in self.more_fake_encrypted_spoiled_ballots:
ballot_box.spoil(fake_ballot)
# generate encrypted tally
self.ciphertext_tally = tally_ballots(ballot_store,
self.internal_manifest,
self.context)
self.ciphertext_ballots = get_ballots(ballot_store,
BallotBoxState.SPOILED)
def step_4_decrypt_tally(self) -> None:
"""
Homomorphically combine the selections made on all of the cast ballots
and use the Available Guardians to decrypt the combined tally.
In this way, no individual voter's cast ballot is ever decrypted drectly.
"""
# Generate a Homomorphically Accumulated Tally of the ballots
self.ciphertext_tally = get_optional(
tally_ballots(self.ballot_store, self.internal_manifest,
self.context))
self.ciphertext_ballots = get_ballots(self.ballot_store,
BallotBoxState.SPOILED)
self._assert_message(
tally_ballots.__qualname__,
f"""
- cast: {self.ciphertext_tally.cast()}
- spoiled: {self.ciphertext_tally.spoiled()}
Total: {len(self.ciphertext_tally)}
""",
self.ciphertext_tally is not None,
)
# Configure the Decryption
ciphertext_ballots = list(self.ciphertext_ballots.values())
self.decryption_mediator = DecryptionMediator(
"decryption-mediator",
self.context,
)
# Announce each guardian as present
count = 0
for guardian in self.guardians:
guardian_key = guardian.share_election_public_key()
tally_share = guardian.compute_tally_share(self.ciphertext_tally,
self.context)
ballot_shares = guardian.compute_ballot_shares(
ciphertext_ballots, self.context)
self.decryption_mediator.announce(guardian_key, tally_share,
ballot_shares)
count += 1
self._assert_message(
DecryptionMediator.announce.__qualname__,
f"Guardian Present: {guardian.id}",
len(self.decryption_mediator.get_available_guardians()) ==
count,
)
# Get the plaintext Tally
self.plaintext_tally = get_optional(
self.decryption_mediator.get_plaintext_tally(
self.ciphertext_tally))
self._assert_message(
DecryptionMediator.get_plaintext_tally.__qualname__,
"Tally Decrypted",
self.plaintext_tally is not None,
)
# Get the plaintext Spoiled Ballots
self.plaintext_spoiled_ballots = get_optional(
self.decryption_mediator.get_plaintext_ballots(ciphertext_ballots))
self._assert_message(
DecryptionMediator.get_plaintext_ballots.__qualname__,
"Spoiled Ballots Decrypted",
self.plaintext_tally is not None,
)
# Now, compare the results
self.compare_results()
def generate(
self,
number_of_ballots: int = DEFAULT_NUMBER_OF_BALLOTS,
cast_spoil_ratio: int = CAST_SPOIL_RATIO,
):
"""
Generate the sample data set
"""
# Clear the results directory
rmtree(RESULTS_DIR, ignore_errors=True)
# Configure the election
(
public_data,
private_data,
) = self.election_factory.get_hamilton_election_with_encryption_context(
)
plaintext_ballots = self.ballot_factory.generate_fake_plaintext_ballots_for_election(
public_data.metadata, number_of_ballots)
self.encrypter = EncryptionMediator(public_data.metadata,
public_data.context,
self.encryption_device)
# Encrypt some ballots
ciphertext_ballots: List[CiphertextBallot] = []
for plaintext_ballot in plaintext_ballots:
ciphertext_ballots.append(
get_optional(self.encrypter.encrypt(plaintext_ballot)))
ballot_store = BallotStore()
ballot_box = BallotBox(public_data.metadata, public_data.context,
ballot_store)
# Randomly cast/spoil the ballots
accepted_ballots: List[CiphertextAcceptedBallot] = []
for ballot in ciphertext_ballots:
if randint(0, 100) % cast_spoil_ratio == 0:
accepted_ballots.append(ballot_box.spoil(ballot))
else:
accepted_ballots.append(ballot_box.cast(ballot))
# Tally
ciphertext_tally = get_optional(
tally_ballots(ballot_store, public_data.metadata,
public_data.context))
# Decrypt
decrypter = DecryptionMediator(public_data.metadata,
public_data.context, ciphertext_tally)
for i, guardian in enumerate(private_data.guardians):
if i < QUORUM or not THRESHOLD_ONLY:
decrypter.announce(guardian)
plaintext_tally = get_optional(decrypter.get_plaintext_tally())
# Publish
publish(
public_data.description,
public_data.context,
public_data.constants,
[self.encryption_device],
accepted_ballots,
ciphertext_tally.spoiled_ballots.values(),
publish_ciphertext_tally(ciphertext_tally),
plaintext_tally,
public_data.guardians,
)
publish_private_data(plaintext_ballots, ciphertext_ballots,
private_data.guardians)
def generate(
self,
number_of_ballots: int = DEFAULT_NUMBER_OF_BALLOTS,
spoil_rate: int = DEFAULT_SPOIL_RATE,
use_all_guardians: bool = DEFAULT_USE_ALL_GUARDIANS,
):
"""
Generate the sample data set
"""
# Clear the results directory
rmtree(RESULTS_DIR, ignore_errors=True)
# Configure the election
(
manifest,
private_data,
) = self.election_factory.get_hamilton_manifest_with_encryption_context()
plaintext_ballots = (
self.ballot_factory.generate_fake_plaintext_ballots_for_election(
manifest.internal_manifest, number_of_ballots
)
)
self.encrypter = EncryptionMediator(
manifest.internal_manifest, manifest.context, self.encryption_device
)
# Encrypt some ballots
ciphertext_ballots: List[CiphertextBallot] = []
for plaintext_ballot in plaintext_ballots:
ciphertext_ballots.append(
get_optional(self.encrypter.encrypt(plaintext_ballot))
)
ballot_store = DataStore()
ballot_box = BallotBox(
manifest.internal_manifest, manifest.context, ballot_store
)
# Randomly cast/spoil the ballots
submitted_ballots: List[SubmittedBallot] = []
for ballot in ciphertext_ballots:
if randint(0, 100) < spoil_rate:
submitted_ballots.append(ballot_box.spoil(ballot))
else:
submitted_ballots.append(ballot_box.cast(ballot))
# Tally
spoiled_ciphertext_ballots = get_ballots(ballot_store, BallotBoxState.SPOILED)
ciphertext_tally = get_optional(
tally_ballots(ballot_store, manifest.internal_manifest, manifest.context)
)
# Decrypt
mediator = DecryptionMediator("sample-manifest-decrypter", manifest.context)
available_guardians = (
private_data.guardians
if use_all_guardians
else private_data.guardians[0:QUORUM]
)
DecryptionHelper.perform_decryption_setup(
available_guardians,
mediator,
manifest.context,
ciphertext_tally,
spoiled_ciphertext_ballots,
)
plaintext_tally = get_optional(mediator.get_plaintext_tally(ciphertext_tally))
plaintext_spoiled_ballots = get_optional(
mediator.get_plaintext_ballots(spoiled_ciphertext_ballots)
)
# Publish
publish(
manifest.manifest,
manifest.context,
manifest.constants,
[self.encryption_device],
submitted_ballots,
plaintext_spoiled_ballots.values(),
ciphertext_tally.publish(),
plaintext_tally,
manifest.guardians,
)
publish_private_data(
plaintext_ballots, ciphertext_ballots, private_data.guardians
)
