Exemplo n.º 1
0
def time_scalar_mul():
    import time, pprint

    G = EcGroup()
    d = G.parameters()
    a, b, p = d["a"], d["b"], d["p"]
    g = G.generator()
    x, y = g.get_affine()
    scalars = G.order().hex()
    results = []

    for i in range(0, len(scalars), 3):
        r = Bn.from_hex(scalars[:i+1])
        start = time.clock()
        point_scalar_multiplication_double_and_add(a, b, p, x, y, r)
        elapsed = (time.clock() - start)
        results.append((r, elapsed))
    pp = pprint.PrettyPrinter(indent=2, width=160)
    pp.pprint(results)

    for i in range(0, len(scalars), 3):
        r = Bn.from_hex(scalars[:i+1])
        start = time.clock()
        point_scalar_multiplication_montgomerry_ladder(a, b, p, x, y, r)
        elapsed = (time.clock() - start)
        results.append((r, elapsed))
    pp = pprint.PrettyPrinter(indent=2, width=160)
    pp.pprint(results)
Exemplo n.º 2
0
def time_scalar_mul():
    # setup curve
    G = EcGroup(713)  # NIST curve
    d = G.parameters()
    a, b, p = d["a"], d["b"], d["p"]
    g = G.generator()
    gx0, gy0 = g.get_affine()
    order = G.order()

    r = order.random()

    gx2, gy2 = (r * g).get_affine()

    # First a value with low hamming weight
    scalar_1 = Bn.from_hex('11111111111111111111111111111111111111111')

    # The second scalar value with a much higher hamming weight
    scalar_2 = Bn.from_hex('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF')
    # Scalar values with higher hamming weight will take longer to
    # compute the multiplication of.
    t1 = time.clock()
    x2, y2 = point_scalar_multiplication_double_and_add(
        a, b, p, gx0, gy0, scalar_1)
    t2 = time.clock()
    runtime = t2 - t1
    print("Runtime for scalar 1: " + str(runtime))

    t1 = time.clock()
    x2, y2 = point_scalar_multiplication_double_and_add(
        a, b, p, gx0, gy0, scalar_2)
    t2 = time.clock()
    runtime = t2 - t1
    print("Runtime for scalar 2: " + str(runtime))
Exemplo n.º 3
0
    def report():
        frank = request.form['frank'].split(DELIMITER)
        sender = request.form['sender']
        reporter = request.form['reporter']
        msg = request.form['message']
        test = request.form['test']
        db = get_db()

        sig = str_to_frank(frank, G)

        if test == "True":
            with open("test.txt", "rb") as file:
                data = file.read()
                info = data.split(DELIMITER.encode('ascii'))
                pk_s = EcPt.from_binary(info[0], G)
                pk_r = EcPt.from_binary(info[2], G)

        else:
            sender_kb = db.execute(
                'SELECT keybase FROM user WHERE twitter = ?',
                (sender, )).fetchone()['keybase']
            reporter_kb = db.execute(
                'SELECT keybase FROM user WHERE twitter = ?',
                (reporter, )).fetchone()['keybase']

            r = requests.get("https://" + sender_kb +
                             ".keybase.pub/amf/amf_pk.txt")
            pk_s = EcPt.from_binary(
                binascii.a2b_base64(r.text.encode('ascii')), G)

            r = requests.get("https://" + reporter_kb +
                             ".keybase.pub/amf/amf_pk.txt")
            pk_r = EcPt.from_binary(
                binascii.a2b_base64(r.text.encode('ascii')), G)

        db = get_db()
        g_db = db.execute('SELECT g FROM judge_keys').fetchone()['g']
        o_db = db.execute('SELECT o FROM judge_keys').fetchone()['o']
        sk_j_db = db.execute('SELECT sk_j FROM judge_keys').fetchone()['sk_j']
        g = EcPt.from_binary(g_db, G)
        o = Bn.from_hex(o_db.decode('ascii'))
        sk_j = Bn.from_hex(sk_j_db.decode('ascii'))
        aux = (g, o)

        if not dmf.Judge(pk_s, pk_r, sk_j, msg, sig, aux):
            return "Message could not be authenticated by judge."
        else:
            prob = call_perspective_api(msg, ["TOXICITY"], PERSPECTIVE_KEY)
            if prob["TOXICITY"] > TOXICITY_THRESHOLD:
                db.execute('INSERT INTO blacklist VALUES (?)', (sender, ))
                db.commit()
                return sender + " has been added to the blacklist."
            else:
                return "Message not judged to be abusive."
