Naive_implementation_using_sage_math_DEMO for understanding purposes only.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# This Naive implementation for understanding purposes\n",
    "## Real world examples measuring over all the levels of security\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from hwcounter import Timer, count, count_end\n",
    "import time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Defining the needed functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_basis_points(E, level):\n",
    "    # input : -  E the initial elliptic curve E\n",
    "    #         - The level of securrity matching SIKE434, SIKE503, SIKE610, SIKE751 respectively\n",
    "    # output: - PA, QA: Alice's points on E with order of 2^{e_A}\n",
    "    #         - PB, QB: Bob's points on E with order of 3^{e_B}\n",
    "               \n",
    "    if(level == 0): ##SIKEp434 basis points##\n",
    "        PA = E(18590308952679468489364793668589003541299106140709579196186461020066893645141198854487503147226318730158493210982567772716162869840*i + 2634539327592482918121599540115765431217195093350648632832477775508933673747596362667240890051240463853167541162279343167040310090 , 10983718925653566249610333622918370357192097441961014913751641775508865561311331364566791542776619041356373750734992554370506677551*i + 18499992072774772182750461054948965122862326576938683155863157755664308576685791546530637605543615310883354355922717114976263189216 )\n",
    "        QA = E(1640555213321637736080614728970921962714590288563692816952785470842808462670732196555713644986698688787353020078064569199240185333*i + 8633131302536015373065425580178973814526244742660764898957635611033517358603093513483897324469034427019598357249425684820405193838 , 10045306525245350298803819046509877432229480969314772374869175643233206473596453796721101344057683381390923103776706006170651177942*i + 20276452752220665548202189403598170750834982427130760850813254160550305310659929663123304778814287531500756146204805251963783256037 )\n",
    "        PB = E(5822289030790821842647204127346110197186614331916510409554480418611145246532692679762948023941031185216358707524703325193156147115 , 4631002038627486062145710538859886699092897850004224163519174820337269208909673679867855016325656365561668068341925816094377133115 )\n",
    "        QB = E(13106015910647201458426811493288965923311702902321179794984306791335898269651901670809619116119997952683697617529379507339288983624 , 10209775938515962501771741506081580425243588708606392462054462399651871393790372518908435424495021346995173633235373991504988757970*i )\n",
    "        \n",
    "    elif(level == 1): ##SIKEp503 basis points###\n",
    "        PA= E(6320532212404399382016063711621672519097819289093008132287422899586558654154409534465288623620152707063792403841177958686744730460358867369790214313426*i + 598731473478175178061187348602069297333549163428939979629523574390608068248963076780259720359959333459849068307643602107176506677543421128505637017210 , 4933101381662632860793723128899783676713316867789870876301082420674288633349127213108982942657184880054878201780353332330135295382721630567005079288999*i + 7426962917961886750223017992649030370937754287299592176293296013750046278528127270441749990770397646543053639338703118870066071949533225567468389035535 )\n",
    "        QA= E(12782700525274606080563088995687953414271121242085716929817360778487970449266550563914806669696607531319998303840529920531168654117474642657984154795441*i + 10303639081125516279001395287746760176758405254609941364872116054854162905961918713361681608991552251201029580427357273234152024018341363107600917423203 ,5292840094190856756897919330752760358645449293970119310207955661961420744230791925978770188802827628077305751047954330175704766117841777492781885522580*i + 11907913747401263372631993650383474010460887355731972007259579839843387604583306264088777388731137707596732200482457305106853755102838384483226607408980 )\n",
    "        PB= E(10395771746384663457709878182675363876289472956896319955035800944963560043487131351381624225079611557910169511157250351409611867388651460757963950045921 , 9309552127100257329408002157658859489453309131568607095068230354479868403549207476529964476434226430001454218770443683472755151470484422193528293469683 )\n",
    "        QB= E(11662485637823763116959534565001872592010882475641226843176985866588019368676991560369559249358763311711849556241666760730606211268182513109721338236245 , 7634548483727126773543333352398604451954368718228168550650277018082903630942062065511172438901759852748000940036717851411221926820916595391278637026820*i )\n",
    "    elif(level == 2): ##SIKEp610##\n",
    "        PA= E(1351032392344570862820165806841417419483707333389008032303844817986587931915067411261641353376786861740821136696258561077148293590024228334589369728107287048428009459387461704345197218*i + 1806736940449204756670130402045974891976541035129146635282788880605274195484852513511499140814745888005770886742088608789738701225260796101949251672750216548726048403327295530268488302 ,2124817562111324870916785225238457163073501863745565628478675166072657660756968132145149012564540863190658044019839657530708614993593391844597004323203766106519379786043735933044429912*i + 1914836262154229412574833552285540119942953261355870652513258346940220805607860257037379503860349019441684789905537418459133057322907158810963334977929603783189005569389818236718757287 )\n",
    "        QA =E(2278312578911463860663452047317840188913500964088463497564614625278006320197173705099325691383536120882530302172224873945210653977858551912928766782033403861412424442219027598444372205*i + 157069315455315725572406262836101190536820419345266922310200723719159706129514384706934713497529220788845330796136656469811063377500153295284407501527218118951386898985387213358467980 ,2131943785947274690175172687017894976900651676838954493459391896401215835004922340925879480814182310742063072231869657104890652187484750858130293569134468169460850644363191828281970838*i + 684626837739439515527178368449616516042502767036426400873151573458794526207996577208813714111255823391912747544929297502418344725328410684102507049000900022835828681443590694359470796 )\n",
    "        PB = E(1429380650836801398435074225540873431964527974757736685640904411443279737690636600949107717631340803268699150860993995901981057449903476488360396389680606139935614560386298802463567853 , 86922338762137764722249229503399840011748426938614565165720420711418613695847056338321754727088992463807067011159743359520826426882081401616192743451060098430406302548560564784275248 )\n",
    "        QB=E(1387566999709320073344076391171172507738190670755781932803785722061027377438810471125423396121694767682815386582033193953279150259291357025344318501976216211001662765956497194286817353 , 956269241486681620129413265985396885225285468299622733925657142107888353766338280468038649293217037815600441332404132752013327889696962453572069418479767380512285984353519960428869979*i )\n",
    "    elif(level == 3): ##SIKEp751##\n",
    "        PA = E(1993436594774325849134512059294984900092784525889309731865924302516333954639088053874784298502590615500299169775920492705338536494948131816798689951115100682529755597000522266521373993031102110056636212011317531431383151419457*i + 6392653750389499144594798145926583444354409039583606858359849849952175922439864668710005278778374444865434395866810086432449384862893379044515952989369610078853427396744868696171536543536691791447062025853410930611265727936252 , 1944360814274992967790694755086384528911568810504894043226517588614661307924121353430029161010012544745085495519191328692275625095407629659251973225185479118063426457881083398198905214991988954261689720043570183102687622930302*i + 1107155950129604944058105130119415511264677550994695757860863353531605838302084169705309368726951698311435745863980668883833942102749156669587603793264404414816300918111443416878395850730885359490151046561089035507783599969704 )\n",
    "        QA =E(3462139332946457351613256472394206428708902796442953775366163334092154110965882738568198703970873585433373209361346635159539572450380354861849053160099274714477389537230240941950694098078938506114926490884815238642940114646471*i + 2141306817115640038993862181765492931500972641785085350947220052387904285572880641340973064166142567836013875254694387171253686309941716659316458912387577733949836538957913038827049600784199475852241950366745525218545897974032 ,1400417812997368920915551682180377281636897329246851400968757977812707768224457059133981091372384547426963624786120814884621423687862104250447066981364505731819707788795768880909806522716391019159881409233478267422518729910305*i + 4971051208676818538130306644600904750607598138754082242929568850388838017558578628906892821517384408377387956108839597010516351547749023772854937884508640768345992159506835114833220113674841882696215314922388871071388491092308 )\n",
    "        PB = E(8917296521312037934018779383955573993264347381711746006893090701936594237023232166684104618705889709151882479004705477580016078091729035680421189641116128972780575456542140523559278016360828837041023736833315936592076152779520 , 7977151852055161869642019263638055005058107660484391511988982056175137577840003410730173583183108331994556547443371187542870574283672599677654119934277234663107913274966085467251791279439311595825268323079739889435353405326871 )\n",
    "        QB =E(8511019311184218364369646557252415173765495706553816075924705665118452233626065646710473783622713033004291163624815196837285573011460225202480327659675906178097793861901498715713456623486950717478378070640744966049319812387059 , 4749025853221149447389147807862158495105283944255389717972469416583735997074470053838648384206219228347785356007779344031309965298006031166126067665328960313132108190232784245275591536191227746136931577835184145448867010458179*i )\n",
    "\n",
    "    return PA, QA, PB, QB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Mont2wer(A):\n",
    "    a = 1+0*i - A^2/3\n",
    "    b = (2*A^3 - 9*A)/(27+0*i)\n",
    "    return a,b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def isogeny_2_eA(E_0, S_A, BobPoints):\n",
    "    #The function computes the isogeny map of Alice of degree 2^{e_A} by decompossing the map into e_A isogeny map of degree 2\n",
    "    # Input: -The initital elliptic curve E_0\n",
    "    #        -Alice secret_point S_A = P_A+ [n_A].Q_A (with order 2^{e_A})\n",
    "    #        -Bobpoints = [PB, QB]\n",
    "    # Output: -Alice's public key consists of: E_A, the evaluation of Bob's points according to Alice's map [P_B_prime, Q_B_prime ]\n",
    "    P_B = BobPoints[0]\n",
    "    Q_B = BobPoints[1]\n",
    "    E_0_prime = E_0\n",
    "    S_A_prime = S_A\n",
    "    P_B_prime = P_B\n",
    "    Q_B_prime = Q_B   \n",
    "    for i in range(1,eA+1):\n",
    "        pow = eA -i\n",
    "        R_A = 2^pow * S_A_prime\n",
    "       # print(\"order 2\", R_A)\n",
    "        phi = E_0_prime.isogeny(R_A)\n",
    "        E_0_prime = phi.codomain()\n",
    "        S_A_prime = phi(S_A_prime)\n",
    "        P_B_prime = phi(P_B_prime)\n",
    "        Q_B_prime= phi(Q_B_prime) \n",
    "        \n",
    "    return [phi.codomain(), [P_B_prime, Q_B_prime]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def isogeny_3_eB(E_0,S_B, AlicePoints):\n",
    "    #The function computes the isogeny map of Bob with degree 2^{e_B} by decompossing the map into e_B isogeny map of degree 3\n",
    "    # Input: - The initital elliptic curve E_0\n",
    "    #        - Bob secret_point S_B = P_B+ [m_A].Q_B (with order 2^{e_B})\n",
    "    #        - Alice's points = [PA, QA]\n",
    "    # Output:  -Bob's public key consists of: E_B, the evaluation of Alice's points according to Bob's map [P_A_prime, Q_A_prime ]\n",
    "    P_A = AlicePoints[0]\n",
    "    Q_A = AlicePoints[1]\n",
    "    E_0_prime = E_0\n",
    "    S_B_prime = S_B\n",
    "    P_A_prime = P_A\n",
    "    Q_A_prime = Q_A\n",
    "    for i in range(1,eB+1):\n",
    "        pow = eB -i\n",
    "        R_B = 3^pow * S_B_prime\n",
    "        #print(\"order 3\", R_B)\n",
    "        phi = E_0_prime.isogeny(R_B)\n",
    "        E_0_prime= phi.codomain()\n",
    "        S_B_prime = phi(S_B_prime)\n",
    "        P_A_prime = phi(P_A_prime)\n",
    "        Q_A_prime = phi(Q_A_prime)\n",
    "        #print(phi) \n",
    "        #print(\"R_bar\", R_bar)\n",
    "        #print(\"P_bar\", Pa_bar)\n",
    "        #print(\"Q_bar\", Qa_bar)\n",
    "    return [phi.codomain(), [P_A_prime, Q_A_prime]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Alice_sk(E_B, S_A_prime):\n",
    "    # This function computes the shared key of Alice\n",
    "    #input: - Bob's public curve E_B\n",
    "    #       - Alice's secret point S_A_prime calculated based on the received points that have beeen evaluated according to-\n",
    "    #       - -Bob's map i.e S_A_prime = P_A_prime + [n_A].Q_A_prime\n",
    "    # output: the shared key of Alice calculated as the j_invariant value of E_AB      \n",
    "    E_AB = E_B\n",
    "    #R_bar = R\n",
    "    for i in range(1,eA+1):\n",
    "        pow = eA -i\n",
    "        R_A = 2^pow * S_A_prime\n",
    "        #print(\"The point of order 2\", R_A)\n",
    "        phi = E_AB.isogeny(R_A)\n",
    "        E_AB= phi.codomain()\n",
    "        #print(\"E\",Eab)\n",
    "        S_A_prime = phi(S_A_prime)\n",
    "       \n",
    "    \n",
    "    return phi.codomain().j_invariant()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Bob_sk(E_A, S_B_prime):\n",
    "    # This function computes the shared key of Bob\n",
    "    #input: - Alice's public curve E_A\n",
    "    #       - Bob's secret point S_B_prime calculated based on the received points that have beeen evaluated according to-\n",
    "    #       - -Alice's map i.e S_B_prime = P_B_prime + [m_A].Q_B_prime\n",
    "    # output: the shared key of Bob calculated as the j_invariant value of E_BA       \n",
    "    E_BA = E_A\n",
    "    #R_bar = R\n",
    "    for i in range(1,eB+1):\n",
    "        pow = eB -i\n",
    "        R_B = 3^pow * S_B_prime\n",
    "        #print(\"point with order 3\", R_B)\n",
    "        phi = E_BA.isogeny(R_B)\n",
    "        E_BA= phi.codomain()\n",
    "        S_B_prime = phi(S_B_prime)\n",
    "    return phi.codomain().j_invariant()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example step by step"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Public Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24439423661345221551909145011457493619085780243761596511325807336205221239331976725970216671828618445898719026692884939342314733567 True\n"
     ]
    }
   ],
   "source": [
    "eA = 216\n",
    "eB = 137\n",
    "p = 2^eA*3^eB - 1\n",
    "print(p, p.is_prime())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Build field $F_{P^2}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "_.<I> = GF(p)[]\n",
    "K.<i> = GF(p^2, modulus=I^2+1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define a Short-weierstrass curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The define elliptic curve E_{a,b} is equivelant to the Montogomery curve E_A where A=6 as of SIKE specification\n",
    "A = 6 +0*i\n",
    "a,b = Mont2wer(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Elliptic Curve defined by y^2 = x^3 + 24439423661345221551909145011457493619085780243761596511325807336205221239331976725970216671828618445898719026692884939342314733556*x + 14 over Finite Field in i of size 24439423661345221551909145011457493619085780243761596511325807336205221239331976725970216671828618445898719026692884939342314733567^2"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E_0 = EllipticCurve(K,[a,b])\n",
    "E_0\n",
    "#E_0.points()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [$2^{e_A}$]-torsion generators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alice's points: \n",
      "(18590308952679468489364793668589003541299106140709579196186461020066893645141198854487503147226318730158493210982567772716162869840*i + 2634539327592482918121599540115765431217195093350648632832477775508933673747596362667240890051240463853167541162279343167040310090 : 10983718925653566249610333622918370357192097441961014913751641775508865561311331364566791542776619041356373750734992554370506677551*i + 18499992072774772182750461054948965122862326576938683155863157755664308576685791546530637605543615310883354355922717114976263189216 : 1)\n",
      "(1640555213321637736080614728970921962714590288563692816952785470842808462670732196555713644986698688787353020078064569199240185333*i + 8633131302536015373065425580178973814526244742660764898957635611033517358603093513483897324469034427019598357249425684820405193838 : 10045306525245350298803819046509877432229480969314772374869175643233206473596453796721101344057683381390923103776706006170651177942*i + 20276452752220665548202189403598170750834982427130760850813254160550305310659929663123304778814287531500756146204805251963783256037 : 1)\n"
     ]
    }
   ],
   "source": [
    "#get Alice and Bob points equivelant to the first level of security corresponding to level 0\n",
    "P_A, Q_A, P_B, Q_B =get_basis_points(E_0,0)\n",
    "# Alice's points of degree 2^{e_A}\n",
    "print(\"Alice's points: \")\n",
    "print(P_A)\n",
    "print(Q_A)\n",
    "AlicePoints = [P_A, Q_A]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [$3^{e_B}$]-torsion generators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bob's points: \n",
      "(5822289030790821842647204127346110197186614331916510409554480418611145246532692679762948023941031185216358707524703325193156147115 : 4631002038627486062145710538859886699092897850004224163519174820337269208909673679867855016325656365561668068341925816094377133115 : 1)\n",
      "(13106015910647201458426811493288965923311702902321179794984306791335898269651901670809619116119997952683697617529379507339288983624 : 10209775938515962501771741506081580425243588708606392462054462399651871393790372518908435424495021346995173633235373991504988757970*i : 1)\n"
     ]
    }
   ],
   "source": [
    "# Bob's points of degree 3^{e_B}\n",
    "print(\"Bob's points: \")\n",
    "print(P_B)\n",
    "print(Q_B)\n",
    "BobPoints = [P_B, Q_B]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Alice public key generating"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(15258420719247443973658521799701613350754230828259003178060133147494694039793055322449086132544981156207885232972021393953796700619*i + 14429332496837303099354176943926266616961021635630628434294163234850601739729164627132987932532649086408712528667713411704528691775 : 15467799489044303896294128069509075792902639556143439961534354249286153942157388352391520252104036592700464799663595867114685105379*i + 13984699900358626441448848879222350366461656659130081644176375059874387647904488040840901457645237319266428999250802698126829386914 : 1)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_A= randint(0, 2^eA-1)\n",
    "#n_A =11\n",
    "S_A = P_A + n_A * Q_A\n",
    "S_A\n",
    "#print (S_A.order(), \" \", 2^eA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "E_A, BobPointsfromA = isogeny_2_eA(E_0,S_A, BobPoints)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alice's public key: \n",
      "Elliptic Curve defined by y^2 = x^3 + (21959810377872509077752388264447917685275195382892854605445286556807977256690355324282078410147414197702753331207593303967535501366*i+20009360894570966846571054123880569526111854322442954280414297223137682779451069510448478887147057244898476946633911792477412864939)*x + (12875491756731989468616760452267152931092338738057376800440236199478536833739731743317899676826232821680251115753645250718251978595*i+5221825855992389679563792564568002683476321958125902761093241584220916352178887934267602539207090110458667480193717251056449235294) over Finite Field in i of size 24439423661345221551909145011457493619085780243761596511325807336205221239331976725970216671828618445898719026692884939342314733567^2 \n",
      "\n",
      "[(7599375250565414570862099986311577017569095900346369590707505626082716609796989995301189187340420861204461885860038681404505373776*i + 8687138845643710892869026659174181345608061916412168618944467073091068778711478355223995444147024190748136645449906767079451915714 : 7139484431821482374437129219685919171389441702366601465741736827825282116611843881937565405558648563497504590470480793627138616444*i + 7336107681953571746795850225618675934906623495406286081396732989400306898775744467648662702418361764946559577231221932224871386083 : 1), (18613652657690851546956653114256865976803016733212342950367430391004974036403742760672844916578212356701578434790685248266476924982*i + 2151276734863496909028854789983120250839989110477861899256365707134380967819249662318372895035818226173239321191013691031401198676 : 24250112533714088512913494520984543544865941307858576752095559894276034427046573453045861163678322403932824583152597753506531523375*i + 15527186601068991254528782074225730701249562851399188856823647091222665772986978131314551177334065378485870303069191105428442544335 : 1)]\n"
     ]
    }
   ],
   "source": [
    "print(\"Alice's public key: \")\n",
    "print(E_A,\"\\n\")\n",
    "print(BobPointsfromA)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bob public key generating"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(15492187935058678705359069331176591715406647261119234889630323706565891874046273083480454703122659520238060025664065618228611256661*i + 8166083495164966479596301062564767990709586150684243108469684377786171439149556404241368725286579521107719751307753150546875446169 : 10013325235530728282398990119252165153258852803021360619315350864497471460589778461075708325759930786382518757213629864719351216248*i + 18999726747565366240284823425464117273004912391724809036240357876998093224991772161332657842340049950497557950943256293942363467880 : 1)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_B= randint(0, 3^eB-1)\n",
    "#n_B =2\n",
    "S_B = P_B + n_B* Q_B\n",
    "S_B\n",
    "#print(S_B.order(), \" \", 3^eB)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "E_B, AlicePointsfromB = isogeny_3_eB(E_0,S_B,AlicePoints)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bob's public key:\n",
      "Elliptic Curve defined by y^2 = x^3 + (1777054879379327088979170928207071609383790020845340122416238851868527588475102419440977512900132835790113910974202866459333882759*i+6625387547398707741513214642011880086557244246761610211839648736918191038219312231332738667337904842809736656028052847434628912282)*x + (16264660017272380313732180288628699219868446753009084620762431781843328297433558743578691645279633635387008607312114420745080193583*i+5537995806528235992801059754580434265403806226409327494051149086800597861368874096712937297264086401725939908672510047243311931274) over Finite Field in i of size 24439423661345221551909145011457493619085780243761596511325807336205221239331976725970216671828618445898719026692884939342314733567^2 \n",
      "\n",
      "[(7314615496706425939030743748916761465265668082375391963806452645437405973797338562679083096774155591162095120031805245376655368014*i + 21912610978842769901311186332746804053006383277805446044818626664152353831116138174522517660378849760473538507937589181446009858228 : 1365360351245170796281213368206389403958120125162846260545355893572556522173029779605991761928080929420380755450955848361431000194*i + 3343844632261671257904431488687543901596410595166122907061453424802570711946891632982201022506394480716630397994934108970545716135 : 1), (19688564420468587365584077128968616913774946178281230426903752089498870395203387533863081384114452112014343667286275894017225166689*i + 9167195677116106114171899348238273311890964424749647464922728872052543088137381185791490753131576646849967168215952483464996288977 : 3953126855007406122277098352197188957960381470497919310240763046608803203315657583163354134329931453852561599681859561928388370115*i + 19487818693613783166232301277624615075296741280480897973090815694049420382191328162602077036107082991377907451402802555412168554987 : 1)]\n"
     ]
    }
   ],
   "source": [
    "print(\"Bob's public key:\")\n",
    "print(E_B,\"\\n\")\n",
    "print(AlicePointsfromB)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Alice Shared key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The secret point S_A_prime (5663379871218628617788076479840351035829266595257821204616171906124034245163690281564996790739145267758266621959375031678007866265*i + 1212089447229133648117129831053831063562258569949136147567564736871315819284305671702939682087080193057581353060897646433071162776 : 22324354399935309528787362869543348356149001150057931398583793724612350123620069307672397643016700664783225369844515645237737110003*i + 16683238594642125474843338398060658435131295993783720824267624503119261418489750852958276877543465352592116377530715502392452132689 : 1)\n"
     ]
    }
   ],
   "source": [
    "S_A_prime = AlicePointsfromB[0] + n_A*AlicePointsfromB[1]\n",
    "print(\"The secret point S_A_prime\", S_A_prime)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Alice Shared key is: \n",
      "13841332635465877861329492158837539181568333418550826246979476707124774207381025108500663017132248291868115821645653316302163417474*i + 22146449190838776443575165518870399700706038330533433353725736764165302960277069452971554443991484162547830372421802455172763669659\n"
     ]
    }
   ],
   "source": [
    "Alice_shared_key = Alice_sk(E_B,S_A_prime)\n",
    "print(\" Alice Shared key is: \")\n",
    "print(Alice_shared_key)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bob Shared key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The secret point S_B_prime (1580783420679613608216490382797931900193096590601359353228685815412707391234927432871058426070872000521438425145682781997753462874*i + 2649166367582434954624804355860265674450757353094687635947005304297868191082458130217316441502449651123405746112324344957165614438 : 19998138422413903736189148068056609790299349839937169702617666940843264946243676753524338559894421088207107475978518372030002612976*i + 7612679673890878614110894430855816064096032065390638920616674801647104114801284014252249558221669739099052051360317109063498964687 : 1)\n"
     ]
    }
   ],
   "source": [
    "S_B_prime = BobPointsfromA[0] + n_B*BobPointsfromA[1]\n",
    "print(\"The secret point S_B_prime\", S_B_prime)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Bob shared key is: \n",
      "13841332635465877861329492158837539181568333418550826246979476707124774207381025108500663017132248291868115821645653316302163417474*i + 22146449190838776443575165518870399700706038330533433353725736764165302960277069452971554443991484162547830372421802455172763669659\n"
     ]
    }
   ],
   "source": [
    "Bob_shared_key = Bob_sk(E_A,S_B_prime)\n",
    "print(\" Bob shared key is: \")\n",
    "print(Bob_shared_key)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Check that Alice and Bob got the same shared key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Bob_shared_key == Alice_shared_key"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Real World short-Weierstrass example (Measuring time and cycles needed to generate PK & get the shared key)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Measuring Time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Elapsed time in seconds to generate Alice pk:  3.9252243041992188\n",
      "Elapsed time in seconds to generate Bob pk:  3.264252185821533\n",
      "Elapsed time to get the shared key of Alice is:  3.6743955612182617\n",
      "Elapsed time to get the shared key of Bob is:  3.0504300594329834\n",
      "The shared key is: \n",
      "21207037381272915667298326031796929894840099634130292446684091754782145247606886148458165049000297694574450514543172063357842357312*i + 7055038106104015053189932977775256460407561281179928812143358198906291382766816067283765034178815631395692773716574995836254485710\n",
      "---------------------------------------------------------------------------\n",
      "Elapsed time in seconds to generate Alice pk:  5.549593210220337\n",
      "Elapsed time in seconds to generate Bob pk:  5.162451267242432\n",
      "Elapsed time to get the shared key of Alice is:  6.428488492965698\n",
      "Elapsed time to get the shared key of Bob is:  5.033581018447876\n",
      "The shared key is: \n",
      "3948751798276567064688216435069368915599311138948295561155697231319582577657749652024801418914186385690739564556387360248783397597590633775015519150980*i + 6580068423177257734701982589560144291441978841012286520211185763804012480473975314152658011322770122741521078218290039941167864461304592573130425262680\n",
      "---------------------------------------------------------------------------\n",
      "Elapsed time in seconds to generate Alice pk:  8.10134243965149\n",
      "Elapsed time in seconds to generate Bob pk:  6.610045909881592\n",
      "Elapsed time to get the shared key of Alice is:  7.690523862838745\n",
      "Elapsed time to get the shared key of Bob is:  6.173560857772827\n",
      "The shared key is: \n",
      "2629267466829423984353018133407408976261590113774924714017696290946324878764413403567397503413056200017229177653514040063854973588999221317759099856186511132535505424187249843318369884*i + 2624100099823820567987905350039289996593796473016566935990338020628414784708536603406535843602640901619760716209211459083269924802938333651616389894629966641242083597732354918088249394\n",
      "---------------------------------------------------------------------------\n",
      "Elapsed time in seconds to generate Alice pk:  12.42782473564148\n",
      "Elapsed time in seconds to generate Bob pk:  10.39509630203247\n",
      "Elapsed time to get the shared key of Alice is:  11.39254903793335\n",
      "Elapsed time to get the shared key of Bob is:  10.19715142250061\n",
      "The shared key is: \n",
      "2842143229059257113298982052048708920932592505133488112912433767959363430266515510036725974696516721999056830616140781231152733803060674471613839623706345838408702351118188420963890846359033363569066732491506266305607695191529*i + 1667863704067166464986098971096226862297178284432626571198913163131497017993720298832311060237901140223250542361868784895784966746722217053046624286649845151151807349758124284820124927070774437246816691143934362923991050675853\n",
      "---------------------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "## Public Parameters: \n",
    "eA_list = [ 216, 250, 305, 372]\n",
    "eB_list = [137, 159, 192,239]\n",
    "prime = [434, 503, 610,751]\n",
    "Alice_time_pk0 = [0,0,0,0]\n",
    "Bob_time_pk0 = [0,0,0,0]\n",
    "Alice_time_shared_key0 = [0,0,0,0]\n",
    "Bob_time_shared_key0 = [0,0,0,0]\n",
    "\n",
    "\n",
    "for level in range(0,4,1):\n",
    "    \n",
    "    eA = eA_list[level]\n",
    "    eB = eB_list[level]\n",
    "    p = 2^eA*3^eB - 1\n",
    "    _.<I> = GF(p)[]\n",
    "    K.<i> = GF(p^2, modulus=I^2+1)\n",
    "    A = 6+0*i\n",
    "    a,b = Mont2wer(A)\n",
    "    E_0 = EllipticCurve(K,[a,b])\n",
    "    \n",
    "    P_A, Q_A, P_B, Q_B = get_basis_points(E_0,level)\n",
    "\n",
    "    AlicePoints = [P_A, Q_A]\n",
    "    BobPoints = [P_B, Q_B]\n",
    "\n",
    "    ## Alice Pk generating \n",
    "    \n",
    "    n_A = randint(0, 2^eA-1)\n",
    "    #Sa =11\n",
    "    t = time.time()\n",
    "    S_A = AlicePoints[0] + n_A * AlicePoints[1]\n",
    "    E_A, BobPointsfromA = isogeny_2_eA(E_0, S_A, BobPoints)\n",
    "    elapsed = time.time()-t\n",
    "    print(\"Elapsed time in seconds to generate Alice pk: \", elapsed)\n",
    "    Alice_time_pk0[level]+= elapsed\n",
    "    del t\n",
    "\n",
    "    ## Bob pk generating\n",
    "    n_B = randint(0, 3^eB-1)\n",
    "    #Sb =2\n",
    "    t = time.time()\n",
    "    S_B = BobPoints[0] + n_B * BobPoints[1]\n",
    "    E_B, AlicePointsfromB = isogeny_3_eB(E_0, S_B,AlicePoints)\n",
    "    elapsed = time.time()-t\n",
    "    print(\"Elapsed time in seconds to generate Bob pk: \", elapsed)\n",
    "    Bob_time_pk0[level]+=elapsed\n",
    "    del t\n",
    "\n",
    "    ##Alice Shared key\n",
    "    t = time.time()\n",
    "    S_A_prime = AlicePointsfromB[0] + n_A*AlicePointsfromB[1]\n",
    "    Alice_shared_key = Alice_sk(E_B,S_A_prime)\n",
    "    elapsed = time.time()-t\n",
    "    print(\"Elapsed time to get the shared key of Alice is: \", elapsed)\n",
    "    Alice_time_shared_key0[level]+=elapsed\n",
    "    del t\n",
    "\n",
    "    ##Bob shared key\n",
    "    t = time.time()\n",
    "    S_B_prime = BobPointsfromA[0] + n_B*BobPointsfromA[1]\n",
    "    Bob_shared_key = Bob_sk(E_A,S_B_prime)\n",
    "    elapsed = time.time()-t\n",
    "    print(\"Elapsed time to get the shared key of Bob is: \", elapsed)\n",
    "    Bob_time_shared_key0[level]+=elapsed\n",
    "    del t\n",
    "\n",
    "    if (Alice_shared_key == Bob_shared_key):\n",
    "        print(\"The shared key is: \")\n",
    "        print(Alice_shared_key)\n",
    "\n",
    "    else:\n",
    "        print(\"some error happened in calculations ...shared keys aren't equals !!! :(\")\n",
    "        \n",
    "    print(\"---------------------------------------------------------------------------\")\n",
    "    del eA, eB, p, P_A, Q_A, P_B, Q_B, K, I "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "## Time in seconds to generate the primitives: \n",
       " \n",
       " <table style='width:80%; border: 1px solid black'><tr><th>  </th><th> Alice's PK</th><th>Bob's PK</th><th>Alice's shared key(sk)</th><th>Bob's shared key (sk)</th></tr><tr><th>p434-level 1</th><td>3.9252243041992188</td><td>3.264252185821533</td><td>3.6743955612182617</td><td>3.0504300594329834</td></tr><tr><th>p503-level 2</th><td>5.549593210220337</td><td>5.162451267242432</td><td>6.428488492965698</td><td>5.033581018447876</td></tr><tr><th>p610-level 3</th><td>8.10134243965149</td><td>6.610045909881592</td><td>7.690523862838745</td><td>6.173560857772827</td></tr><tr><th>p710-level 5</th><td>12.42782473564148</td><td>10.39509630203247</td><td>11.39254903793335</td><td>10.19715142250061</td></tr></table>"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import Markdown as md\n",
    "md(\"## Time in seconds to generate the primitives: \\n \\n <table style='width:80%; border: 1px solid black'><tr><th>  </th><th> Alice's PK</th><th>Bob's PK</th><th>Alice's shared key(sk)</th><th>Bob's shared key (sk)</th></tr><tr><th>p434-level 1</th><td>{}</td><td>{}</td><td>{}</td><td>{}</td></tr><tr><th>p503-level 2</th><td>{}</td><td>{}</td><td>{}</td><td>{}</td></tr><tr><th>p610-level 3</th><td>{}</td><td>{}</td><td>{}</td><td>{}</td></tr><tr><th>p710-level 5</th><td>{}</td><td>{}</td><td>{}</td><td>{}</td></tr></table>\".format(Alice_time_pk0[0],Bob_time_pk0[0],Alice_time_shared_key0[0],Bob_time_shared_key0[0],Alice_time_pk0[1],Bob_time_pk0[1],Alice_time_shared_key0[1],Bob_time_shared_key0[1],Alice_time_pk0[2],Bob_time_pk0[2],Alice_time_shared_key0[2],Bob_time_shared_key0[2],Alice_time_pk0[3],Bob_time_pk0[3],Alice_time_shared_key0[3],Bob_time_shared_key0[3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Drawing figure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/sagemath-9.3/local/lib/python3.7/site-packages/sage/repl/ipython_kernel/__main__.py:15: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# libraries\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "# Data\n",
    "df=pd.DataFrame({'x_values': [1,2,3,5], 'Alice PK': Alice_time_pk0, 'Bob PK': Bob_time_pk0, 'Alice shared key': Alice_time_shared_key0,'Bob shared key': Bob_time_shared_key0 })\n",
    "factor = 2\n",
    "# multiple line plots\n",
    "plt.plot( 'x_values', \"Alice PK\", data=df, marker='o', markerfacecolor='red', markersize=factor*4, color='red', linewidth=factor, linestyle ='dashed')\n",
    "plt.plot( 'x_values', \"Bob PK\", data=df, marker='o', markerfacecolor='blue', markersize=factor*4, color='blue', linewidth=factor, linestyle = 'dashed')\n",
    "plt.plot( 'x_values', \"Alice shared key\", data=df, marker='^', markerfacecolor='red', markersize=factor*4, color='red', linewidth=factor)\n",
    "plt.plot( 'x_values', \"Bob shared key\", data=df, marker='^', markerfacecolor='blue', markersize=factor*4, color='blue', linewidth=factor)\n",
    "plt.xticks([1,2,3,5])\n",
    "ax = plt.subplot()\n",
    "fontsize = factor*6\n",
    "ax.set_xlabel('Security level',fontsize=fontsize)\n",
    "ax.set_ylabel('Time in seconds',fontsize=fontsize)\n",
    "ax.set_xticklabels([1,2,3,5], fontsize=fontsize)\n",
    "plt.yticks(fontsize=fontsize)\n",
    "# show legend. \n",
    "plt.legend(fontsize=fontsize)\n",
    "#plt.annotate (Alice_time_pk0[0], (1,Alice_time_pk0[0]))\n",
    "figure_size = plt.gcf().get_size_inches()\n",
    "# show graph\n",
    "plt.gcf().set_size_inches(factor * figure_size)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.measuring the CPU Cycles "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Elapsed cpu cycles to generate Alice pk:  15460286669\n",
      "Elapsed cpu cycles to generate Bob pk:  12626978258\n",
      "Elapsed time to get the shared key of Alice is:  14793728240\n",
      "Elapsed time to get the shared key of Bob is:  11917781126\n",
      "The shared key is: \n",
      "10289332052018245286861505176230633122630754957789875235830242170398722418834607485656447010056111903703189999375817271869647499314*i + 6114180593597395044229078290691595557014565425163438140438704701264251640206129683288481471484875789437818213687570266189045374156\n",
      "---------------------------------------------------------------------------\n",
      "Elapsed cpu cycles to generate Alice pk:  20461811090\n",
      "Elapsed cpu cycles to generate Bob pk:  17131253516\n",
      "Elapsed time to get the shared key of Alice is:  18872679312\n",
      "Elapsed time to get the shared key of Bob is:  16044324855\n",
      "The shared key is: \n",
      "1246408795470930358506536918514018169920474986018254850027229442833730815452998612074169851024846062205541985093105203712825406397324342611007551741200*i + 5856740985070432205321824170800696307161117334646247181349531121940055589190957205726628806232272342538962704080283016571136750498990535351026942541484\n",
      "---------------------------------------------------------------------------\n",
      "Elapsed cpu cycles to generate Alice pk:  32456193393\n",
      "Elapsed cpu cycles to generate Bob pk:  25848140623\n",
      "Elapsed time to get the shared key of Alice is:  28682333080\n",
      "Elapsed time to get the shared key of Bob is:  23480048210\n",
      "The shared key is: \n",
      "297525529347860186554163979302449965958578775976394644819913560301993189524816581919106662407804874451749790614911182269489756903130902556212309325995428746322702138299904264142348493*i + 1430464644256946670428700293236263152000346139080163695969401808428395786530694022986101647226250607741831137206683258063595636745254242837144794026497060942236395323767173574475513400\n",
      "---------------------------------------------------------------------------\n",
      "Elapsed cpu cycles to generate Alice pk:  44008191228\n",
      "Elapsed cpu cycles to generate Bob pk:  40151949477\n",
      "Elapsed time to get the shared key of Alice is:  43234243694\n",
      "Elapsed time to get the shared key of Bob is:  36248069116\n",
      "The shared key is: \n",
      "2101240681665741268358432872218076236013484203553682934651527754443252714483609417630992121680656618740776165903306362326186807367217151012378007505647280008827750399620388253594116445315205427411090595628719184319474203136955*i + 9516899686127943466717832978344519474072808692847607925431666311669310850924566869756103101598136075878249904821174918533005837005145196361719475790099399533181105623591316922610164760061075655981141498206581955157256819710355\n",
      "---------------------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "## Public Parameters: \n",
    "eA_list = [ 216, 250, 305, 372]\n",
    "eB_list = [137, 159, 192,239]\n",
    "prime = [434, 503, 610,751]\n",
    "Alice_cpu_pk0 = [0,0,0,0]\n",
    "Bob_cpu_pk0 = [0,0,0,0]\n",
    "Alice_cpu_shared_key0 = [0,0,0,0]\n",
    "Bob_cpu_shared_key0 = [0,0,0,0]\n",
    "\n",
    "\n",
    "for level in range(0,4,1):\n",
    "    \n",
    "    eA = eA_list[level]\n",
    "    eB = eB_list[level]\n",
    "    p = 2^eA*3^eB - 1\n",
    "    _.<I> = GF(p)[]\n",
    "    K.<i> = GF(p^2, modulus=I^2+1)\n",
    "    A = 6+0*i\n",
    "    a,b = Mont2wer(A)\n",
    "    E_0 = EllipticCurve(K,[a,b])\n",
    "    \n",
    "    P_A, Q_A, P_B, Q_B = get_basis_points(E_0,level)\n",
    "\n",
    "    AlicePoints = [P_A, Q_A]\n",
    "    BobPoints = [P_B, Q_B]\n",
    "\n",
    "    ## Alice Pk generating \n",
    "    n_A = randint(0, 2^eA-1)\n",
    "        #n_A =11\n",
    "    with Timer() as alice_pk_timer:\n",
    "        S_A = AlicePoints[0] + n_A * AlicePoints[1]\n",
    "        E_A, BobPointsfromA = isogeny_2_eA(E_0, S_A, BobPoints)\n",
    "    elapsed = alice_pk_timer.cycles\n",
    "    print(\"Elapsed cpu cycles to generate Alice pk: \", elapsed)\n",
    "    Alice_cpu_pk0[level]+= elapsed\n",
    "\n",
    "    ## Bob pk generating\n",
    "    n_B = randint(0, 3^eB-1)\n",
    "        #n_B =2\n",
    "    with Timer() as bob_pk_timer:\n",
    "        S_B = BobPoints[0] + n_B * BobPoints[1]\n",
    "        E_B, AlicePointsfromB = isogeny_3_eB(E_0, S_B,AlicePoints)\n",
    "    elapsed = bob_pk_timer.cycles\n",
    "    print(\"Elapsed cpu cycles to generate Bob pk: \", elapsed)\n",
    "    Bob_cpu_pk0[level]+=elapsed\n",
    "       \n",
    "\n",
    "    ##Alice Shared key\n",
    "    with Timer() as alice_sk_timer:\n",
    "        S_A_prime = AlicePointsfromB[0] + n_A*AlicePointsfromB[1]\n",
    "        Alice_shared_key = Alice_sk(E_B,S_A_prime)\n",
    "    elapsed = alice_sk_timer.cycles\n",
    "    print(\"Elapsed time to get the shared key of Alice is: \", elapsed)\n",
    "    Alice_cpu_shared_key0[level]+=elapsed\n",
    "\n",
    "    ##Bob shared key\n",
    "    with Timer() as bob_sk_timer: \n",
    "        S_B_prime = BobPointsfromA[0] + n_B*BobPointsfromA[1]\n",
    "        Bob_shared_key = Bob_sk(E_A,S_B_prime)\n",
    "    elapsed = bob_sk_timer.cycles\n",
    "    print(\"Elapsed time to get the shared key of Bob is: \", elapsed)\n",
    "    Bob_cpu_shared_key0[level]+=elapsed\n",
    "\n",
    "    if (Alice_shared_key == Bob_shared_key):\n",
    "        print(\"The shared key is: \")\n",
    "        print(Alice_shared_key)\n",
    "\n",
    "    else:\n",
    "        print(\"some error happened in calculations ...shared keys aren't equals !!! :(\")\n",
    "        \n",
    "    print(\"---------------------------------------------------------------------------\")\n",
    "    del eA, eB, p, P_A, Q_A, P_B, Q_B, K, I "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "## CPU cycles needed to generate the primitives: \n",
       " \n",
       " <table style='width:80%; border: 1px solid black'><tr><th>  </th><th> Alice's PK</th><th>Bob's PK</th><th>Alice's shared key(sk)</th><th>Bob's shared key (sk)</th></tr><tr><th>p434-level 1</th><td>15460286669</td><td>12626978258</td><td>14793728240</td><td>11917781126</td></tr><tr><th>p503-level 2</th><td>20461811090</td><td>17131253516</td><td>18872679312</td><td>16044324855</td></tr><tr><th>p610-level 3</th><td>32456193393</td><td>25848140623</td><td>28682333080</td><td>23480048210</td></tr><tr><th>p710-level 5</th><td>44008191228</td><td>40151949477</td><td>43234243694</td><td>36248069116</td></tr></table>"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import Markdown as md\n",
    "md(\"## CPU cycles needed to generate the primitives: \\n \\n <table style='width:80%; border: 1px solid black'><tr><th>  </th><th> Alice's PK</th><th>Bob's PK</th><th>Alice's shared key(sk)</th><th>Bob's shared key (sk)</th></tr><tr><th>p434-level 1</th><td>{}</td><td>{}</td><td>{}</td><td>{}</td></tr><tr><th>p503-level 2</th><td>{}</td><td>{}</td><td>{}</td><td>{}</td></tr><tr><th>p610-level 3</th><td>{}</td><td>{}</td><td>{}</td><td>{}</td></tr><tr><th>p710-level 5</th><td>{}</td><td>{}</td><td>{}</td><td>{}</td></tr></table>\".format(Alice_cpu_pk0[0],Bob_cpu_pk0[0],Alice_cpu_shared_key0[0],Bob_cpu_shared_key0[0],Alice_cpu_pk0[1],Bob_cpu_pk0[1],Alice_cpu_shared_key0[1],Bob_cpu_shared_key0[1],Alice_cpu_pk0[2],Bob_cpu_pk0[2],Alice_cpu_shared_key0[2],Bob_cpu_shared_key0[2],Alice_cpu_pk0[3],Bob_cpu_pk0[3],Alice_cpu_shared_key0[3],Bob_cpu_shared_key0[3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/sagemath-9.3/local/lib/python3.7/site-packages/sage/repl/ipython_kernel/__main__.py:10: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Data\n",
    "df=pd.DataFrame({'x_values': [1,2,3,5], 'Alice PK': Alice_cpu_pk0, 'Bob PK': Bob_cpu_pk0, 'Alice shared key': Alice_cpu_shared_key0,'Bob shared key': Bob_cpu_shared_key0 })\n",
    "factor = 2\n",
    "# multiple line plots\n",
    "plt.plot( 'x_values', \"Alice PK\", data=df, marker='o', markerfacecolor='red', markersize=factor*4, color='red', linewidth=factor, linestyle ='dashed')\n",
    "plt.plot( 'x_values', \"Bob PK\", data=df, marker='o', markerfacecolor='blue', markersize=factor*4, color='blue', linewidth=factor, linestyle ='dashed')\n",
    "plt.plot( 'x_values', \"Alice shared key\", data=df, marker='^', markerfacecolor='red', markersize=factor*4, color='red', linewidth=factor)\n",
    "plt.plot( 'x_values', \"Bob shared key\", data=df, marker='^', markerfacecolor='blue', markersize=factor*4, color='blue', linewidth=factor)\n",
    "plt.xticks([1,2,3,5])\n",
    "ax = plt.subplot()\n",
    "fontsize = factor*6\n",
    "ax.set_xlabel('Security level',fontsize=fontsize)\n",
    "ax.set_ylabel('CPU Cycles',fontsize=fontsize)\n",
    "ax.set_xticklabels([1,2,3,5], fontsize=fontsize)\n",
    "plt.yticks(fontsize=fontsize)\n",
    "# show legend. \n",
    "plt.legend(fontsize=fontsize)\n",
    "#plt.annotate (Alice_time_pk0[0], (1,Alice_time_pk0[0]))\n",
    "figure_size = plt.gcf().get_size_inches()\n",
    "# show graph\n",
    "plt.gcf().set_size_inches(factor * figure_size)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "SageMath 9.3",
   "language": "sage",
   "name": "sagemath"
  },
  "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.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}