dkelly/pynkode
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

implement keypad size

Browse Source
This commit is contained in:
Donovan
2024-07-19 10:39:05 -05:00
parent b37c17eca6
commit 65d78867ca
13 changed files with 198 additions and 191 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/customer.py
View File

@@ -17,7 +17,7 @@ class Customer(BaseModel):
def valid_key_entry(self, username, selected_keys) -> bool:
assert (username in self.users.keys())
assert (all(key_idx < self.interface.numb_of_keys for key_idx in selected_keys))
assert (all(key_idx < self.interface.keypad_size.numb_of_keys for key_idx in selected_keys))
passcode_len = len(selected_keys)
user = self.users[username]

26
src/customer_interface.py
View File

@@ -1,33 +1,33 @@
from pydantic import BaseModel
from src.utils import generate_random_nonrepeating_list, list_to_matrix, matrix_transpose
from src.models import KeypadSize
from src.utils import generate_random_nonrepeating_list
class CustomerInterface(BaseModel):
attr_vals: list[int]
set_vals: list[int]
numb_of_keys: int
attrs_per_key: int
keypad_size: KeypadSize
@staticmethod
def new(numb_keys: int, attrs_per_key: int):
assert (numb_keys <= 256)
assert (attrs_per_key <= 256)
def new(keypad_size: KeypadSize):
assert (keypad_size.numb_of_keys <= 256)
assert (keypad_size.attrs_per_key <= 256)
return CustomerInterface(
attr_vals=generate_random_nonrepeating_list(attrs_per_key * numb_keys),
set_vals=generate_random_nonrepeating_list(attrs_per_key),
numb_of_keys=numb_keys,
attrs_per_key=attrs_per_key,
attr_vals=generate_random_nonrepeating_list(keypad_size.numb_of_attrs),
set_vals=generate_random_nonrepeating_list(keypad_size.attrs_per_key),
keypad_size=keypad_size,
)
def renew_interface(self):
self.attr_vals = generate_random_nonrepeating_list(self.attrs_per_key * self.numb_of_keys)
self.set_vals = generate_random_nonrepeating_list(self.attrs_per_key)
self.attr_vals = generate_random_nonrepeating_list(self.keypad_size.numb_of_attrs)
self.set_vals = generate_random_nonrepeating_list(self.keypad_size.attrs_per_key)
def get_attr_set_val(self, attr: int) -> int:
assert (attr in self.attr_vals)
attr_idx = self.attr_vals.index(attr)
set_idx = attr_idx % self.attrs_per_key
set_idx = attr_idx % self.keypad_size.attrs_per_key
return self.set_vals[set_idx]
def get_set_index(self, set_val: int) -> int:

9
src/models.py
View File

@@ -17,3 +17,12 @@ class NKodePolicy(BaseModel):
distinct_sets: int = 0
distinct_attributes: int = 4
# TODO: bytes_per_attr
class KeypadSize(BaseModel):
attrs_per_key: int
numb_of_keys: int
@property
def numb_of_attrs(self) -> int:
return self.attrs_per_key * self.numb_of_keys

3
src/user.py
View File

@@ -21,8 +21,7 @@ class User(BaseModel):
def refresh_passcode(self, passcode_attr_idx: list[int], customer_interface: CustomerInterface):
self.user_keys = UserCipherKeys.new(
customer_interface.numb_of_keys,
customer_interface.attrs_per_key,
customer_interface.keypad_size,
customer_interface.set_vals,
self.user_keys.max_nkode_len
)

10
src/user_cipher_keys.py
View File

