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

remove unneeded functions

Browse Source
This commit is contained in:
Donovan
2025-03-14 11:15:56 -05:00
parent 439b706fbd
commit 303f4a7457
7 changed files with 21 additions and 35 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
notebooks/dispersion_tutorial.ipynb
View File

@@ -19,7 +19,7 @@
"import numpy as np\n",
"\n",
"def keypad_md_table(keypad_list: np.ndarray, keypad_size: KeypadSize) -> str:\n",
" assert (keypad_size.numb_of_props == len(keypad_list))\n",
" assert (keypad_size.total_props == len(keypad_list))\n",
" keypad = keypad_list.reshape(-1, keypad_size.props_per_key)\n",
" table = \"|key|\" + \"\".join([f\"set{idx}|\" for idx in range(keypad_size.props_per_key)])\n",
" table += \"\\n|\" + \"\".join(\"-|\" for _ in range(keypad_size.props_per_key + 1))\n",

4
src/customer_cipher.py
View File

@@ -26,7 +26,7 @@ class CustomerCipher:
raise ValueError(f"Keys and properties per key must not exceed {cls.MAX_KEYS}")
# Using numpy to generate non-repeating random integers
prop_key = np.random.choice(2 ** 16, size=keypad_size.numb_of_props, replace=False)
prop_key = np.random.choice(2 ** 16, size=keypad_size.total_props, replace=False)
set_key = np.random.choice(2 ** 16, size=keypad_size.props_per_key, replace=False)
return cls(
@@ -36,7 +36,7 @@ class CustomerCipher:
)
def renew(self):
self.prop_key = np.random.choice(2 ** 16, size=self.keypad_size.numb_of_props, replace=False)
self.prop_key = np.random.choice(2 ** 16, size=self.keypad_size.total_props, replace=False)
self.set_key = np.random.choice(2 ** 16, size=self.keypad_size.props_per_key, replace=False)
def get_prop_set_val(self, prop: int) -> int:

2
src/models.py
View File

@@ -23,7 +23,7 @@ class KeypadSize:
numb_of_keys: int
@property
def numb_of_props(self) -> int:
def total_props(self) -> int:
return self.props_per_key * self.numb_of_keys
@property

42
src/user_cipher.py
View File

@@ -23,13 +23,13 @@ class UserCipher:
raise ValueError("Invalid set values")
set_values_array = np.array(set_values, dtype=np.uint16)
set_key = generate_random_nonrepeating_array(keypad_size.props_per_key)
set_key = np.random.choice(2**16,size=keypad_size.props_per_key, replace=False)
set_key = np.bitwise_xor(set_key, set_values_array)
return UserCipher(
prop_key=generate_random_nonrepeating_array(keypad_size.props_per_key * keypad_size.numb_of_keys),
pass_key=generate_random_nonrepeating_array(max_nkode_len),
mask_key=generate_random_nonrepeating_array(max_nkode_len),
prop_key=np.random.choice(2 ** 16, size=keypad_size.total_props, replace=False),
pass_key=np.random.choice(2 ** 16, size=max_nkode_len, replace=False),
mask_key=np.random.choice(2**16, size=max_nkode_len, replace=False),
set_key=set_key,
salt=bcrypt.gensalt(),
max_nkode_len=max_nkode_len
@@ -63,7 +63,7 @@ class UserCipher:
return np.array(int_list, dtype=np.uint16)
def _hash_passcode(self, passcode: np.ndarray) -> str:
passcode_bytes = int_array_to_bytes(passcode)
passcode_bytes = passcode.astype(np.uint16).tobytes()
passcode_digest = base64.b64encode(hashlib.sha256(passcode_bytes).digest())
hashed_data = bcrypt.hashpw(passcode_digest, self.salt)
return hashed_data.decode("utf-8")
@@ -88,20 +88,20 @@ class UserCipher:
passcode_prop_idx: list[int],
customer_prop: CustomerCipher,
) -> str:
passcode_prop_idx_array = np.array(passcode_prop_idx, dtype=np.uint16)
passcode_len = len(passcode_prop_idx_array)
passcode_props = np.array([customer_prop.prop_key[idx] for idx in passcode_prop_idx_array], dtype=np.uint16)
passcode_len = len(passcode_prop_idx)
passcode_cipher = self.pass_key.copy()
for idx in range(passcode_len):
prop_idx = passcode_prop_idx_array[idx]
passcode_cipher[idx] = passcode_cipher[idx] ^ self.prop_key[prop_idx] ^ passcode_props[idx]
passcode_cipher[:passcode_len] = (
passcode_cipher[:passcode_len] ^
self.prop_key[passcode_prop_idx] ^
customer_prop.prop_key[passcode_prop_idx]
)
return self._hash_passcode(passcode_cipher)
def encipher_mask(
self,
passcode_sets: list[int],
passcode_sets: np.ndarray,
customer_properites: CustomerCipher
) -> str:
padded_passcode_sets = self.pad_user_mask(passcode_sets, customer_properites.set_key)
@@ -131,21 +131,7 @@ class UserCipher:
set_idx = np.where(set_key_rand_component == set_cipher)[0][0]
passcode_sets.append(set_vals[set_idx])
return passcode_sets
# NumPy utility functions to replace the existing ones
def generate_random_nonrepeating_array(array_len: int, min_val: int = 0, max_val: int = 2 ** 16) -> np.ndarray:
if max_val - min_val < array_len:
raise ValueError("Range of values is less than the array length requested")
# Generate array of random unique integers
return np.random.choice(
np.arange(min_val, max_val, dtype=np.uint16),
size=array_len,
replace=False
)
return np.array(passcode_sets)
def int_array_to_bytes(int_arr: np.ndarray, byte_size: int = 2) -> bytes:
return b"".join([int(num).to_bytes(byte_size, byteorder='big') for num in int_arr])

2
src/user_keypad.py
View File

@@ -11,7 +11,7 @@ class UserKeypad:
@classmethod
def create(cls, keypad_size: KeypadSize) -> 'UserKeypad':
keypad = UserKeypad(
keypad=np.arange(keypad_size.numb_of_props),
keypad=np.arange(keypad_size.total_props),
keypad_size=keypad_size
)
keypad.random_keypad_shuffle()

2
test/test_nkode_interface.py
View File

@@ -9,7 +9,7 @@ from src.models import KeypadSize
)
def test_prop_set_idx(keypad_size):
user_keypad = UserKeypad.create(keypad_size)
for prop_idx in range(keypad_size.numb_of_props):
for prop_idx in range(keypad_size.total_props):
user_keypad_idx = user_keypad.keypad[prop_idx]
assert (prop_idx % keypad_size.props_per_key == user_keypad_idx % keypad_size.props_per_key)

2
test/test_user_cipher_keys.py
View File

@@ -29,7 +29,7 @@ def test_encode_decode_base64(passcode_len):
def test_decode_mask(keypad_size, max_nkode_len):
customer = CustomerCipher.create(keypad_size)
#passcode_entry = generate_random_nonrepeating_list(keypad_size.numb_of_props,max_val=keypad_size.numb_of_props)[:4]
passcode_entry = np.random.choice(keypad_size.numb_of_props, 4, replace=False)
passcode_entry = np.random.choice(keypad_size.total_props, 4, replace=False)
passcode_values = [customer.prop_key[idx] for idx in passcode_entry]
set_vals = customer.set_key
user_keys = UserCipher.create(keypad_size, set_vals, max_nkode_len)