Handle dates consistently (#366)

* Handle dates consistently

add hash tests

* use poetry to run mkdocs

* remove frozen attributes

https://bugs.python.org/issue43176

* extend test deadline

Author: AddressXception

Makefile

@@ -11,8 +11,10 @@ all: environment install build validate auto-lint coverage
 environment:
 	@echo 🔧 ENVIRONMENT SETUP
 	make install-gmp
-	make install-poetry
-	make install-mkdocs
+	#make install-poetry
+	#make install-mkdocs
+	pip install 'poetry==1.0.10'
+	poetry install
 	@echo 🚨 Be sure to add poetry to PATH
 
 install:
@@ -83,7 +85,7 @@ lint:
 	poetry build
 	poetry run twine check dist/*
 	@echo 5.Documentation
-	mkdocs build --strict
+	poetry run mkdocs build --strict
 
 auto-lint:
 	@echo 💚 AUTO LINT

src/electionguard/chaum_pedersen.py

@@ -21,7 +21,7 @@
 from .proof import Proof, ProofUsage
 
 
-@dataclass(frozen=True)
+@dataclass
 class DisjunctiveChaumPedersenProof(Proof):
     """
     Representation of disjunctive Chaum Pederson proof
@@ -137,7 +137,7 @@ def is_valid(
         return success
 
 
-@dataclass(frozen=True)
+@dataclass
 class ChaumPedersenProof(Proof):
     """
     Representation of a generic Chaum-Pedersen Zero Knowledge proof
@@ -253,7 +253,7 @@ def is_valid(
         return success
 
 
-@dataclass(frozen=True)
+@dataclass
 class ConstantChaumPedersenProof(Proof):
     """
     Representation of constant Chaum Pederson proof

src/electionguard/election.py

@@ -1,6 +1,15 @@
 from dataclasses import dataclass
 
-from .group import Q, P, R, G, ElementModQ, ElementModP
+from .group import (
+    Q,
+    P,
+    R,
+    G,
+    ElementModQ,
+    ElementModP,
+    int_to_p_unchecked,
+    int_to_q_unchecked,
+)
 from .hash import hash_elems
 from .serializable import Serializable
 
@@ -98,7 +107,12 @@ def make_ciphertext_election_context(
     # form the basis of subsequent hash computations.
 
     crypto_base_hash = hash_elems(
-        P, Q, G, number_of_guardians, quorum, description_hash
+        int_to_p_unchecked(P),
+        int_to_q_unchecked(Q),
+        int_to_p_unchecked(G),
+        number_of_guardians,
+        quorum,
+        description_hash,
     )
     crypto_extended_base_hash = hash_elems(crypto_base_hash, commitment_hash)
     return CiphertextElectionContext(

src/electionguard/elgamal.py

@@ -10,12 +10,12 @@
     pow_p,
     ZERO_MOD_Q,
     TWO_MOD_Q,
-    int_to_q,
     rand_range_q,
+    int_to_q_unchecked,
 )
 from .hash import hash_elems
-from .logs import log_error
-from .utils import flatmap_optional, get_optional
+from .logs import log_info, log_error
+from .utils import get_optional
 
 ELGAMAL_SECRET_KEY = ElementModQ
 ELGAMAL_PUBLIC_KEY = ElementModP
@@ -128,18 +128,22 @@ def elgamal_encrypt(
     :param m: Message to elgamal_encrypt; must be an integer in [0,Q).
     :param nonce: Randomly chosen nonce in [1,Q).
     :param public_key: ElGamal public key.
-    :return: A ciphertext tuple.
+    :return: An `ElGamalCiphertext`.
     """
     if nonce == ZERO_MOD_Q:
         log_error("ElGamal encryption requires a non-zero nonce")
         return None
 
-    return flatmap_optional(
-        int_to_q(m),
-        lambda e: ElGamalCiphertext(
-            g_pow_p(nonce), mult_p(g_pow_p(e), pow_p(public_key, nonce))
-        ),
-    )
+    pad = g_pow_p(nonce)
+    gpowp_m = g_pow_p(int_to_q_unchecked(m))
+    pubkey_pow_n = pow_p(public_key, nonce)
+    data = mult_p(gpowp_m, pubkey_pow_n)
+
+    log_info(f": publicKey: {public_key.to_hex()}")
+    log_info(f": pad: {pad.to_hex()}")
+    log_info(f": data: {data.to_hex()}")
+
+    return ElGamalCiphertext(pad, data)
 
 
 def elgamal_add(*ciphertexts: ElGamalCiphertext) -> ElGamalCiphertext:

src/electionguard/encrypt.py

@@ -1,3 +1,4 @@
+from datetime import datetime
 from typing import List, Optional
 from uuid import getnode
 
@@ -17,7 +18,7 @@
 from .election import CiphertextElectionContext
 from .elgamal import elgamal_encrypt
 from .group import ElementModP, ElementModQ, rand_q
-from .logs import log_warning
+from .logs import log_info, log_warning
 from .manifest import (
     InternalManifest,
     ContestDescription,
@@ -58,6 +59,8 @@ def __init__(
         self.launch_code = launch_code
         self.location = location
 
+        log_info(f": EncryptionDevice: Created: UUID: {uuid} at: {location}")
+
     def get_hash(self) -> ElementModQ:
         """
         Get hash for encryption device
@@ -67,8 +70,12 @@ def get_hash(self) -> ElementModQ:
             self.uuid, self.session_id, self.launch_code, self.location
         )
 
+    # pylint: disable=no-self-use
     def get_timestamp(self) -> int:
-        pass
+        """
+        Get the current timestamp in utc
+        """
+        return int(datetime.utcnow().timestamp())
 
 
 class EncryptionMediator:
@@ -79,7 +86,7 @@ class EncryptionMediator:
     """
 
     _internal_manifest: InternalManifest
-    _encryption: CiphertextElectionContext
+    _context: CiphertextElectionContext
     _encryption_seed: ElementModQ
 
     def __init__(
@@ -89,15 +96,17 @@ def __init__(
         encryption_device: EncryptionDevice,
     ):
         self._internal_manifest = internal_manifest
-        self._encryption = context
+        self._context = context
         self._encryption_seed = encryption_device.get_hash()
 
     def encrypt(self, ballot: PlaintextBallot) -> Optional[CiphertextBallot]:
         """
         Encrypt the specified ballot using the cached election context.
         """
+
+        log_info(f" encrypt: objectId: {ballot.object_id}")
         encrypted_ballot = encrypt_ballot(
-            ballot, self._internal_manifest, self._encryption, self._encryption_seed
+            ballot, self._internal_manifest, self._context, self._encryption_seed
         )
         if encrypted_ballot is not None and encrypted_ballot.code is not None:
             self._encryption_seed = encrypted_ballot.code
@@ -185,6 +194,10 @@ def encrypt_selection(
     selection_nonce = nonce_sequence[selection_description.sequence_order]
     disjunctive_chaum_pedersen_nonce = next(iter(nonce_sequence))
 
+    log_info(
+        f": encrypt_selection: for {selection_description.object_id} hash: {selection_description_hash.to_hex()}"
+    )
+
     selection_representation = selection.vote
 
     # Generate the encryption
@@ -442,6 +455,9 @@ def encrypt_ballot(
         random_master_nonce,
     )
 
+    log_info(f": manifest_hash : {internal_manifest.manifest_hash.to_hex()}")
+    log_info(f": encryption_seed : {encryption_seed.to_hex()}")
+
     encrypted_contests = encrypt_ballot_contests(
         ballot, internal_manifest, context, nonce_seed
     )

src/electionguard/guardian.py

@@ -97,7 +97,7 @@ def publish_guardian_record(election_public_key: ElectionPublicKey) -> GuardianR
     )
 
 
-@dataclass(frozen=True)
+@dataclass
 class PrivateGuardianRecord(Serializable):
     """Unpublishable private record containing information per Guardian"""
 

src/electionguard/logs.py

@@ -98,7 +98,7 @@ def get_stream_handler() -> logging.StreamHandler:
     Get a Stream Handler, sends only warnings and errors to stdout.
     """
     stream_handler = logging.StreamHandler(sys.stdout)
-    stream_handler.setLevel(logging.WARNING)
+    stream_handler.setLevel(logging.INFO)
     stream_handler.setFormatter(logging.Formatter(FORMAT))
     return stream_handler
 

src/electionguard/manifest.py

@@ -7,9 +7,9 @@
 from .election_object_base import ElectionObjectBase
 from .group import ElementModQ
 from .hash import CryptoHashable, hash_elems
-from .logs import log_warning
+from .logs import log_warning, log_debug
 from .serializable import Serializable
-from .utils import get_optional, to_ticks
+from .utils import get_optional, to_iso_date_string
 
 
 @unique
@@ -103,7 +103,9 @@ def crypto_hash(self) -> ElementModQ:
         """
         A hash representation of the object
         """
-        return hash_elems(self.annotation, self.value)
+        hash = hash_elems(self.annotation, self.value)
+        log_debug(f"{self.__class__} : crypto_hash: {hash.to_hex()}")
+        return hash
 
 
 @dataclass(eq=True, unsafe_hash=True)
@@ -120,7 +122,9 @@ def crypto_hash(self) -> ElementModQ:
         """
         A hash representation of the object
         """
-        return hash_elems(self.value, self.language)
+        hash = hash_elems(self.value, self.language)
+        log_debug(f"{self.__class__} : crypto_hash: {hash.to_hex()}")
+        return hash
 
 
 @dataclass(eq=True, unsafe_hash=True)
@@ -136,7 +140,9 @@ def crypto_hash(self) -> ElementModQ:
         """
         A hash representation of the object
         """
-        return hash_elems(self.text)
+        hash = hash_elems(self.text)
+        log_debug(f"{self.__class__} : crypto_hash: {hash.to_hex()}")
+        return hash
 
 
 @dataclass(eq=True, unsafe_hash=True)
@@ -155,7 +161,9 @@ def crypto_hash(self) -> ElementModQ:
         """
         A hash representation of the object
         """
-        return hash_elems(self.name, self.address_line, self.email, self.phone)
+        hash = hash_elems(self.name, self.address_line, self.email, self.phone)
+        log_debug(f"{self.__class__} : crypto_hash: {hash.to_hex()}")
+        return hash
 
 
 @dataclass(eq=True, unsafe_hash=True)
@@ -174,9 +182,11 @@ def crypto_hash(self) -> ElementModQ:
         """
         A hash representation of the object
         """
-        return hash_elems(
+        hash = hash_elems(
             self.object_id, self.name, str(self.type.name), self.contact_information
         )
+        log_debug(f"{self.__class__} : crypto_hash: {hash.to_hex()}")
+        return hash
 
 
 @dataclass(eq=True, unsafe_hash=True)
@@ -193,9 +203,11 @@ def crypto_hash(self) -> ElementModQ:
         """
         A hash representation of the object
         """
-        return hash_elems(
+        hash = hash_elems(
             self.object_id, self.geopolitical_unit_ids, self.party_ids, self.image_uri
         )
+        log_debug(f"{self.__class__} : crypto_hash: {hash.to_hex()}")
+        return hash
 
 
 @dataclass(eq=True, unsafe_hash=True)
@@ -220,13 +232,15 @@ def crypto_hash(self) -> ElementModQ:
         """
         A hash representation of the object
         """
-        return hash_elems(
+        hash = hash_elems(
             self.object_id,
             self.name,
             self.abbreviation,
             self.color,
             self.logo_uri,
         )
+        log_debug(f"{self.__class__} : crypto_hash: {hash.to_hex()}")
+        return hash
 
 
 @dataclass(eq=True, unsafe_hash=True)
@@ -256,7 +270,9 @@ def crypto_hash(self) -> ElementModQ:
         """
         A hash representation of the object
         """
-        return hash_elems(self.object_id, self.name, self.party_id, self.image_uri)
+        hash = hash_elems(self.object_id, self.name, self.party_id, self.image_uri)
+        log_debug(f"{self.__class__} : crypto_hash: {hash.to_hex()}")
+        return hash
 
 
 @dataclass(eq=True, unsafe_hash=True)
@@ -287,7 +303,9 @@ def crypto_hash(self) -> ElementModQ:
         """
         A hash representation of the object
         """
-        return hash_elems(self.object_id, self.sequence_order, self.candidate_id)
+        hash = hash_elems(self.object_id, self.sequence_order, self.candidate_id)
+        log_debug(f"{self.__class__} : crypto_hash: {hash.to_hex()}")
+        return hash
 
 
 # pylint: disable=too-many-instance-attributes
@@ -358,7 +376,7 @@ def crypto_hash(self) -> ElementModQ:
         description match up.
         """
         # remove any placeholders from the hash mechanism
-        return hash_elems(
+        hash = hash_elems(
             self.object_id,
             self.sequence_order,
             self.electoral_district_id,
@@ -370,6 +388,8 @@ def crypto_hash(self) -> ElementModQ:
             self.votes_allowed,
             self.ballot_selections,
         )
+        log_debug(f"{self.__class__} : crypto_hash: {hash.to_hex()}")
+        return hash
 
     def is_valid(self) -> bool:
         """
@@ -561,19 +581,20 @@ def crypto_hash(self) -> ElementModQ:
         """
         Returns a hash of the metadata components of the election
         """
-
-        return hash_elems(
+        hash = hash_elems(
             self.election_scope_id,
             str(self.type.name),
-            to_ticks(self.start_date),
-            to_ticks(self.end_date),
+            to_iso_date_string(self.start_date),
+            to_iso_date_string(self.end_date),
             self.name,
             self.contact_information,
             self.geopolitical_units,
             self.parties,
             self.contests,
             self.ballot_styles,
         )
+        log_debug(f"{self.__class__} : crypto_hash: {hash.to_hex()}")
+        return hash
 
     def is_valid(self) -> bool:
         """