Exemplo n.º 4
0
 def verifyK(self,pi,P,Q):
     # c是内部的?C也是内部的?r也是内部的?不用不用,pi传入了
     # 预处理
     n = len(Q)
     (C,c,r) = pi
     # 得到c_,同样分为(1),(2),(3),(4)四步
     # (1)得到P,Qi,C各自的二进制表示P_,Q_[],C_,Sigma_(1,n){ri*Qi+r_{n+1}*P+c*C}_
     P_ = P.export()
     Q_ = []
     for i in range(n):
         Q_.append(Q[i].export())
     C_ = C.export()
     # 求点Sigma的位置:
     Sigma = r[n] * P + c * C
     for i in range(n):
         Sigma += r[i] * Q[i] 
     # 将点Sigma转换成byte形式
     Sigma_ = Sigma.export()
     # (2)将P_,Q_[],C_,Sigma_(1,n){ri*Qi+r_{n+1}*P+c*C}顺次拼接在一起,得到二进制串bytestr
     bytestr = P_
     for i in range(n):
         bytestr += Q_[i]
     bytestr += C_ + Sigma_
     # (3)将二进制串bytestr转换成字符串str0
     str0 = str(bytestr)
     # (4)调用hashlib中的md5函数,将str0映射成为十六进制数字c_,再进一步转换为Bn类型的大整数对象c_
     c_ = hashlib.md5(str0.encode('utf8')).hexdigest()
     c_ = Bn.from_hex(str(c_))
     return c_==c
Exemplo n.º 5
0
 def verifyDL(self,pi,Q):
     # 预处理
     n = len(Q)
     (C,c,r) = pi
     # 得到c_,同样分为(1),(2),(3),(4)四步
     # (1)得到{Qi},C,Sigma_(1,n){ri*Qi+c*C}各自的二进制表示Q_[],C_,Sigma_
     Q_ = []
     for i in range(n):
         Q_.append(Q[i].export())
     C_ = C.export()
     # 求点Sigma的位置:
     Sigma = c * C 
     for i in range(n):
         Sigma += r[i] * Q[i]
     # 将点Sigma转换成byte形式
     Sigma_ = Sigma.export()
     # (2)将Q_[],C_,Sigma_顺次拼接在一起,得到二进制串bytestr
     bytestr = Q_[0]
     for i in range(1,n):
         bytestr += Q_[i]
     bytestr += C_ + Sigma_
     # (3)将二进制串bytestr转换成字符串str0
     str0 = str(bytestr)
     # (4)调用hashlib中的md5函数,将str0映射成为十六进制数字c_,再进一步转换为Bn类型的大整数对象c_
     c_ = hashlib.md5(str0.encode('utf8')).hexdigest()
     c_ = Bn.from_hex(str(c_))
     return c_==c
Exemplo n.º 6
0
    def load_store_list(self, w, d, store_dict):
        counter = 0
        for i in range(d):
            for j in range(w):
                contents = store_dict[str(counter)]

                try:
                    self.store[i][j] = Ct(
                        EcPt.from_binary(binascii.unhexlify(contents['pub']),
                                         G),
                        EcPt.from_binary(binascii.unhexlify(contents['a']), G),
                        EcPt.from_binary(binascii.unhexlify(contents['b']), G),
                        Bn.from_hex(contents['k']), Bn.from_hex(contents['m']))
                    counter += 1
                except Exception as e:
                    print "Exception while loading sketch store matrix: " + str(
                        e)
                    traceback.print_exc()
