From 161cd8733e0d481ed161b1f78551d93bc347e0a7 Mon Sep 17 00:00:00 2001 From: Andrew Date: Fri, 23 Apr 2021 22:26:39 +0700 Subject: [PATCH] Copy from Colaboratory --- 4sem/isaip/02/RSA/rsaNk.ipynb | 465 ++++++++++++++++++++++++++++++++++ 1 file changed, 465 insertions(+) create mode 100644 4sem/isaip/02/RSA/rsaNk.ipynb diff --git a/4sem/isaip/02/RSA/rsaNk.ipynb b/4sem/isaip/02/RSA/rsaNk.ipynb new file mode 100644 index 0000000..95bf1f9 --- /dev/null +++ b/4sem/isaip/02/RSA/rsaNk.ipynb @@ -0,0 +1,465 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "rsaNk.ipynb", + "provenance": [], + "collapsed_sections": [], + "authorship_tag": "ABX9TyPpT9gQBsvr+52dw80/CCws", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "sbpO6gadYhw3" + }, + "source": [ + "import random\n", + "\n", + "def n_bit_random(n):\n", + " return(random.randrange(2**(n-1)+1, 2**n-1))\n", + "\n", + "first_primes_list = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, \n", + " 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, \n", + " 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, \n", + " 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, \n", + " 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, \n", + " 293, 307, 311, 313, 317, 331, 337, 347, 349]\n", + "\n", + "def check_low_level_prime(n):\n", + " while True: \n", + " prime_candidate = n_bit_random(n) \n", + " for divisor in first_primes_list: \n", + " if prime_candidate % divisor == 0 and divisor**2 <= prime_candidate: \n", + " break\n", + " return prime_candidate \n", + "\n", + "def check_miller_rabin_primality(mrc):\n", + " max_divisions_by_two = 0\n", + " ec = mrc-1\n", + " while ec % 2 == 0: \n", + " ec >>= 1\n", + " max_divisions_by_two += 1\n", + " assert(2**max_divisions_by_two * ec == mrc-1) # lame\n", + " \n", + " def trial_composite(round_tester): \n", + " if pow(round_tester, ec, mrc) == 1: \n", + " return False\n", + " for i in range(max_divisions_by_two): \n", + " if pow(round_tester, 2**i * ec, mrc) == mrc-1: \n", + " return False\n", + " return True\n", + " \n", + " trials_amount = 20 \n", + " for i in range(trials_amount): \n", + " round_tester = random.randrange(2, mrc) \n", + " if trial_composite(round_tester): \n", + " return False\n", + " return True\n", + "\n", + "def n_bit_random_prime(n):\n", + " while True:\n", + " possible_prime = check_low_level_prime(n) \n", + " if not check_miller_rabin_primality(possible_prime): \n", + " continue\n", + " return possible_prime" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "UKJWDO3Pvqri" + }, + "source": [ + "import math\n", + "\n", + "import decimal\n", + "decimal.getcontext().prec=10000\n", + "_d = lambda x: decimal.Decimal(x)\n", + "\n", + "# Modular exponentiation goes brrrrr \n", + "def modular_pow(base, exponent, modulus):\n", + " base, modulus = _d(base), _d(modulus)\n", + " base %= modulus\n", + " result = 1\n", + " while exponent > 0:\n", + " if int(exponent) & 1:\n", + " result = (result * base) % modulus\n", + " base = (base * base) % modulus\n", + " exponent //= 2\n", + " return result\n", + "\n", + "def encrypt(message, exponent, modulus):\n", + " out = []\n", + " for c in message:\n", + " encv = modular_pow(ord(c), exponent, modulus)\n", + " out.append(encv)\n", + " return out\n", + "\n", + "def decrypt(encrypted, pkey, modulus):\n", + " out = []\n", + " for num in encrypted:\n", + " decv = modular_pow(num, pkey, modulus)\n", + " out.append(chr(decv))\n", + " return \"\".join(out)\n", + "\n", + "def lcm(a, b):\n", + " return abs(a*b) // math.gcd(a, b)\n", + "\n", + "def choose_e(lcmv):\n", + " while 1:\n", + " e = random.randrange(3, 2**16+2)\n", + " if e < lcmv and math.gcd(e, lcmv) == 1:\n", + " return e\n", + "\n", + "def extended_gcd(a, b):\n", + " x, old_x = 0, 1\n", + " y, old_y = 1, 0\n", + "\n", + " while (b != 0):\n", + " quotient = a // b\n", + " a, b = b, a - quotient * b\n", + " old_x, x = x, old_x - quotient * x\n", + " old_y, y = y, old_y - quotient * y\n", + "\n", + " return a, old_x, old_y" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "bw4RrEVrY5CD", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "faa2c44a-3614-4bdc-9a16-2b82714f9034" + }, + "source": [ + "key_length = 1024\n", + "%time P = n_bit_random_prime(key_length)\n", + "%time Q = n_bit_random_prime(key_length)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "CPU times: user 3.67 s, sys: 999 µs, total: 3.67 s\n", + "Wall time: 3.69 s\n", + "CPU times: user 1.85 s, sys: 0 ns, total: 1.85 s\n", + "Wall time: 1.86 s\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "jmogw7cUubMA" + }, + "source": [ + "n = P * Q\n", + "lcmv = lcm(P-1, Q-1)\n", + "e = choose_e(lcmv)\n", + "\n", + "gcd, x, y = extended_gcd(e, lcmv)\n", + "if x < 0:\n", + " d = x + lcmv\n", + "else:\n", + " d = x" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "wJr-rgmGCwZg", + "outputId": "72707a66-fe1c-4ec0-c682-4cd741a50eee" + }, + "source": [ + "print(e, d, n, sep=\"\\n\")" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "39649\n", + "2775085486572169457933031624471639527709572371571563930751706363455686679103931887012786872357300821852072462055701332168753464477069850100477857634950881057962034588705265582670348431618430187943675082038338808823502290083334757934315038640497969786069367822629393372740634217481080439281756759203535191518030611113366713687329262086331416243914608547464393822243234244247787598602422663859280454972323707900579310354345134163802897882709119063046579316638215239586955495026262129316401981036727648176233721051089840544139490182413169518916207283731389315379326286341277949065063422651145928466610428684652315668195\n", + "23566779236161770643112862787707714768319744752887788874531340221608793304492584597473313112218174480194085827590012234139629339174956445928785901695962763659830088046458803074421870909628916257832886158798721043310543454720481166030983536298954914657023031763702456252981131493715209010905445417269332126191376334319895522288189118297669317432037971085289460034222690931966559137798412723327254054307131802134542456875495143040890127834885396847838923210976349174614092437902214219214789194798418440795059024409693565307454667852500406186883883445142228234703191640206646086208037120337436442497385687546078418876013\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "uKS9PEF0wu0M", + "outputId": "0555f9a9-d86a-4063-fed7-1ae8da28b2e8" + }, + "source": [ + "message = \"sosait\"\n", + "encrypted_message = encrypt(message, e, n)\n", + "decrypted_message = decrypt(encrypted_message, d, n)\n", + "\n", + "print(message, \"Encrypted message will be really long\", decrypted_message, sep=\"\\n\")" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "sosait\n", + "Encrypted message will be really long\n", + "sosait\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "v9TcbW1b822_" + }, + "source": [ + "import os\n", + "import pickle\n", + "import IPython\n", + "from google.colab import output, files\n", + "\n", + "def prepare_file(filename, data):\n", + " with open(filename, \"wb+\") as f:\n", + " pickle.dump(data, f, pickle.HIGHEST_PROTOCOL)\n", + " return filename\n", + "\n", + "def download_public():\n", + " files.download(prepare_file(\"public.key\", [e, n]))\n", + "\n", + "def download_private():\n", + " files.download(prepare_file(\"private.key\", [d, n]))\n", + "\n", + "def download_unlink(filename):\n", + " try:\n", + " os.remove(filename)\n", + " except OSError:\n", + " pass\n", + "\n", + "output.register_callback(\"notebook.download_public\", download_public)\n", + "output.register_callback(\"notebook.download_private\", download_private)\n", + "output.register_callback(\"notebook.download_unlink\", download_unlink)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "bmO9YlMLAjvr" + }, + "source": [ + "import os\n", + "import pickle\n", + "import IPython\n", + "from google.colab import output, files\n", + "\n", + "def check_correctness():\n", + " download_unlink(\"public.key\")\n", + " download_unlink(\"private.key\")\n", + " \n", + " print(\"Select `public.key` and `private.key` files\")\n", + " uploaded = files.upload()\n", + " \n", + " eu, nf = pickle.loads(uploaded[\"public.key\"])\n", + " du, ns = pickle.loads(uploaded[\"private.key\"])\n", + " \n", + " try:\n", + " assert(nf == ns)\n", + " except AssertionError:\n", + " print(\"Keys modules are not equal!\")\n", + " return\n", + "\n", + " nu = nf\n", + "\n", + " test_message = \"test messages for days\"\n", + "\n", + " try:\n", + " encm = encrypt(test_message, eu, nu)\n", + " decm = decrypt(encm, du, nu)\n", + " except AssertionError:\n", + " print(\"Test message not correctly encrypted\")\n", + " else:\n", + " print(\"Everything seems correct. Encryption and decryption worked well.\")\n", + " \n", + "output.register_callback(\"notebook.check_correctness\", check_correctness)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "resources": { + "http://localhost:8080/nbextensions/google.colab/files.js": { + "data": "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", + "ok": true, + "headers": [ + [ + "content-type", + "application/javascript" + ] + ], + "status": 200, + "status_text": "" + } + }, + "base_uri": "https://localhost:8080/", + "height": 161 + }, + "id": "tKBqI0PV8wQ7", + "outputId": "f0dc10d0-fa3b-4b75-a55a-c85b76154e2e" + }, + "source": [ + "%%javascript\n", + "(async function() {\n", + " let dPublic = document.createElement(\"button\");\n", + " let dPrivate = document.createElement(\"button\");\n", + " let dCheckC = document.createElement(\"button\");\n", + "\n", + " dPublic.innerText = \"Download public key\";\n", + " dPrivate.innerText = \"Download private key\";\n", + " dCheckC.innerText = \"Check Correctness\";\n", + "\n", + " dPublic.addEventListener('click', async (event) => {\n", + " await google.colab.kernel.invokeFunction(\"notebook.download_public\", [], {});\n", + " await google.colab.kernel.invokeFunction(\"notebook.download_unlink\", [\"public.key\"], {});\n", + " });\n", + "\n", + " dPrivate.addEventListener('click', async (event) => {\n", + " await google.colab.kernel.invokeFunction(\"notebook.download_private\", [], {});\n", + " await google.colab.kernel.invokeFunction(\"notebook.download_unlink\", [\"private.key\"], {});\n", + " });\n", + "\n", + " dCheckC.addEventListener('click', async (event) => {\n", + " await google.colab.kernel.invokeFunction(\"notebook.check_correctness\", [], {});\n", + " });\n", + "\n", + " document.querySelector(\"#output-area\").appendChild(dPublic);\n", + " document.querySelector(\"#output-area\").appendChild(dPrivate);\n", + " document.querySelector(\"#output-area\").appendChild(dCheckC);\n", + "})();" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "application/javascript": [ + "(async function() {\n", + " let dPublic = document.createElement(\"button\");\n", + " let dPrivate = document.createElement(\"button\");\n", + " let dCheckC = document.createElement(\"button\");\n", + "\n", + " dPublic.innerText = \"Download public key\";\n", + " dPrivate.innerText = \"Download private key\";\n", + " dCheckC.innerText = \"Check Correctness\";\n", + "\n", + " dPublic.addEventListener('click', async (event) => {\n", + " await google.colab.kernel.invokeFunction(\"notebook.download_public\", [], {});\n", + " await google.colab.kernel.invokeFunction(\"notebook.download_unlink\", [\"public.key\"], {});\n", + " });\n", + "\n", + " dPrivate.addEventListener('click', async (event) => {\n", + " await google.colab.kernel.invokeFunction(\"notebook.download_private\", [], {});\n", + " await google.colab.kernel.invokeFunction(\"notebook.download_unlink\", [\"private.key\"], {});\n", + " });\n", + "\n", + " dCheckC.addEventListener('click', async (event) => {\n", + " await google.colab.kernel.invokeFunction(\"notebook.check_correctness\", [], {});\n", + " });\n", + "\n", + " document.querySelector(\"#output-area\").appendChild(dPublic);\n", + " document.querySelector(\"#output-area\").appendChild(dPrivate);\n", + " document.querySelector(\"#output-area\").appendChild(dCheckC);\n", + "})();" + ], + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "Select `public.key` and `private.key` files\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "Saving private.key to private.key\n", + "Saving public.key to public.key\n", + "Everything seems correct. Encryption and decryption worked well.\n" + ], + "name": "stdout" + } + ] + } + ] +} \ No newline at end of file