def decrypt(share, expected_result):
decrypted_share = paillier.decrypt(share.enc_shares[runtime.id - 1])
decrypted_shares = _convolute(runtime, decrypted_share)
def test_sum(vals, expected_result):
v = Zp(sum(vals))
self.assertEquals(expected_result, v)
runtime.schedule_callback(decrypted_shares, test_sum, expected_result)
def decrypt(share_contents):
self.assertEquals(1, len(share_contents))
decrypted_share = paillier.decrypt(
share_contents[0].enc_shares[runtime.id - 1])
decrypted_shares = _convolute(runtime, decrypted_share)
def test_sum(vals):
self.assertEquals([Zp(e) for e in [1, 2, 3]], vals)
runtime.schedule_callback(decrypted_shares, test_sum)
def test_convolute_int(self, runtime):
res = _convolute(runtime, runtime.id)
def verify(result):
self.assertEquals(runtime.players.keys(), result)
runtime.schedule_callback(res, verify)
return res
def decrypt(share):
decrypted_share = paillier.decrypt(share.enc_shares[runtime.id -
1])
decrypted_shares = _convolute(runtime, decrypted_share)
def test_sum(vals):
self.assertEquals(secret, sum(vals) % modulus)
runtime.schedule_callback(decrypted_shares, test_sum)
def decrypt(share_contents):
self.assertEquals(1, len(share_contents))
decrypted_share = paillier.decrypt(
share_contents[0].enc_shares[runtime.id - 1])
decrypted_shares = _convolute(runtime, decrypted_share)
def test_sum(vals):
self.assertEquals([Zp(e) for e in [1, 2, 3]], vals)
runtime.schedule_callback(decrypted_shares, test_sum)
def decrypt(share, expected_result):
decrypted_share = paillier.decrypt(
share.enc_shares[runtime.id - 1])
decrypted_shares = _convolute(runtime, decrypted_share)
def test_sum(vals, expected_result):
v = Zp(sum(vals))
self.assertEquals(expected_result, v)
runtime.schedule_callback(decrypted_shares, test_sum,
expected_result)
def check(shares):
def test_sum(ls):
self.assertEquals(8, Zp(sum(ls[0])))
self.assertEquals(3, Zp(sum(ls[1])))
self.assertEquals(6, Zp(sum(ls[2])))
values = []
for share in shares:
value = _convolute(runtime, share.value.value)
values.append(value)
d = gatherResults(values)
runtime.schedule_callback(d, test_sum)
return d
def check(shares):
def test_sum(ls):
self.assertEquals(8, Zp(sum(ls[0])))
self.assertEquals(3, Zp(sum(ls[1])))
self.assertEquals(6, Zp(sum(ls[2])))
values = []
for share in shares:
value = _convolute(runtime, share.value.value)
values.append(value)
d = gatherResults(values)
runtime.schedule_callback(d, test_sum)
return d
def decrypt(share_contents):
self.assertEquals(2, len(share_contents))
decrypted_shares = [paillier.decrypt(
share_contents[i].enc_shares[runtime.id - 1])
for i in range(2)]
decrypted_shares = [_convolute(runtime, decrypted_shares[i])
for i in range(2)]
def test_sum(vals, should_be):
self.assertEquals([Zp(e) for e in should_be], vals)
runtime.schedule_callback(
decrypted_shares[0], test_sum, [1, 2, 3])
runtime.schedule_callback(
decrypted_shares[1], test_sum, [3, 6, 9])
def check(shares):
all_enc_shares = []
for share in shares:
def test_enc(enc_shares, value):
all_the_same, zi_enc = reduce(lambda x, y: (x[0] and x[1] == y, y), enc_shares, (True, enc_shares[0]))
zi_enc = triple_generator.paillier.decrypt(zi_enc)
self.assertEquals(value, Zp(zi_enc))
return True
for inx, enc_share in enumerate(share.enc_shares):
d = _convolute(runtime, enc_share)
if runtime.id == inx + 1:
d.addCallback(test_enc, share.value)
all_enc_shares.append(d)
return gatherResults(all_enc_shares)
def decrypt(share_contents):
self.assertEquals(2, len(share_contents))
decrypted_shares = [
paillier.decrypt(share_contents[i].enc_shares[runtime.id - 1])
for i in range(2)
]
decrypted_shares = [
_convolute(runtime, decrypted_shares[i]) for i in range(2)
]
def test_sum(vals, should_be):
self.assertEquals([Zp(e) for e in should_be], vals)
runtime.schedule_callback(decrypted_shares[0], test_sum, [1, 2, 3])
runtime.schedule_callback(decrypted_shares[1], test_sum, [3, 6, 9])
def generate_share(self, value):
self.runtime.increment_pc()
# TODO: Exclusive?
r = [self.Zp(self.random.randint(0, self.Zp.modulus - 1))
for _ in range(self.runtime.num_players - 1)]
if self.runtime.id == 1:
share = value - sum(r)
else:
share = r[self.runtime.id - 2]
enc_share = self.paillier.encrypt(share.value)
enc_shares = _convolute(self.runtime, enc_share)
def create_partial_share(enc_shares, share):
return PartialShare(self.runtime, self.Zp, share, enc_shares)
self.runtime.schedule_callback(enc_shares, create_partial_share, share)
return enc_shares
def check(shares):
all_enc_shares = []
for share in shares:
def test_enc(enc_shares, value):
all_the_same, zi_enc = reduce(
lambda x, y: (x[0] and x[1] == y, y), enc_shares,
(True, enc_shares[0]))
zi_enc = triple_generator.paillier.decrypt(zi_enc)
self.assertEquals(value, Zp(zi_enc))
return True
for inx, enc_share in enumerate(share.enc_shares):
d = _convolute(runtime, enc_share)
if runtime.id == inx + 1:
d.addCallback(test_enc, share.value)
all_enc_shares.append(d)
return gatherResults(all_enc_shares)
def generate_random_shares(self, n):
self.runtime.increment_pc()
N_squared_list = [self.runtime.players[player_id].pubkey['n_square']
for player_id in self.runtime.players]
shares = [PartialShare(self.runtime, self.Zp) for _ in xrange(n)]
for inx in xrange(n):
r = self.random.randint(0, self.Zp.modulus - 1)
ri = self.Zp(r)
enc_share = self.paillier.encrypt(ri.value)
enc_shares = _convolute(self.runtime, enc_share)
def create_partial_share(enc_shares, ri, s, N_squared_list):
s.callback(PartialShareContents(ri, enc_shares,
N_squared_list))
self.runtime.schedule_callback(enc_shares,
create_partial_share,
ri,
shares[inx],
N_squared_list)
return shares
def generate_random_shares(self, n):
self.runtime.increment_pc()
N_squared_list = [
self.runtime.players[player_id].pubkey['n_square']
for player_id in self.runtime.players
]
shares = [PartialShare(self.runtime, self.Zp) for _ in xrange(n)]
for inx in xrange(n):
r = self.random.randint(0, self.Zp.modulus - 1)
ri = self.Zp(r)
enc_share = self.paillier.encrypt(ri.value)
enc_shares = _convolute(self.runtime, enc_share)
def create_partial_share(enc_shares, ri, s, N_squared_list):
s.callback(PartialShareContents(ri, enc_shares,
N_squared_list))
self.runtime.schedule_callback(enc_shares, create_partial_share,
ri, shares[inx], N_squared_list)
return shares
def generate_share(self, value):
self.runtime.increment_pc()
# TODO: Exclusive?
r = [
self.Zp(self.random.randint(0, self.Zp.modulus - 1))
for _ in range(self.runtime.num_players - 1)
]
if self.runtime.id == 1:
share = value - sum(r)
else:
share = r[self.runtime.id - 2]
enc_share = self.paillier.encrypt(share.value)
enc_shares = _convolute(self.runtime, enc_share)
def create_partial_share(enc_shares, share):
return PartialShare(self.runtime, self.Zp, share, enc_shares)
self.runtime.schedule_callback(enc_shares, create_partial_share, share)
return enc_shares
def decrypt(share):
decrypted_share = paillier.decrypt(share.enc_shares[runtime.id - 1])
decrypted_shares = _convolute(runtime, decrypted_share)
def test_sum(vals):
self.assertEquals(secret, sum(vals) % modulus)
runtime.schedule_callback(decrypted_shares, test_sum)
def test_convolute_int(self, runtime):
res = _convolute(runtime, runtime.id)
def verify(result):
self.assertEquals(runtime.players.keys(), result)
runtime.schedule_callback(res, verify)
return res