Exemplo n.º 7
0
def H_hat(pi_NIZK, phi, otsvk):
    X_ = otsvk[0].export()
    Y_ = otsvk[1].export()
    X_str = str(X_)
    Y_str = str(Y_)
    str0 = pi_NIZK + phi + X_str + Y_str
    c_ = hashlib.md5(str0.encode('utf8')).hexdigest()
    c_ = Bn.from_hex(str(c_))
    return c_
Exemplo n.º 8
0
def stage3():

    # super annoying that gI have to do this
    reset_dict_keys()

    session["challenges"] = {}
    for i in session["candidates"]:
        if i != session["chosen"]:
            session["challenges"][i] = request.form["challenge" + str(i)]
        # else:
        # 	session["challenges"][i] = None
    # print(session["challenges"])

    R = genvote.order.random()
    rc, masks, rb = genvote.genRealCommitments(session["chosen"], genvote.K, R)
    commitments, randoms = genvote.genFakeCommitments(session["challenges"],
                                                      genvote.K,
                                                      session["chosen"], R)
    randoms[session["chosen"]] = rb
    commitments[session["chosen"]] = masks
    cmt_list = []
    for sk in sorted(commitments):
        cmt_list.append(commitments[sk])
    everything = genvote.challengeHash(
        ''.join(map(str, [rc] + list(chain(cmt_list)))), genvote.K)
    rx = genvote.order.random()
    x = genvote.commit(Bn.from_hex(everything), rx)

    # print("gCHECKING THAT ENCODE AND DECODE WORK!")
    # eR = encode(R)
    # ueR = decode(eR)
    # print("R: ", type(R), type(eR), type(ueR), R == ueR)

    persist_tricky_objects(R,
                           rc,
                           masks,
                           rb,
                           commitments,
                           randoms,
                           cmt_list,
                           everything,
                           rx,
                           x,
                           answers=None,
                           receipt=None)

    # NOW WE NEED TO PRINT THE TWO LINES BEHIND THE SHIELD
    #os.system('echo "' + genvote.EcPtToStr(x) + '" | lpr')
    print_text(genvote.EcPtToStr(x))

    return render_template("stage3.html",
                           candidates=session["candidates"],
                           cand_dict=session["rev_d"],
                           chosen=session["chosen"],
                           challenges=session["challenges"],
                           voter_id=session["voter_id"])
Exemplo n.º 9
0
    def dec(self, priv, cipher):
        """Decrypts an encrypted group element"""
        #print("CSEnc: Dec")
        u1, u2, e, v = cipher
        x1, x2, y1, y2, z = priv

        H = sha256()
        H.update(u1.export() + u2.export() + e.export())
        a = Bn.from_hex(H.hexdigest())

        if v.eq((x1 + y1 * a) * u1 + (x2 + y2 * a) * u2):
            return 1, e + (-1 * z) * u1
        else:
            print("Decryption error")
            return 0, -1
