From 2ccf6471375abca412deec3add5965c47050cb8b Mon Sep 17 00:00:00 2001 From: Donovan Date: Sun, 30 Mar 2025 05:01:21 -0500 Subject: [PATCH] update README; and environment.yaml --- README.md | 35 ++++++++++- environment.yml | 125 ++++++++++++++++++++++++++++++++++++++ notebooks/evilkode.ipynb | 128 +++++++++++++++++++++++++-------------- src/keypad.py | 15 ++++- 4 files changed, 255 insertions(+), 48 deletions(-) create mode 100644 environment.yml diff --git a/README.md b/README.md index f30e9f0..d8af45f 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,36 @@ # Evil nKode -Simulated nKode Cracker \ No newline at end of file +Simulated nKode Cracker + +## Installation + +- Python version 3.10 or greater is required +- Install conda (or your preferred tool) for environment management + +### Using conda +```bash +conda env create -f environment.yml +conda activate pynkode +``` + +## Starting a Jupyter Notebook + +### Option 1: Using classic Jupyter Notebook +```bash +# Ensure your environment is activated +# For conda: conda activate pynkode +# For pyenv: (should be automatic if in the directory) + +# Start the Jupyter Notebook server +jupyter notebook +``` + +### Option 2: Using JupyterLab +```bash +# Ensure your environment is activated +# Start JupyterLab +jupyter lab +``` + +## Notebooks +- [evilnkode](notebooks/evilkode.ipynb) diff --git a/environment.yml b/environment.yml new file mode 100644 index 0000000..e55411a --- /dev/null +++ b/environment.yml @@ -0,0 +1,125 @@ +name: evilnkode +channels: + - defaults +dependencies: + - anyio=4.6.2=py312hca03da5_0 + - appnope=0.1.3=py312hca03da5_1001 + - argon2-cffi=21.3.0=pyhd3eb1b0_0 + - argon2-cffi-bindings=21.2.0=py312h80987f9_0 + - asttokens=2.0.5=pyhd3eb1b0_0 + - async-lru=2.0.4=py312hca03da5_0 + - attrs=24.2.0=py312hca03da5_0 + - babel=2.11.0=py312hca03da5_0 + - beautifulsoup4=4.12.3=py312hca03da5_0 + - bleach=6.2.0=py312hca03da5_0 + - brotli-python=1.0.9=py312h313beb8_8 + - bzip2=1.0.8=h80987f9_6 + - ca-certificates=2024.12.31=hca03da5_0 + - certifi=2024.12.14=py312hca03da5_0 + - cffi=1.17.1=py312h3eb5a62_0 + - charset-normalizer=3.3.2=pyhd3eb1b0_0 + - comm=0.2.1=py312hca03da5_0 + - debugpy=1.6.7=py312h313beb8_0 + - decorator=5.1.1=pyhd3eb1b0_0 + - defusedxml=0.7.1=pyhd3eb1b0_0 + - executing=0.8.3=pyhd3eb1b0_0 + - expat=2.6.3=h313beb8_0 + - h11=0.14.0=py312hca03da5_0 + - httpcore=1.0.2=py312hca03da5_0 + - httpx=0.27.0=py312hca03da5_0 + - idna=3.7=py312hca03da5_0 + - ipykernel=6.29.5=py312hca03da5_0 + - ipython=8.27.0=py312hca03da5_0 + - jedi=0.19.1=py312hca03da5_0 + - jinja2=3.1.4=py312hca03da5_1 + - json5=0.9.25=py312hca03da5_0 + - jsonschema=4.23.0=py312hca03da5_0 + - jsonschema-specifications=2023.7.1=py312hca03da5_0 + - jupyter-lsp=2.2.0=py312hca03da5_0 + - jupyter_client=8.6.0=py312hca03da5_0 + - jupyter_core=5.7.2=py312hca03da5_0 + - jupyter_events=0.10.0=py312hca03da5_0 + - jupyter_server=2.14.1=py312hca03da5_0 + - jupyter_server_terminals=0.4.4=py312hca03da5_1 + - jupyterlab=4.2.5=py312hca03da5_0 + - jupyterlab_pygments=0.1.2=py_0 + - jupyterlab_server=2.27.3=py312hca03da5_0 + - libcxx=14.0.6=h848a8c0_0 + - libffi=3.4.4=hca03da5_1 + - libsodium=1.0.18=h1a28f6b_0 + - markupsafe=2.1.3=py312h80987f9_0 + - matplotlib-inline=0.1.6=py312hca03da5_0 + - mistune=2.0.4=py312hca03da5_0 + - nbclient=0.8.0=py312hca03da5_0 + - nbconvert=7.16.4=py312hca03da5_0 + - nbformat=5.10.4=py312hca03da5_0 + - ncurses=6.4=h313beb8_0 + - nest-asyncio=1.6.0=py312hca03da5_0 + - notebook=7.2.2=py312hca03da5_1 + - notebook-shim=0.2.3=py312hca03da5_0 + - openssl=3.0.15=h80987f9_0 + - overrides=7.4.0=py312hca03da5_0 + - packaging=24.1=py312hca03da5_0 + - pandocfilters=1.5.0=pyhd3eb1b0_0 + - parso=0.8.3=pyhd3eb1b0_0 + - pexpect=4.8.0=pyhd3eb1b0_3 + - pip=24.2=py312hca03da5_0 + - platformdirs=3.10.0=py312hca03da5_0 + - prometheus_client=0.21.0=py312hca03da5_0 + - prompt-toolkit=3.0.43=py312hca03da5_0 + - prompt_toolkit=3.0.43=hd3eb1b0_0 + - psutil=5.9.0=py312h80987f9_0 + - ptyprocess=0.7.0=pyhd3eb1b0_2 + - pure_eval=0.2.2=pyhd3eb1b0_0 + - pycparser=2.21=pyhd3eb1b0_0 + - pygments=2.15.1=py312hca03da5_1 + - pysocks=1.7.1=py312hca03da5_0 + - python=3.12.7=h99e199e_0 + - python-dateutil=2.9.0post0=py312hca03da5_2 + - python-fastjsonschema=2.20.0=py312hca03da5_0 + - python-json-logger=2.0.7=py312hca03da5_0 + - pytz=2024.1=py312hca03da5_0 + - pyyaml=6.0.2=py312h80987f9_0 + - pyzmq=25.1.2=py312h313beb8_0 + - readline=8.2=h1a28f6b_0 + - referencing=0.30.2=py312hca03da5_0 + - requests=2.32.3=py312hca03da5_1 + - rfc3339-validator=0.1.4=py312hca03da5_0 + - rfc3986-validator=0.1.1=py312hca03da5_0 + - rpds-py=0.10.6=py312h2aea54e_1 + - send2trash=1.8.2=py312hca03da5_0 + - setuptools=75.1.0=py312hca03da5_0 + - six=1.16.0=pyhd3eb1b0_1 + - sniffio=1.3.0=py312hca03da5_0 + - soupsieve=2.5=py312hca03da5_0 + - sqlite=3.45.3=h80987f9_0 + - stack_data=0.2.0=pyhd3eb1b0_0 + - terminado=0.17.1=py312hca03da5_0 + - tinycss2=1.2.1=py312hca03da5_0 + - tk=8.6.14=h6ba3021_0 + - tornado=6.4.1=py312h80987f9_0 + - traitlets=5.14.3=py312hca03da5_0 + - typing-extensions=4.11.0=py312hca03da5_0 + - typing_extensions=4.11.0=py312hca03da5_0 + - tzdata=2024b=h04d1e81_0 + - urllib3=2.2.3=py312hca03da5_0 + - wcwidth=0.2.5=pyhd3eb1b0_0 + - webencodings=0.5.1=py312hca03da5_2 + - websocket-client=1.8.0=py312hca03da5_0 + - wheel=0.44.0=py312hca03da5_0 + - xz=5.4.6=h80987f9_1 + - yaml=0.2.5=h1a28f6b_0 + - zeromq=4.3.5=h313beb8_0 + - zlib=1.2.13=h18a0788_1 + - pip: + - contourpy==1.3.1 + - cycler==0.12.1 + - fonttools==4.55.3 + - iniconfig==2.0.0 + - kiwisolver==1.4.7 + - matplotlib==3.9.3 + - numpy==2.1.3 + - pillow==11.0.0 + - pluggy==1.5.0 + - pyparsing==3.2.0 + - pytest==8.3.4 diff --git a/notebooks/evilkode.ipynb b/notebooks/evilkode.ipynb index 3ecf5da..c489867 100644 --- a/notebooks/evilkode.ipynb +++ b/notebooks/evilkode.ipynb @@ -6,33 +6,34 @@ "metadata": { "collapsed": true, "ExecuteTime": { - "end_time": "2024-12-12T17:09:58.749289Z", - "start_time": "2024-12-12T17:09:58.747461Z" + "end_time": "2025-03-28T15:57:47.590110Z", + "start_time": "2025-03-28T15:57:47.588084Z" } }, "source": [ "from src.benchmark import shuffle_benchmark, ShuffleTypes\n", - "import matplotlib.pyplot as plt" + "import matplotlib.pyplot as plt\n", + "from pathlib import Path" ], "outputs": [], - "execution_count": 6 + "execution_count": 17 }, { "metadata": { "ExecuteTime": { - "end_time": "2024-12-12T17:09:58.765574Z", - "start_time": "2024-12-12T17:09:58.758204Z" + "end_time": "2025-03-28T15:58:00.690240Z", + "start_time": "2025-03-28T15:57:47.595988Z" } }, "cell_type": "code", "source": [ - "multiple = 3\n", - "number_of_keys=6 * multiple\n", - "properties_per_key=12 * multiple\n", - "passcode_len=1\n", - "max_tries_before_lockout= 5\n", - "complexity=1\n", - "disparity=1\n", + "multiple = 1\n", + "number_of_keys=6* multiple\n", + "properties_per_key=9 * multiple\n", + "passcode_len=4\n", + "max_tries_before_lockout= 3\n", + "complexity=2\n", + "disparity=2\n", "run_count=10000\n", "\n", "bench_split = shuffle_benchmark(\n", @@ -44,31 +45,36 @@ " complexity=complexity,\n", " disparity=disparity,\n", " shuffle_type=ShuffleTypes.SPLIT_SHUFFLE\n", - ")" + ")\n", + "\n", + "bench_full = shuffle_benchmark(\n", + " number_of_keys=number_of_keys,\n", + " properties_per_key=properties_per_key,\n", + " passcode_len=passcode_len,\n", + " max_tries_before_lockout=max_tries_before_lockout,\n", + " run_count=run_count,\n", + " complexity=complexity,\n", + " disparity=disparity,\n", + " shuffle_type=ShuffleTypes.FULL_SHUFFLE\n", + ")\n" ], "id": "c86c6ed5014dac44", - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "file exists ../output\n" - ] - } - ], - "execution_count": 7 + "outputs": [], + "execution_count": 18 }, { "metadata": { "ExecuteTime": { - "end_time": "2024-12-12T17:09:58.835376Z", - "start_time": "2024-12-12T17:09:58.833451Z" + "end_time": "2025-03-28T15:58:00.699509Z", + "start_time": "2025-03-28T15:58:00.696975Z" } }, "cell_type": "code", "source": [ "print(f\"Bench Split Mean {bench_split.mean}\\n\"\n", - " f\"Bench Split Var: {bench_split.variance}\")" + " f\"Bench Split Var: {bench_split.variance}\")\n", + "print(f\"Bench full Mean {bench_full.mean}\\n\"\n", + " f\"Bench full Var: {bench_full.variance}\")\n" ], "id": "6de455d5097d9c3d", "outputs": [ @@ -76,54 +82,78 @@ "name": "stdout", "output_type": "stream", "text": [ - "Bench Split Mean 5.571\n", - "Bench Split Var: 0.5252115211521152\n" + "Bench Split Mean 7.23\n", + "Bench Split Var: 2.3785378537853785\n", + "Bench full Mean 4.179\n", + "Bench full Var: 0.26178517851785177\n" ] } ], - "execution_count": 8 + "execution_count": 19 }, { "metadata": { "ExecuteTime": { - "end_time": "2024-12-12T17:09:58.908054Z", - "start_time": "2024-12-12T17:09:58.905569Z" + "end_time": "2025-03-28T15:58:00.730290Z", + "start_time": "2025-03-28T15:58:00.726439Z" } }, "cell_type": "code", "source": [ - "def bench_histogram(data, title):\n", + "def bench_histogram(data, title, number_of_keys, properties_per_key, \n", + " passcode_len, max_tries_before_lockout, complexity, disparity, run_count, save_path: Path = None):\n", " # Create the histogram\n", " min_val = min(data)\n", " max_val = max(data)\n", " \n", - " # Create bins for each integer. \n", - " # For example, if the data goes from 1 to 5, \n", - " # then bins = [1, 2, 3, 4, 5, 6]\n", + " # Create bins for each integer\n", " bins = range(min_val, max_val + 2)\n", " plt.hist(data, bins=bins, edgecolor='black')\n", " \n", " # Add titles and labels\n", " plt.title(title)\n", - " plt.xlabel('Value')\n", - " plt.ylabel('Frequency')\n", + " plt.xlabel('# of Login Observations')\n", + " plt.ylabel('Simulations')\n", " \n", + " # Display parameters as text in the plot\n", + " text = (f\"number_of_keys={number_of_keys}\\n\"\n", + " f\"properties_per_key={properties_per_key}\\n\"\n", + " f\"passcode_len={passcode_len}\\n\"\n", + " f\"max_tries_before_lockout={max_tries_before_lockout}\\n\"\n", + " f\"complexity={complexity}\\n\"\n", + " f\"disparity={disparity}\\n\"\n", + " f\"run_count={run_count}\")\n", + " \n", + " plt.text(0.95, 0.95, text, transform=plt.gca().transAxes, fontsize=10,\n", + " verticalalignment='top', horizontalalignment='right', bbox=dict(facecolor='white', alpha=0.5))\n", + " \n", + " # Save plot if a path is provided\n", + " if save_path:\n", + " save_path.mkdir(parents=True, exist_ok=True)\n", + " filename = (f\"{title.replace(' ', '_')}_multi{multiple}_keys{number_of_keys}_\"\n", + " f\"props{properties_per_key}_pass{passcode_len}_tries{max_tries_before_lockout}_\"\n", + " f\"comp{complexity}_disp{disparity}_runs{run_count}.png\")\n", + " plt.savefig(save_path / filename, bbox_inches='tight', dpi=300)\n", + " \n", " # Display the plot\n", " plt.show()\n" ], "id": "99ddd0fbd421b058", "outputs": [], - "execution_count": 9 + "execution_count": 20 }, { "metadata": { "ExecuteTime": { - "end_time": "2024-12-12T17:09:58.989830Z", - "start_time": "2024-12-12T17:09:58.918011Z" + "end_time": "2025-03-28T15:58:01.371828Z", + "start_time": "2025-03-28T15:58:00.746066Z" } }, "cell_type": "code", - "source": "bench_histogram(bench_split.runs, \"bench split\")", + "source": [ + "bench_histogram(bench_split.runs, \"Key Logger Split Shuffle\", number_of_keys, properties_per_key, passcode_len, max_tries_before_lockout, complexity, disparity, run_count, Path(\"../output/histograms\"))\n", + "bench_histogram(bench_full.runs, \"Key Logger Random Shuffle\", number_of_keys, properties_per_key, passcode_len, max_tries_before_lockout, complexity, disparity, run_count, Path(\"../output/histograms\"))" + ], "id": "9cbf9282eba285e6", "outputs": [ { @@ -131,13 +161,23 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 10 + "execution_count": 21 } ], "metadata": { diff --git a/src/keypad.py b/src/keypad.py index 751fee4..49777d0 100644 --- a/src/keypad.py +++ b/src/keypad.py @@ -7,7 +7,7 @@ class Keypad: keypad: np.ndarray k: int # number of keys p: int # properties per key - keypad_cache: list + keypad_cache: list # max_cache_size: int = 100 @staticmethod @@ -24,16 +24,25 @@ class Keypad: return Keypad(keypad=set_view.T, k=k, p=p, keypad_cache=[]) def split_shuffle(self): + """ + This is a modified split shuffle. + It doesn't shuffle the keys only the properties in the keys. + Shuffling the keys makes it hard for people to guess an nKode not a machine. + This split shuffle includes a cache to prevent the same configuration from being used. + This cache is not in any other implementation. + Testing suggests it's not necessary. + Getting the same keypad twice over 100 shuffles is very unlikely. + """ shuffled_sets = self._shuffle() + # Sort the shuffled sets by the first column sorted_set = shuffled_sets[np.argsort(shuffled_sets[:, 0])] - while str(sorted_set) in self.keypad_cache: + # continue shuffling until we get a unique configuration shuffled_sets = self._shuffle() sorted_set = shuffled_sets[np.argsort(shuffled_sets[:, 0])] self.keypad_cache.append(str(sorted_set)) self.keypad_cache = self.keypad_cache[:self.max_cache_size] - self.keypad = shuffled_sets