Bug/cleanup output data (#138)

* ✨ Implement Scheduler for multi processing

- Add scheduler singleton to handle creating pools an closing pools. 
- Remove Pool references and replace scheduler
- Update tests and benchmarks

* Modify scheduler to include only one method

add tally methods to tally in batches

* fix naming

* Adjust proof fields to reflect new output requirements

also, fix a bug where the tally did not include the decryption shares, and where a few of the CP proofs were not using the crypto_extended_base_hash in their challenge inputs

* fix unused inports

* return int

* increase the deadline on slow tests

* fix imports

* fix CI Errors

* Address PR Feedback

* fix lint error

Co-authored-by: Keith Fung <keith.fung@infernored.com>
Co-authored-by: Keith Fung <keithrfung@users.noreply.github.com>

Author: AddressXception

bench/bench_chaum_pedersen.py

@@ -10,7 +10,7 @@
     ElGamalKeyPair,
     elgamal_encrypt,
 )
-from electionguard.group import ElementModQ, int_to_q_unchecked
+from electionguard.group import ElementModQ, int_to_q_unchecked, ONE_MOD_Q
 from electionguard.nonces import Nonces
 from electionguard.scheduler import Scheduler
 from electionguard.utils import get_optional
@@ -30,9 +30,11 @@ def chaum_pedersen_bench(bi: BenchInput) -> Tuple[float, float]:
     (keypair, r, s) = bi
     ciphertext = get_optional(elgamal_encrypt(0, r, keypair.public_key))
     start1 = timer()
-    proof = make_disjunctive_chaum_pedersen_zero(ciphertext, r, keypair.public_key, s)
+    proof = make_disjunctive_chaum_pedersen_zero(
+        ciphertext, r, keypair.public_key, ONE_MOD_Q, s
+    )
     end1 = timer()
-    valid = proof.is_valid(ciphertext, keypair.public_key)
+    valid = proof.is_valid(ciphertext, keypair.public_key, ONE_MOD_Q)
     end2 = timer()
     if not valid:
         raise Exception("Wasn't expecting an invalid proof during a benchmark!")

src/electionguard/ballot.py

