Exemplo n.º 1
0
def key_gen(p, q):
    if utils.nonrec_gcd(p, q) != 1:
        # non-distinct
        exit(1)
    n = p * q
    g = n + 1
    lmdba = (p - 1) * (q - 1)
    mu = utils.invert(lmdba, n)
    return (n, g), (n, p, q, g, lmdba, mu)
Exemplo n.º 2
0
def gen_params(bits):
    while True:
        ptildprim = utils.randomnumber(pow(2, bits >> 1))
        qtildprim = utils.randomnumber(pow(2, bits >> 1))
        ptild = (2 * ptildprim + 1)
        qtild = (qtildprim + 1)
        if utils.is_prime(ptild) and utils.is_prime(qtild):
            break
    ntild = ptild * qtild
    pq = ptildprim * qtildprim
    while True:
        h2 = utils.randomnumber(ntild)
        if utils.nonrec_gcd(h2, ntild) == 1 and utils.powmod(h2, pq,
                                                             ntild) == 1:
            break
    x = utils.randomnumber(pq)
    h1 = utils.powmod(h2, x, ntild)
    return ntild, h1, h2
Exemplo n.º 3
0
def rnd_inv(n):
    while True:
        b = utils.randomnumber(n)
        if utils.nonrec_gcd(b, n) == 1:
            return b
Exemplo n.º 4
0
def R(n):
    return utils.randomnumber(n)
    while True:
        r = utils.randomnumber(n)
        if utils.nonrec_gcd(r, n) == 1:
            return r
Exemplo n.º 5
0
def lcm(a, b):
    """Computing the least common multiple between a and b"""
    n = a * b
    if n < 0:
        n = n * -1
    return int(n / utils.nonrec_gcd(a, b))
Exemplo n.º 6
0
def pi2(m, c, d, w1, w2, m1, m2, m3, m4, r1, r2, x1, x2, x3, zkpparam, ka_pub,
        kb_pub):
    pkn, g = ka_pub
    pkn2 = pkn * pkn
    pknprim, gprim = kb_pub
    pknprim2 = pknprim * pknprim
    ntild, h1, h2 = zkpparam
    q3 = pow(dsa.Q, 3)
    q5 = pow(dsa.Q, 5)
    q6 = pow(dsa.Q, 6)
    q8 = pow(dsa.Q, 8)
    q3ntild = q3 * ntild
    qntild = dsa.Q * ntild

    if pkn <= q8:
        return False
    if pknprim <= q6:
        return False

    if (utils.nonrec_gcd(c, dsa.P) != 1 or utils.nonrec_gcd(d, dsa.P) != 1
            or utils.nonrec_gcd(w1, dsa.P) != 1
            or utils.nonrec_gcd(w2, dsa.P) != 1):
        return False

    if (pow(c, dsa.Q, dsa.P) != 1 or pow(d, dsa.Q, dsa.P) != 1
            or pow(w1, dsa.Q, dsa.P) != 1 or pow(w2, dsa.Q, dsa.P) != 1):
        return False

    if m1 > pknprim2 or utils.nonrec_gcd(m1, pknprim2) != 1:
        return False
    if m2 > pkn2 or utils.nonrec_gcd(m2, pkn2) != 1:
        return False

    if x1 > dsa.Q or x2 > dsa.Q:
        print x1 > dsa.Q
        print x2 > dsa.Q
        return False
    if x3 > q5:
        return False

    if r1 > pknprim or utils.nonrec_gcd(r1, pknprim) != 1:
        return False
    if r2 > pkn or utils.nonrec_gcd(r2, pkn) != 1:
        return False

    alpha = utils.randomnumber(q3)
    beta = rnd_inv(pknprim)
    gamma = utils.randomnumber(q3ntild)
    p1 = utils.randomnumber(qntild)
    delta = utils.randomnumber(q3)
    mu = rnd_inv(pkn)
    vu = utils.randomnumber(q3ntild)
    p2 = utils.randomnumber(qntild)
    p3 = utils.randomnumber(dsa.Q)
    p4 = utils.randomnumber(pow(dsa.Q, 5) * ntild)
    epsilon = utils.randomnumber(dsa.Q)
    sigma = utils.randomnumber(pow(dsa.Q, 7))
    tau = utils.randomnumber(pow(dsa.Q, 7) * ntild)

    z1 = pow(h1, x1, ntild) * pow(h2, p1, ntild) % ntild
    u1 = pow(c, alpha, dsa.P)
    u2 = (pow(gprim, alpha, pknprim2) *
          pow(beta, pknprim, pknprim2)) % pknprim2
    u3 = (pow(h1, alpha, ntild) * pow(h2, gamma, ntild)) % ntild

    z2 = (pow(h1, x2, ntild) * pow(h2, p2, ntild)) % ntild
    y = pow(d, x2 + p3, dsa.P)
    v1 = pow(d, delta + epsilon, dsa.P)
    v2 = (pow(w2, alpha, dsa.P) * pow(d, epsilon, dsa.P)) % dsa.P

    v3 = (pow(m3, alpha, pkn2) * pow(m4, delta, pkn2) *
          pow(g, dsa.Q * sigma, pkn2) * pow(mu, pkn, pkn2)) % pkn2

    v4 = (pow(h1, delta, ntild) * pow(h2, vu, ntild)) % ntild
    z3 = (pow(h1, x3, ntild) * pow(h2, p4, ntild)) % ntild
    v5 = (pow(h1, sigma, ntild) * pow(h2, tau, ntild)) % ntild

    h = hashlib.sha256()
    h.update(str(c))
    h.update(str(w1))
    h.update(str(d))
    h.update(str(w2))
    h.update(str(m1))
    h.update(str(m2))
    h.update(str(z1))
    h.update(str(u1))
    h.update(str(u2))
    h.update(str(u3))
    h.update(str(z2))
    h.update(str(z3))
    h.update(str(y))
    h.update(str(v1))
    h.update(str(v2))
    h.update(str(v3))
    h.update(str(v4))
    h.update(str(v5))
    e = long(h.hexdigest(), 16)

    s1 = e * x1 + alpha
    s2 = (pow(r1, e, pknprim) * beta) % pknprim
    s3 = e * p1 + gamma
    s4 = e * ((x1 * m) % dsa.Q) + alpha

    t1 = e * x2 + delta
    t2 = (e * p3 + epsilon) % dsa.Q
    t3 = (pow(r2, e, pkn) * mu) % pkn
    t4 = e * p2 + vu
    t5 = e * x3 + sigma
    t6 = e * p4 + tau

    return (z1, u1, u2, u3, z2, z3, y, v1, v2, v3, v4, v5, s1, s2, s3, s4, t1,
            t2, t3, t4, t5, t6, e)