refactor loose files

src/nkode_api.py

@@ -0,0 +1,106 @@
+from uuid import UUID, uuid4
+from pydantic import BaseModel
+from src.customer import Customer
+from src.models import NKodePolicy, KeypadSize
+from src.user import User
+from src.user_cipher_keys import UserCipherKeys
+from src.user_signup_session import UserSignupSession
+from src.user_interface import UserInterface
+from src.customer_attributes import CustomerAttributes
+
+
+class NKodeAPI(BaseModel):
+    customers: dict[UUID, Customer] = {}
+    signup_sessions: dict[UUID, UserSignupSession] = {}
+
+    def create_new_customer(self, keypad_size: KeypadSize, nkode_policy: NKodePolicy) -> UUID:
+        new_customer = Customer(
+            customer_id=uuid4(),
+            attributes=CustomerAttributes.new(keypad_size),
+            users={},
+            nkode_policy=nkode_policy
+        )
+        self.customers[new_customer.customer_id] = new_customer
+
+        return new_customer.customer_id
+
+    def generate_signup_interface(self, customer_id: UUID) -> tuple[UUID, list[int]]:
+        assert (customer_id in self.customers.keys())
+        customer = self.customers[customer_id]
+        login_interface = UserInterface.new(customer.attributes.keypad_size)
+        set_interface = login_interface.sign_up_interface()
+        new_session = UserSignupSession(
+            session_id=uuid4(),
+            login_interface=login_interface,
+            set_interface=set_interface.interface,
+            customer_id=customer_id,
+            keypad_size=set_interface.keypad_size,
+        )
+        self.signup_sessions[new_session.session_id] = new_session
+        return new_session.session_id, new_session.set_interface
+
+    def set_nkode(
+            self,
+            username: str,
+            customer_id: UUID,
+            key_selection: list[int],
+            session_id: UUID
+    ) -> list[int]:
+        assert (customer_id in self.customers.keys())
+        customer = self.customers[customer_id]
+        assert (username not in customer.users.keys())
+        assert (session_id in self.signup_sessions.keys())
+        self.signup_sessions[session_id].set_user_nkode(username, key_selection)
+        return self.signup_sessions[session_id].confirm_interface
+
+    def confirm_nkode(
+            self,
+            username: str,
+            customer_id: UUID,
+            confirm_key_entry: list[int],
+            session_id: UUID
+    ) -> bool:
+        assert (
+                session_id in self.signup_sessions.keys() and
+                customer_id == self.signup_sessions[session_id].customer_id and
+                username == self.signup_sessions[session_id].username
+        )
+        customer = self.customers[customer_id]
+
+        passcode = self.signup_sessions[session_id].deduce_passcode(confirm_key_entry)
+        new_user_keys = UserCipherKeys.new(
+            customer.attributes.keypad_size,
+            customer.attributes.set_vals,
+            customer.nkode_policy.max_nkode_len
+        )
+
+        enciphered_passcode = new_user_keys.encipher_nkode(passcode, customer.attributes)
+        new_user = User(
+            username=username,
+            enciphered_passcode=enciphered_passcode,
+            user_keys=new_user_keys,
+            user_interface=self.signup_sessions[session_id].login_interface,
+        )
+        self.customers[customer_id].add_new_user(new_user)
+        del self.signup_sessions[session_id]
+        return True
+
+    def get_login_interface(self, username: str, customer_id: UUID) -> list[int]:
+        """
+        TODO: how do we prevent a targeted denial-of-service attack?
+        """
+        assert (customer_id in self.customers.keys())
+        customer = self.customers[customer_id]
+        assert (username in customer.users.keys())
+        user = customer.users[username]
+        user.user_interface.partial_interface_shuffle()
+        return user.user_interface.interface
+
+    def login(self, customer_id: UUID, username: str, key_selection: list[int]) -> bool:
+        assert (customer_id in self.customers.keys())
+        customer = self.customers[customer_id]
+        return customer.valid_key_entry(username, key_selection)
+
+    def renew_attributes(self, customer_id: UUID) -> bool:
+        assert (customer_id in self.customers.keys())
+        return self.customers[customer_id].renew_keys()