Exemplo n.º 10
0
def castVote(voter_id, candidate):
    DC = {}
    R = order.random()
    for non_vote in filter(lambda l: l != candidate, candidates):
        DC[non_vote] = ' '.join([getRandomWord() for i in range(4)])
    rc, masks, rb = genRealCommitments(candidate, K, R)
    commitments, randoms = genFakeCommitments(DC, K, candidate, R)
    randoms[candidate] = rb
    commitments[candidate] = masks
    cmt_list = []
    for sk in sorted(commitments):
        cmt_list.append(commitments[sk])
    everything = challengeHash(''.join(map(str, [rc] + list(chain(cmt_list)))),
                               K)  #alphabetize this
    rx = order.random()
    x = commit(Bn.from_hex(everything), rx)
    DC[candidate] = ' '.join([getRandomWord()
                              for i in range(4)])  #random challenge real vote
    answers = answerChallenges(DC, randoms, K, R)
    verifyCommitment(x, rc, cmt_list, rx)
    challenge_dict = {
        candidate: {
            'challenge': DC[candidate],
            'answer': list(map(str, answers[candidate])),
            'proof': commitments[candidate]
        }
        for candidate in DC
    }
    receipt = serializeEcPts({
        'voter_id': voter_id,
        'challenges': challenge_dict,
        'vote_commitment': rc,
        'rx': str(rx),
        'commitment_to_everything': x
    })
    sig = do_ecdsa_sign(G, sig_key, EcPtToStr(x).encode('utf-8'), kinv_rp)
    signed_cmt = '_'.join((EcPtToStr(x), hex(sig[0])[2:], hex(sig[1])[2:]))
    qr = qrcode.QRCode(
        version=1,
        error_correction=qrcode.constants.ERROR_CORRECT_L,
        box_size=4,
        border=4,
    )
    qr.add_data(signed_cmt)
    qr.make()
    img = qr.make_image()
    img.save('qrcodes/to_print.png')
    return (candidate, rc, R, everything, str(x), answers, receipt)
Exemplo n.º 11
0
    def enc(self, params, pub, m):
        """Encrypts the values of a group element"""
        #print("CSEnc: Enc")
        o, G, g1, g2 = params
        c, d, h = pub

        r = o.random()
        u1, u2 = r * g1, r * g2
        e = r * h + m

        H = sha256()
        H.update(u1.export() + u2.export() + e.export())
        a = Bn.from_hex(H.hexdigest())

        v = r * c + (a * r) * d

        return [u1, u2, e, v], [r, a]
Exemplo n.º 12
0
 def proveK(self,m,s,P,Q):
     # 得到C
     n = len(m)
     C = s * P
     # i = [0,n-1]
     for i in range(n):
         C += Q[i] * m[i]
     # 得到{wi}
     w = []
     for i in range(n + 1):
         w.append(Bn().from_decimal(str(self.p)).random())
     # 得到W
     W = w[n] * P  # w_{n+1}*P
     for i in range(n): 
         W += Q[i] * w[i]
     # 得到c,分为(1),(2),(3),(4)四步
     # (1)得到P,Qi,C,W各自的二进制表示P_,Q_[],C_,W_
     P_ = P.export()
     Q_ = []
     for i in range(n):
         Q_.append(Q[i].export())
     C_ = C.export()
     W_ = W.export()
     print("W_为",W_)
     # (2)将P_,Q_[],C_,W_顺次拼接在一起,得到二进制串bytestr
     bytestr = P_
     for i in range(n):
         bytestr += Q_[i]
     bytestr += C_ + W_
     # (3)将二进制串bytestr转换成字符串str0
     str0 = str(bytestr)
     # (4)调用hashlib中的md5函数,将str0映射成为十六进制数字c,再进一步转换为Bn类型的大整数对象
     c = hashlib.md5(str0.encode('utf8')).hexdigest()
     c = Bn.from_hex(str(c))
     # 得到ri
     r = []
     for i in range(n):
         r.append(w[i]-c*m[i])
     # 得到r_{i+1},存放在r[n]位置
     r.append(w[n] - c * s)
     # 返回pi
     pi = (C,c,r)
     return pi
