134 lines
5.3 KiB
Python
134 lines
5.3 KiB
Python
from uuid import UUID, uuid4
|
|
from pydantic import BaseModel
|
|
|
|
from src.models import EncipheredNKode
|
|
from src.user_cipher_keys import UserCipherKeys
|
|
from src.user_interface import UserInterface
|
|
from src.nkode_interface import CustomerInterface
|
|
|
|
|
|
class UserDBModel(BaseModel):
|
|
username: str
|
|
enciphered_passcode: EncipheredNKode
|
|
user_keys: UserCipherKeys
|
|
user_interface: UserInterface
|
|
|
|
|
|
class CustomerDBModel(BaseModel):
|
|
customer_id: UUID
|
|
interface: CustomerInterface
|
|
users: list[UserDBModel]
|
|
|
|
|
|
class SessionCacheModel(BaseModel):
|
|
session_id: UUID
|
|
set_interface: list[int] | None = None
|
|
confirm_interface: list[int] | None = None
|
|
set_key_entry: list[int] | None = None
|
|
confirm_key_entry: list[int] | None = None
|
|
username: str | None = None
|
|
customer_id: UUID
|
|
|
|
# timeout: datetime
|
|
|
|
|
|
class PseudoNKodeAPI(BaseModel):
|
|
customers: dict[UUID, CustomerDBModel] = {}
|
|
sessions: dict[UUID, SessionCacheModel] = {}
|
|
|
|
def generate_index_interface(self, customer_id: UUID) -> tuple[UUID, list[int]]:
|
|
assert (customer_id in self.customers.keys())
|
|
customer = self.customers[customer_id]
|
|
set_interface = UserInterface.new_interface(customer.interface.attrs_per_key, customer.interface.numb_keys)
|
|
new_session = SessionCacheModel(
|
|
session_id=uuid4(),
|
|
set_interface=set_interface.interface_index,
|
|
customer_id=customer_id,
|
|
)
|
|
self.sessions[new_session.session_id] = new_session
|
|
return new_session.session_id, new_session.set_interface
|
|
|
|
def get_login_index_interface(self):
|
|
pass
|
|
|
|
def set_nkode(
|
|
self, username: str, customer_id: UUID,
|
|
key_selection: list[int], session_id: UUID) -> list[int]:
|
|
assert (username not in [user.username for user in self.customers[customer_id].users])
|
|
assert (session_id in self.sessions.keys())
|
|
assert (customer_id == self.sessions[session_id].customer_id)
|
|
numb_of_keys = self.customers[customer_id].interface.numb_keys
|
|
attrs_per_key = self.customers[customer_id].interface.attrs_per_key
|
|
assert (all(0 <= key <= numb_of_keys for key in key_selection))
|
|
session = self.sessions[session_id]
|
|
set_interface = UserInterface(
|
|
interface_index=session.set_interface,
|
|
numb_sets=attrs_per_key,
|
|
numb_keys=numb_of_keys,
|
|
)
|
|
set_interface.disperse_interface()
|
|
session.username = username
|
|
session.set_key_entry = key_selection
|
|
session.confirm_interface = set_interface.interface_index
|
|
self.sessions[session_id] = session
|
|
return self.sessions[session_id].confirm_interface
|
|
|
|
def confirm_nkode(self, username: str, customer_id: UUID, confirm_key_entry: list[int], session_id: UUID):
|
|
assert (
|
|
session_id in self.sessions.keys() and
|
|
customer_id == self.sessions[session_id].customer_id and
|
|
username == self.sessions[session_id].username
|
|
)
|
|
customer = self.customers[customer_id]
|
|
numb_of_keys = customer.interface.numb_keys
|
|
attrs_per_key = customer.interface.attrs_per_key
|
|
assert(all(0 <= key <= numb_of_keys for key in confirm_key_entry))
|
|
passcode = self._deduce_passcode(session_id, numb_of_keys, attrs_per_key, confirm_key_entry)
|
|
attrs_per_key = customer.interface.numb_of_sets
|
|
set_values = customer.interface.set_vals
|
|
new_user_keys = UserCipherKeys.new_user_encipher_keys(numb_of_keys, attrs_per_key, set_values)
|
|
enciphered_passcode = new_user_keys.encipher_nkode(passcode, customer.interface)
|
|
new_user = UserDBModel(
|
|
username=username,
|
|
enciphered_passcode=enciphered_passcode,
|
|
user_keys=new_user_keys,
|
|
user_interface=self.sessions[session_id].confirm_interface
|
|
)
|
|
self.customers[customer_id].users.append(new_user)
|
|
return "success"
|
|
# del self.sessions[session_id]
|
|
|
|
def _deduce_passcode(self, session_id: UUID, numb_of_keys: int, attrs_per_key, confirm_key_entry: list[int]) -> list[int]:
|
|
session = self.sessions[session_id]
|
|
set_key_entry = session.set_key_entry
|
|
assert (len(set_key_entry) == len(confirm_key_entry))
|
|
set_interface = session.set_interface
|
|
confirm_interface = session.confirm_interface
|
|
set_key_vals = [set_interface[key*attrs_per_key:(key+1)*attrs_per_key] for key in set_key_entry]
|
|
confirm_key_vals = [confirm_interface[key*attrs_per_key:(key+1)*attrs_per_key] for key in confirm_key_entry]
|
|
|
|
passcode = []
|
|
for idx in range(len(set_key_entry)):
|
|
set_key = set(set_key_vals[idx])
|
|
confirm_key = set(confirm_key_vals[idx])
|
|
intersection = list(set_key.intersection(confirm_key))
|
|
assert (len(intersection) == 1)
|
|
passcode.append(intersection[0])
|
|
return passcode
|
|
|
|
def login(self):
|
|
pass
|
|
|
|
def renew_keys(self):
|
|
pass
|
|
|
|
def create_new_customer(self, numb_keys: int, numb_sets: int) -> CustomerDBModel:
|
|
new_customer = CustomerDBModel(
|
|
customer_id=uuid4(),
|
|
interface=CustomerInterface.new_interface(numb_keys, numb_sets),
|
|
users=[],
|
|
)
|
|
self.customers[new_customer.customer_id] = new_customer
|
|
|
|
return new_customer
|