ECC_validation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Haygen Tsoi\\AppData\\Local\\Temp\\ipykernel_9548\\1020801726.py:5: DeprecationWarning: \n",
      "Pyarrow will become a required dependency of pandas in the next major release of pandas (pandas 3.0),\n",
      "(to allow more performant data types, such as the Arrow string type, and better interoperability with other libraries)\n",
      "but was not found to be installed on your system.\n",
      "If this would cause problems for you,\n",
      "please provide us feedback at https://github.com/pandas-dev/pandas/issues/54466\n",
      "        \n",
      "  import pandas as pd\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "import numpy as np\n",
    "import random\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "# curves we will be using for experiments \n",
    "from ecdsa.curves import SECP160r1, NIST224p, SECP256k1, NIST384p, BRAINPOOLP512r1\n",
    "import secrets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://sefiks.com/2016/04/11/key-exchange-from-carrying-handcuffed-briefcases-to-modern-cryptosystems/\n",
    "def add_points(P, Q, q, a, b):\n",
    "    x1, y1 = P\n",
    "    x2, y2 = Q\n",
    "\n",
    "    if x1 == x2 and y1 == y2:\n",
    "        beta = (3 * x1 * x2 + a) * pow(2 * y1, -1, q)\n",
    "    else:\n",
    "        beta = (y2 - y1) * pow(x2 - x1, -1, q)\n",
    "    \n",
    "    x3 = (beta * beta - x1 - x2) % q\n",
    "    y3 = (beta * (x1 - x3) - y1) % q\n",
    "\n",
    "    is_on_curve((x3, y3), q, a, b)\n",
    "\n",
    "    return x3, y3\n",
    "\n",
    "def is_on_curve(P, q, a, b):\n",
    "    x, y = P\n",
    "    assert (y*y) % q == (pow(x,3, q) + a*x + b) % q\n",
    "\n",
    "def apply_double_and_add_method(G, k, q, a, b):\n",
    "    target_point = G\n",
    "    k_binary = bin(k)[2:]\n",
    "\n",
    "    for i in range(1, len(k_binary)):\n",
    "        current_bit = k_binary[i: i+1]\n",
    "\n",
    "        # doubling - always\n",
    "        target_point = add_points(target_point, target_point, q, a, b)\n",
    "\n",
    "        if current_bit == \"1\":\n",
    "            target_point = add_points(target_point, G, q, a, b)\n",
    "\n",
    "    is_on_curve(target_point, q, a, b)\n",
    "\n",
    "    return target_point"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "115792089237316195423570985008687907853269984665640564039457584007908834671663\n"
     ]
    }
   ],
   "source": [
    "#curve configuration: secp256k1\n",
    "# y^2 = x^3 + a*x + b = y^2 = x^3 + 7\n",
    "a = 0\n",
    "b = 7\n",
    " \n",
    "# base point\n",
    "G = (55066263022277343669578718895168534326250603453777594175500187360389116729240, \n",
    "     32670510020758816978083085130507043184471273380659243275938904335757337482424)\n",
    " \n",
    "# modulo\n",
    "q = pow(2, 256) - pow(2, 32) - pow(2, 9) - pow(2, 8) - pow(2, 7) - pow(2, 6) - pow(2, 4) - pow(2, 0)\n",
    "print(q)\n",
    " \n",
    "# order\n",
    "n = 115792089237316195423570985008687907852837564279074904382605163141518161494337"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "is_on_curve(G, q, a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(89565891926547004231252920425935692360644145829622209833684329913297188986597,\n",
       " 12158399299693830322967808612713398636155367887041628176798871954788371653930)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "point_2G = add_points(G, G, q, a, b)\n",
    "point_2G"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(34773495056115281091786765947597603724784643419904767525769502836017890139287,\n",
       " 8470533044743364938367028725608288731153024648869546164814808839694950063162)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "apply_double_and_add_method(G, 20, q, a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(43772992182850224475884602775731924151786657957823585038013769478761832412884,\n",
       " 50703267231922445974984902439256894169921176001845864492670616863236899560211)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = random.getrandbits(256)\n",
    "A = apply_double_and_add_method(G, s, q, a, b)\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def encrypt(pt, A, q, a, b):\n",
    "    r = random.getrandbits(128)\n",
    "    x = apply_double_and_add_method(G, pt, q, a, b)\n",
    "     \n",
    "    c1 = apply_double_and_add_method(G, r, q, a, b) \n",
    " \n",
    "    c2 = apply_double_and_add_method(A, r, q, a, b)\n",
    "    c2 = add_points(c2, x, q, a, b)\n",
    "     \n",
    "    return c1, c2\n",
    "\n",
    "def decrypt(ct, s, q, a, b):\n",
    "    c1, c2 = ct\n",
    "    c1_prime = (c1[0], (-1*c1[1]) % q)\n",
    "    s_prime = apply_double_and_add_method(c1_prime, s, q, a, b)\n",
    "    s_prime = add_points(c2, s_prime, q, a, b)\n",
    "    return s_prime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((30258266753272642504243646183133554375914481146900861833804129959286550544226,\n",
       "  81693922819845289854121873523951731034192338643638954530037829009652357806859),\n",
       " (51189681004702853519231549357330090379225846078029258093680624122894804427149,\n",
       "  89379806531236321902857198495617321890930694213792648634133686993924077704465))"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pt = 12345\n",
    "ct = encrypt(pt, A, q, a, b)\n",
    "ct"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(108607064596551879580190606910245687803607295064141551927605737287325610911759,\n",
       " 6661302038839728943522144359728938428925407345457796456954441906546235843221)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s_prime = decrypt(ct, s, q, a, b)\n",
    "s_prime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(108607064596551879580190606910245687803607295064141551927605737287325610911759,\n",
       " 6661302038839728943522144359728938428925407345457796456954441906546235843221)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s_real = apply_double_and_add_method(G, pt, q, a, b)\n",
    "s_real\n",
    "# the decrypted data is the same as the point in the curve"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SAKE machanism\n",
    "Declare configurations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "115792089237316195423570985008687907853269984665640564039457584007908834671663\n"
     ]
    }
   ],
   "source": [
    "#curve configuration: secp256k1\n",
    "# y^2 = x^3 + a*x + b = y^2 = x^3 + 7\n",
    "a = 0\n",
    "b = 7\n",
    " \n",
    "# base point\n",
    "G = (55066263022277343669578718895168534326250603453777594175500187360389116729240, \n",
    "     32670510020758816978083085130507043184471273380659243275938904335757337482424)\n",
    " \n",
    "# modulo\n",
    "q = pow(2, 256) - pow(2, 32) - pow(2, 9) - pow(2, 8) - pow(2, 7) - pow(2, 6) - pow(2, 4) - pow(2, 0)\n",
    "print(q)\n",
    " \n",
    "# order\n",
    "n = 115792089237316195423570985008687907852837564279074904382605163141518161494337"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Edge starts the encryption process"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8857972648207128053326221275514024558665904529490805074548938972855350327086,\n",
       " 30195615213063391639232768547516825480982732150737911944217043723818662799009)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Edge secret key\n",
    "Se = random.getrandbits(256)\n",
    "# Edge shared key\n",
    "Ae = apply_double_and_add_method(G=G, k=Se, q=q, a=a, b=b)\n",
    "# Ae is then sent to the IoT device\n",
    "Ae"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "IoT device process the shared key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(91645783991975419211569526390957520932577486273929909704968297866688148203239,\n",
       " 66387544363359596007106502293635958674140980719002088004791057076673356081829)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# IoT secret key\n",
    "Si = random.getrandbits(256)\n",
    "# IoT shared key\n",
    "Ai = apply_double_and_add_method(G=G, k=Si, q=q, a=a, b=b)\n",
    "# IoT computes the session key\n",
    "SHi = apply_double_and_add_method(G=Ae, k=Si, q=q, a=a, b=b)\n",
    "# IoT then sends the shared key and session key to the Edge\n",
    "Ai"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Edge then validate the keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation completed successfully\n"
     ]
    }
   ],
   "source": [
    "# Edge computes the session key\n",
    "SHe = apply_double_and_add_method(G=Ai, k=Se, q=q, a=a, b=b)\n",
    "# Edge checks if the session keys match\n",
    "if SHe == SHi:\n",
    "    print(\"Validation completed successfully\")\n",
    "else:\n",
    "    print(\"Validation failed\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Experiment on key size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def experiment(curve, size):\n",
    "    generator = curve.generator\n",
    "    n = generator.order()\n",
    "\n",
    "    a = curve.curve.a()\n",
    "    b = curve.curve.b()\n",
    "    q = curve.curve.p()\n",
    "\n",
    "    print(f\"Equation of the curve: y^2 = x^3 + {a}*x + {b}\")\n",
    "    print(f\"Base point of the curve: {(generator.x(), generator.y())}\")\n",
    "    print(f\"Order of the curve: {n}\")\n",
    "    print(f\"Modulus of the curve: {q}\")\n",
    "\n",
    "    G = (generator.x(), generator.y())\n",
    "    is_on_curve(G, q, a, b)\n",
    "\n",
    "    start = time.time()\n",
    "    for i in range(100):\n",
    "        Se = secrets.randbits(size)\n",
    "        Ae = apply_double_and_add_method(G=G, k=Se, q=q, a=a, b=b)\n",
    "    time_taken = (time.time() - start) / 100\n",
    "\n",
    "    return time_taken, q.bit_length()\n",
    "\n",
    "key_gen_time = []\n",
    "schemes = []\n",
    "security = []\n",
    "key_sizes = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SECP160r1 (80 bits for Symmetric Key Size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Equation of the curve: y^2 = x^3 + -3*x + 163235791306168110546604919403271579530548345413\n",
      "Base point of the curve: (425826231723888350446541592701409065913635568770, 203520114162904107873991457957346892027982641970)\n",
      "Order of the curve: 1461501637330902918203687197606826779884643492439\n",
      "Modulus of the curve: 1461501637330902918203684832716283019653785059327\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.00938199758529663\n"
     ]
    }
   ],
   "source": [
    "time_taken, key_size = experiment(SECP160r1, 160)\n",
    "print(time_taken)\n",
    "key_gen_time.append(time_taken)\n",
    "schemes.append(\"SECP160r1\")\n",
    "security.append(80)\n",
    "key_sizes.append(key_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NIST224p (112 bits for Symmetic Key Size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Equation of the curve: y^2 = x^3 + -3*x + 18958286285566608000408668544493926415504680968679321075787234672564\n",
      "Base point of the curve: (19277929113566293071110308034699488026831934219452440156649784352033, 19926808758034470970197974370888749184205991990603949537637343198772)\n",
      "Order of the curve: 26959946667150639794667015087019625940457807714424391721682722368061\n",
      "Modulus of the curve: 26959946667150639794667015087019630673557916260026308143510066298881\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.02260238170623779\n"
     ]
    }
   ],
   "source": [
    "time_taken, key_size = experiment(NIST224p, 224)\n",
    "print(time_taken)\n",
    "key_gen_time.append(time_taken)\n",
    "schemes.append(\"NIST224p\")\n",
    "security.append(112)\n",
    "key_sizes.append(key_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SECP256k1 (128 bits for Symmetric Key Size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Equation of the curve: y^2 = x^3 + 0*x + 7\n",
      "Base point of the curve: (55066263022277343669578718895168534326250603453777594175500187360389116729240, 32670510020758816978083085130507043184471273380659243275938904335757337482424)\n",
      "Order of the curve: 115792089237316195423570985008687907852837564279074904382605163141518161494337\n",
      "Modulus of the curve: 115792089237316195423570985008687907853269984665640564039457584007908834671663\n",
      "0.02272352695465088\n"
     ]
    }
   ],
   "source": [
    "time_taken, key_size = experiment(SECP256k1, 256)\n",
    "print(time_taken)\n",
    "key_gen_time.append(time_taken)\n",
    "schemes.append(\"SECP256k1\")\n",
    "security.append(128)\n",
    "key_sizes.append(key_size)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NIST384p (192 bits for Symmetric Key Size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Equation of the curve: y^2 = x^3 + -3*x + 27580193559959705877849011840389048093056905856361568521428707301988689241309860865136260764883745107765439761230575\n",
      "Base point of the curve: (26247035095799689268623156744566981891852923491109213387815615900925518854738050089022388053975719786650872476732087, 8325710961489029985546751289520108179287853048861315594709205902480503199884419224438643760392947333078086511627871)\n",
      "Order of the curve: 39402006196394479212279040100143613805079739270465446667946905279627659399113263569398956308152294913554433653942643\n",
      "Modulus of the curve: 39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319\n",
      "0.05361811876296997\n"
     ]
    }
   ],
   "source": [
    "time_taken, key_size = experiment(NIST384p, 384)\n",
    "print(time_taken)\n",
    "key_gen_time.append(time_taken)\n",
    "schemes.append(\"NIST384p\")\n",
    "security.append(192)\n",
    "key_sizes.append(key_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### BRAINPOOLP512r1 (256 bits for Symmetric Key Size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Equation of the curve: y^2 = x^3 + 6294860557973063227666421306476379324074715770622746227136910445450301914281276098027990968407983962691151853678563877834221834027439718238065725844264138*x + 3245789008328967059274849584342077916531909009637501918328323668736179176583263496463525128488282611559800773506973771797764811498834995234341530862286627\n",
      "Base point of the curve: (6792059140424575174435640431269195087843153390102521881468023012732047482579853077545647446272866794936371522410774532686582484617946013928874296844351522, 6592244555240112873324748381429610341312712940326266331327445066687010545415256461097707483288650216992613090185042957716318301180159234788504307628509330)\n",
      "Order of the curve: 8948962207650232551656602815159153422162609644098354511344597187200057010413418528378981730643524959857451398370029280583094215613882043973354392115544169\n",
      "Modulus of the curve: 8948962207650232551656602815159153422162609644098354511344597187200057010413552439917934304191956942765446530386427345937963894309923928536070534607816947\n",
      "0.12364020109176636\n"
     ]
    }
   ],
   "source": [
    "time_taken, key_size = experiment(BRAINPOOLP512r1, 512)\n",
    "print(time_taken)\n",
    "key_gen_time.append(time_taken)\n",
    "schemes.append(\"BRAINPOOLP512r1\")\n",
    "security.append(256)\n",
    "key_sizes.append(key_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[160, 224, 256, 384, 512]\n"
     ]
    }
   ],
   "source": [
    "print(key_sizes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n",
      "C:\\Users\\Haygen Tsoi\\AppData\\Local\\Temp\\ipykernel_9548\\868951278.py:17: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
      "  axes[0].annotate(txt, (df['Security(in bits)'][i], df['Time(in ms)'][i]))\n",
      "C:\\Users\\Haygen Tsoi\\AppData\\Local\\Temp\\ipykernel_9548\\868951278.py:29: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
      "  axes[1].annotate(txt, (df['Security(in bits)'][i], df['Key Size (in bits)'][i]))\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df = pd.DataFrame({\n",
    "    'Time(in ms)': key_gen_time,\n",
    "    'Security(in bits)': security,\n",
    "    'Key Size (in bits)': key_sizes\n",
    "}, index=schemes)\n",
    "\n",
    "fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(12, 6))\n",
    "\n",
    "# Plot 'Time(in ms)' vs. 'Security(in bits)'\n",
    "axes[0].scatter(df['Security(in bits)'], df['Time(in ms)'], color='blue', label='ECC')\n",
    "axes[0].set_title('Key Generation Time vs. Security')\n",
    "axes[0].set_xlabel('Security (in bits)')\n",
    "axes[0].set_ylabel('Time (in ms)')\n",
    "axes[1].legend()\n",
    "\n",
    "for i, txt in enumerate(schemes):\n",
    "    axes[0].annotate(txt, (df['Security(in bits)'][i], df['Time(in ms)'][i]))\n",
    "\n",
    "# z = np.polyfit(df['Security(in bits)'], df['Time(in ms)'], 1)\n",
    "# p = np.poly1d(z)\n",
    "# axes[0].plot(df['Security(in bits)'], p(df['Security(in bits)']), \"b--\")\n",
    "\n",
    "\n",
    "\n",
    "# Plot 'Size(in bytes)' vs. 'Key Size(in bits)' for df\n",
    "axes[1].scatter(df['Security(in bits)'], df['Key Size (in bits)'], color='orange', label='ECC')\n",
    "# Annotate points from df\n",
    "for i, txt in enumerate(df.index):\n",
    "    axes[1].annotate(txt, (df['Security(in bits)'][i], df['Key Size (in bits)'][i]))\n",
    "\n",
    "# z = np.polyfit(df['Security(in bits)'], df['Key Size (in bits)'], 1)\n",
    "# p = np.poly1d(z)\n",
    "# axes[1].plot(df['Security(in bits)'], p(df['Security(in bits)']), \"y--\")\n",
    "\n",
    "\n",
    "axes[1].set_title('Size vs. Security')\n",
    "axes[1].set_xlabel('Security (in bits)')\n",
    "axes[1].set_ylabel('Key Size (in bits)')\n",
    "axes[1].legend()\n",
    "\n",
    "\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Haygen Tsoi\\AppData\\Local\\Temp\\ipykernel_9548\\702010492.py:39: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
      "  ax.annotate(txt, (df['Security(in bits)'][i], df[y_data_label][i]), fontsize=9,\n",
      "C:\\Users\\Haygen Tsoi\\AppData\\Local\\Temp\\ipykernel_9548\\702010492.py:44: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n",
      "  ax.annotate(txt, (filtered_df['Security(in bits)'][i], filtered_df[y_data_label][i]), fontsize=9,\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x700 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df = pd.DataFrame({\n",
    "    'Time(in s)': key_gen_time,\n",
    "    'Security(in bits)': security,\n",
    "    'Key Size (in bits)': key_sizes\n",
    "}, index=schemes)\n",
    "\n",
    "rsa_key_gen_time = [0.8536460399627686, 7.0309107303619385, 8.89483904838562, 10000, 10000]\n",
    "rsa_security = [80, 112, 128, 192, 256]\n",
    "rsa_size = [1024, 2048, 3072, 7680, 15360]\n",
    "rsa_schemes = ['1024', '2048', '3072', '7680', '15360']\n",
    "\n",
    "df2 = pd.DataFrame({\n",
    "    'Time(in s)': rsa_key_gen_time,\n",
    "    'Security(in bits)': rsa_security,\n",
    "    'Key Size (in bits)': rsa_size,\n",
    "}, index=rsa_schemes)\n",
    "\n",
    "# Threshold to filter the RSA data\n",
    "threshold = 1000\n",
    "filtered_df = df2[df2['Time(in s)'] < threshold]\n",
    "\n",
    "# Create the subplot figure with two axes\n",
    "fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(15, 7))\n",
    "\n",
    "# Adjust the font size globally for clearer text\n",
    "plt.rcParams.update({'font.size': 12})\n",
    "\n",
    "# Improved plotting with clearer annotations\n",
    "for ax, y_label, title, y_data_label, label in zip(axes, \n",
    "                                                    ['Time(in s)', 'Key Size (in bits)'], \n",
    "                                                    ['Key Generation Time vs. Security', 'Key Size vs. Security'], \n",
    "                                                    ['Time(in s)', 'Key Size (in bits)'], \n",
    "                                                    ['ECC', 'RSA']):\n",
    "    ax.scatter(df['Security(in bits)'], df[y_data_label], color='blue', label='ECC')\n",
    "    ax.scatter(filtered_df['Security(in bits)'], filtered_df[y_data_label], color='green', label='RSA')\n",
    "    \n",
    "    # Annotate ECC points with adjusted positioning to avoid overlap\n",
    "    for i, txt in enumerate(df.index):\n",
    "        ax.annotate(txt, (df['Security(in bits)'][i], df[y_data_label][i]), fontsize=9, \n",
    "                    textcoords=\"offset points\", xytext=(-10,10), ha='center')\n",
    "    \n",
    "    # Annotate RSA points with adjusted positioning to avoid overlap\n",
    "    for i, txt in enumerate(filtered_df.index):\n",
    "        ax.annotate(txt, (filtered_df['Security(in bits)'][i], filtered_df[y_data_label][i]), fontsize=9, \n",
    "                    textcoords=\"offset points\", xytext=(10,-10), ha='center')\n",
    "    \n",
    "    # Trend lines for ECC\n",
    "    z = np.polyfit(df['Security(in bits)'], df[y_data_label], 1)\n",
    "    p = np.poly1d(z)\n",
    "    ax.plot(df['Security(in bits)'], p(df['Security(in bits)']), \"b--\")\n",
    "    \n",
    "    # Trend lines for RSA\n",
    "    z2 = np.polyfit(filtered_df['Security(in bits)'], filtered_df[y_data_label], 1)\n",
    "    p2 = np.poly1d(z2)\n",
    "    ax.plot(filtered_df['Security(in bits)'], p2(filtered_df['Security(in bits)']), \"g--\")\n",
    "    \n",
    "    # Set titles and labels with adjusted font sizes for clarity\n",
    "    ax.set_title(title, fontsize=14)\n",
    "    ax.set_xlabel('Security (in bits)', fontsize=12)\n",
    "    ax.set_ylabel(y_label, fontsize=12)\n",
    "    ax.legend()\n",
    "\n",
    "# Adjust layout for better spacing\n",
    "plt.tight_layout()\n",
    "\n",
    "# Display the figure\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x700 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create the subplot figure with two axes\n",
    "fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(15, 7))\n",
    "\n",
    "# Adjust the font size globally for clearer text\n",
    "plt.rcParams.update({'font.size': 12})\n",
    "\n",
    "# Improved plotting with clearer annotations\n",
    "for ax, y_label, title, y_data_label, label in zip(axes, \n",
    "                                                    ['Time(in s)', 'Key Size (in bits)'], \n",
    "                                                    ['Key Generation Time vs. Security', 'Key Size vs. Security'], \n",
    "                                                    ['Time(in s)', 'Key Size (in bits)'], \n",
    "                                                    ['ECC', 'RSA']):\n",
    "    ax.scatter(df['Security(in bits)'], df[y_data_label], color='blue', label='ECC')\n",
    "    ax.scatter(filtered_df['Security(in bits)'], filtered_df[y_data_label], color='green', label='RSA')\n",
    "    \n",
    "    # Trend lines for ECC\n",
    "    z = np.polyfit(df['Security(in bits)'], df[y_data_label], 1)\n",
    "    p = np.poly1d(z)\n",
    "    ax.plot(df['Security(in bits)'], p(df['Security(in bits)']), \"b--\")\n",
    "    \n",
    "    # Trend lines for RSA\n",
    "    z2 = np.polyfit(filtered_df['Security(in bits)'], filtered_df[y_data_label], 1)\n",
    "    p2 = np.poly1d(z2)\n",
    "    ax.plot(filtered_df['Security(in bits)'], p2(filtered_df['Security(in bits)']), \"g--\")\n",
    "    \n",
    "    # Set titles and labels with adjusted font sizes for clarity\n",
    "    ax.set_title(title, fontsize=14)\n",
    "    ax.set_xlabel('Security (in bits)', fontsize=12)\n",
    "    ax.set_ylabel(y_label, fontsize=12)\n",
    "    ax.legend()\n",
    "\n",
    "# Adjust layout for better spacing\n",
    "plt.tight_layout()\n",
    "\n",
    "# Display the figure\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "projectenv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}