@@ -4,7 +4,7 @@ import bcrypt
from secrets import choice
from pydantic import BaseModel
from src.models import EncipheredNKode
from src.models import EncipheredNKode, KeypadSize
from src.customer_interface import CustomerInterface
from src.utils import generate_random_nonrepeating_list, xor_lists, int_array_to_bytes
@@ -18,14 +18,14 @@ class UserCipherKeys(BaseModel):
max_nkode_len: int
@staticmethod
def new(numb_of_keys: int, attrs_per_key: int, set_values: list[int], max_nkode_len: int):
assert len(set_values) == attrs_per_key
def new(keypad_size: KeypadSize, set_values: list[int], max_nkode_len: int):
assert len(set_values) == keypad_size.attrs_per_key
set_key = generate_random_nonrepeating_list(attrs_per_key)
set_key = generate_random_nonrepeating_list(keypad_size.attrs_per_key)
set_key = xor_lists(set_key, set_values)
return UserCipherKeys(
alpha_key=generate_random_nonrepeating_list(attrs_per_key * numb_of_keys),
alpha_key=generate_random_nonrepeating_list(keypad_size.attrs_per_key * keypad_size.numb_of_keys),
pass_key=generate_random_nonrepeating_list(max_nkode_len),
mask_key=generate_random_nonrepeating_list(max_nkode_len),
set_key=set_key,

32
src/user_interface.py
View File

@@ -1,20 +1,20 @@
from pydantic import BaseModel
from secrets import choice
from src.models import KeypadSize
from src.utils import list_to_matrix, secure_fisher_yates_shuffle, matrix_to_list, matrix_transpose
class UserInterface(BaseModel):
attr_indices: list[int]
attrs_per_key: int
numb_of_keys: int
keypad_size: KeypadSize
@staticmethod
def new(attrs_per_key: int, numb_of_keys: int):
def new(keypad_size: KeypadSize):
# Todo: this a hack do a proper random interface
interface = UserInterface(
attr_indices=list(range(attrs_per_key * numb_of_keys)),
attrs_per_key=attrs_per_key,
numb_of_keys=numb_of_keys,
attr_indices=list(range(keypad_size.numb_of_attrs)),
keypad_size=keypad_size
)
interface.disperse_interface()
for _ in range(10):
@@ -22,18 +22,18 @@ class UserInterface(BaseModel):
return interface
def disperse_interface(self):
user_interface_matrix = list_to_matrix(self.attr_indices, self.attrs_per_key)
user_interface_matrix = list_to_matrix(self.attr_indices, self.keypad_size.attrs_per_key)
shuffled_keys = secure_fisher_yates_shuffle(user_interface_matrix)
dispersed_interface = self._random_attribute_rotation(shuffled_keys, list(range(self.attrs_per_key)))
dispersed_interface = self._random_attribute_rotation(shuffled_keys, list(range(self.keypad_size.attrs_per_key)))
self.attr_indices = matrix_to_list(dispersed_interface)
def shuffle_interface(self):
"""just like dispersion but only half the sets are rotated"""
numb_of_selected_sets = self.attrs_per_key // 2
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.attrs_per_key & 1) == 1 else 0
selected_sets = secure_fisher_yates_shuffle(list(range(self.attrs_per_key)))[:numb_of_selected_sets]
user_interface_matrix = list_to_matrix(self.attr_indices, self.attrs_per_key)
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.attr_indices, self.keypad_size.attrs_per_key)
shuffled_keys = secure_fisher_yates_shuffle(user_interface_matrix)
interface_by_sets = []
for idx, attrs in enumerate(matrix_transpose(shuffled_keys)):
@@ -44,7 +44,7 @@ class UserInterface(BaseModel):
self.attr_indices = matrix_to_list(matrix_transpose(interface_by_sets))
def _random_attribute_rotation(self, user_interface: list[list[int]], selected_sets: list[int]) -> list[list[int]]:
attr_rotation = secure_fisher_yates_shuffle(list(range(self.numb_of_keys)))[:self.attrs_per_key]
attr_rotation = secure_fisher_yates_shuffle(list(range(self.keypad_size.numb_of_keys)))[:self.keypad_size.attrs_per_key]
transposed_user_interface = matrix_transpose(user_interface)
assert (len(attr_rotation) == len(transposed_user_interface))
for idx, attr_set in enumerate(transposed_user_interface):
@@ -55,7 +55,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.attr_indices, self.attrs_per_key)
user_interface_keypad = list_to_matrix(self.attr_indices, self.keypad_size.attrs_per_key)
graph = {}
for key in user_interface_keypad:
for attr in key:
@@ -65,6 +65,6 @@ class UserInterface(BaseModel):
return graph
def get_key_attr_idxs(self, key_numb: int) -> list[int]:
assert (0 <= key_numb < self.numb_of_keys)
keypad_attr_idx = list_to_matrix(self.attr_indices, self.attrs_per_key)
assert (0 <= key_numb < self.keypad_size.numb_of_keys)
keypad_attr_idx = list_to_matrix(self.attr_indices, self.keypad_size.attrs_per_key)
return keypad_attr_idx[key_numb]

40
src/user_signup_session.py
View File

@@ -2,22 +2,23 @@ from uuid import UUID
from pydantic import BaseModel
from src.customer import Customer
from src.user import User
from src.user_cipher_keys import UserCipherKeys
from src.user_interface import UserInterface
from src.models import KeypadSize
class UserSignupSession(BaseModel):
session_id: UUID
customer_id: UUID
keypad_size: KeypadSize
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
def _deduce_passcode(self, attrs_per_key, confirm_key_entry: list[int]) -> list[int]:
def deduce_passcode(self, confirm_key_entry: list[int]) -> list[int]:
assert (all(0 <= key <= self.keypad_size.numb_of_keys for key in confirm_key_entry))
attrs_per_key = self.keypad_size.attrs_per_key
set_key_entry = self.set_key_entry
assert (len(set_key_entry) == len(confirm_key_entry))
set_interface = self.set_interface
@@ -35,37 +36,14 @@ class UserSignupSession(BaseModel):
passcode.append(intersection[0])
return passcode
def set_user_nkode(self, username: str, customer: Customer, key_selection: list[int]):
assert (customer.customer_id == self.customer_id)
numb_of_keys = customer.interface.numb_of_keys
attrs_per_key = customer.interface.attrs_per_key
assert (all(0 <= key <= numb_of_keys for key in key_selection))
def set_user_nkode(self, username: str, key_selection: list[int]):
assert (all(0 <= key <= self.keypad_size.numb_of_keys for key in key_selection))
set_interface = UserInterface(
attr_indices=self.set_interface,
attrs_per_key=attrs_per_key,
numb_of_keys=numb_of_keys,
keypad_size=self.keypad_size
)
set_interface.disperse_interface()
self.username = username
self.set_key_entry = key_selection
self.confirm_interface = set_interface.attr_indices
def create_user(self, username: str, customer: Customer, confirm_key_entry: list[int]) -> User:
numb_of_keys = customer.interface.numb_of_keys
attrs_per_key = customer.interface.attrs_per_key
assert (all(0 <= key <= numb_of_keys for key in confirm_key_entry))
passcode_attrs = self._deduce_passcode(attrs_per_key, confirm_key_entry)
set_values = customer.interface.set_vals
assert customer.valid_new_nkode(passcode_attrs)
new_user_keys = UserCipherKeys.new(numb_of_keys, attrs_per_key, set_values, customer.nkode_policy.max_nkode_len)
enciphered_passcode = new_user_keys.encipher_nkode(passcode_attrs, customer.interface)
return User(
username=username,
enciphered_passcode=enciphered_passcode,
user_keys=new_user_keys,
user_interface=UserInterface(
attr_indices=self.confirm_interface,
attrs_per_key=attrs_per_key,
numb_of_keys=numb_of_keys,
),
)