@@ -203,7 +203,10 @@ class CiphertextBallotSelection(
     """encrypted representation of the extended_data field"""
 
     def is_valid_encryption(
-        self, seed_hash: ElementModQ, elgamal_public_key: ElementModP
+        self,
+        seed_hash: ElementModQ,
+        elgamal_public_key: ElementModP,
+        crypto_extended_base_hash: ElementModQ,
     ) -> bool:
         """
         Given an encrypted BallotSelection, validates the encryption state against a specific seed hash and public key.
@@ -233,7 +236,9 @@ def is_valid_encryption(
             log_warning(f"no proof exists for: {self.object_id}")
             return False
 
-        return self.proof.is_valid(self.ciphertext, elgamal_public_key)
+        return self.proof.is_valid(
+            self.ciphertext, elgamal_public_key, crypto_extended_base_hash
+        )
 
     def crypto_hash_with(self, seed_hash: ElementModQ) -> ElementModQ:
         """
@@ -262,6 +267,7 @@ def make_ciphertext_ballot_selection(
     description_hash: ElementModQ,
     ciphertext: ElGamalCiphertext,
     elgamal_public_key: ElementModP,
+    crypto_extended_base_hash: ElementModQ,
     proof_seed: ElementModQ,
     selection_representation: int,
     is_placeholder_selection: bool = False,
@@ -285,7 +291,12 @@ def make_ciphertext_ballot_selection(
         proof = flatmap_optional(
             nonce,
             lambda n: make_disjunctive_chaum_pedersen(
-                ciphertext, n, elgamal_public_key, proof_seed, selection_representation
+                ciphertext,
+                n,
+                elgamal_public_key,
+                crypto_extended_base_hash,
+                proof_seed,
+                selection_representation,
             ),
         )
 
@@ -443,7 +454,10 @@ def elgamal_accumulate(self) -> ElGamalCiphertext:
         return _ciphertext_ballot_elgamal_accumulate(self.ballot_selections)
 
     def is_valid_encryption(
-        self, seed_hash: ElementModQ, elgamal_public_key: ElementModP
+        self,
+        seed_hash: ElementModQ,
+        elgamal_public_key: ElementModP,
+        crypto_extended_base_hash: ElementModQ,
     ) -> bool:
         """
         Given an encrypted BallotContest, validates the encryption state against a specific seed hash and public key
@@ -475,7 +489,9 @@ def is_valid_encryption(
 
         # Verify the sum of the selections matches the proof
         elgamal_accumulation = self.elgamal_accumulate()
-        return self.proof.is_valid(elgamal_accumulation, elgamal_public_key)
+        return self.proof.is_valid(
+            elgamal_accumulation, elgamal_public_key, crypto_extended_base_hash
+        )
 
 
 def _ciphertext_ballot_elgamal_accumulate(
@@ -521,6 +537,7 @@ def make_ciphertext_ballot_contest(
     description_hash: ElementModQ,
     ballot_selections: List[CiphertextBallotSelection],
     elgamal_public_key: ElementModP,
+    crypto_extended_base_hash: ElementModQ,
     proof_seed: ElementModQ,
     number_elected: int,
     crypto_hash: Optional[ElementModQ] = None,
@@ -548,6 +565,7 @@ def make_ciphertext_ballot_contest(
                 r=ag,
                 k=elgamal_public_key,
                 seed=proof_seed,
+                hash_header=crypto_extended_base_hash,
             ),
         )
     return CiphertextBallotContest(
@@ -606,7 +624,7 @@ class CiphertextBallot(ElectionObjectBase, CryptoHashCheckable):
     When a ballot is in it's complete, encrypted state, the `nonce` is the master nonce
     from which all other nonces can be derived to encrypt the ballot.  Allong with the `nonce`
     fields on `Ballotcontest` and `BallotSelection`, this value is sensitive.
-     :field object_id: A unique Ballot ID that is relevant to the external system
+    :field object_id: A unique Ballot ID that is relevant to the external system
     """
 
     ballot_style: str
@@ -638,7 +656,16 @@ def __post_init__(self) -> None:
         self.timestamp = to_ticks(datetime.utcnow())
         self.generate_tracking(self.previous_tracking_hash)
 
-    @property
+    @staticmethod
+    def nonce_seed(
+        description_hash: ElementModQ, object_id: str, nonce: ElementModQ
+    ) -> ElementModQ:
+        """
+        :return: a representation of the election and the external Id in the nonce's used
+        to derive other nonce values on the ballot
+        """
+        return hash_elems(description_hash, object_id, nonce)
+
     def hashed_ballot_nonce(self) -> Optional[ElementModQ]:
         """
         :return: a hash value derived from the description hash, the object id, and the nonce value
@@ -651,7 +678,7 @@ def hashed_ballot_nonce(self) -> Optional[ElementModQ]:
             )
             return None
 
-        return hash_elems(self.description_hash, self.object_id, self.nonce)
+        return self.nonce_seed(self.description_hash, self.object_id, self.nonce)
 
     def generate_tracking(self, seed_hash: ElementModQ) -> None:
         """
@@ -691,7 +718,10 @@ def crypto_hash_with(self, seed_hash: ElementModQ) -> ElementModQ:
         return hash_elems(self.object_id, seed_hash, *contest_hashes)
 
     def is_valid_encryption(
-        self, seed_hash: ElementModQ, elgamal_public_key: ElementModP
+        self,
+        seed_hash: ElementModQ,
+        elgamal_public_key: ElementModP,
+        crypto_extended_base_hash: ElementModQ,
     ) -> bool:
         """
         Given an encrypted Ballot, validates the encryption state against a specific seed hash and public key
@@ -723,12 +753,16 @@ def is_valid_encryption(
             for selection in contest.ballot_selections:
                 valid_proofs.append(
                     selection.is_valid_encryption(
-                        selection.description_hash, elgamal_public_key
+                        selection.description_hash,
+                        elgamal_public_key,
+                        crypto_extended_base_hash,
                     )
                 )
             valid_proofs.append(
                 contest.is_valid_encryption(
-                    contest.description_hash, elgamal_public_key
+                    contest.description_hash,
+                    elgamal_public_key,
+                    crypto_extended_base_hash,
                 )
             )
         return all(valid_proofs)

src/electionguard/ballot_validator.py

@@ -22,7 +22,9 @@ def ballot_is_valid_for_election(
         return False
 
     if not ballot.is_valid_encryption(
-        context.crypto_extended_base_hash, context.elgamal_public_key,
+        metadata.description_hash,
+        context.elgamal_public_key,
+        context.crypto_extended_base_hash,
     ):
         log_warning(
             f"ballot_is_valid_for_election: mismatching ballot encryption {ballot.object_id}"