test and validate signup with dispersable keypad and login with non-dispersable keypad

src/customer.py

@@ -12,6 +12,9 @@ class Customer(BaseModel):
     attributes: CustomerAttributes
     users: dict[str, User]
 
+    # TODO: validate policy and keypad size don't conflict
+
+
     def add_new_user(self, user: User):
         self.users[user.username] = user
 

src/customer_attributes.py

@@ -1,4 +1,4 @@
-from pydantic import BaseModel
+from pydantic import BaseModel, model_validator
 
 from src.models import KeypadSize
 from src.utils import generate_random_nonrepeating_list
@@ -9,6 +9,13 @@ class CustomerAttributes(BaseModel):
     set_vals: list[int]
     keypad_size: KeypadSize
 
+    @model_validator(mode='after')
+    def check_keys_vs_attrs(self):
+        if self.keypad_size.is_dispersable:
+            raise ValueError("number of keys must be less than the number of "
+                             "attributes per key to be dispersion resistant")
+        return self
+
     @staticmethod
     def new(keypad_size: KeypadSize):
         assert (keypad_size.numb_of_keys <= 256)

src/models.py

@@ -16,7 +16,7 @@ class NKodePolicy(BaseModel):
     min_nkode_len: int = 4
     distinct_sets: int = 0
     distinct_attributes: int = 4
-    # TODO: bytes_per_attr
+    byte_len: int = 2  # Todo: this should change the total number of bytes an attribute or set value can be
 
 
 class KeypadSize(BaseModel):
@@ -26,3 +26,7 @@ class KeypadSize(BaseModel):
     @property
     def numb_of_attrs(self) -> int:
         return self.attrs_per_key * self.numb_of_keys
+
+    @property
+    def is_dispersable(self) -> bool:
+        return self.attrs_per_key <= self.numb_of_keys

src/user_interface.py

@@ -16,28 +16,55 @@ class UserInterface(BaseModel):
             interface=list(range(keypad_size.numb_of_attrs)),
             keypad_size=keypad_size
         )
-        interface.disperse_interface()
-        for _ in range(10):
-            interface.shuffle_interface()
+        interface.random_interface_shuffle()
         return interface
 
+    def sign_up_interface(self):
+        assert (not self.keypad_size.is_dispersable)
+        self.random_interface_shuffle()
+        interface_matrix = self.interface_keypad_matrix()
+        attr_set_view = matrix_transpose(interface_matrix)
+        attr_set_view = secure_fisher_yates_shuffle(attr_set_view)
+        attr_set_view = attr_set_view[:self.keypad_size.numb_of_keys]
+        interface_matrix = matrix_transpose(attr_set_view)
+        return UserInterface(
+            interface=matrix_to_list(interface_matrix),
+            keypad_size=KeypadSize(
+                numb_of_keys=self.keypad_size.numb_of_keys,
+                attrs_per_key=self.keypad_size.numb_of_keys
+            )
+        )
+
+    def interface_keypad_matrix(self) -> list[list[int]]:
+        return list_to_matrix(self.interface, self.keypad_size.attrs_per_key)
+
+    def random_interface_shuffle(self):
+        keypad_view = self.interface_keypad_matrix()
+        keypad_view = secure_fisher_yates_shuffle(keypad_view)
+        set_view = matrix_transpose(keypad_view)
+        set_view = [secure_fisher_yates_shuffle(attr_set) for attr_set in set_view]
+        keypad_view = matrix_transpose(set_view)
+        self.interface = matrix_to_list(keypad_view)
+
     def disperse_interface(self):
+        assert (self.keypad_size.is_dispersable)
         user_interface_matrix = list_to_matrix(self.interface, self.keypad_size.attrs_per_key)
         shuffled_keys = secure_fisher_yates_shuffle(user_interface_matrix)
 
-        attr_rotation = secure_fisher_yates_shuffle(list(range(self.keypad_size.numb_of_keys)))[:self.keypad_size.attrs_per_key]
+        attr_rotation = secure_fisher_yates_shuffle(list(range(self.keypad_size.numb_of_keys)))[
+                        :self.keypad_size.attrs_per_key]
         dispersed_interface = self.random_attribute_rotation(
             shuffled_keys,
             attr_rotation,
         )
         self.interface = matrix_to_list(dispersed_interface)
 
-    def shuffle_interface(self):
+    def partial_interface_shuffle(self):
         numb_of_selected_sets = self.keypad_size.attrs_per_key // 2
         # randomly shuffle half the sets. if attrs_per_key is odd, randomly add one 50% of the time
         numb_of_selected_sets += choice([0, 1]) if (self.keypad_size.attrs_per_key & 1) == 1 else 0
         selected_sets = secure_fisher_yates_shuffle(list(range(self.keypad_size.attrs_per_key)))[:numb_of_selected_sets]
-        user_interface_matrix = list_to_matrix(self.interface, self.keypad_size.attrs_per_key)
+        user_interface_matrix = self.interface_keypad_matrix()
         shuffled_keys = secure_fisher_yates_shuffle(user_interface_matrix)
         interface_by_sets = []
         for idx, attrs in enumerate(matrix_transpose(shuffled_keys)):
@@ -60,7 +87,7 @@ class UserInterface(BaseModel):
         return matrix_transpose(transposed_user_interface)
 
     def attribute_adjacency_graph(self) -> dict[int, set[int]]:
-        user_interface_keypad = list_to_matrix(self.interface, self.keypad_size.attrs_per_key)
+        user_interface_keypad = self.interface_keypad_matrix()
         graph = {}
         for key in user_interface_keypad:
             for attr in key:
@@ -71,5 +98,5 @@ class UserInterface(BaseModel):
 
     def get_key_attr_idxs(self, key_numb: int) -> list[int]:
         assert (0 <= key_numb < self.keypad_size.numb_of_keys)
-        keypad_attr_idx = list_to_matrix(self.interface, self.keypad_size.attrs_per_key)
+        keypad_attr_idx = self.interface_keypad_matrix()
         return keypad_attr_idx[key_numb]

src/user_signup_session.py

@@ -9,6 +9,8 @@ from src.models import KeypadSize
 class UserSignupSession(BaseModel):
     session_id: UUID
     customer_id: UUID
+    login_interface: UserInterface
+
     keypad_size: KeypadSize
     set_interface: list[int] | None = None
     confirm_interface: list[int] | None = None