tss.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## пороговая подпись на изогениях\n",
    "scheme_setup() - генерация параметров схемы\n",
    "        \n",
    "key_generation(k, EK, PM, PS, QS) - генерация ключей и их распределение\n",
    "            \n",
    "choose_signers(s) - подписывающие\n",
    "sign_by_group(mes, sk, gpk, e, f, p, PM, PS, QS, EK, s, signers, k, table) - групповая подпись сообщения\n",
    "            \n",
    "verify_sign(mes,sign,gpk[k+1],e,p,PM,deg) - проверка сгенерированной подписи для нашего сообщения"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1. Введите n и t \n",
      "2. Если хотите использовать значения по умолчанию n=10 t=5\n",
      "1\n",
      "введите n 4\n",
      "введите t 2\n",
      "4 2\n",
      "Параметр безопасности lambda =  4\n",
      "====================================================\n",
      "Выберите действие: \n",
      "1. Сгенерировать открытые параметры\n",
      "2. Сгенерировать ключи\n",
      "3. Сгенерировать подпись\n",
      "4. Проверить подпись\n",
      "5. Печать меню\n",
      "Выход (любое другое число)\n",
      "====================================================\n",
      "\n",
      "выберите действие (меню - 5)1\n",
      "[*] Генерация параметров схемы ...\n",
      "p =  1516319999\n",
      "mod(p,4) == 3\n",
      "E =  Elliptic Curve defined by y^2 = x^3 + 1516319998*x over Finite Field of size 1516319999\n",
      "N =  2^16 * 3^12 * 5^8 * 13^2\n",
      "\n",
      "Ps = (699074679*t + 536250445 : 1313901824*t + 1372232857 : 1)\n",
      "Qs = (263733089*t + 128959003 : 922650995*t + 741773153 : 1)\n",
      "\n",
      "\n",
      "PS =  (699074679*t + 536250445 : 1313901824*t + 1372232857 : 1)\n",
      "QS =  (263733089*t + 128959003 : 922650995*t + 741773153 : 1)\n",
      "PM =  (984494066*t + 1292473236 : 1042874537*t + 1323215015 : 1)\n",
      "====================================================\n",
      "\n",
      "\n",
      "выберите действие (меню - 5)2\n",
      "[*] Генерация и распределение ключей ...\n",
      "ms =  489 , ns =  477\n",
      "S =  (62332477*t + 1456179747 : 691148463*t + 695112928 : 1)\n",
      "phiS =  Isogeny of degree 625 from Elliptic Curve defined by y^2 = x^3 + 1516319998*x over Finite Field in t of size 1516319999^2 to Elliptic Curve defined by y^2 = x^3 + (1437223054*t+177672495)*x + (310316003*t+138387487) over Finite Field in t of size 1516319999^2\n",
      " isogeny phi-ver:  Isogeny of degree 256 from Elliptic Curve defined by y^2 = x^3 + 1516319998*x over Finite Field in t of size 1516319999^2 to Elliptic Curve defined by y^2 = x^3 + (893542673*t+622194464)*x + (516302760*t+142153761) over Finite Field in t of size 1516319999^2\n",
      "deg phi-ver =  2^8\n",
      "____________________\n",
      "\n",
      "phi  0\n",
      "m =  136 , n =  39\n",
      "0  isogeny phi:  Isogeny of degree 729 from Elliptic Curve defined by y^2 = x^3 + (893542673*t+622194464)*x + (516302760*t+142153761) over Finite Field in t of size 1516319999^2 to Elliptic Curve defined by y^2 = x^3 + (591542261*t+453067251)*x + (920607573*t+619804981) over Finite Field in t of size 1516319999^2\n",
      "deg phi =  3^6\n",
      "____________________\n",
      "\n",
      "phi  1\n",
      "m =  712 , n =  231\n",
      "1  isogeny phi:  Isogeny of degree 729 from Elliptic Curve defined by y^2 = x^3 + (591542261*t+453067251)*x + (920607573*t+619804981) over Finite Field in t of size 1516319999^2 to Elliptic Curve defined by y^2 = x^3 + (1482315591*t+205608857)*x + (313130486*t+610093296) over Finite Field in t of size 1516319999^2\n",
      "deg phi =  3^6\n",
      "____________________\n",
      "\n",
      "phi  2\n",
      "m =  91 , n =  201\n",
      "2  isogeny phi:  Isogeny of degree 256 from Elliptic Curve defined by y^2 = x^3 + (1482315591*t+205608857)*x + (313130486*t+610093296) over Finite Field in t of size 1516319999^2 to Elliptic Curve defined by y^2 = x^3 + (1279273758*t+1514887533)*x + (332267827*t+289696320) over Finite Field in t of size 1516319999^2\n",
      "deg phi =  2^8\n",
      "____________________\n",
      "\n",
      "phi  3\n",
      "m =  343 , n =  233\n",
      "3  isogeny phi:  Isogeny of degree 729 from Elliptic Curve defined by y^2 = x^3 + (1279273758*t+1514887533)*x + (332267827*t+289696320) over Finite Field in t of size 1516319999^2 to Elliptic Curve defined by y^2 = x^3 + (1183755273*t+256838889)*x + (907535666*t+1108697743) over Finite Field in t of size 1516319999^2\n",
      "deg phi =  3^6\n",
      "_____________\n",
      "deg:  25389989167104\n",
      "\n",
      " ========================================================================================== \n",
      "----- Открытые ключи -----\n",
      "[Elliptic Curve defined by y^2 = x^3 + (893542673*t+622194464)*x + (516302760*t+142153761) over Finite Field in t of size 1516319999^2, (1153858376*t + 324824302 : 553345703*t + 15618240 : 1), (1464178357*t + 348279686 : 1480878830*t + 955047847 : 1)]\n",
      "[Elliptic Curve defined by y^2 = x^3 + (591542261*t+453067251)*x + (920607573*t+619804981) over Finite Field in t of size 1516319999^2, (215663579*t + 236961137 : 923443757*t + 150417334 : 1), (1390765505*t + 457560398 : 630133527*t + 379104318 : 1)]\n",
      "[Elliptic Curve defined by y^2 = x^3 + (1482315591*t+205608857)*x + (313130486*t+610093296) over Finite Field in t of size 1516319999^2, (1054015172*t + 1006217707 : 915688915*t + 1015205067 : 1), (162194149*t + 88984454 : 524575250*t + 1443780232 : 1)]\n",
      "[Elliptic Curve defined by y^2 = x^3 + (1279273758*t+1514887533)*x + (332267827*t+289696320) over Finite Field in t of size 1516319999^2, (1502253008*t + 858451024 : 314926262*t + 253161463 : 1), (282662962*t + 446574811 : 26539450*t + 688729584 : 1)]\n",
      "[Elliptic Curve defined by y^2 = x^3 + (1183755273*t+256838889)*x + (907535666*t+1108697743) over Finite Field in t of size 1516319999^2, (406515814*t + 1335654087 : 1344425631*t + 577386491 : 1), (472384769*t + 138313400 : 1349349917*t + 1488575739 : 1)]\n",
      "[Elliptic Curve defined by y^2 = x^3 + (1437223054*t+177672495)*x + (310316003*t+138387487) over Finite Field in t of size 1516319999^2, (48627846*t + 41377403 : 1254647551*t + 193503719 : 1)]\n",
      "\n",
      " ========================================================================================== \n",
      "----- Секретные ключи -----\n",
      "User 0 .  {'s': [489, 477], 'ver': [101, 42], 1: [712, 231], 2: [91, 201], 3: [343, 233]}\n",
      "------------------------------------------------------------------------------------------\n",
      "User 1 .  {'s': [489, 477], 'ver': [101, 42], 0: [136, 39], 2: [91, 201], 3: [343, 233]}\n",
      "------------------------------------------------------------------------------------------\n",
      "User 2 .  {'s': [489, 477], 'ver': [101, 42], 0: [136, 39], 1: [712, 231], 3: [343, 233]}\n",
      "------------------------------------------------------------------------------------------\n",
      "User 3 .  {'s': [489, 477], 'ver': [101, 42], 0: [136, 39], 1: [712, 231], 2: [91, 201]}\n",
      "------------------------------------------------------------------------------------------\n",
      "\n",
      "выберите действие (меню - 5)3\n",
      "Введите ваше число (инициатора подписи): 3\n",
      "[3, 1]\n",
      "Введите сообщение для подписи: \n",
      "hello\n",
      "[*] Начало подписывания сообщения hello пользователя 3 ...\n",
      "signers:  [3, 1]\n",
      "hash  6234903848102772583\n",
      "QM = (207304336*t + 1065360737 : 580206642*t + 1183935975 : 1)\n",
      "Порядок QM = 625\n",
      "\n",
      "\n",
      "Signer verification\n",
      "___________________\n",
      "Sign by  3\n",
      "Sigma[ 0 ] =  (1218076720*t + 630988793 : 1183500679*t + 179104451 : 1) (776501167*t + 516166768 : 1278014173*t + 1012883105 : 1) (622341526*t + 838610079 : 62514842*t + 876944318 : 1)\n",
      "___________________\n",
      "Sign by  3\n",
      "Sigma[ 1 ] =  (1512701242*t + 250143778 : 144976207*t + 816680415 : 1) (1181838285*t + 872553807 : 337481387*t + 989732162 : 1) (1083267310*t + 1229774570 : 737688051*t + 846164636 : 1)\n",
      "___________________\n",
      "Sign by  3\n",
      "Sigma[ 2 ] =  (1480139645*t + 667237940 : 1395687611*t + 908887608 : 1) (562234951*t + 962325645 : 285398723*t + 1468547442 : 1) (1369326*t + 202462430 : 1058609537*t + 212369456 : 1)\n",
      "___________________\n",
      "Sending to user  1\n",
      "Check knowledge of isogeny phiS:\n",
      "E_tmp = E_is\n",
      "Sigma[ 3 ] =  (561726797*t + 1462769484 : 93852424*t + 1313261256 : 1) (1470280143*t + 963986760 : 795313249*t + 148608096 : 1) (882131748*t + 327653551 : 952479276*t + 1067979831 : 1)\n",
      "Пороговая подпись:  [(571942430*t + 481958863 : 1277093679*t + 456999199 : 1), (561726797*t + 1462769484 : 93852424*t + 1313261256 : 1)]\n",
      "\n",
      "выберите действие (меню - 5)4\n",
      "Введите сообщение: \n",
      "hello\n",
      "[*] Проверка подписи сообщения ...\n",
      "message hash:  6234903848102772583\n",
      "pairing e1 =  460125566*t + 307410179\n",
      "pairing e2 =  460125566*t + 307410179\n",
      "Подпись для сообщения  hello   True\n",
      "\n",
      "выберите действие (меню - 5)4\n",
      "Введите сообщение: \n",
      "hell\n",
      "[*] Проверка подписи сообщения ...\n",
      "message hash:  6769373583327246546\n",
      "pairing e1 =  460125566*t + 307410179\n",
      "pairing e2 =  534954229*t + 190129718\n",
      "Подпись для сообщения  hell   False\n",
      "\n",
      "выберите действие (меню - 5)6\n",
      "Выход\n"
     ]
    }
   ],
   "source": [
    "### import shutil\n",
    "import numpy as np\n",
    "import scipy.special\n",
    "import random\n",
    "from sys import exit\n",
    "from itertools import product\n",
    "\n",
    "\n",
    "class TSS:\n",
    "    def __init__(self, n=10, t=5):\n",
    "        self.lam = 4\n",
    "        self.l = [2, 3, 5]\n",
    "        self.n = n\n",
    "        self.t = t\n",
    "    \n",
    "    @staticmethod\n",
    "    def __gen_D(p):\n",
    "\tD = 2\n",
    "\twhile True:\n",
    "\t\tif kronecker_symbol(D,p) == -1 and mod(D,4) == 3:\n",
    "\t\t\treturn D\n",
    "\t\tD = D+1\n",
    "    \n",
    "#     генерация характеристики поля\n",
    "    @staticmethod\n",
    "    def __gen_p(l, lam):\n",
    "        e = [0, 0, 0]\n",
    "        ll = 1\n",
    "        for i in range(len(l)):\n",
    "            e[i] = lam / 2\n",
    "            while True:\n",
    "                if l[i] ^ e[i] >= 2 ^ (2 * lam):\n",
    "                    ll = ll * l[i] ^ e[i]\n",
    "                    break\n",
    "                else:\n",
    "                    e[i] += 1\n",
    "        f = l[2] + 1\n",
    "        while True:\n",
    "            p1 = ll * f + 1\n",
    "            p2 = ll * f - 1\n",
    "            if ((p1 in Primes())==True ) and ((f in Primes())==True ):\n",
    "                p = p1\n",
    "                break\n",
    "            if ((p2 in Primes())==True ) and ((f in Primes())==True ):\n",
    "                p = p2\n",
    "                break\n",
    "            f = next_prime(f)\n",
    "        return e, f, p\n",
    "    \n",
    "#     генерация кривой\n",
    "    @staticmethod\n",
    "    def __gen_supersingularEC(p):\n",
    "        if mod(p,4)==3:\n",
    "            print(\"mod(p,4) == 3\")\n",
    "            E = EllipticCurve(GF(p),[0,0,0,-1,0])\n",
    "        else:\n",
    "            D = self.__gen_D(p)\n",
    "            #print \"D = \",D\n",
    "            H = hilbert_class_polynomial(-D)\n",
    "            #print \"H: \",H\n",
    "            js = H.roots(GF(p**2),multiplicities=False)\n",
    "            #print \"js = \",js\n",
    "            F = GF(p**2)\n",
    "            j = js[0]\n",
    "            tmp = (4 * (1728-j) )\n",
    "            A = F((27*j) * pow(tmp,-1,p**2) )\n",
    "            E = EllipticCurve(GF(p**2),[A,-A])\n",
    "        return E\n",
    "    \n",
    "    @staticmethod\n",
    "    def __gen_base_point(E, l, e):\n",
    "        N = E.cardinality()\n",
    "        F = E.base_field()\n",
    "        PP = E.random_point()        \n",
    "        c = ZZ(N / (l^e)^2)\n",
    "        P = c * PP\n",
    "        checkP = ZZ(l^e)*P\n",
    "        if checkP[0] == 0 and checkP[2] == 0:\n",
    "            PA = P\n",
    "            return PA\n",
    "        return None\n",
    "        \n",
    "#     генерация точки Ps, Qs\n",
    "    def __gen_bases(self, E, l, e):\n",
    "        while True:\n",
    "            P = self.__gen_base_point(E,l,e)\n",
    "            Q = self.__gen_base_point(E,l,e)\n",
    "            ee = P.weil_pairing(Q, ZZ(l**e))\n",
    "            if ee^(l^e) == 1:\n",
    "                return P,Q\n",
    "    \n",
    "#     генерация параметров схемы\n",
    "    def scheme_setup(self):\n",
    "        print(\"[*] Генерация параметров схемы ...\")\n",
    "        e, f, p = self.__gen_p(self.l, self.lam)\n",
    "        print(\"p = \", p)\n",
    "        E = self.__gen_supersingularEC(p)\n",
    "        print(\"E = \", E)\n",
    "        P = E.random_point()\n",
    "        F.<a> = GF(p^2)\n",
    "        ff = a.minpoly('x')\n",
    "        K.<t> = GF(p^2,modulus=ff)\n",
    "        EK = E.base_extend(K)\n",
    "        N = EK.cardinality()\n",
    "        print(\"N = \",factor(N))\n",
    "        PS,QS = self.__gen_bases(EK, self.l[2], e[2])\n",
    "        print(\"\\nPs = {}\\nQs = {}\\n\".format(PS, QS))\n",
    "        PP = self.__gen_base_point(EK, self.l[2], e[2])\n",
    "        if PP[0] != PS[0] and PP[0] != QS[0]:\n",
    "            PM=PP\n",
    "        else:\n",
    "            raise ValueError(\"Ошибка генерации точки PM\")\n",
    "        print(\"\\nPS = \",PS)\n",
    "        print(\"QS = \",QS)\n",
    "        print(\"PM = \",PM)\n",
    "        print(\"====================================================\\n\")\n",
    "        return e,f,p,EK,PM,PS,QS\n",
    "\n",
    "######## генерация ключей ######### \n",
    "    @staticmethod\n",
    "    def gen_base_point(E,l,e):\n",
    "        N=E.cardinality()\n",
    "        F=E.base_field()\n",
    "        PP=E.random_point()\n",
    "        c=ZZ(N/(l^e)^2)\n",
    "        P=c*PP\n",
    "        checkP=ZZ(l^e)*P\n",
    "        if checkP[0]==0 and checkP[2]==0:\n",
    "            PA=P\n",
    "            return PA\n",
    "        return None\n",
    "\n",
    "    \n",
    "    def gen_bases(self, E,l,e):\n",
    "        while True:\n",
    "            P=self.gen_base_point(E,l,e)\n",
    "            Q=self.gen_base_point(E,l,e)\n",
    "            ee=P.weil_pairing(Q, ZZ(l**e))\n",
    "            if ee^(l^e)==1:\n",
    "                return P,Q\n",
    "\n",
    "    @staticmethod\n",
    "    def gen_kernel_coefficients(l,e):\n",
    "        while True:\n",
    "            m = randint(1,l^e-1)\n",
    "            n = randint(1,l^e-1)\n",
    "            if mod(m,l^e) != 0 and mod(n,l^e) != 0:\n",
    "                return m,n\n",
    "    \n",
    "    @staticmethod\n",
    "    def comb(k, n):\n",
    "        \"\"\"Генерация сочетаний из `n` по `k` без повторений.\"\"\"\n",
    "        d = list(range(0, k))\n",
    "        yield d\n",
    "        while True:\n",
    "            i = k - 1\n",
    "            while i >= 0 and d[i] + k - i + 1 > n:\n",
    "                i -= 1\n",
    "            if i < 0:\n",
    "                return\n",
    "            d[i] += 1\n",
    "            for j in range(i + 1, k):\n",
    "                d[j] = d[j - 1] + 1\n",
    "            yield d\n",
    "\n",
    "    \n",
    "    def key_distribution(self, k,t,n):\n",
    "        table = [2**n-1] * k\n",
    "        i = 0\n",
    "        for c in self.comb(t-1,n):\n",
    "            for j in c:\n",
    "                table[i] = table[i]^^(1<<j)\n",
    "            i+=1\n",
    "        return table \n",
    "\n",
    "    \n",
    "    def gen_users_data(self, EK,PM,k,num,ll,ee,ms,ns,table):\n",
    "        gpk = list()\n",
    "        sk = list()\n",
    "        phi = list()\n",
    "        deg = 1\n",
    "        j = randint(1,10^10)\n",
    "        if mod(j,2)==0:\n",
    "            P,Q = self.gen_bases(EK,ll[0],ee[0])\n",
    "            m,n = self.gen_kernel_coefficients(ll[0],ee[0])\n",
    "        else:\n",
    "            P,Q = self.gen_bases(EK,ll[1],ee[1])\n",
    "            m,n = self.gen_kernel_coefficients(ll[1],ee[1])\n",
    "        for i in range(num):\n",
    "            sk.append(dict())\n",
    "            sk[i]['s'] = [ms,ns]\n",
    "            sk[i]['ver'] = [m,n]\n",
    "        phi.append(EllipticCurveIsogeny(EK, m*P+n*Q))\n",
    "        print(\" isogeny phi-ver: \",phi[0])\n",
    "        E = phi[0].codomain()\n",
    "        deg = deg*phi[0].degree()\n",
    "        print(\"deg phi-ver = \",factor(phi[0].degree()))\n",
    "        gpk.append([E,P,Q])\n",
    "        imagePM = phi[0](PM)\n",
    "        PM = imagePM\n",
    "        EK = E\n",
    "        for i in range(0,k):\n",
    "            print(\"____________________\")\n",
    "            print()\n",
    "            print(\"phi \",i)\n",
    "            j = randint(1, 10^10)\n",
    "            if mod(j,2) == 0:\n",
    "                P,Q = self.gen_bases(EK,ll[0],ee[0])\n",
    "                m,n = self.gen_kernel_coefficients(ll[0],ee[0])\n",
    "            else:\n",
    "                P,Q = self.gen_bases(EK,ll[1],ee[1])\n",
    "                m,n = self.gen_kernel_coefficients(ll[1],ee[1])\n",
    "            for j in range(num):\n",
    "                if table[i]&(1<<j):\n",
    "                    sk[j][i] = [m,n]\n",
    "            print(\"m = \",m,\", n = \",n)\n",
    "            phi.append(EllipticCurveIsogeny(EK, m*P+n*Q))\n",
    "            print(i,\" isogeny phi: \",phi[i+1])\n",
    "            E = phi[i+1].codomain()\n",
    "            deg = deg*phi[i+1].degree()\n",
    "            print(\"deg phi = \",factor(phi[i+1].degree()))\n",
    "            gpk.append([E,P,Q])\n",
    "            imagePM = phi[i+1](PM)\n",
    "            PM = imagePM\n",
    "            EK = E\n",
    "        return gpk,sk,PM,deg\n",
    "\n",
    "    def key_generation(self, k, EK, PM, PS, QS):\n",
    "        print(\"[*] Генерация и распределение ключей ...\")\n",
    "        mS,nS = self.gen_kernel_coefficients(self.l[2],e[2])\n",
    "        print(\"ms = \",mS,\", ns = \",nS)\n",
    "        S = mS*PS+nS*QS\n",
    "        print(\"S = \",S)\n",
    "        phiS = EllipticCurveIsogeny(EK,S)\n",
    "        print(\"phiS = \",phiS)\n",
    "        ES = phiS.codomain()\n",
    "        table = self.key_distribution(k, self.t, self.n)\n",
    "        #print table\n",
    "        gpk,sk,imagePM,deg = self.gen_users_data(EK,PM,k,self.n,self.l,e,mS,nS,table)\n",
    "        print(\"_____________\")\n",
    "        gpk.append([ES,imagePM])\n",
    "        print(\"deg: \",deg)\n",
    "        print(\"\\n\",90 * \"=\",\"\\n----- Открытые ключи -----\")\n",
    "        for i in gpk:\n",
    "            print(i)\n",
    "        j = 0\n",
    "        print(\"\\n\",90 * \"=\",\"\\n----- Секретные ключи -----\")\n",
    "        for i in sk:\n",
    "            print(\"User\",j,\". \",i)\n",
    "            j+=1\n",
    "            print(90 * \"-\")\n",
    "        return gpk, sk, deg, table\n",
    "    \n",
    "\n",
    "######## генерация подписи \n",
    "# выбор подписывающих\n",
    "    def choose_signers(self, s):\n",
    "        count = random.sample(range(self.n), self.n)\n",
    "        count.remove(s)\n",
    "        values = list()\n",
    "        values.append(s)\n",
    "        for i in range (self.t-1):\n",
    "            val = count.pop()\n",
    "            values.append(val)\n",
    "        return values\n",
    "    \n",
    "    def __sign_by_user(self, e, f, p, QQ, QMI, PS, QS, sk, sk_pr, pk, E_prev):\n",
    "        m,n = sk[0],sk[1]\n",
    "        mS,nS = sk_pr[0],sk_pr[1]\n",
    "        P,Q = pk[1],pk[2]\n",
    "        phi = E_prev.isogeny(m*P+n*Q)\n",
    "        #E_user = phi.codomain()\n",
    "        ksi = E_prev.isogeny(mS*PS+nS*QS)\n",
    "        imageP = ksi(P)\n",
    "        imageQ = ksi(Q)\n",
    "        E_s = ksi.codomain()\n",
    "        imageQM = phi(QMI)\n",
    "        imagePS = phi(PS)\n",
    "        imageQS = phi(QS)\n",
    "        ksi_is = E_s.isogeny(m*imageP+n*imageQ)\n",
    "        E_is = ksi_is.codomain()\n",
    "        sigma = [E_is,QQ,imageQM,imagePS,imageQS]\n",
    "        return sigma\n",
    "    \n",
    "    def __choose_signer(self, n_isog, signers, table):\n",
    "        i = 0\n",
    "        while 1:\n",
    "            if table[n_isog] & (1<<signers[i]):\n",
    "                break\n",
    "            i+=1\n",
    "        return signers[i]\n",
    "    \n",
    "    def __sign_by_himself(self, e, f, p, QQ, QMI, PS, QS, sk, sk_pr, pk, E_prev):\n",
    "        m,n = sk[0],sk[1]\n",
    "        #mS,nS = sk_pr[0],sk_pr[1]\n",
    "        P,Q = pk[1],pk[2]\n",
    "        phi = E_prev.isogeny(m*P+n*Q)\n",
    "        #E_user = phi.codomain()\n",
    "        imageQM = phi(QMI)\n",
    "        imagePS = phi(PS)\n",
    "        imageQS = phi(QS)\n",
    "        sigma = [QQ,imageQM,imagePS,imageQS]\n",
    "        return sigma  \n",
    "    \n",
    "    def sign_by_group(self, mes, sk, pk, e, f, p, PM, PS, QS, EK, s, signers, k, table):\n",
    "        print(\"[*] Начало подписывания сообщения \" + str(mes) + \" пользователя \" + str(s) + \" ...\")\n",
    "        print(\"signers: \", signers)\n",
    "        h = hash(mes)\n",
    "        print(\"hash \",h)\n",
    "        PP = self.__gen_base_point(EK, self.l[2], e[2])\n",
    "        if PP[0] != PS[0] and PP[0] != QS[0] :\n",
    "            QQ = PP\n",
    "            QM = ZZ(h)*QQ\n",
    "            print(\"QM = {}\\nПорядок QM = {}\\n\\n\".format(QM, QM.order()))\n",
    "        else:\n",
    "            raise ValueError(\"Ошибка генерации точки QM\")\n",
    "    \n",
    "        E_prev = EK\n",
    "        imagePS = PS\n",
    "        imageQS = QS\n",
    "        imageQM = QM\n",
    "        \n",
    "        sigma = self.__sign_by_himself(e,f,p,QQ,imageQM,imagePS,imageQS,sk[s]['ver'],sk[s]['s'],gpk[0],E_prev)\n",
    "        QQ, imageQM, imagePS, imageQS = sigma[0],sigma[1], sigma[2],sigma[3]\n",
    "        print(\"Signer verification\")\n",
    "        \n",
    "        for i in range(k):\n",
    "            sig = self.__choose_signer(i, signers, table)\n",
    "            if sig != s:\n",
    "                print(\"___________________\")\n",
    "                print(\"Sending to user \",sig)\n",
    "                sigma = self.__sign_by_user(e,f,p,QQ,imageQM,imagePS,imageQS,sk[sig][i],sk[sig]['s'],gpk[i+1],gpk[i][0])\n",
    "                E_is,QQ,imageQM,imagePS,imageQS = sigma[0],sigma[1], sigma[2],sigma[3],sigma[4]\n",
    "                #E_prev = gpk[i+1][0]\n",
    "                #proof\n",
    "                phi_proof = gpk[i+1][0].isogeny(sk[s]['s'][0]*imagePS+sk[s]['s'][1]*imageQS)\n",
    "                E_tmp = phi_proof.codomain()\n",
    "                print(\"Check knowledge of isogeny phiS:\")\n",
    "                if E_tmp != E_is:\n",
    "                    print(\"!ALARM! User \",sig,\" doesn't know secret isogeny!!!\")\n",
    "                else:\n",
    "                    print(\"E_tmp = E_is\")\n",
    "            else:\n",
    "                print(\"___________________\")\n",
    "                print(\"Sign by \",s)\n",
    "                sigma = self.__sign_by_himself(e,f,p,QQ,imageQM,imagePS,imageQS,sk[s][i],sk[s]['s'],gpk[i+1],gpk[i][0])\n",
    "                QQ,imageQM,imagePS,imageQS = sigma[0],sigma[1], sigma[2],sigma[3]\n",
    "            print(\"Sigma[\",i,\"] = \",imageQM,imagePS,imageQS)\n",
    "        \n",
    "        threshold_sigma = []\n",
    "        threshold_sigma.append(QQ)\n",
    "        threshold_sigma.append(imageQM)\n",
    "        print(\"Пороговая подпись: \", threshold_sigma)\n",
    "#         print(\"*********** time: **********\")\n",
    "#         print(t_new-t_old)\n",
    "#         print(\"****************************\")\n",
    "        return threshold_sigma\n",
    "        \n",
    "######## проверка подписи #######     \n",
    "    def verify_sign(self, mes,sign,gpk,e,p,PM,deg):\n",
    "        print(\"[*] Проверка подписи сообщения ...\")\n",
    "        h=hash(mes)\n",
    "        print(\"message hash: \",h)\n",
    "        QQ, imageQM = sign[0], sign[1]\n",
    "        QM = ZZ(h)*QQ\n",
    "        ES, imagePM = gpk[0], gpk[1]\n",
    "        e1 = imagePM.weil_pairing(imageQM, ZZ(self.l[2]^e[2]))\n",
    "        print(\"pairing e1 = \",e1)\n",
    "        e2 = (PM).weil_pairing(QM,ZZ(self.l[2]^e[2]))\n",
    "        print(\"pairing e2 = \",e2^deg)\n",
    "        return e1 == e2^deg\n",
    "        \n",
    "\n",
    "    \n",
    "    \n",
    "def start():\n",
    "    print(\"====================================================\")\n",
    "    print(\"Выберите действие: \")\n",
    "    print(\"1. Сгенерировать открытые параметры\")\n",
    "    print(\"2. Сгенерировать ключи\")\n",
    "    print(\"3. Сгенерировать подпись\")\n",
    "    print(\"4. Проверить подпись\")\n",
    "    print(\"5. Печать меню\")\n",
    "    print(\"Выход (любое другое число)\")\n",
    "    print(\"====================================================\")\n",
    "    \n",
    "    \n",
    "    \n",
    "if __name__ == \"__main__\":\n",
    "    tss = None\n",
    "    EK = PM = PS = QS = None\n",
    "    print(\"1. Введите n и t \\n\\\n",
    "2. Если хотите использовать значения по умолчанию n=10 t=5\")\n",
    "    choose = int(input())\n",
    "    if choose == 1:\n",
    "        n = int(input(\"введите n \"))\n",
    "        t = int(input(\"введите t \"))\n",
    "        tss = TSS(n, t)\n",
    "        print(tss.n, tss.t)\n",
    "    elif choose == 2:\n",
    "        tss = TSS()\n",
    "        print(tss.n, tss.t)\n",
    "        n, t = 10, 5\n",
    "    else:\n",
    "        print(\"Ошибка!\")\n",
    "        exit()\n",
    "    print(\"Параметр безопасности lambda = \", tss.lam)\n",
    "    start()\n",
    "    while 1:\n",
    "        choose = int(input(\"\\nвыберите действие (меню - 5)\"))\n",
    "        if choose == 1:\n",
    "            e, f, p, EK, PM, PS, QS = tss.scheme_setup()\n",
    "#             print(\"\\n\\n{}\\n\\n\".format(e))\n",
    "        elif choose == 2:\n",
    "            k = scipy.special.comb(n, t - 1, exact=True)\n",
    "            gpk, sk, deg, table = tss.key_generation(k, EK, PM, PS, QS)\n",
    "        elif choose == 3:\n",
    "            s = int(input(\"Введите ваше число (инициатора подписи): \"))\n",
    "            signers = tss.choose_signers(s) # подписывающие \n",
    "            print(signers)\n",
    "            \n",
    "            print(\"Введите сообщение для подписи: \")\n",
    "            mes = input()\n",
    "            sign = tss.sign_by_group(mes, sk, gpk, e, f, p, PM, PS, QS, EK, s, signers, k, table)\n",
    "            \n",
    "        elif choose == 4:\n",
    "            print(\"Введите сообщение: \")\n",
    "            mes = input()\n",
    "            result_verify = tss.verify_sign(mes,sign,gpk[k+1],e,p,PM,deg)\n",
    "            print (\"Подпись для сообщения \",mes,\" \", result_verify)\n",
    "        elif choose == 5:\n",
    "            start()\n",
    "        else:\n",
    "            print(\"Выход\")\n",
    "            break\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "SageMath 9.2",
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}