def get_pubkey(self, n, id):
seed = sha256(id).digest()
cand = ''
for i in range(16):
cand += seed
seed = sha256(seed).digest()
cand = int(cand.encode('hex'), 16) % n
while jacobi(cand, n) != 1:
cand = (cand + 1) % n
return cand
def getkey(id, n, p, q):
seed = sha256(id).digest()
cand = ''
for i in range(16):
cand += seed
seed = sha256(seed).digest()
cand = int(cand.encode('hex'), 16) % n
while jacobi(cand, n) != 1:
cand = (cand + 1) % n
priv = pow(cand, (n + 5 - p - q) / 8, n)
return cand, priv
def get_rand(self, m, n):
cand = getRandomRange(0, n, os.urandom)
while jacobi(cand, n) != m:
cand = (cand + 1) % n
return cand
def get_oracle(self):
self.request.sendall('number: ')
a = self.request.recv(2050)
a = int(a)
self.request.sendall("%d %d\n" %
(jacobi(a, self.p), jacobi(a, self.q)))
def test_equality_once(self_pid, socket_list, comp_shares, t, N, nB,
act_parties):
'''
test equality of two shared secrets, can give false positives with probability 1/2
@arg : self party id, list of party sockets, tuple of shares to be compared, prime base,
share size, pids of contributing parties
@returns : share of equality boolean x==y
'''
n = len(socket_list)
x, y = comp_shares
d = add(self_pid, socket_list, (x, neg(y, N)), N)[1]
x, y = x[1], y[1]
A, B = act_parties # index of contributing parties
party_A = socket_list[A - 1]
party_B = socket_list[B - 1]
# obtain random input shares
if self_pid in act_parties:
r_i = randint(1, N - 1)
r_shares = ss.gen_shares(n, t, r_i, N)
ns.distribute_secret(r_shares, socket_list, nB)
r_a = r_shares[self_pid - 1][1]
party_other_pid = [i for i in act_parties if i != self_pid][0]
party_other = socket_list[party_other_pid - 1]
r_b = nr.recv_share(party_other, nB)
else:
r_a = nr.recv_share(party_A, nB)
r_b = nr.recv_share(party_B, nB)
r = mult(self_pid, socket_list, [(self_pid, r_a), (self_pid, r_b)], t, N,
nB)[1]
# obtain random input s
if self_pid == B:
s_val = randint(1, N - 1)
s_shares = ss.gen_shares(n, t, s_val, N)
ns.distribute_secret(s_shares, socket_list, nB)
s = s_shares[self_pid - 1][1]
else:
s = nr.recv_share(party_B, nB)
u = mult(self_pid, socket_list, ((self_pid, r), (self_pid, r)), t, N,
nB)[1]
u = add(self_pid, socket_list, ((None, d), (None, u)), N)[1]
u = mult(self_pid, socket_list, ((self_pid, u), (self_pid, s)), t, N,
nB)[1]
# reconstruct t (A) and find jacobi of t and s
if self_pid == A:
u_shares_recvd = nr.recv_shares(socket_list, nB)
u_shares_recvd[A - 1] = (A, u)
f = ss.interpolate_poly(u_shares_recvd, N)
u_val = f(0)
j_u_val = jacobi(int(u_val), N)
else:
nr.send_share([party_A], u, nB)
if self_pid == B:
j_s_val = jacobi(int(s_val), N)
# share jacobi symbols
if self_pid == A:
j_u_shares = ss.gen_shares(n, t, j_u_val, N)
ns.distribute_secret(j_u_shares, socket_list, nB)
j_u = j_u_shares[self_pid - 1][1]
j_s = nr.recv_share(party_B, nB)
elif self_pid == B:
j_s_shares = ss.gen_shares(n, t, j_s_val, N)
ns.distribute_secret(j_s_shares, socket_list, nB)
j_s = j_s_shares[self_pid - 1][1]
j_u = nr.recv_share(party_A, nB)
else:
j_u = nr.recv_share(party_A, nB)
j_s = nr.recv_share(party_B, nB)
# calculate jacobi symbol of d+r^2
j_fin = mult(self_pid, socket_list, ((self_pid, j_u), (self_pid, j_s)), t,
N, nB)[1]
j_tilde = add(self_pid, socket_list, ((None, j_fin), (None, 1)), N)[1]
fin_share = j_tilde * mmh.find_inv_mod(2, N) % N
return (self_pid, fin_share)
def decrypt(c1, c2, a, r, n):
if pow(r, 2, n) == a:
x = (c1 + 2 * r) % n
else:
x = (c2 + 2 * r) % n
return jacobi(x, n)
exit()
'''
pp = []
for i in range(10000):
if isPrime(i):
pp.append(i)
for i in range(400):
if i == 0:
jtable = [[]]
continue
ii = pp[i]
tmp = [0]
for j in range(1, ii):
tmp.append(jacobi(j, ii))
jtable.append(tmp)
pused = [2]
dused = [{}]
delta = 24
for i in range(400):
if i == 0:
prod = 2
continue
ii = pp[i]
dic = {}
ok = True
for j in range(1, ii):
#tmp=(j-delta)%ii
tmp = j