implement and test renew keys

src/nkode_interface.py

@@ -17,12 +17,16 @@ class CustomerInterface(BaseModel):
         assert (attrs_per_key <= 256)
 
         return CustomerInterface(
-            customer_interface=generate_random_nonrepeating_list(attrs_per_key*numb_keys),
+            customer_interface=generate_random_nonrepeating_list(attrs_per_key * numb_keys),
             set_vals=generate_random_nonrepeating_list(attrs_per_key),
             numb_keys=numb_keys,
             attrs_per_key=attrs_per_key,
         )
 
+    def renew_interface(self):
+        self.customer_interface = generate_random_nonrepeating_list(self.attrs_per_key * self.numb_keys)
+        self.set_vals = generate_random_nonrepeating_list(self.attrs_per_key)
+
     def get_interface_by_set(self) -> dict[int, list[int]]:
         interface_by_set = {self.set_vals[set_val]: [] for set_val in self.set_vals}
         for idx, attr_set in enumerate(self.interface):
@@ -37,11 +41,11 @@ class CustomerInterface(BaseModel):
         return secure_fisher_yates_shuffle(list(range(len(self.interface))))
 
     def get_attr_set_val(self, attr: int) -> int:
-        assert(attr in self.customer_interface)
+        assert (attr in self.customer_interface)
         attr_idx = self.customer_interface.index(attr)
         set_idx = attr_idx % self.attrs_per_key
         return self.set_vals[set_idx]
 
     def get_set_index(self, set_val: int) -> int:
-        assert(set_val in self.set_vals)
+        assert (set_val in self.set_vals)
         return self.set_vals.index(set_val)

src/pseudo_nkode_api.py

@@ -5,6 +5,7 @@ from src.models import EncipheredNKode
 from src.user_cipher_keys import UserCipherKeys
 from src.user_interface import UserInterface
 from src.nkode_interface import CustomerInterface
+from src.utils import xor_lists
 
 
 class UserDBModel(BaseModel):
@@ -13,9 +14,19 @@ class UserDBModel(BaseModel):
     user_keys: UserCipherKeys
     user_interface: UserInterface
 
-    def get_passcode_set_vals(self) -> list[int]:
-        pass
+    def renew_keys(self, sets_xor: list[int], attrs_xor: list[int]):
+        self.user_keys.renew = True
+        self.user_keys.set_key = xor_lists(self.user_keys.set_key, sets_xor)
+        self.user_keys.alpha_key = xor_lists(self.user_keys.alpha_key, attrs_xor)
 
+    def refresh_passcode(self, passcode_attr_idx: list[int], customer_interface: CustomerInterface):
+        self.user_keys = UserCipherKeys.new_user_encipher_keys(
+            customer_interface.numb_keys,
+            customer_interface.attrs_per_key,
+            customer_interface.set_vals
+
+        )
+        self.enciphered_passcode = self.user_keys.encipher_nkode(passcode_attr_idx, customer_interface)
 
 class CustomerDBModel(BaseModel):
     customer_id: UUID
@@ -36,19 +47,37 @@ class CustomerDBModel(BaseModel):
         set_vals_idx = [self.interface.get_set_index(set_val) for set_val in passcode_set_vals]
 
         presumed_selected_attributes = []
+        presumed_selected_attributes_idx = []
         for idx in range(passcode_len):
             key_numb = selected_keys[idx]
             key_attribute_idxs = user.user_interface.get_key_attr_idxs(key_numb)
 
             set_idx = set_vals_idx[idx]
             selected_attr_idx = key_attribute_idxs[set_idx]
+            presumed_selected_attributes_idx.append(selected_attr_idx)
             presumed_selected_attributes.append(selected_attr_idx)
 
         enciphered_attr = user.user_keys.encipher_salt_hash_code(presumed_selected_attributes, self.interface)
-        if enciphered_attr == user.enciphered_passcode.code:
-            return True
+        if enciphered_attr != user.enciphered_passcode.code:
+            return False
 
-        return False
+        if user.user_keys.renew:
+            user.refresh_passcode(presumed_selected_attributes_idx, self.interface)
+
+        return True
+
+    def renew_keys(self) -> bool:
+        attrs_before = self.interface.customer_interface.copy()
+        sets_before = self.interface.set_vals.copy()
+        self.interface.renew_interface()
+        attrs_after = self.interface.customer_interface
+        sets_after = self.interface.set_vals
+
+        attrs_xor = xor_lists(attrs_after, attrs_before)
+        set_xor = xor_lists(sets_after, sets_before)
+        for user in self.users.values():
+            user.renew_keys(set_xor, attrs_xor)
+        return True
 
 
 class SessionCacheModel(BaseModel):
@@ -166,8 +195,9 @@ class PseudoNKodeAPI(BaseModel):
         customer = self.customers[customer_id]
         return customer.valid_key_entry(username, key_selection)
 
-    def renew_keys(self):
-        pass
+    def renew_keys(self, customer_id: UUID) -> bool:
+        assert (customer_id in self.customers.keys())
+        return self.customers[customer_id].renew_keys()
 
     def create_new_customer(self, numb_keys: int, numb_sets: int) -> CustomerDBModel:
         new_customer = CustomerDBModel(

src/user_cipher_keys.py

@@ -16,6 +16,7 @@ class UserCipherKeys(BaseModel):
     mask_key: list[int]
     salt: bytes
     max_nkode_len: int = 10
+    renew: bool = False
 
     @staticmethod
     def new_user_encipher_keys(numb_of_keys: int, attrs_per_key: int, set_values: list[int]):