Use consistent tracking code format (#213)

* Use consistent tracking code format

* Fix LGTM errors

* fix linter error

Author: AddressXception

src/electionguard/group.py

@@ -3,6 +3,7 @@
 # made about timing or other side-channels.
 
 from typing import Any, Final, NamedTuple, Optional, Union
+from base64 import b16decode
 from secrets import randbelow
 from gmpy2 import mpz, powmod, invert, to_binary, from_binary
 
@@ -23,12 +24,19 @@ class ElementModQ(NamedTuple):
 
     elem: mpz
 
+    def to_bytes(self) -> bytes:
+        """
+        Converts from the element to the representation of bytes by first going through hex. 
+        This is preferable to directly accessing `elem`, whose representation might change.
+        """
+        return b16decode(self.to_hex())
+
     def to_hex(self) -> str:
         """
         Converts from the element to the hex representation of bytes. This is preferable to directly
         accessing `elem`, whose representation might change.
         """
-        h = format(self.elem, "02x")
+        h = format(self.elem, "02X")
         if len(h) % 2:
             h = "0" + h
         return h

src/electionguard/tracker.py

@@ -1,8 +1,7 @@
 from typing import List, Optional
-
 from .hash import hash_elems
-from .group import ElementModQ, q_to_bytes, bytes_to_q
-from .words import get_word, get_index_from_word
+from .group import ElementModQ
+from .words import get_word
 
 DEFAULT_SEPERATOR = "-"
 
@@ -39,32 +38,29 @@ def tracker_hash_to_words(
     :return: Human readable tracker string or None
     """
 
-    segments = q_to_bytes(tracker_hash)
+    segments = tracker_hash.to_bytes()
     words: List[str] = []
-    for value in segments:
-        word = get_word(value)
-        if word is None:
-            return None
-        words.append(word)
-    # FIXME ISSUE #82 Minimize length of tracker
-    return seperator.join(words)
+    for i in range(0, len(segments), 4):
+        # Select 4 bytes for the segment
+        first = segments[i]
+        second = segments[i + 1]
+        third = segments[i + 2]
+        fourth = segments[i + 3]
 
+        # word is byte(1) + 1/2 of byte(2)
+        word_part = get_word((first * 16 + (second >> 4)))
 
-def tracker_words_to_hash(
-    tracker_words: str, seperator: str = DEFAULT_SEPERATOR
-) -> Optional[ElementModQ]:
-    """
-    Convert tracker from human readable / friendly words to hash
-    :param tracker_words: Tracker words
-    :param seperator: Seperator used between words
-    :return: Tracker hash or None
-    """
-    words = tracker_words.split(seperator)
-    int_values: List[int] = []
-    for word in words:
-        index = get_index_from_word(word)
-        if index is None:
+        # hex is other 1/2 of byte(2) + byte(3) + byte(4)
+        hex_part = [
+            format((second & 0x0F) >> 0, "1X"),
+            format((third & 0xF0) >> 4, "1X"),
+            format((third & 0x0F) >> 0, "1X"),
+            format((fourth & 0xF0) >> 4, "1X"),
+            format((fourth & 0x0F) >> 0, "1X"),
+        ]
+        if word_part is None:
             return None
-        int_values.append(index)
-    value = bytes(int_values)
-    return bytes_to_q(value)
+        words.append(word_part)
+        words.append("".join(hex_part))
+    # FIXME ISSUE #82 Minimize length of tracker
+    return seperator.join(words)

src/electionguard/words.py

@@ -14,7 +14,7 @@ def get_word(index: int) -> Optional[str]:
         return None
     if index > MAX_INDEX:
         return None
-    return words[index]
+    return words[index & 0xFFF]
 
 
 def get_index_from_word(word: str) -> Optional[int]:

tests/test_tracker.py

@@ -6,7 +6,6 @@
 
 from electionguard.tracker import (
     tracker_hash_to_words,
-    tracker_words_to_hash,
     get_rotating_tracker_hash,
     get_hash_for_device,
 )
@@ -56,11 +55,25 @@ def test_tracker_converts_to_words(self):
         device_words = tracker_hash_to_words(device_hash)
         tracker_words = tracker_hash_to_words(tracker_hash)
         tracker_different_words = tracker_hash_to_words(tracker_hash_different)
-        tracker_hash_from_words = tracker_words_to_hash(tracker_words)
 
         # Assert
         self.assertIsNotNone(device_words)
         self.assertIsNotNone(tracker_words)
         self.assertNotEqual(device_words, tracker_words)
         self.assertNotEqual(tracker_different_words, tracker_words)
-        self.assertEqual(tracker_hash, tracker_hash_from_words)
+
+    def test_tracker_converts_to_known_words(self):
+        expected_hash = (
+            "325AB2622D35311DB0320C9F3B421EE93017D16B9E4C7FEF06704EDA4FA5E30B"
+        )
+        expected_words = "change-AB262-cart-5311D-ladder-20C9F-cloudburst-21EE9-cellar-7D16B-illegal-C7FEF-alias-04EDA-curriculum-5E30B"
+
+        device_hash = ONE_MOD_Q
+        ballot_hash = TWO_MOD_Q
+        timestamp = 1000
+
+        tracker_hash = get_rotating_tracker_hash(device_hash, timestamp, ballot_hash)
+        tracker_words = tracker_hash_to_words(tracker_hash)
+
+        self.assertEqual(tracker_hash.to_hex(), expected_hash)
+        self.assertEqual(tracker_words, expected_words)