p3.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# IMPORTANT!!!\n",
    "# [1] Introduïu les dades sobre el vostre grup en el format especificat.\n",
    "# [2] Desar la pràctica posant els NIUs dels membres del grup\n",
    "# [3] És imprescindible que el worksheet es pugui avaluar completament (Cell->Run All) sense que es produeixi cap error de sintaxi. \n",
    "# [4] Cal lliurar el worksheet ABANS de finalitzar la vostra sessió de pràctiques.\n",
    "# [5] No s'avaluaran worksheets que no compleixin els requisits anteriors.\n",
    "\n",
    "GROUP = \"A11\"\n",
    "\n",
    "NIU_ESTUDIANT_1 = 1382429\n",
    "NOM_ESTUDIANT_1 = \"RUBEN VERA GARCIA\"\n",
    "\n",
    "NIU_ESTUDIANT_2 = 1459132\n",
    "NOM_ESTUDIANT_2 = \"JHOANESTIBEN GRANADA RUIZ\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# EXERCISE 1a: Implement ElGamal key generation algorithm\n",
    "#\n",
    "# Function UAB_generate_ElGamal_keys.\n",
    "# * Parameter nBits: Length in bits of the prime p\n",
    "# * Returns: two element list with private and public keys. \n",
    "#    The private key is a list of three values: the prime p, the generator alpha, and the secret value d. \n",
    "#    The public key is a list of three values: the prime p, the generator alpha, and public value c (alpha^d).\n",
    "# \n",
    "\n",
    "def UAB_generate_ElGamal_keys(nBits):\n",
    "    \n",
    "    k_priv = (None, None, None)\n",
    "    k_pub = (None, None, None)\n",
    "    \n",
    "    #### IMPLEMENTATION GOES HERE ####\n",
    "    p=random_prime(2^(nBits)-1,None,3)\n",
    "    Z=GF(p)\n",
    "    keep=True\n",
    "    while(keep):\n",
    "        a=Z(randint(1,p-1))\n",
    "        if (a.multiplicative_order() == (p-1)):\n",
    "            keep=False\n",
    "    keep=True\n",
    "    while(keep):\n",
    "        d=randint(2,p-2)\n",
    "        if(gcd(d,p-1)==1):\n",
    "            keep=False\n",
    "    c=power_mod(a,d,p)\n",
    "    \n",
    "    k_priv=p,a,d\n",
    "    k_pub=p,a,c\n",
    " \n",
    "    \n",
    "    ##################################\n",
    "    return [k_priv,k_pub]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# EXERCISE 1b: Implement ElGamal signature generation algorithm\n",
    "#\n",
    "# Function UAB_ElGamal_sign.\n",
    "# * Parameter k_priv: 3-element list with the private key (as returned by UAB_generate_ElGamal_keys).\n",
    "# * Parameter m: Integer, message to sign\n",
    "# * Parameter k: Optional Integer, the random k value (if present, the function must use the supplied k value, otherwise, \n",
    "#     it must select k randomly.\n",
    "# * Returns: two element list with the signature ([r, s]) \n",
    "# \n",
    "\n",
    "def UAB_ElGamal_sign(k_priv, m, k=None):\n",
    "\n",
    "    r, s = None, None\n",
    "    \n",
    "    #### IMPLEMENTATION GOES HERE ####\n",
    "\n",
    "    p=k_priv[0]\n",
    "    a=Integer(k_priv[1])\n",
    "    d=k_priv[2]\n",
    "    if(k == None):\n",
    "        keep=True\n",
    "        while(keep):\n",
    "            k=randint(1,p-1)\n",
    "            if(gcd(k,p-1)==1):\n",
    "                keep=False          \n",
    "    r=power_mod(a,k,p)\n",
    "    hinv=inverse_mod(k,p-1)\n",
    "    x=mod((m-d*r), p-1) \n",
    "    s=mod(x*hinv,p-1)\n",
    "    ##################################\n",
    "    return (r, s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# EXERCISE 1c (part 1): Show that v1 == v2\n",
    "#\n",
    "#\n",
    "\n",
    "#### EXPLANATION GOES HERE #######\n",
    "# \n",
    "#v1=c^r * r^s mod p\n",
    "#v2=a^m mod p\n",
    "#c=a^d mod p\n",
    "#r=a^l mod p\n",
    "#v1=a^(dr) * a^(ls) mod p\n",
    "# if v1=v2 --> a^(dr) * a^(ls) = a^m (mod p) això implica m=dr+ls, condició que ha de complir la m al generar s.\n",
    "\n",
    "##################################\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# EXERCISE 1c (part 2): Implement ElGamal signature verification algorithm\n",
    "#\n",
    "# Function UAB_ElGamal_verify.\n",
    "# * Parameter sig: signature to verify (as returned by UAB_ElGamal_sign)\n",
    "# * Parameter k_pub: 3-element list with the public key (as returned by UAB_generate_ElGamal_keys).\n",
    "# * Parameter m: Integer, message that was signed\n",
    "# * Returns: boolean, True iff signature is valid\n",
    "# \n",
    "\n",
    "def UAB_ElGamal_verify(sig, k_pub, m):\n",
    "\n",
    "    result = None\n",
    "\n",
    "    #### IMPLEMENTATION GOES HERE ####\n",
    "    c=Integer(k_pub[2])\n",
    "    p=(k_pub[0])\n",
    "    p1=p-1\n",
    "    r=Integer(sig[0])\n",
    "    s=Integer(sig[1])\n",
    "    if(1 <= r and  r <= p1 ):\n",
    "        Br=(power_mod(c,r,p))\n",
    "        rs=power_mod(r,s,p)\n",
    "        t=mod(Br*rs,  p)\n",
    "        x=power_mod(k_pub[1],m,p)\n",
    "        result= t == x\n",
    "    else:\n",
    "        result =False\n",
    "\n",
    "    \n",
    "    ##################################\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# EXERCISE 2a: Describe the procedure followed by the attacker\n",
    "#\n",
    "#\n",
    "\n",
    "#### EXPLANATION GOES HERE #######\n",
    "# Un atacant pot recuperar la clau privada d si té 2 signatures realitzades amb el mateix valor aleatori h.\n",
    "#degut a que les r són iguals, es dedueix que la h es la mateixa\n",
    "#amb les equacions de les dues s, fem un sistema de 2 equacions amb dues incògnites\n",
    "#restem les dues i obtenim:\n",
    "# h = (m2 - m1) / (s2 - s1) mod p-1\n",
    "#d'aquí, substituïnt en qualsevol equació obtenim d:\n",
    "# d = (m1 hs1)·r^-1 mod p-1\n",
    "\n",
    "# Important que mcd(s2 - s1, p - 1) = 1, és a dir, s2 - s1 és invertible per poder fer l'atac.\n",
    "\n",
    "##################################\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# EXERCISE 2b: Implement the algorithm used by the attacker to recover the private key\n",
    "#\n",
    "# Function UAB_extract_private_key.\n",
    "# * Parameter k_pub: 3-element list with the public key (as returned by UAB_generate_ElGamal_keys).\n",
    "# * Parameter m1: Integer, a message that was signed\n",
    "# * Parameter sig1: signature of message m1 (as returned by UAB_ElGamal_sign)\n",
    "# * Parameter m2: Integer, a message that was signed\n",
    "# * Parameter sig2: signature of message m2 (as returned by UAB_ElGamal_sign)\n",
    "# * Returns: a 3-element list with the private key if it was possible to recover it, -1 otherwise\n",
    "# \n",
    "\n",
    "def UAB_extract_private_key(k_pub, m1, sig1, m2, sig2):\n",
    "    #k_pub=p,a,c\n",
    "    k_priv = None\n",
    "    p = k_pub[0]\n",
    "    r = sig1[0]\n",
    "    s1 = sig1[1]\n",
    "    s2 = sig2[1]\n",
    "    Z=GF(p)\n",
    "    a = Z(k_pub[1])\n",
    "    \n",
    "    #### IMPLEMENTATION GOES HERE ####\n",
    "    k_priv=-1\n",
    "    #en cas de que les dues s siguin iguals, els missatges siguin diferents i l'ordre d'alfa sigui q,\n",
    "    #vol dir que la signatuera es vàlida i les h són iguals\n",
    "    if(r == sig2[0] and m1 != m2 and a.multiplicative_order() == (p-1)):\n",
    "        #si s2-s1 té invers\n",
    "        if(gcd(s2 - s1, p - 1) == 1):\n",
    "            h = mod((m2 - m1) / (s2 - s1), p - 1)\n",
    "            #si r té invers\n",
    "            if gcd(r, p - 1) == 1:\n",
    "        \n",
    "                d = mod((m1 - h * s1) * inverse_mod(r, p - 1), p - 1)\n",
    "                k_priv = (p, a, d)\n",
    "            else:\n",
    "                #si r no té invers provem valors de \"d\",desde d=2 fins p-2 en cas de que p  < 100000\n",
    "                if(p<100000):\n",
    "                    looper = True\n",
    "                    d = 2\n",
    "                    while looper or d < p-1:\n",
    "                        d = d + 1\n",
    "                        if power_mod(a, d, p) == k_pub[2]:\n",
    "                            k_priv = (p, a, d)\n",
    "                            looper = False\n",
    "        else:\n",
    "            #si s no té invers provem valors de \"d\",desde d=2 fins p-2 en cas de que p  < 100000\n",
    "            if(p<100000):\n",
    "                looper = True\n",
    "                d = 2\n",
    "                while looper or d < p-1:\n",
    "                    d = d + 1\n",
    "                    if power_mod(a, d, p) == k_pub[2]:\n",
    "                        k_priv = (p, a, d)\n",
    "                        looper = False\n",
    "            \n",
    "   \n",
    "    ##################################\n",
    "    return k_priv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test 1a.1: True\n",
      "Test 1a.2: True\n",
      "Test 1a.3: True\n"
     ]
    }
   ],
   "source": [
    "####################################################################################\n",
    "# TEST CASES EXERCICE 1a:\n",
    "####################################################################################\n",
    "\n",
    "def test_case_1a(name, num_tries, num_bits):\n",
    "    \n",
    "    [k_priv, k_pub] = UAB_generate_ElGamal_keys(num_bits)\n",
    "    \n",
    "    t1 = len(k_priv) == 3\n",
    "    t2 = len(k_pub) == 3\n",
    "    \n",
    "    t3, t4, t5 = False, False, False\n",
    "    if t1 & t2:\n",
    "        t3 = k_pub[0] == k_priv[0]\n",
    "        t4 = k_pub[1] == k_priv[1]\n",
    "        t5 = k_pub[2] == power_mod(k_pub[1], k_priv[2], k_pub[0])\n",
    "        \n",
    "    print \"Test\", name + \":\", t1 & t2 & t3 & t4 & t5            \n",
    "\n",
    "test_case_1a(\"1a.1\", 20, 64)\n",
    "test_case_1a(\"1a.2\", 20, 128)\n",
    "test_case_1a(\"1a.3\", 1, 256)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test 1b.1: True\n",
      "Test 1b.2: True\n",
      "Test 1b.3: True\n",
      "Test 1b.4: True\n"
     ]
    }
   ],
   "source": [
    "####################################################################################\n",
    "# TEST CASES EXERCICE 1b:\n",
    "####################################################################################\n",
    "\n",
    "def test_case_1b(name, k_priv, h, m, exp_r, exp_s):\n",
    "\n",
    "    (r, s) = UAB_ElGamal_sign(k_priv, m, h) \n",
    "    print \"Test\", name + \":\", (r == exp_r) & (s == exp_s)\n",
    "\n",
    "k_priv =  (141627058957340093855620484680587497231, 49407674567884478422262585667470127500, 91557801542207645804476483173676169513L)\n",
    "k_pub =  (141627058957340093855620484680587497231, 49407674567884478422262585667470127500, 136166465183429483437614516541235447540)\n",
    "h =  6505205550934361491179720631243\n",
    "exp_r =  16070586247864526048715174304611921161\n",
    "exp_s =  79906657969558945308772045181673566953\n",
    "test_case_1b(\"1b.1\", k_priv, h, 42, exp_r, exp_s)\n",
    "\n",
    "k_priv =  (12992917616897605511470512010377760999, 6497100366721531782651229087612454514, 8184645315919973579263902520077142907L)\n",
    "k_pub =  (12992917616897605511470512010377760999, 6497100366721531782651229087612454514, 4784536271623967017080018506651914749)\n",
    "h =  30541127218530291833593754023\n",
    "exp_r =  370282987414176508036351785758150113\n",
    "exp_s =  57221387644974029881195998309189883\n",
    "test_case_1b(\"1b.2\", k_priv, h, 42424242, exp_r, exp_s)\n",
    "\n",
    "k_priv =  (111095862244100561185773259658903092441, 68715015864842833415840443685753818922, 10688562822627073336062911686899436628L)\n",
    "k_pub =  (111095862244100561185773259658903092441, 68715015864842833415840443685753818922, 37400235185594015815971136915025528910)\n",
    "h =  6235123811656012209298405325689\n",
    "exp_r =  16165481899748746481848784352851142527\n",
    "exp_s =  98809740663833529553705269007330012337\n",
    "test_case_1b(\"1b.3\", k_priv, h, 123456789, exp_r, exp_s)\n",
    "\n",
    "k_priv =  (112847941112170644296267772277509350846555975113583168624796765318122631009049, 8727126823951345831686546296722679628937575768766379507115329576365730863802, 90254950644239289915262816357689053461511329394130471493737946140216700916566L)\n",
    "k_pub =  (112847941112170644296267772277509350846555975113583168624796765318122631009049, 8727126823951345831686546296722679628937575768766379507115329576365730863802, 2099965966935399988641793851392022051292773481845879860193310339903489213462)\n",
    "h =  2294742374266784531203391331539988254350495938206389588496594528290435\n",
    "exp_r =  5243953816691648242050551475605541294498933363835245262768302013908462924792\n",
    "exp_s =  72567626378663072501746825375182155635676274934487883661122801069515340587487\n",
    "test_case_1b(\"1b.4\", k_priv, h, 123456789123456789123456789, exp_r, exp_s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test 1c.1: True\n",
      "Test 1c.2: True\n",
      "Test 1c.3: True\n",
      "Test 1c.4: True\n",
      "Test 1c.5: True\n",
      "Test 1c.6: True\n",
      "Test 1c.7: True\n",
      "Test 1c.8: True\n"
     ]
    }
   ],
   "source": [
    "####################################################################################\n",
    "# TEST CASES EXERCICE 1c:\n",
    "####################################################################################\n",
    "\n",
    "def test_case_1c(name, sig, k_pub, m, exp_result):\n",
    "\n",
    "    result = UAB_ElGamal_verify(sig, k_pub, m)\n",
    "    print \"Test\", name + \":\", (result == exp_result)\n",
    "    \n",
    "k_pub =  (141627058957340093855620484680587497231, 49407674567884478422262585667470127500, 136166465183429483437614516541235447540)\n",
    "r =  16070586247864526048715174304611921161\n",
    "s =  79906657969558945308772045181673566953\n",
    "test_case_1c(\"1c.1\", (r, s), k_pub, 42, True)\n",
    "\n",
    "k_pub =  (12992917616897605511470512010377760999, 6497100366721531782651229087612454514, 4784536271623967017080018506651914749)\n",
    "r =  370282987414176508036351785758150113\n",
    "s =  57221387644974029881195998309189883\n",
    "test_case_1c(\"1c.2\", (r, s), k_pub, 42424242, True)\n",
    "\n",
    "k_pub =  (111095862244100561185773259658903092441, 68715015864842833415840443685753818922, 37400235185594015815971136915025528910)\n",
    "r =  16165481899748746481848784352851142527\n",
    "s =  98809740663833529553705269007330012337\n",
    "test_case_1c(\"1c.3\", (r, s), k_pub, 123456789, True)\n",
    "\n",
    "k_pub =  (112847941112170644296267772277509350846555975113583168624796765318122631009049, 8727126823951345831686546296722679628937575768766379507115329576365730863802, 2099965966935399988641793851392022051292773481845879860193310339903489213462)\n",
    "r =  5243953816691648242050551475605541294498933363835245262768302013908462924792\n",
    "s =  72567626378663072501746825375182155635676274934487883661122801069515340587487\n",
    "test_case_1c(\"1c.4\", (r, s), k_pub, 123456789123456789123456789, True)\n",
    "\n",
    "k_pub =  (141627058957340093855620484680587497231, 49407674567884478422262585667470127500, 136166465183429483437614516541235447540)\n",
    "r =  16070586247864526048715174304611921161\n",
    "s =  79906657969558945308772045181673566954\n",
    "test_case_1c(\"1c.5\", (r, s), k_pub, 42, False)\n",
    "\n",
    "k_pub =  (12992917616897605511470512010377760999, 6497100366721531782651229087612454514, 4784536271623967017080018506651914749)\n",
    "r =  370282987414176508036351785758150115\n",
    "s =  57221387644974029881195998309189883\n",
    "test_case_1c(\"1c.6\", (r, s), k_pub, 42424242, False)\n",
    "\n",
    "k_pub =  (111095862244100561185773259658903092443, 68715015864842833415840443685753818922, 37400235185594015815971136915025528910)\n",
    "r =  16165481899748746481848784352851142527\n",
    "s =  98809740663833529553705269007330012337\n",
    "test_case_1c(\"1c.7\", (r, s), k_pub, 123456789, False)\n",
    "\n",
    "k_pub =  (112847941112170644296267772277509350846555975113583168624796765318122631009049, 8727126823951345831686546296722679628937575768766379507115329576365730863803, 2099965966935399988641793851392022051292773481845879860193310339903489213462)\n",
    "r =  5243953816691648242050551475605541294498933363835245262768302013908462924792\n",
    "s =  72567626378663072501746825375182155635676274934487883661122801069515340587487\n",
    "test_case_1c(\"1c.8\", (r, s), k_pub, 123456789123456789123456789, False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test 1d.1: True\n",
      "Test 1d.2: True\n",
      "Test 1e.1: True\n",
      "Test 1e.2: True\n"
     ]
    }
   ],
   "source": [
    "####################################################################################\n",
    "# TEST CASES EXERCICE 1(all):\n",
    "####################################################################################\n",
    "\n",
    "def test_case_1d(name, num_its, num_bits):\n",
    "\n",
    "    acc_r = []\n",
    "    for _ in range(num_its):\n",
    "        m = randint(2, 2^(num_bits-1)-1)\n",
    "        \n",
    "        [k_priv, k_pub] = UAB_generate_ElGamal_keys(num_bits)\n",
    "        result = UAB_ElGamal_verify(UAB_ElGamal_sign(k_priv, m), k_pub, m)\n",
    "        acc_r.append(result)\n",
    "    \n",
    "    print \"Test\", name + \":\", all(acc_r)\n",
    "   \n",
    "\n",
    "def test_case_1e(name, num_its, num_bits):\n",
    "\n",
    "    acc_r = []\n",
    "    for _ in range(num_its):\n",
    "        m = randint(2, 2^(num_bits-1)-1)\n",
    "        \n",
    "        [k_priv, k_pub] = UAB_generate_ElGamal_keys(num_bits)\n",
    "        result = UAB_ElGamal_verify(UAB_ElGamal_sign(k_priv, m), k_pub, m-1)\n",
    "        acc_r.append(result)\n",
    "    \n",
    "    print \"Test\", name + \":\", not any(acc_r)\n",
    "   \n",
    "        \n",
    "        \n",
    "test_case_1d(\"1d.1\", 100, 64)    \n",
    "test_case_1d(\"1d.2\", 10, 128)  \n",
    "\n",
    "test_case_1e(\"1e.1\", 10, 64)    \n",
    "test_case_1e(\"1e.2\", 10, 128)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test 2.1: True\n",
      "Test 2.2: True\n",
      "Test 2.3: True\n",
      "Test 2.4: True\n",
      "Test 2.5: True\n",
      "Test 2.6: True\n",
      "Test 2.7: True\n",
      "Test 2.8: True\n",
      "Test 2.9: True\n",
      "Test 2.10: True\n"
     ]
    }
   ],
   "source": [
    "####################################################################################\n",
    "# TEST CASES EXERCICE 2:\n",
    "####################################################################################\n",
    "\n",
    "def test_case_2(name, k_pub, m1, sig1, m2, sig2, exp_k_priv):\n",
    "    \n",
    "    extracted_k_priv = UAB_extract_private_key(k_pub, m1, sig1, m2, sig2)\n",
    "    print \"Test\", name + \":\",  exp_k_priv == extracted_k_priv\n",
    "    \n",
    "exp_k_priv =  (1736419493, 423105914, 1439798331)\n",
    "k_pub =  (1736419493, 423105914, 1388681513)\n",
    "m1, m2 = 4321, 1234\n",
    "sig1 =  (1670801833L, 813531998L)\n",
    "sig2 =  (1670801833L, 1514976703L)\n",
    "test_case_2(\"2.1\", k_pub, m1, sig1, m2, sig2, exp_k_priv)\n",
    "       \t\n",
    "exp_k_priv =  (3043480277, 949971850, 2984002184L)\n",
    "k_pub =  (3043480277, 949971850, 450506446)\n",
    "m1, m2 = 4321, 1234\n",
    "sig1 =  (652612267, 1904199797)\n",
    "sig2 =  (652612267, 716941154)\n",
    "test_case_2(\"2.2\", k_pub, m1, sig1, m2, sig2, exp_k_priv)\n",
    "\n",
    "exp_k_priv =  (3081644339, 432364326, 231991852)\n",
    "k_pub =  (3081644339, 432364326, 1072654913)\n",
    "m1, m2 = 4321, 1234\n",
    "sig1 =  (2294114827L, 97380409)\n",
    "sig2 =  (2294114827L, 744220606)\n",
    "test_case_2(\"2.3\", k_pub, m1, sig1, m2, sig2, exp_k_priv)\n",
    "\n",
    "exp_k_priv =  (39929, 23050, 17872)\n",
    "k_pub =  (39929, 23050, 3414)\n",
    "m1, m2 = 4321, 1234\n",
    "sig1 =  (39612, 35145)\n",
    "sig2 =  (39612, 38386)\n",
    "test_case_2(\"2.4\", k_pub, m1, sig1, m2, sig2, exp_k_priv)\n",
    "\n",
    "exp_k_priv =  (38783, 10357, 9046)\n",
    "k_pub =  (38783, 10357, 14443)\n",
    "m1, m2 = 4321, 1234\n",
    "sig1 =  (12778, 29913)\n",
    "sig2 =  (12778, 20620)\n",
    "test_case_2(\"2.5\", k_pub, m1, sig1, m2, sig2, exp_k_priv)\n",
    "       \t\n",
    "exp_k_priv =  (6203, 3754, 5115)\n",
    "k_pub =  (6203, 3754, 540)\n",
    "m1, m2 = 4321, 1234\n",
    "sig1 =  (3747, 3790)\n",
    "sig2 =  (3747, 5435)\n",
    "test_case_2(\"2.6\", k_pub, m1, sig1, m2, sig2, exp_k_priv)\n",
    "\n",
    "exp_k_priv =  -1\n",
    "k_pub =  (1400337509, 1359471971, 45907697)\n",
    "m1, m2 = 4321, 4321\n",
    "sig1 =  (639541257L, 1115934695L)\n",
    "sig2 =  (639541257L, 1115934695L)\n",
    "test_case_2(\"2.7\", k_pub, m1, sig1, m2, sig2, exp_k_priv)\n",
    "\n",
    "exp_k_priv =  -1\n",
    "k_pub =  (2056635443, 830686420, 1880350451)\n",
    "m1, m2 = 4321, 1234\n",
    "sig1 =  (1601254651L, 1061368902L)\n",
    "sig2 =  (1601254651L, 935119992L)\n",
    "test_case_2(\"2.8\", k_pub, m1, sig1, m2, sig2, exp_k_priv)\n",
    "\n",
    "exp_k_priv = -1\n",
    "m1, m2 = 4321, 1234\n",
    "k_pub =  (460730117, 91503345, 401055661)\n",
    "sig1 =  (457648992L, 18325781L)\n",
    "sig2 =  (457648992L, 180721743L)\n",
    "test_case_2(\"2.9\", k_pub, m1, sig1, m2, sig2, exp_k_priv)\n",
    "\n",
    "\n",
    "exp_k_priv =  -1\n",
    "m1, m2 = 4321, 1234\n",
    "k_pub =  (3342796253, 1046051573, 77303856)\n",
    "sig1 =  (1629150615, 2477614166L)\n",
    "sig2 =  (1462514112, 61485630)\n",
    "test_case_2(\"2.10\", k_pub, m1, sig1, m2, sig2, exp_k_priv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "SageMath 8.2",
   "language": "",
   "name": "sagemath"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}