From 65f3559ef006d73d3c99ff2ab6740ad6f0fe5726 Mon Sep 17 00:00:00 2001 From: Donovan Date: Thu, 20 Mar 2025 04:01:15 -0500 Subject: [PATCH] refactor set_key -> position_key --- docs/render_readme.py | 16 +- notebooks/nkode_tutorial.ipynb | 395 ++++++++++++++++----------------- src/customer.py | 4 +- src/models.py | 2 +- src/user.py | 4 +- src/user_cipher.py | 49 ++-- src/user_keypad.py | 6 +- test/test_user_cipher_keys.py | 12 +- 8 files changed, 241 insertions(+), 247 deletions(-) diff --git a/docs/render_readme.py b/docs/render_readme.py index 1f32057..92238e0 100644 --- a/docs/render_readme.py +++ b/docs/render_readme.py @@ -53,7 +53,7 @@ if __name__ == "__main__": policy = NKodePolicy( max_nkode_len=10, min_nkode_len=4, - distinct_sets=0, + distinct_positions=0, distinct_properties=4, byte_len=2, ) @@ -92,14 +92,14 @@ if __name__ == "__main__": passcode_server_prop = [customer.cipher.property_key[idx] for idx in user_passcode] passcode_server_set = customer.cipher.get_props_position_vals(user_passcode) user_keys = customer.users[username].cipher - + # TODO: pad_user_mask is deprecated padded_passcode_server_set = user_keys.pad_user_mask(np.array(passcode_server_set), customer.cipher.position_key) set_idx = [customer.cipher.get_position_index(set_val) for set_val in padded_passcode_server_set] - mask_set_keys = [user_keys.combined_set_key[idx] for idx in set_idx] + mask_set_keys = [user_keys.combined_position_key[idx] for idx in set_idx] ciphered_mask = mask_set_keys ^ padded_passcode_server_set ^ user_keys.mask_key mask = user_keys.encode_base64_str(ciphered_mask) - ciphered_customer_props = customer.cipher.property_key ^ user_keys.prop_key + ciphered_customer_props = customer.cipher.property_key ^ user_keys.property_key passcode_ciphered_props = [ciphered_customer_props[idx] for idx in user_passcode] pad_len = customer.nkode_policy.max_nkode_len - passcode_len passcode_ciphered_props.extend([0 for _ in range(pad_len)]) @@ -133,7 +133,7 @@ if __name__ == "__main__": user_mask = user.enciphered_passcode.mask decoded_mask = user_keys.decode_base64_str(user_mask) deciphered_mask = np.bitwise_xor(decoded_mask, user_keys.mask_key) - set_key_rand_component = np.bitwise_xor(set_vals, user_keys.combined_set_key) + set_key_rand_component = np.bitwise_xor(set_vals, user_keys.combined_position_key) login_passcode_sets = [] for set_cipher in deciphered_mask[:passcode_len]: set_idx = np.where(set_key_rand_component == set_cipher)[0][0] @@ -162,8 +162,8 @@ if __name__ == "__main__": sets_xor = np.bitwise_xor(new_sets, old_sets) for user in customer.users.values(): user.renew = True - user.cipher.combined_set_key = np.bitwise_xor(user.cipher.combined_set_key, sets_xor) - user.cipher.prop_key = np.bitwise_xor(user.cipher.prop_key, props_xor) + user.cipher.combined_position_key = np.bitwise_xor(user.cipher.combined_position_key, sets_xor) + user.cipher.property_key = np.bitwise_xor(user.cipher.property_key, props_xor) """ REFRESH USER KEYS @@ -184,7 +184,7 @@ if __name__ == "__main__": 'set_property_dict': set_property_dict, 'set_signup_keypad': signup_keypad, 'username': 'test_user', - 'user_passcode_indices': user_passcode, + 'passcode_property_indices': user_passcode, 'selected_keys_set': selected_keys_set, 'server_side_prop': server_side_prop, 'confirm_keypad': confirm_keypad, diff --git a/notebooks/nkode_tutorial.ipynb b/notebooks/nkode_tutorial.ipynb index 55495a6..64d4fdc 100644 --- a/notebooks/nkode_tutorial.ipynb +++ b/notebooks/nkode_tutorial.ipynb @@ -30,12 +30,12 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2025-03-19T14:18:48.405476Z", - "start_time": "2025-03-19T14:18:48.400091Z" + "end_time": "2025-03-20T08:32:08.092320Z", + "start_time": "2025-03-20T08:32:08.087658Z" } }, "outputs": [], - "execution_count": 195 + "execution_count": 27 }, { "cell_type": "code", @@ -53,12 +53,12 @@ "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2025-03-19T14:18:48.416324Z", - "start_time": "2025-03-19T14:18:48.413345Z" + "end_time": "2025-03-20T08:32:08.113043Z", + "start_time": "2025-03-20T08:32:08.110624Z" } }, "outputs": [], - "execution_count": 196 + "execution_count": 28 }, { "metadata": {}, @@ -77,8 +77,8 @@ "Each customer has unique cipher keys.\n", "These keys are used to encipher and decipher user nKode.\n", "There are two types of Customer Cipher Keys:\n", - "1. property key: Combined with the user property key to get the server-side representation of a users icons. Each property belongs to a set.\n", - "2. set key: Combined with the user set Key to the the server-side representation the position in each key.\n" + "1. property key: Combined with the user property key to get the server-side representation of a users icons.\n", + "2. position key: Combined with the user position key to the server-side representation the position in each key.\n" ], "metadata": { "collapsed": false @@ -90,7 +90,7 @@ "policy = NKodePolicy(\n", " max_nkode_len=10,\n", " min_nkode_len=4,\n", - " distinct_sets=0,\n", + " distinct_positions=0,\n", " distinct_properties=4,\n", ")\n", "keypad_size = KeypadSize(\n", @@ -99,21 +99,21 @@ ")\n", "customer_id = api.create_new_customer(keypad_size, policy)\n", "customer = api.customers[customer_id]\n", - "print(f\"Customer Set Key: {customer.cipher.position_key}\")\n", + "print(f\"Customer Position Key: {customer.cipher.position_key}\")\n", "print(f\"Customer Properties Key:\")\n", "customer_prop_keypad = customer.cipher.property_key.reshape(-1, keypad_size.props_per_key)\n", "for idx, key_vals in enumerate(customer_prop_keypad):\n", " print(f\"{key_vals}\")\n", - "set_properties_dict = dict(zip(customer.cipher.position_key, customer_prop_keypad.T))\n", - "print(f\"Set to Properties Map:\")\n", - "for set_val, props in set_properties_dict.items():\n", - " print(f\"{set_val}: {props}\")" + "position_properties_dict = dict(zip(customer.cipher.position_key, customer_prop_keypad.T))\n", + "print(f\"Position to Properties Map:\")\n", + "for pos_val, props in position_properties_dict.items():\n", + " print(f\"{pos_val}: {props}\")" ], "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2025-03-19T14:18:48.432441Z", - "start_time": "2025-03-19T14:18:48.426289Z" + "end_time": "2025-03-20T08:32:08.198233Z", + "start_time": "2025-03-20T08:32:08.193182Z" } }, "outputs": [ @@ -121,56 +121,56 @@ "name": "stdout", "output_type": "stream", "text": [ - "Customer Set Key: [52236 1143 22391 5610 24876 51604]\n", + "Customer Position Key: [21284 3999 4057 48308 14680 46323]\n", "Customer Properties Key:\n", - "[48274 26421 59355 34554 61533 13623]\n", - "[22492 47901 17487 10515 61939 8923]\n", - "[32708 61921 973 1449 52341 29868]\n", - "[10212 24136 41690 31747 29169 19891]\n", - "[18093 29532 18702 45116 15485 53514]\n", - "Set to Properties Map:\n", - "52236: [48274 22492 32708 10212 18093]\n", - "1143: [26421 47901 61921 24136 29532]\n", - "22391: [59355 17487 973 41690 18702]\n", - "5610: [34554 10515 1449 31747 45116]\n", - "24876: [61533 61939 52341 29169 15485]\n", - "51604: [13623 8923 29868 19891 53514]\n" + "[45633 21215 48438 45863 52540 14191]\n", + "[11907 4042 56372 63103 45179 58318]\n", + "[28909 48497 31171 15125 2886 9246]\n", + "[15651 10936 5595 16546 8096 13333]\n", + "[41923 43364 15227 43001 11056 62605]\n", + "Position to Properties Map:\n", + "21284: [45633 11907 28909 15651 41923]\n", + "3999: [21215 4042 48497 10936 43364]\n", + "4057: [48438 56372 31171 5595 15227]\n", + "48308: [45863 63103 15125 16546 43001]\n", + "14680: [52540 45179 2886 8096 11056]\n", + "46323: [14191 58318 9246 13333 62605]\n" ] } ], - "execution_count": 197 + "execution_count": 29 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-03-19T14:18:48.443885Z", - "start_time": "2025-03-19T14:18:48.441137Z" + "end_time": "2025-03-20T08:32:08.226660Z", + "start_time": "2025-03-20T08:32:08.224216Z" } }, "cell_type": "code", "source": [ "user_icon_keypad = user_icons.reshape(-1, keypad_size.props_per_key)\n", - "set_icons_dict = dict(zip(customer.cipher.position_key, user_icon_keypad.T))\n", - "print(\"Set to Icons Map:\")\n", - "for set_val, icons in set_icons_dict.items():\n", - " print(f\"{set_val}: {icons}\")\n" + "pos_icons_dict = dict(zip(customer.cipher.position_key, user_icon_keypad.T))\n", + "print(\"Position Value to Icons Map:\")\n", + "for pos_val, icons in pos_icons_dict.items():\n", + " print(f\"{pos_val}: {icons}\")\n" ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Set to Icons Map:\n", - "52236: ['😀' '🥺' '🤔' '🐱' '🦄']\n", - "1143: ['😂' '😡' '🙃' '🐶' '🌟']\n", - "22391: ['🥳' '😱' '😇' '🦁' '⚡']\n", - "5610: ['😍' '🤯' '🤖' '🐻' '🔥']\n", - "24876: ['🤓' '🥰' '👽' '🐸' '🍕']\n", - "51604: ['😎' '😴' '👾' '🐙' '🎉']\n" + "Position Value to Icons Map:\n", + "21284: ['😀' '🥺' '🤔' '🐱' '🦄']\n", + "3999: ['😂' '😡' '🙃' '🐶' '🌟']\n", + "4057: ['🥳' '😱' '😇' '🦁' '⚡']\n", + "48308: ['😍' '🤯' '🤖' '🐻' '🔥']\n", + "14680: ['🤓' '🥰' '👽' '🐸' '🍕']\n", + "46323: ['😎' '😴' '👾' '🐙' '🎉']\n" ] } ], - "execution_count": 198 + "execution_count": 30 }, { "metadata": {}, @@ -184,8 +184,8 @@ "\n", "#### Generate Keypad\n", " For the server to determine the users nkode, the user's keypad must be dispersable.\n", - " To make the keypad dispersable, the server will randomly drop properties sets to the number of properties is equal to the number of keys.\n", - " In our case, the server drops 1 properties set to give us a 5 X 5 keypad with possible index values ranging from 0-29.\n", + " To make the keypad dispersable, the server will randomly drop key positions so the number of properties per key is equal to the number of keys.\n", + " In our case, the server drops 1 key position to give us a 5 X 5 keypad with possible index values ranging from 0-29.\n", " - Run the cell below over and over to see it change. Notice that values never move out of their columns just their rows.\n", " - each value in the keypad is the index value of a customer properties\n", " - the user never learns what their server-side properties" @@ -194,8 +194,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-03-19T14:21:05.988739Z", - "start_time": "2025-03-19T14:21:05.981809Z" + "end_time": "2025-03-20T08:32:08.256237Z", + "start_time": "2025-03-20T08:32:08.250147Z" } }, "cell_type": "code", @@ -223,11 +223,11 @@ "name": "stdout", "output_type": "stream", "text": [ - "Key 0: ['🙃' '🥳' '🔥' '🐸' '👾']\n", - "Key 1: ['😡' '😱' '🤯' '🥰' '😴']\n", - "Key 2: ['🌟' '🦁' '🐻' '🍕' '😎']\n", - "Key 3: ['🐶' '⚡' '🤖' '👽' '🎉']\n", - "Key 4: ['😂' '😇' '😍' '🤓' '🐙']\n" + "Key 0: ['🦄' '😂' '😇' '👽' '😴']\n", + "Key 1: ['🐱' '🌟' '😱' '🐸' '😎']\n", + "Key 2: ['🤔' '🙃' '🦁' '🥰' '🐙']\n", + "Key 3: ['😀' '😡' '⚡' '🍕' '👾']\n", + "Key 4: ['🥺' '🐶' '🥳' '🤓' '🎉']\n" ] }, { @@ -244,11 +244,11 @@ "name": "stdout", "output_type": "stream", "text": [ - "Key 0: [13 2 27 22 17]\n", - "Key 1: [ 7 8 9 10 11]\n", - "Key 2: [25 20 21 28 5]\n", - "Key 3: [19 26 15 16 29]\n", - "Key 4: [ 1 14 3 4 23]\n" + "Key 0: [24 1 14 16 11]\n", + "Key 1: [18 25 8 22 5]\n", + "Key 2: [12 13 20 10 23]\n", + "Key 3: [ 0 7 26 28 17]\n", + "Key 4: [ 6 19 2 4 29]\n" ] }, { @@ -265,15 +265,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "Key 0: [32049 6729 60466 26997 1309]\n", - "Key 1: [61686 12369 40030 7765 16822]\n", - "Key 2: [29442 13543 37604 7572 18665]\n", - "Key 3: [29124 1259 53208 47841 51215]\n", - "Key 4: [48741 14803 46096 27958 19258]\n" + "Key 0: [41923 21215 31171 2886 58318]\n", + "Key 1: [15651 43364 56372 8096 14191]\n", + "Key 2: [28909 48497 5595 45179 13333]\n", + "Key 3: [45633 4042 15227 11056 9246]\n", + "Key 4: [11907 10936 48438 52540 62605]\n" ] } ], - "execution_count": 229 + "execution_count": 31 }, { "metadata": {}, @@ -286,19 +286,19 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-03-19T14:22:48.143268Z", - "start_time": "2025-03-19T14:22:48.140039Z" + "end_time": "2025-03-20T08:32:08.280568Z", + "start_time": "2025-03-20T08:32:08.277339Z" } }, "cell_type": "code", "source": [ "username = random_username()\n", "passcode_len = 4\n", - "user_passcode_indices = np.random.choice(set_signup_keypad.reshape(-1), size=passcode_len, replace=False).tolist()\n", - "selected_keys_set = select_keys_with_passcode_values(user_passcode_indices, set_signup_keypad, keypad_size.numb_of_keys)\n", - "print(f\"User Passcode Indices: {user_passcode_indices}\")\n", - "print(f\"User Passcode Icons: {user_icons[user_passcode_indices]}\")\n", - "print(f\"User Passcode Server-side properties: {customer.cipher.property_key[user_passcode_indices]}\")\n", + "passcode_property_indices = np.random.choice(set_signup_keypad.reshape(-1), size=passcode_len, replace=False).tolist()\n", + "selected_keys_set = select_keys_with_passcode_values(passcode_property_indices, set_signup_keypad, keypad_size.numb_of_keys)\n", + "print(f\"User Passcode Indices: {passcode_property_indices}\")\n", + "print(f\"User Passcode Icons: {user_icons[passcode_property_indices]}\")\n", + "print(f\"User Passcode Server-side properties: {customer.cipher.property_key[passcode_property_indices]}\")\n", "print(f\"Selected Keys: {selected_keys_set}\")" ], "outputs": [ @@ -306,27 +306,27 @@ "name": "stdout", "output_type": "stream", "text": [ - "User Passcode Indices: [11, 22, 1, 23]\n", - "User Passcode Icons: ['😴' '🐸' '😂' '🐙']\n", - "User Passcode Server-side properties: [16822 26997 48741 19258]\n", - "Selected Keys: [1, 0, 4, 4]\n" + "User Passcode Indices: [19, 7, 10, 6]\n", + "User Passcode Icons: ['🐶' '😡' '🥰' '🥺']\n", + "User Passcode Server-side properties: [10936 4042 45179 11907]\n", + "Selected Keys: [4, 3, 2, 4]\n" ] } ], - "execution_count": 237 + "execution_count": 32 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-03-19T14:18:48.697364Z", - "start_time": "2025-03-19T14:18:48.694055Z" + "end_time": "2025-03-20T08:32:08.316148Z", + "start_time": "2025-03-20T08:32:08.313495Z" } }, "cell_type": "code", "source": [ "confirm_keypad = api.set_nkode(username, customer_id, selected_keys_set, signup_session_id)\n", "keypad_view(confirm_keypad, keypad_size.numb_of_keys)\n", - "selected_keys_confirm = select_keys_with_passcode_values(user_passcode_indices, confirm_keypad, keypad_size.numb_of_keys)\n", + "selected_keys_confirm = select_keys_with_passcode_values(passcode_property_indices, confirm_keypad, keypad_size.numb_of_keys)\n", "print(f\"Selected Keys\\n{selected_keys_confirm}\")" ], "outputs": [ @@ -334,23 +334,23 @@ "name": "stdout", "output_type": "stream", "text": [ - "Key 0: [13 14 9 10 23]\n", - "Key 1: [25 20 21 4 17]\n", - "Key 2: [ 1 8 15 22 5]\n", - "Key 3: [19 26 27 28 11]\n", - "Key 4: [ 7 2 3 16 29]\n", + "Key 0: [18 7 20 4 11]\n", + "Key 1: [12 1 26 22 29]\n", + "Key 2: [ 0 19 14 10 5]\n", + "Key 3: [24 25 2 28 23]\n", + "Key 4: [ 6 13 8 16 17]\n", "Selected Keys\n", - "[2, 2, 3, 0]\n" + "[2, 0, 2, 4]\n" ] } ], - "execution_count": 202 + "execution_count": 33 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-03-19T14:18:49.028822Z", - "start_time": "2025-03-19T14:18:48.719642Z" + "end_time": "2025-03-20T08:32:08.575664Z", + "start_time": "2025-03-20T08:32:08.337518Z" } }, "cell_type": "code", @@ -360,7 +360,7 @@ "assert success" ], "outputs": [], - "execution_count": 203 + "execution_count": 34 }, { "metadata": {}, @@ -369,9 +369,9 @@ "## User Cipher\n", "\n", "Users have 4 cipher keys:\n", - "1. prop_key: Half of the user's server-side passcode. the counterpart to the `customer_prop_key`. A user's passcode is made from elements in `user_prop_key XOR customer_prop_key`. Each property belongs to a set.\n", + "1. property_key: The counterpart to the `customer_prop_key`. A user's server-side passcode is composed of elements in `user_prop_key XOR customer_prop_key`.\n", "2. pass_key: The passcode key is used to encipher user passcode\n", - "3. combined_set_key: The combined set key is `user_set_key XOR customer_set_key`. The user_set_key isn't stored and can't be recovered with the `customer_set_key`\n", + "3. combined_position_key: The combined position key is `user_pos_key XOR customer_pos_key`.\n", "4. mask_key: The mask key used to encipher user nKode\n", "\n", "\n" @@ -380,24 +380,24 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-03-19T14:18:49.044808Z", - "start_time": "2025-03-19T14:18:49.038903Z" + "end_time": "2025-03-20T08:32:08.588049Z", + "start_time": "2025-03-20T08:32:08.583087Z" } }, "cell_type": "code", "source": [ "from src.user_cipher import UserCipher\n", "user_cipher = UserCipher.create(keypad_size, customer.cipher.position_key, customer.nkode_policy.max_nkode_len)\n", - "user_prop_key_keypad = user_cipher.prop_key.reshape(-1, keypad_size.props_per_key)" + "user_prop_key_keypad = user_cipher.property_key.reshape(-1, keypad_size.props_per_key)" ], "outputs": [], - "execution_count": 204 + "execution_count": 35 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-03-19T14:18:49.056184Z", - "start_time": "2025-03-19T14:18:49.053919Z" + "end_time": "2025-03-20T08:32:08.596984Z", + "start_time": "2025-03-20T08:32:08.595221Z" } }, "cell_type": "code", @@ -408,21 +408,21 @@ "output_type": "stream", "text": [ "Property Key:\n", - "[[42472 31697 42349 63196 42777 61068]\n", - " [ 7243 387 55065 19589 60418 22963]\n", - " [26541 59081 11622 22333 35608 42306]\n", - " [58621 57412 35828 19293 16394 53334]\n", - " [ 5908 43761 45282 44085 8881 21753]]\n" + "[[43643 58945 45655 10493 17462 5635]\n", + " [42071 15680 60860 39600 15784 4102]\n", + " [60857 21300 14877 25869 12858 50934]\n", + " [55451 44486 22660 41758 36853 37697]\n", + " [24236 53340 57175 52425 5167 2017]]\n" ] } ], - "execution_count": 205 + "execution_count": 36 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-03-19T14:18:49.080744Z", - "start_time": "2025-03-19T14:18:49.078469Z" + "end_time": "2025-03-20T08:32:08.615012Z", + "start_time": "2025-03-20T08:32:08.613119Z" } }, "cell_type": "code", @@ -432,17 +432,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "Passcode Key: [15958 16933 12810 19682 61534 54403 52645 54893 63261 22611]\n" + "Passcode Key: [31049 4633 40678 55986 14115 22499 3470 53359 20871 60539]\n" ] } ], - "execution_count": 206 + "execution_count": 37 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-03-19T14:18:49.125439Z", - "start_time": "2025-03-19T14:18:49.123Z" + "end_time": "2025-03-20T08:32:08.639696Z", + "start_time": "2025-03-20T08:32:08.637469Z" } }, "cell_type": "code", @@ -452,119 +452,112 @@ "name": "stdout", "output_type": "stream", "text": [ - "Mask Key: [11511 36348 3693 57612 7883 59516 54039 57361 15218 43846]\n" + "Mask Key: [55361 38182 36656 63013 26815 17961 23911 65497 28524 60226]\n" ] } ], - "execution_count": 207 + "execution_count": 38 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-03-19T14:18:49.154768Z", - "start_time": "2025-03-19T14:18:49.152444Z" + "end_time": "2025-03-20T08:32:08.658960Z", + "start_time": "2025-03-20T08:32:08.657009Z" } }, "cell_type": "code", - "source": "print(f\"Combined Set Key: {user_cipher.combined_set_key}\")", + "source": "print(f\"Combined Position Key: {user_cipher.combined_position_key}\")", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Combined Set Key: [16302 28740 39642 59999 35588 576]\n" + "Combined Position Key: [33934 3750 42586 25190 7504 35546]\n" ] } ], - "execution_count": 208 + "execution_count": 39 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-03-19T14:18:49.188943Z", - "start_time": "2025-03-19T14:18:49.186648Z" + "end_time": "2025-03-20T08:32:08.678360Z", + "start_time": "2025-03-20T08:32:08.676228Z" } }, "cell_type": "code", - "source": "print(f\"User Set Key = combined_set_key XOR customer_set_key: {user_cipher.combined_set_key ^ customer.cipher.position_key}\")", + "source": "print(f\"User Position Key = combined_pos_key XOR customer_pos_key: {user_cipher.combined_position_key ^ customer.cipher.position_key}\")", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "User Set Key = combined_set_key XOR customer_set_key: [62370 29747 52653 65461 59944 52180]\n" + "User Position Key = combined_pos_key XOR customer_pos_key: [55210 313 43395 57042 9224 15913]\n" ] } ], - "execution_count": 209 + "execution_count": 40 }, { "metadata": { "ExecuteTime": { - "end_time": "2025-03-19T14:18:49.217942Z", - "start_time": "2025-03-19T14:18:49.215165Z" + "end_time": "2025-03-20T08:32:08.698976Z", + "start_time": "2025-03-20T08:32:08.696420Z" } }, "cell_type": "code", "source": [ - "set_properties_dict = dict(zip(user_cipher.combined_set_key, user_prop_key_keypad.T))\n", - "print(f\"Combined Set to Properties Map:\")\n", - "for set_val, props in set_properties_dict.items():\n", - " print(f\"{set_val}: {props}\")" + "position_properties_dict = dict(zip(user_cipher.combined_position_key, user_prop_key_keypad.T))\n", + "print(f\"Combined Position to Properties Map:\")\n", + "for pos_val, props in position_properties_dict.items():\n", + " print(f\"{pos_val}: {props}\")" ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Combined Set to Properties Map:\n", - "16302: [42472 7243 26541 58621 5908]\n", - "28740: [31697 387 59081 57412 43761]\n", - "39642: [42349 55065 11622 35828 45282]\n", - "59999: [63196 19589 22333 19293 44085]\n", - "35588: [42777 60418 35608 16394 8881]\n", - "576: [61068 22963 42306 53334 21753]\n" + "Combined Position to Properties Map:\n", + "33934: [43643 42071 60857 55451 24236]\n", + "3750: [58945 15680 21300 44486 53340]\n", + "42586: [45655 60860 14877 22660 57175]\n", + "25190: [10493 39600 25869 41758 52425]\n", + "7504: [17462 15784 12858 36853 5167]\n", + "35546: [ 5635 4102 50934 37697 2017]\n" ] } ], - "execution_count": 210 + "execution_count": 41 }, { "metadata": {}, "cell_type": "markdown", "source": [ "#### Encipher Mask\n", - "1. Order customer properties by user passcode.\n", - "2. Get the set indices (`set_indices`) of the ordered customer properties.\n", - "3. Pad the\n", - "1. combined_set_key = user_set_key ^ customer_set_key\n", - "2. padded_ordered_customer_set = customer_set_key # ordered by user passcode and padded with extra set key values to be equal to max_nkode_len\n", - "3. len(set_key) == len(mask_key) == len(padded_ordered_customer_set) == max_nkode_len == 10\n", - "where i is the index\n", - " \n", - "- mask = mask_key ^ padded_ordered_customer_set ^ ordered_combined_set_key\n", - "- mask = mask_key ^ (customer_set_key) ^ set_rand_numb ^ set_val\n", - "- mask = mask_rand_num ^ set_rand_numb # set_val is cancelled out" + "1. Get the `padded_passcode_position_indices`; padded with random position indices to equal length `max_nkode_len`.\n", + "2. Recover the `user_position_key`. Recall `user.cipher.combined_position_key = user_position_key XOR customer.cipher.positon_key`\n", + "3. Order the `user_position_key` by the `padded_passcode_position_indices`\n", + "4. Mask the `ordered_user_position_key`\n", + "5. Base 64 encode the mask" ] }, { "metadata": { "ExecuteTime": { - "end_time": "2025-03-19T14:18:49.244375Z", - "start_time": "2025-03-19T14:18:49.241861Z" + "end_time": "2025-03-20T08:32:08.762578Z", + "start_time": "2025-03-20T08:32:08.760236Z" } }, "cell_type": "code", "source": [ - "set_indices = customer.cipher.get_passcode_position_indices_padded(list(user_passcode_indices), customer.nkode_policy.max_nkode_len)\n", - "ordered_combined_set_key = user_cipher.combined_set_key[set_indices]\n", - "ordered_customer_set_key = customer.cipher.position_key[set_indices]\n", - "ordered_user_set_key = ordered_customer_set_key ^ ordered_combined_set_key\n", - "mask = ordered_user_set_key ^ user_cipher.mask_key\n", + "padded_passcode_position_indices = customer.cipher.get_passcode_position_indices_padded(list(passcode_property_indices), customer.nkode_policy.max_nkode_len)\n", + "user_position_key = user_cipher.combined_position_key ^ customer.cipher.position_key\n", + "ordered_user_position_key = user_position_key[padded_passcode_position_indices]\n", + "mask = ordered_user_position_key ^ user_cipher.mask_key\n", "encoded_mask = user_cipher.encode_base64_str(mask)" ], "outputs": [], - "execution_count": 211 + "execution_count": 42 }, { "metadata": {}, @@ -581,14 +574,14 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-03-19T14:18:49.575573Z", - "start_time": "2025-03-19T14:18:49.268784Z" + "end_time": "2025-03-20T08:32:09.024060Z", + "start_time": "2025-03-20T08:32:08.789902Z" } }, "cell_type": "code", "source": [ - "combined_prop_key = customer.cipher.property_key ^ user_cipher.prop_key\n", - "user_passcode = combined_prop_key[user_passcode_indices]\n", + "combined_prop_key = customer.cipher.property_key ^ user_cipher.property_key\n", + "user_passcode = combined_prop_key[passcode_property_indices]\n", "pad_len = customer.nkode_policy.max_nkode_len - passcode_len\n", "user_passcode_padded = np.concatenate((user_passcode, np.zeros(pad_len, dtype=user_passcode.dtype)))\n", "ciphered_passcode = user_passcode_padded ^ user_cipher.pass_key\n", @@ -596,7 +589,7 @@ "passcode_hash = bcrypt.hashpw(passcode_prehash, bcrypt.gensalt(rounds=12)).decode(\"utf-8\")" ], "outputs": [], - "execution_count": 212 + "execution_count": 43 }, { "metadata": {}, @@ -617,8 +610,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-03-19T14:18:49.585161Z", - "start_time": "2025-03-19T14:18:49.583132Z" + "end_time": "2025-03-20T08:32:09.032955Z", + "start_time": "2025-03-20T08:32:09.030937Z" } }, "cell_type": "code", @@ -631,7 +624,7 @@ ")" ], "outputs": [], - "execution_count": 213 + "execution_count": 44 }, { "metadata": {}, @@ -645,16 +638,16 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-03-19T14:18:49.901534Z", - "start_time": "2025-03-19T14:18:49.594710Z" + "end_time": "2025-03-20T08:32:09.273099Z", + "start_time": "2025-03-20T08:32:09.040255Z" } }, "cell_type": "code", "source": [ "login_keypad = api.get_login_keypad(username, customer_id)\n", "keypad_view(login_keypad, keypad_size.props_per_key)\n", - "selected_keys_login = select_keys_with_passcode_values(user_passcode_indices, login_keypad, keypad_size.props_per_key)\n", - "print(f\"User Passcode: {user_passcode_indices}\\n\")\n", + "selected_keys_login = select_keys_with_passcode_values(passcode_property_indices, login_keypad, keypad_size.props_per_key)\n", + "print(f\"User Passcode: {passcode_property_indices}\\n\")\n", "print(f\"Selected Keys:\\n {selected_keys_login}\\n\")\n", "success = api.login(customer_id, username, selected_keys_login)\n", "assert success" @@ -664,20 +657,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "Key 0: [ 6 19 8 3 4 23]\n", - "Key 1: [18 13 2 21 28 5]\n", - "Key 2: [12 25 14 15 16 11]\n", - "Key 3: [24 7 26 9 22 17]\n", - "Key 4: [ 0 1 20 27 10 29]\n", - "User Passcode: [15, 1, 19, 23]\n", + "Key 0: [24 1 14 27 16 11]\n", + "Key 1: [18 25 8 3 22 5]\n", + "Key 2: [12 13 20 21 10 23]\n", + "Key 3: [ 0 7 26 9 28 17]\n", + "Key 4: [ 6 19 2 15 4 29]\n", + "User Passcode: [19, 7, 10, 6]\n", "\n", "Selected Keys:\n", - " [2, 4, 0, 0]\n", + " [4, 3, 2, 4]\n", "\n" ] } ], - "execution_count": 214 + "execution_count": 45 }, { "metadata": {}, @@ -708,24 +701,24 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-03-19T14:18:49.914512Z", - "start_time": "2025-03-19T14:18:49.911338Z" + "end_time": "2025-03-20T08:32:09.282728Z", + "start_time": "2025-03-20T08:32:09.279895Z" } }, "cell_type": "code", "source": [ "login_keypad = api.get_login_keypad(username, customer_id)\n", - "selected_keys_login = select_keys_with_passcode_values(user_passcode_indices, login_keypad, keypad_size.props_per_key)\n", + "selected_keys_login = select_keys_with_passcode_values(passcode_property_indices, login_keypad, keypad_size.props_per_key)\n", "user = api.customers[customer_id].users[username]\n", "mask = user.cipher.decode_base64_str(user.enciphered_passcode.mask)\n", "deciphered_mask = mask ^ user.cipher.mask_key\n", - "set_key = customer.cipher.position_key ^ user.cipher.combined_set_key\n", + "set_key = customer.cipher.position_key ^ user.cipher.combined_position_key\n", "passcode_set_index = [int(np.where(set_key == set_cipher)[0][0]) for set_cipher in deciphered_mask[:passcode_len]]\n", "presumed_selected_properties_idx = customer.users[username].user_keypad.get_prop_idxs_by_keynumb_setidx(selected_keys_login, passcode_set_index)\n", - "assert user_passcode_indices == presumed_selected_properties_idx\n" + "assert passcode_property_indices == presumed_selected_properties_idx\n" ], "outputs": [], - "execution_count": 215 + "execution_count": 46 }, { "metadata": {}, @@ -735,8 +728,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-03-19T14:18:50.236818Z", - "start_time": "2025-03-19T14:18:49.932427Z" + "end_time": "2025-03-20T08:32:09.526068Z", + "start_time": "2025-03-20T08:32:09.295445Z" } }, "cell_type": "code", @@ -745,7 +738,7 @@ "assert valid_nkode\n" ], "outputs": [], - "execution_count": 216 + "execution_count": 47 }, { "metadata": {}, @@ -761,8 +754,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-03-19T14:18:50.851576Z", - "start_time": "2025-03-19T14:18:50.240709Z" + "end_time": "2025-03-20T08:32:09.996256Z", + "start_time": "2025-03-20T08:32:09.529950Z" } }, "cell_type": "code", @@ -777,7 +770,7 @@ "print_user_enciphered_code()\n", "\n", "login_keypad = api.get_login_keypad(username, customer_id)\n", - "selected_keys_login = select_keys_with_passcode_values(user_passcode_indices, login_keypad, keypad_size.props_per_key)\n", + "selected_keys_login = select_keys_with_passcode_values(passcode_property_indices, login_keypad, keypad_size.props_per_key)\n", "success = api.login(customer_id, username, selected_keys_login)\n", "assert success\n", "print_user_enciphered_code()" @@ -787,16 +780,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "mask: tBqaWnmsGlsclLRq7qdFeuZ/Krg=, code: $2b$12$iBdtB4bRMx9VnWKwAInkwecUx5wwiL1C0DVWO.sk9EG1syVVe2CaS\n", + "mask: cz9m1OunYlEK42X0jRrGAzKvheg=, code: $2b$12$Z.N7qwUTMgSVJFQC9hKgjeQ8owBpZMm5Aa14RQdiJH7C8l61QJENS\n", "\n", - "mask: tBqaWnmsGlsclLRq7qdFeuZ/Krg=, code: $2b$12$iBdtB4bRMx9VnWKwAInkwecUx5wwiL1C0DVWO.sk9EG1syVVe2CaS\n", + "mask: cz9m1OunYlEK42X0jRrGAzKvheg=, code: $2b$12$Z.N7qwUTMgSVJFQC9hKgjeQ8owBpZMm5Aa14RQdiJH7C8l61QJENS\n", "\n", - "mask: DpuEwDyPrOF4pAxxozyqUHigaak=, code: $2b$12$ngd6PgpZo/UhIANnrRimlOliRIGwAaS6zbe5gqTzYHPBaeAa3vJsy\n", + "mask: e+RtDYeB1G1RfuTOjCna6K9xLUU=, code: $2b$12$DHdD52jbBdVoXYArhWCm7eABlnch.tNhO/1Eipygj8fpoUFuPzyEC\n", "\n" ] } ], - "execution_count": 217 + "execution_count": 48 }, { "metadata": {}, @@ -810,8 +803,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-03-19T14:18:50.865243Z", - "start_time": "2025-03-19T14:18:50.861260Z" + "end_time": "2025-03-20T08:32:10.012897Z", + "start_time": "2025-03-20T08:32:10.009292Z" } }, "cell_type": "code", @@ -823,7 +816,7 @@ "new_sets = customer.cipher.position_key" ], "outputs": [], - "execution_count": 218 + "execution_count": 49 }, { "metadata": {}, @@ -836,8 +829,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-03-19T14:18:50.876670Z", - "start_time": "2025-03-19T14:18:50.874092Z" + "end_time": "2025-03-20T08:32:10.019285Z", + "start_time": "2025-03-20T08:32:10.017224Z" } }, "cell_type": "code", @@ -846,11 +839,11 @@ "sets_xor = np.bitwise_xor(new_sets, old_sets)\n", "for user in customer.users.values():\n", " user.renew = True\n", - " user.cipher.combined_set_key = np.bitwise_xor(user.cipher.combined_set_key, sets_xor)\n", - " user.cipher.prop_key = np.bitwise_xor(user.cipher.prop_key, props_xor)" + " user.cipher.combined_position_key = np.bitwise_xor(user.cipher.combined_position_key, sets_xor)\n", + " user.cipher.property_key = np.bitwise_xor(user.cipher.property_key, props_xor)" ], "outputs": [], - "execution_count": 219 + "execution_count": 50 }, { "metadata": {}, @@ -860,8 +853,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2025-03-19T14:18:51.191895Z", - "start_time": "2025-03-19T14:18:50.885862Z" + "end_time": "2025-03-20T08:32:10.260051Z", + "start_time": "2025-03-20T08:32:10.026503Z" } }, "cell_type": "code", @@ -875,7 +868,7 @@ "user.renew = False" ], "outputs": [], - "execution_count": 220 + "execution_count": 51 } ], "metadata": { diff --git a/src/customer.py b/src/customer.py index fd8b5cb..903eb64 100644 --- a/src/customer.py +++ b/src/customer.py @@ -16,7 +16,7 @@ class Customer: @classmethod def create(cls, nkode_policy: NKodePolicy, cipher: CustomerCipher) -> 'Customer': - if nkode_policy.distinct_sets > cipher.keypad_size.numb_of_keys: + if nkode_policy.distinct_positions > cipher.keypad_size.numb_of_keys: raise ValueError("Distinct sets cannot be greater than the number of keys") if nkode_policy.distinct_properties > cipher.keypad_size.total_props: raise ValueError("Distinct properties cannot be greater than the total number of properties") @@ -76,7 +76,7 @@ class Customer: distinct_properties = len(set(passcode_prop_idx)) if ( self.nkode_policy.min_nkode_len <= nkode_len <= self.nkode_policy.max_nkode_len and - distinct_sets >= self.nkode_policy.distinct_sets and + distinct_sets >= self.nkode_policy.distinct_positions and distinct_properties >= self.nkode_policy.distinct_properties ): return True diff --git a/src/models.py b/src/models.py index 121d29c..326e5f5 100644 --- a/src/models.py +++ b/src/models.py @@ -10,7 +10,7 @@ class EncipheredNKode: class NKodePolicy: max_nkode_len: int = 10 min_nkode_len: int = 4 - distinct_sets: int = 0 + distinct_positions: int = 0 distinct_properties: int = 4 byte_len: int = 2 # Todo: this should change the total number of bytes an properties or set value can be lock_out: int = 5 diff --git a/src/user.py b/src/user.py index 0700c0a..9023afa 100644 --- a/src/user.py +++ b/src/user.py @@ -18,8 +18,8 @@ class User: def renew_keys(self, set_xor: np.ndarray, prop_xor: np.ndarray): self.renew = True - self.cipher.combined_set_key = self.cipher.combined_set_key ^ set_xor - self.cipher.prop_key = self.cipher.prop_key ^ prop_xor + self.cipher.combined_position_key = self.cipher.combined_position_key ^ set_xor + self.cipher.property_key = self.cipher.property_key ^ prop_xor def refresh_passcode(self, passcode_prop_idxs: list[int], customer_cipher: CustomerCipher): self.cipher = UserCipher.create( diff --git a/src/user_cipher.py b/src/user_cipher.py index e5bd3de..42cfcc4 100644 --- a/src/user_cipher.py +++ b/src/user_cipher.py @@ -9,30 +9,31 @@ from src.customer_cipher import CustomerCipher @dataclass class UserCipher: - prop_key: np.ndarray - combined_set_key: np.ndarray + property_key: np.ndarray + combined_position_key: np.ndarray pass_key: np.ndarray mask_key: np.ndarray max_nkode_len: int @classmethod - def create(cls, keypad_size: KeypadSize, customer_set_key: np.ndarray, max_nkode_len: int) -> 'UserCipher': - if len(customer_set_key) != keypad_size.props_per_key: - raise ValueError("Invalid set values") - user_set_key = np.random.choice(2**16,size=keypad_size.props_per_key, replace=False) + def create(cls, keypad_size: KeypadSize, customer_pos_key: np.ndarray, max_nkode_len: int) -> 'UserCipher': + if len(customer_pos_key) != keypad_size.props_per_key: + raise ValueError("Invalid position values") + user_pos_key = np.random.choice(2**16,size=keypad_size.props_per_key, replace=False) return UserCipher( - prop_key=np.random.choice(2 ** 16, size=keypad_size.total_props, replace=False), + property_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), - combined_set_key=user_set_key ^ customer_set_key, + combined_position_key=user_pos_key ^ customer_pos_key, max_nkode_len=max_nkode_len ) - def pad_user_mask(self, user_mask: np.ndarray, set_vals: np.ndarray) -> np.ndarray: + def pad_user_mask(self, user_mask: np.ndarray, pos_vals: np.ndarray) -> np.ndarray: + # TODO: replace with new method if len(user_mask) >= self.max_nkode_len: raise ValueError("User encoded_mask is too long") padding_size = self.max_nkode_len - len(user_mask) - padding = np.random.choice(set_vals, size=padding_size, replace=True).astype(np.uint16) + padding = np.random.choice(pos_vals, size=padding_size, replace=True).astype(np.uint16) return np.concatenate([user_mask, padding]) @staticmethod @@ -90,7 +91,7 @@ class UserCipher: passcode_cipher = self.pass_key.copy() passcode_cipher[:passcode_len] = ( passcode_cipher[:passcode_len] ^ - self.prop_key[passcode_prop_idx] ^ + self.property_key[passcode_prop_idx] ^ customer_prop.property_key[passcode_prop_idx] ) return passcode_cipher.astype(np.uint16).tobytes() @@ -100,21 +101,21 @@ class UserCipher: passcode_prop_idx: list[int], customer_cipher: CustomerCipher ) -> str: - set_idxs = customer_cipher.get_passcode_position_indices_padded(passcode_prop_idx, len(self.mask_key)) - ordered_set_key = self.combined_set_key[set_idxs] - ordered_customer_key = customer_cipher.position_key[set_idxs] - mask = ordered_set_key ^ ordered_customer_key ^ self.mask_key + pos_idxs = customer_cipher.get_passcode_position_indices_padded(passcode_prop_idx, len(self.mask_key)) + ordered_pos_key = self.combined_position_key[pos_idxs] + ordered_customer_pos_key = customer_cipher.position_key[pos_idxs] + mask = ordered_pos_key ^ ordered_customer_pos_key ^ self.mask_key encoded_mask = self.encode_base64_str(mask) return encoded_mask - def decipher_mask(self, encoded_mask: str, customer_set_key: np.ndarray, passcode_len: int) -> list[int]: + def decipher_mask(self, encoded_mask: str, customer_pos_key: np.ndarray, passcode_len: int) -> list[int]: mask = self.decode_base64_str(encoded_mask) - # user_set_key ordered by the user's nkode and padded to be length max_nkode_len - ordered_set_key = mask ^ self.mask_key - user_set_key = customer_set_key ^ self.combined_set_key - passcode_sets = [] - for partial_set in ordered_set_key[:passcode_len]: - set_idx = np.where(user_set_key == partial_set)[0][0] - passcode_sets.append(int(customer_set_key[set_idx])) - return passcode_sets + # user_pos_key ordered by the user's nkode and padded to be length max_nkode_len + ordered_user_pos_key = mask ^ self.mask_key + user_pos_key = customer_pos_key ^ self.combined_position_key + passcode_position = [] + for position_val in ordered_user_pos_key[:passcode_len]: + position_idx = np.where(user_pos_key == position_val)[0][0] + passcode_position.append(int(customer_pos_key[position_idx])) + return passcode_position diff --git a/src/user_keypad.py b/src/user_keypad.py index 399c092..80efd27 100644 --- a/src/user_keypad.py +++ b/src/user_keypad.py @@ -83,16 +83,16 @@ class UserKeypad: if not (0 <= key_numb < self.keypad_size.numb_of_keys): raise ValueError(f"key_numb must be between 0 and {self.keypad_size.numb_of_keys - 1}") if not (0 <= set_idx < self.keypad_size.props_per_key): - raise ValueError(f"set_indices must be between 0 and {self.keypad_size.props_per_key - 1}") + raise ValueError(f"padded_passcode_position_indices must be between 0 and {self.keypad_size.props_per_key - 1}") keypad_prop_idx = self.keypad_matrix() return int(keypad_prop_idx[key_numb][set_idx]) def get_prop_idxs_by_keynumb_setidx(self, key_numb: list[int], set_idx: list[int]) -> list[int]: if len(key_numb) != len(set_idx): - raise ValueError("key_numb and set_indices must be the same length") + raise ValueError("key_numb and padded_passcode_position_indices must be the same length") if not all(0 <= kn < self.keypad_size.numb_of_keys for kn in key_numb): raise ValueError(f"All key_numb must be between 0 and {self.keypad_size.numb_of_keys - 1}") if not all(0 <= si < self.keypad_size.props_per_key for si in set_idx): - raise ValueError(f"All set_indices must be between 0 and {self.keypad_size.props_per_key - 1}") + raise ValueError(f"All padded_passcode_position_indices must be between 0 and {self.keypad_size.props_per_key - 1}") keypad_matrix = self.keypad_matrix() return keypad_matrix[key_numb, set_idx].reshape(-1).tolist() diff --git a/test/test_user_cipher_keys.py b/test/test_user_cipher_keys.py index 26845d5..d867995 100644 --- a/test/test_user_cipher_keys.py +++ b/test/test_user_cipher_keys.py @@ -29,10 +29,10 @@ def test_decode_mask(keypad_size, max_nkode_len): customer = CustomerCipher.create(keypad_size) passcode_entry = np.random.choice(keypad_size.total_props, 4, replace=False) passcode_values = [customer.property_key[idx] for idx in passcode_entry] - set_vals = customer.position_key - user_keys = UserCipher.create(keypad_size, set_vals, max_nkode_len) + customer_pos_vals = customer.position_key + user_keys = UserCipher.create(keypad_size, customer_pos_vals, max_nkode_len) passcode = user_keys.encipher_nkode(passcode_entry, customer) - orig_passcode_set_vals = customer.get_props_position_vals(passcode_values) - passcode_set_vals = user_keys.decipher_mask(passcode.mask, set_vals, len(passcode_entry)) - assert (len(passcode_set_vals) == len(orig_passcode_set_vals)) - assert (all(orig_passcode_set_vals[idx] == passcode_set_vals[idx] for idx in range(len(passcode_set_vals)))) + orig_passcode_pos_vals = customer.get_props_position_vals(passcode_values) + passcode_pos_vals = user_keys.decipher_mask(passcode.mask, customer_pos_vals, len(passcode_entry)) + assert (len(passcode_pos_vals) == len(orig_passcode_pos_vals)) + assert (all(orig_passcode_pos_vals[idx] == passcode_pos_vals[idx] for idx in range(len(passcode_pos_vals))))