def step45(lists): """For all i in test_set the parties reveal the randomness used for TripleTest() and checks that the randomness is consistent with the actual values.""" M_without_test_set = lists[0] T = lists[1] def get_share(x, ls): share = ls[x * 4] rho1 = ls[x * 4 + 1] rho2 = ls[x * 4 + 2] commitment = ls[x * 4 + 3] return (share, rho1, rho2, commitment) def send_share(player_id, pc, a): self._send_orlandi_share(player_id, pc, a.share, a.rho, a.commitment) def receive_shares(player_id): Cx = Deferred() xi = self._expect_share(player_id, field) rho1 = self._expect_share(player_id, field) rho2 = self._expect_share(player_id, field) self._expect_data(player_id, TEXT, Cx) Cx.addCallbacks(commitment.deserialize, self.error_handler) return gatherResults([xi, rho1, rho2, Cx]) def send_long(player_id, pc, l): self.protocols[player_id].sendData(pc, TEXT, str(l)) def receive_long(player_id): l = Deferred() self._expect_data(player_id, TEXT, l) l.addCallbacks(long, self.error_handler) return l def check((ais, bis, cis, alpha_randomness, dijs), alphas, gammas): """So if B receives ai, bi, dij, ri, si, and the randomness used in the computation of alpha, he then checks that: 1) the alpha_i he received is equals to the encryption of ai and the commitment he received, Ai, is equal to the commitment of ai and ri 2) the commitment he received, Bj, is equal to the commitment of bj and sj 3) the gammaij he received is equal to the gammaij he now computes based on the values he reveives 4) a, b, c is a triple, a * b = c 5) ai, bi < p and dij < p^3 """ a = 0 a_rho1 = 0 a_rho2 = 0 b = 0 b_rho1 = 0 b_rho2 = 0 c = 0 c_rho1 = 0 c_rho2 = 0 for x in xrange(len(ais)): (ai, a_rhoi1, a_rhoi2, A) = ais[x] (bi, b_rhoi1, b_rhoi2, B) = bis[x] (ci, c_rhoi1, c_rhoi2, C) = cis[x] # 5) ai, bi < p... if ai >= field.modulus: raise OrlandiException( "Inconsistent share ai, ai >= p: %i" % ai) if bi >= field.modulus: raise OrlandiException( "Inconsistent share bi, bi >= p: %i" % bi) a += ai a_rho1 += a_rhoi1 a_rho2 += a_rhoi2 b += bi b_rho1 += b_rhoi1 b_rho2 += b_rhoi2 c += ci c_rho1 += c_rhoi1 c_rho2 += c_rhoi2 # 1) the alpha_i he received is equals to the encryption of ai... alphai = encrypt_r(ai.value, alpha_randomness[x], self.players[x + 1].pubkey) if not (alphas[x] == alphai): raise OrlandiException( "Inconsistent alpha from player %i, %i, %i" % (x + 1, alphas[x], alphai)) A1 = commitment.commit(a.value, a_rho1.value, a_rho2.value) B1 = commitment.commit(b.value, b_rho1.value, b_rho2.value) C1 = commitment.commit(c.value, c_rho1.value, c_rho2.value) # 1) ... and the commitment he received, Ai, is equal # to the commitment of ai and ri. if A1 != A: raise OrlandiException( "Inconsistent commitment for value %s, found %s expected %s." % (a, A1, A)) # 2) the commitment he received, Bj, is equal to the # commitment of bj and sj. if B1 != B: raise OrlandiException( "Inconsistent commitment for value %s, found %s expected %s." % (b, B1, B)) if C1 != C: raise OrlandiException( "Inconsistent commitment for value %s, found %s expected %s." % (c, C1, C)) # 4) a, b, c is a triple, a * b = c if a * b != c: raise OrlandiException( "Inconsistent triple, %i * %i does not equals %i." % (a, b, c)) # 3) the gammaij he received is equal to the gammaij # he now computes based on the values he reveives player = self.players[self.id] fixed_base = player.pubkey['fixed_base'] alpha = alphas[self.id - 1] modulus_3 = field.modulus**3 for j in xrange(len(ais)): dij = dijs[j] # 5) ... and dij < p^3. if dij >= (modulus_3): raise OrlandiException( "Inconsistent random value dij %i from player %i" % (dij, j + 1)) # gamma_ij = alpha_i^b_j Enc_ek_i(1;1)^d_ij # gammaij = tripple_2c(alphas[self.id - 1], bis[j][0].value, # dij, self.players[self.id].pubkey) gammaij = fixed_base.calc(dij, alpha, bis[j][0].value) if gammaij != gammas[j]: raise OrlandiException("Inconsistent gammaij, %i, %i" % (gammaij, gammas[j])) return True
def step45(lists): """For all i in test_set the parties reveal the randomness used for TripleTest() and checks that the randomness is consistent with the actual values.""" M_without_test_set = lists[0] T = lists[1] def get_share(x, ls): share = ls[x * 4] rho1 = ls[x * 4 + 1] rho2 = ls[x * 4 + 2] commitment = ls[x * 4 + 3] return (share, rho1, rho2, commitment) def send_share(player_id, pc, a): self._send_orlandi_share(player_id, pc, a.share, a.rho, a.commitment) def receive_shares(player_id): Cx = Deferred() xi = self._expect_share(player_id, field) rho1 = self._expect_share(player_id, field) rho2 = self._expect_share(player_id, field) self._expect_data(player_id, TEXT, Cx) Cx.addCallbacks(commitment.deserialize, self.error_handler) return gatherResults([xi, rho1, rho2, Cx]) def send_long(player_id, pc, l): self.protocols[player_id].sendData(pc, TEXT, str(l)) def receive_long(player_id): l = Deferred() self._expect_data(player_id, TEXT, l) l.addCallbacks(long, self.error_handler) return l def check((ais, bis, cis, alpha_randomness, dijs), alphas, gammas): """So if B receives ai, bi, dij, ri, si, and the randomness used in the computation of alpha, he then checks that: 1) the alpha_i he received is equals to the encryption of ai and the commitment he received, Ai, is equal to the commitment of ai and ri 2) the commitment he received, Bj, is equal to the commitment of bj and sj 3) the gammaij he received is equal to the gammaij he now computes based on the values he reveives 4) a, b, c is a triple, a * b = c 5) ai, bi < p and dij < p^3 """ a = 0 a_rho1 = 0 a_rho2 = 0 b = 0 b_rho1 = 0 b_rho2 = 0 c = 0 c_rho1 = 0 c_rho2 = 0 for x in xrange(len(ais)): (ai, a_rhoi1, a_rhoi2, A) = ais[x] (bi, b_rhoi1, b_rhoi2, B) = bis[x] (ci, c_rhoi1, c_rhoi2, C) = cis[x] # 5) ai, bi < p... if ai >= field.modulus: raise OrlandiException("Inconsistent share ai, ai >= p: %i" % ai) if bi >= field.modulus: raise OrlandiException("Inconsistent share bi, bi >= p: %i" % bi) a += ai a_rho1 += a_rhoi1 a_rho2 += a_rhoi2 b += bi b_rho1 += b_rhoi1 b_rho2 += b_rhoi2 c += ci c_rho1 += c_rhoi1 c_rho2 += c_rhoi2 # 1) the alpha_i he received is equals to the encryption of ai... alphai = encrypt_r(ai.value, alpha_randomness[x], self.players[x + 1].pubkey) if not(alphas[x] == alphai): raise OrlandiException("Inconsistent alpha from player %i, %i, %i" % (x + 1, alphas[x], alphai)) A1 = commitment.commit(a.value, a_rho1.value, a_rho2.value) B1 = commitment.commit(b.value, b_rho1.value, b_rho2.value) C1 = commitment.commit(c.value, c_rho1.value, c_rho2.value) # 1) ... and the commitment he received, Ai, is equal # to the commitment of ai and ri. if A1 != A: raise OrlandiException("Inconsistent commitment for value %s, found %s expected %s." % (a, A1, A)) # 2) the commitment he received, Bj, is equal to the # commitment of bj and sj. if B1 != B: raise OrlandiException("Inconsistent commitment for value %s, found %s expected %s." % (b, B1, B)) if C1 != C: raise OrlandiException("Inconsistent commitment for value %s, found %s expected %s." % (c, C1, C)) # 4) a, b, c is a triple, a * b = c if a * b != c: raise OrlandiException("Inconsistent triple, %i * %i does not equals %i." % (a, b, c)) # 3) the gammaij he received is equal to the gammaij # he now computes based on the values he reveives player = self.players[self.id] fixed_base = player.pubkey['fixed_base'] alpha = alphas[self.id - 1] modulus_3 = field.modulus**3 for j in xrange(len(ais)): dij = dijs[j] # 5) ... and dij < p^3. if dij >= (modulus_3): raise OrlandiException("Inconsistent random value dij %i from player %i" % (dij, j + 1)) # gamma_ij = alpha_i^b_j Enc_ek_i(1;1)^d_ij # gammaij = tripple_2c(alphas[self.id - 1], bis[j][0].value, # dij, self.players[self.id].pubkey) gammaij = fixed_base.calc(dij, alpha, bis[j][0].value) if gammaij != gammas[j]: raise OrlandiException("Inconsistent gammaij, %i, %i" % (gammaij, gammas[j])) return True
result.addErrback(self.error_handler) return result # 1) Every party P_i chooses random values a_i, r_i in Z_p X (Z_p)^2, # compute alpha_i = Enc_eki(a_i) and Ai = Com_ck(a_i, r_i), and # broadcast them. # Every party P_i chooses random values a_i, r_i in Z_p X (Z_p)^2 ai = random_number(field.modulus) r1 = random_number(field.modulus) r2 = random_number(field.modulus) # compute alpha_i = Enc_eki(a_i) pubkey = self.players[self.id].pubkey alpha_randomness = rand.randint(1, long(pubkey['n'])) alphai = encrypt_r(ai.value, alpha_randomness, pubkey) # and A_i = Com_ck(a_i, r_i). Ai = commitment.commit(ai.value, r1.value, r2.value) # choose random b_j, s_j in Z_p X (Z_p)^2. bj = random_number(field.modulus) s1 = random_number(field.modulus) s2 = random_number(field.modulus) # compute B_j = Com_ck(b_j, s_j). Bj = commitment.commit(bj.value, s1.value, s2.value) # broadcast alpha_i, A_i, B_j. ds = self.broadcast(sorted(self.players.keys()), sorted(self.players.keys()), str(alphai) + ":" + repr(Ai) + ":" + repr(Bj))
return result # 1) Every party P_i chooses random values a_i, r_i in Z_p X (Z_p)^2, # compute alpha_i = Enc_eki(a_i) and Ai = Com_ck(a_i, r_i), and # broadcast them. # Every party P_i chooses random values a_i, r_i in Z_p X (Z_p)^2 ai = random_number(field.modulus) r1 = random_number(field.modulus) r2 = random_number(field.modulus) # compute alpha_i = Enc_eki(a_i) pubkey = self.players[self.id].pubkey alpha_randomness = rand.randint(1, long(pubkey['n'])) alphai = encrypt_r(ai.value, alpha_randomness, pubkey) # and A_i = Com_ck(a_i, r_i). Ai = commitment.commit(ai.value, r1.value, r2.value) # choose random b_j, s_j in Z_p X (Z_p)^2. bj = random_number(field.modulus) s1 = random_number(field.modulus) s2 = random_number(field.modulus) # compute B_j = Com_ck(b_j, s_j). Bj = commitment.commit(bj.value, s1.value, s2.value) # broadcast alpha_i, A_i, B_j. ds = self.broadcast(sorted(self.players.keys()), sorted(self.players.keys()), str(alphai) + ":" + repr(Ai) + ":" + repr(Bj))