Exemplo n.º 13
0
 def proveDL(self,m,Q):
     n = len(m)
     # 得到C
     C = m[0] * Q[0]
     for i in range(1,n):
         C += m[i] * Q[i]
     # 得到{wi}
     w = []
     for i in range(n):
         w.append(Bn().from_decimal(str(self.p)).random())
     # 得到W
     W = w[0] * Q[0]
     for i in range(1,n):
         W += w[i] * Q[i]
     # 得到c,分为(1),(2),(3),(4)四步
     # (1)得到{Qi},C,W各自的二进制表示Q_[],C_,W_
     Q_ = []
     for i in range(n):
         Q_.append(Q[i].export())
     C_ = C.export()
     W_ = W.export()
     # (2)将Q_[],C_,W_顺次拼接在一起,得到二进制串bytestr
     bytestr = Q_[0]
     for i in range(1,n):
         bytestr += Q_[i]
     bytestr += C_ + W_
     # (3)将二进制串bytestr转换成字符串str0
     str0 = str(bytestr)
     # (4)调用hashlib中的md5函数,将str0映射成为十六进制数字c,再进一步转换为Bn类型的大整数对象
     c = hashlib.md5(str0.encode('utf8')).hexdigest()
     c = Bn.from_hex(str(c))
     # 得到ri
     r = []
     for i in range(n):
         r.append(w[i]-c*m[i])
     # 返回pi
     pi = (C,c,r)
     return pi
Exemplo n.º 14
0
def build_fiat_shamir_challenge(stmt_prehash, *args, message=""):
    """Generate a Fiat-Shamir challenge.

    >>> prehash = sha256(b"statement id")
    >>> commitment = 42 * EcGroup().generator()
    >>> isinstance(build_fiat_shamir_challenge(prehash, commitment), Bn)
    True

    Args:
        prehash: Hash object seeded with the proof statement ID.
        args: Items to hash (e.g., commitments)
        message: Message to make it a signature PK.
    """
    # Start building the complete hash for the challenge
    for elem in args:
        if not isinstance(elem, bytes) and not isinstance(elem, str):
            encoded = encode(elem)
        else:
            encoded = elem
        stmt_prehash.update(encoded)

    stmt_prehash.update(message.encode())
    return Bn.from_hex(stmt_prehash.hexdigest())
Exemplo n.º 15
0
def str_to_frank(l, G):
    elem1 = EcPt.from_binary(binascii.a2b_base64(l[0].encode('ascii')), G)
    elem2 = EcPt.from_binary(binascii.a2b_base64(l[1].encode('ascii')), G)
    elem3 = EcPt.from_binary(binascii.a2b_base64(l[2].encode('ascii')), G)
    elem4 = EcPt.from_binary(binascii.a2b_base64(l[3].encode('ascii')), G)
    elem5 = EcPt.from_binary(binascii.a2b_base64(l[4].encode('ascii')), G)

    elem6 = Bn.from_hex(l[5])
    elem7 = Bn.from_hex(l[6])
    elem8 = Bn.from_hex(l[7])
    elem9 = Bn.from_hex(l[8])
    elem10 = Bn.from_hex(l[9])
    elem11 = Bn.from_hex(l[10])

    elem12 = EcPt.from_binary(binascii.a2b_base64(l[11].encode('ascii')), G)
    elem13 = EcPt.from_binary(binascii.a2b_base64(l[12].encode('ascii')), G)
    elem14 = EcPt.from_binary(binascii.a2b_base64(l[13].encode('ascii')), G)
    elem15 = EcPt.from_binary(binascii.a2b_base64(l[14].encode('ascii')), G)

    return ((((elem1, elem2), ((elem3, elem4), elem5)), ((elem6, elem7, elem8), \
        (elem9, elem10, elem11))), elem12, elem13, elem14, elem15)
Exemplo n.º 16
0
 def load_store_list(self, w, d, store_dict):
     counter = 0        
     for i in range(d):
         for j in range(w):                
             contents = store_dict[str(counter)]
 
             try:                    
                 self.store[i][j] = Ct(EcPt.from_binary(binascii.unhexlify(contents['pub']),G), EcPt.from_binary(binascii.unhexlify(contents['a']),G), EcPt.from_binary(binascii.unhexlify(contents['b']),G), Bn.from_hex(contents['k']), Bn.from_hex(contents['m']))
                 counter += 1
             except Exception as e:
                 print "Exception while loading sketch store matrix: " + str(e)
                 traceback.print_exc()
Exemplo n.º 17
0
def generateData():
    params = setup(4)
    (G, o, g1, hs, g2, e) = params

    hex_m_priv1 = "24ABEE7D59CA09122391B3ECCBEBE0FA79EB9954D0E9F139A2A6E129445F1208"
    hex_m_priv2 = "1B4A6A9A72935D4D3CBCDEA5143480C543E9F3F0C91787605220BF54EC4E6078"
    hex_m_pub1 = "1D70206E93922A266B6F522CB1EC8AA72F908AC87EED1E43C641BFAF3C82AC32"
    hex_m_pub2 = "0F6EE88081A8A94677A8993F85245C30106B1A8E794496276B1452915F4BB708"
    hex_x = "076501B5E73FA81B28FAB06EE3F6929E6AE4DB9461A49930C49EF1B28A625DD2"
    hex_y0 = "0CE30F26C29ADBE06AE98D9B49DB3FF323C8100072298E9A58AC347E9BE59F36"
    hex_y1 = "09BD32C15ED60E7C9E5EC7FD2D3294D712DDC0AE510071D3AD9CE3DE0F1F23C1"
    hex_y2 = "0CF37DAD7889F0959E571D79532CD1E3AE74BD2B26C78D68251EDB7685782B9E"
    hex_y3 = "07712709AED9F065B553E08267EA9A5C75D0B4F62DE110569BF350E8BDC0F980"
    hex_h = "021c1dbf7bdc24be8d2b5c56d7a3162a9a1ef824134c3a95b6d306ecd8ce90c193"  # (random * g1) (for Pointcheval)
    hex_d = "1CF5133799A1CB2A1A46DD3FA5CB1EA9069D022236747F1CCA77401A265CEA33"
    hex_r = "24338A5F29CAB6BD573F87D5E2E6DDCFFB55CDB55D03A40A828A061E0E9957CE"
    hex_k1 = "077CA2D8137CA54B12011E564BA9B4204ADECA64499D07EE02DE6420E8B058A8"
    hex_k2 = "12B9BD2873FD1BA68D0B61A9B6840CA920C493D54CE85E8C2143C12F144C3B26"
    hex_wr = "1D7A898A391A664BAF3146F7ACA1FC0E954ED426ACD2D50146997A94053DCF6A"
    hex_wk1 = "0AF5628DF706A6CF503237499F793ABBDF4379DE3EF2D3DE777F4AB32B3147BD"
    hex_wk2 = "0E093B9EE3273CFB42C2765A0D78EF4EBD40126DC1703A921680EAA4CF50814D"
    hex_wm1 = "1DA762D767AD63BD4226CC6E859FC376CA03A047E47B82AFE8574D93DF39B5BB"
    hex_wm2 = "11A4B4BF934A3709F9E7A54324AACF0ED13BCAAA0CC2AD2791437363A64E404C"
    hex_wm3 = "096EB6930E70DEE0ACC0093A23A3586217C20FD6FD1ECB9923B2EDCE288F961F"
    hex_wm4 = "131CCECB6386CA3A773C898193116B76A2D6BD34D3BB4A7BC7143E494B7C69D9"
    hex_t = "0ADE8E2E5EC8806EC1B873B0F5735A9EB7FCA8D7DA3AC8D965487E0982C75F68"
    hex_wm1_v = "05E8CB173C636A190CC628803768833123A9FC54A92224D97155E87EF7E3F3C4"
    hex_wm2_v = "124052CD6EB215D98B20F343348E3898E65AC82A43AA57D0720311259D05D3DA"
    hex_wt = "0E7BF9EAD25C09716291E864B99DD063EC911ABCD26CBF682DE9B7C4E95D126F"

    # elgamal keypair
    d = Bn.from_hex(hex_d)
    gamma = g1 * d

    # attributes to sign
    private_m = [Bn.from_hex(hex_m_priv1), Bn.from_hex(hex_m_priv2)]
    public_m = [Bn.from_hex(hex_m_pub1), Bn.from_hex(hex_m_pub2)]

    # coconut keys
    x = Bn.from_hex(hex_x)
    y = [
        Bn.from_hex(hex_y0),
        Bn.from_hex(hex_y1),
        Bn.from_hex(hex_y2),
        Bn.from_hex(hex_y3)
    ]
    beta = [g2 * y[0], g2 * y[1], g2 * y[2], g2 * y[3]]
    sk = (x, y)
    vk = (g2, g2 * x, beta)

    r = Bn.from_hex(hex_r)
    ks = [Bn.from_hex(hex_k1), Bn.from_hex(hex_k2)]

    # create the witnesses
    wr = Bn.from_hex(hex_wr)
    wk = [Bn.from_hex(hex_wk1), Bn.from_hex(hex_wk2)]
    wm = [
        Bn.from_hex(hex_wm1),
        Bn.from_hex(hex_wm2),
        Bn.from_hex(hex_wm3),
        Bn.from_hex(hex_wm4)
    ]
    witnesses = (wr, wk, wm)

    (cm, c, pi_s) = prepare_blind_sign_r(r,
                                         ks,
                                         witnesses,
                                         params,
                                         gamma,
                                         private_m,
                                         public_m=public_m)
    sigma_tilde = blind_sign(params, sk, cm, c, gamma, pi_s, public_m=public_m)
    sigma = unblind(params, sigma_tilde, d)
    # sigma = randomize(params, sig) # multiplication by a constant factor is consistent so there's no need of testing randomization
    t = Bn.from_hex(hex_t)

    # create the witnesses
    wm = [Bn.from_hex(hex_wm1_v), Bn.from_hex(hex_wm2_v)]
    wt = Bn.from_hex(hex_wt)
    witnesses = (wm, wt)

    (kappa, nu, pi_v) = show_blind_sign_t(t, witnesses, params, vk, sigma,
                                          private_m)
    assert blind_verify(params, vk, sigma, kappa, nu, pi_v, public_m=public_m)
Exemplo n.º 18
0
def verifyCommitment(x, vote, commitments, rx):
    everything = challengeHash(''.join(
        map(str, [vote] + list(chain(commitments)))), K)  #alphabetize this
    result = commit(Bn.from_hex(everything), rx)
    assert (result == x)
Exemplo n.º 19
0
#####################################################
# TASK 6 -- Time EC scalar multiplication
#             Open Task.
#
#           - Time your implementations of scalar multiplication
#             (use time.clock() for measurements)for different
#              scalar sizes)
#           - Print reports on timing dependencies on secrets.
#           - Fix one implementation to not leak information.
from pytest import raises
from time import clock

from petlib.ec import EcGroup, EcPt

R1 = Bn.from_hex(
    "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
)
R2 = Bn.from_hex(
    "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001"
)


def time_scalar_mul():
    G = EcGroup(713)  # NIST curve
    d = G.parameters()
    a, b, p = d["a"], d["b"], d["p"]
    g = G.generator()
    gx0, gy0 = g.get_affine()

    def average_time(func, scalar_name, samples=20):
        scalar = globals()[scalar_name]
def read_sk():
    with open("messages.cfg", "rb") as file:
        data = file.read()
        info = data.split(DELIMITER.encode('ascii'))
        sk = Bn.from_hex(info[2].decode('ascii'))
    return sk
def get_aux():
    response = requests.get(ADDRESS + "get_aux")
    info = response.text.split(DELIMITER)
    g = EcPt.from_binary(binascii.a2b_base64(info[0].encode('ascii')), G)
    o = Bn.from_hex(info[1])
    return (g, o)
Exemplo n.º 22
0
 def test_uuid_to_hex(self):
     uuid = uuid4().hex
     bn = Bn.from_hex(uuid)
     print(bn)