def get_mediator_inconsistency_extra_data(): cur = db_execute( conn, 'SELECT sender, complaint, protocol, data FROM "' + mediator + '/inconsistency_extra_data' + '"') res = [] for s, c, p, d in cur: res.append((s, util.string_to_vote(c), util.Protocol(int(p)), util.string_to_vote(d))) cur.close() conn.commit() return res
def differenceshareforzeroone(): verified, data = util.unpack_request(request, str(server_nr)) if not verified: return make_response("Could not verify", 400) try: datas_ = data['datas'] for data_ in datas_: diff_ = data_['diff'] diff_ = util.string_to_vote(diff_) x_ = data_['x'] i_ = data_['i'] j_ = data_['j'] server_a_ = data_['server_a'] server_b_ = data_['server_b'] client_ = data_['client'] server_ = data_['server'] # Save each difference in database db.insert_zero_consistency_check(diff=diff_, x=x_, i=i_, j=j_, server_a=server_a_, server_b=server_b_, client_name=client_, server=server_, db_name=my_name) except TypeError as e: print("differenceshareforzeroone: ", e) return Response(status=400) return Response(status=200)
def test_new_product(self): illegal_vote = np.array([[3,-2],[-2,3]]) illegal_vote_partitions = util.partition_and_secret_share_vote(illegal_vote, local_servers) client_util.postvote("ic3", illegal_vote_partitions, local_servers) client_util.send_vote([1,2], 'c1', local_servers) client_util.send_vote([2,1], 'c2', local_servers) illegal_vote = np.array([[2, -1], [-1, 2]]) illegal_vote_partitions = util.partition_and_secret_share_vote(illegal_vote, local_servers) client_util.postvote("ic4", illegal_vote_partitions, local_servers) illegal_vote = np.array([[0, 0], [0, 0]]) illegal_vote_partitions = util.partition_and_secret_share_vote(illegal_vote, local_servers) client_util.postvote("ic5", illegal_vote_partitions, local_servers) for server in local_servers: util.get_url(server + "/zero_one_consistency") time.sleep(1) for server in local_servers: util.get_url(server + "/sumdifferenceshareforzeroone") time.sleep(1) for server in local_servers: util.get_url(server + '/check_votes') time.sleep(1) for server in local_servers: util.get_url(server + '/ensure_vote_agreement') time.sleep(1) for server in local_servers: util.get_url(server + '/add') time.sleep(1) for server in local_servers: response = util.get_url(server + '/compute_result') self.assertTrue(response.text=="ok") time.sleep(1) for server in local_servers: response = util.get_url(server + '/verify_result') result = util.string_to_vote(response.text) self.assertTrue(np.array_equal(np.array([1.5,1.5]),result))
def test_many_votes(self): reset_servers() for i in range(40): client = 'c' + str(i) client_util.send_vote([1, 2, 3, 4], client, local_servers) for server in local_servers: util.get_url(server + "/zero_one_consistency") time.sleep(1) for server in local_servers: util.get_url(server + "/sumdifferenceshareforzeroone") time.sleep(1) for server in local_servers: util.get_url(server + '/check_votes') time.sleep(1) for server in local_servers: util.get_url(server + '/ensure_vote_agreement') time.sleep(1) for server in local_servers: util.get_url(server + '/add') time.sleep(1) for server in local_servers: response = util.get_url(server + '/compute_result') self.assertTrue(response.text=="ok") time.sleep(1) v = np.array([[40, 0, 0, 0], [0, 40, 0, 0], [0, 0, 40, 0], [0, 0, 0, 40]]) for server in local_servers: response = util.get_url(server + '/verify_result') result = util.string_to_vote(response.text) self.assertTrue(np.array_equal(result, np.array( [sum([v[i][j] * (1 / (j + 1)) for j in range(v.shape[0])]) for i in range(v.shape[1])])))
def summed_votes(): verified, data = util.unpack_request(request, str(server_nr)) if not verified: return make_response("Could not verify", 400) try: vote_ = data['vote'] if type(vote_) == str: vote_ = [vote_] id_ = data['id'] if type(id_) in [str, int]: id_ = [id_] client = data['client'] server_name = data['server'] for i in range(len(vote_)): vote = util.string_to_vote(vote_[i]) assert type(vote) == np.ndarray db.insert_summed_votes(vote, int(id_[i]), client, server_name, my_name) except TypeError as e: print("summed_votes: ", vote_) print("summed_votes: ", e) return Response(status=400) return Response(status=200)
def test_adding_votes(self): client_util.send_vote([4, 2, 1, 3], 'c1', local_servers) client_util.send_vote([1, 2, 3, 4], 'c2', local_servers) # Bad vote client_util.send_vote([1, 1, 1, 1], 'c3', local_servers) client_util.send_vote([2, 2, 2, 2], 'c4', local_servers) for server in local_servers: util.get_url(server + "/zero_one_consistency") time.sleep(1) for server in local_servers: util.get_url(server + "/sumdifferenceshareforzeroone") time.sleep(1) for server in local_servers: util.get_url(server + '/check_votes') time.sleep(1) for server in local_servers: util.get_url(server + '/ensure_vote_agreement') time.sleep(1) for server in local_servers: util.get_url(server + '/add') time.sleep(1) for server in local_servers: response = util.get_url(server + '/compute_result') self.assertTrue(response.text=="ok") time.sleep(1) v = np.array([[1, 0, 0, 1],[0, 2, 0, 0],[1, 0, 1, 0],[0, 0, 1, 1]]) for server in local_servers: response = util.get_url(server + '/verify_result') result = util.string_to_vote(response.text) self.assertTrue(np.array_equal(result, np.array( [sum([v[i][j] * (1 / (j + 1)) for j in range(v.shape[0])]) for i in range(v.shape[1])])))
def extra_data(): verified, data = util.unpack_request(request, my_name) if not verified: return make_response("Could not verify", 400) complaint = util.string_to_vote(data["complaint"]) db.insert_mediator_inconsistency_extra_data(data["sender"], complaint, complaint.protocol, data["data"]) return make_response("ok", 200)
def message_inconsistency(): verified, data = util.unpack_request(request, my_name) if not verified: return make_response("Could not verify", 400) complaint: util.Complaint = util.string_to_vote(data["complaint"]) db.insert_mediator_inconsistency(complaint.sender, complaint, complaint.protocol) timer(5, complaint.protocol, complaint) return make_response("Done", 200)
def get_rows(db_name: str): cur = db_execute( conn, 'SELECT row, id, type_, client, server FROM "' + db_name + '/rows"') res = [] for r, i, t, cl, s in cur: r = util.string_to_vote(r) res.append((r, i, t, cl, s)) cur.close() return res
def get_results(db_name: str): cur = db_execute(conn, 'SELECT matrix, server FROM "' + db_name + '/result"') res = [] for m, s in cur: m = util.string_to_vote(m) res.append((m, s)) cur.close() conn.commit() return res
def round_two(db_name: str): cur = db_execute( conn, 'SELECT matrix, id, client, server FROM "' + db_name + '/summed_votes"') res = [] for m, i, cl, s in cur: m = util.string_to_vote(m) res.append((m, i, cl, s)) cur.close() conn.commit() return res
def get_summed_diffs(db_name: str): cur = db_execute( conn, 'SELECT diffs, client, i, j, server FROM "' + db_name + '/summed_diffs"') res = [] for d, c, i, j, s in cur: d = util.string_to_vote(d) res.append((d, c, i, j, s)) cur.close() conn.commit() return res
def get_zero_check(db_name: str): cur = db_execute( conn, 'SELECT matrix, client, server FROM "' + db_name + '/zerocheck' + '"') res = [] for m, c, s in cur: m = util.string_to_vote(m) res.append((m, c, s)) cur.close() conn.commit() return res
def round_one(db_name: str): cur = db_execute( conn, 'SELECT matrix, id, round, client, server FROM "' + db_name + '" WHERE round = 1') res = [] for m, i, r, cl, s in cur: m = util.string_to_vote(m) res.append((m, i, r, cl, s)) cur.close() conn.commit() return res
def get_mediator_inconsistency(): cur = db_execute( conn, 'SELECT sender, complaint, protocol FROM "' + mediator + '/inconsistency' + '"') res = [] try: for s, c, p in cur: res.append((s, util.string_to_vote(c), util.Protocol(int(p)))) except psy.ProgrammingError: res = [] cur.close() return res
def get_zero_consistency_check_alt(db_name: str): cur = db_execute( conn, 'SELECT diff, x, i, j, server_a, server_b, client, server FROM "' + db_name + '/zeroconsistency"') res = [] for d, x, i, j, sa, sb, c, s in cur: d = util.string_to_vote(d) res.append((d, c, i, j, x, sa, sb, s)) cur.close() conn.commit() return res
def get_zero_partition_sum(db_name): cur = db_execute( conn, 'SELECT matrix, client, server FROM "' + db_name + '/zeropartitionsum"') res = defaultdict(list) for m, c, s in cur: res[c] m = util.string_to_vote(m) res[c].append(dict(matrix=m, server=s)) cur.close() conn.commit() return res
def get_zero_consistency_check(db_name: str): cur = db_execute( conn, 'SELECT diff, x, i, j, server_a, server_b, client, server FROM "' + db_name + '/zeroconsistency"') res = defaultdict(list) for d, x, i, j, sa, sb, c, s in cur: d = util.string_to_vote(d) res[c].append( dict(diff=d, x=x, i=i, j=j, server_a=sa, server_b=sb, server=s)) cur.close() conn.commit() return res
def get_cols(table_name: str): cur = db_execute( conn, 'SELECT col, id, type_, client, server FROM "' + table_name + '/columns"') res = [] try: for (c, i, t, cl, s) in cur: c = util.string_to_vote(c) res.append((c, i, t, cl, s)) except psy.ProgrammingError: res = [] cur.close() return res
def messageinconsistency(): verified, data = util.unpack_request(request, str(server_nr)) if not verified: return make_response("Could not verify", 400) # check_votes = 1 # sum_difference_zero_one = 2 # sum_difference_zero_one_partition = 3 # zero_one_finalize = 4 # ensure_vote_agreement = 5 # compute_result = 6 complaint: util.Complaint = util.string_to_vote(data["complaint"]) relevant_data = [] if complaint.protocol == util.Protocol.check_votes: if complaint.data["votes"][0][2] == "row": my_data = db.get_rows(my_name) else: my_data = db.get_cols(my_name) relevant_data = [x for x in my_data if x[1] == complaint.value_id] elif complaint.protocol == util.Protocol.sum_difference_zero_one: relevant_data = db.get_summed_diffs(my_name) relevant_data = [ x for x in relevant_data if (x[2] == complaint.data["i"] and x[3] == complaint.data["j"] and x[1] == complaint.data["client"]) ] elif complaint.protocol == util.Protocol.sum_difference_zero_one_partition: my_data = db.get_zero_consistency_check_alt(my_name) relevant_data = [ x for x in my_data if (x[2] == complaint.data["i"] and x[3] == complaint.data["j"] and x[1] == complaint.data["client"] and x[4] == complaint.data["x"]) ] elif complaint.protocol == util.Protocol.zero_one_finalize: partition_sums = db.get_zero_partition_sum(my_name) relevant_data = partition_sums[complaint.data["client"]] elif complaint.protocol == util.Protocol.ensure_vote_agreement: relevant_data = db.get_illegal_votes(my_name) elif complaint.protocol == util.Protocol.compute_result: all_votes = db.round_two(my_name) relevant_data = [x for x in all_votes if x[3] != malicious_server] server_util.send_extra_data_to_mediator(relevant_data, complaint, my_name) # Modtager complaints fra andre servere # TODO: send relevant data to mediator return make_response("delivered", 200)
def receive_broadcasted_value(): verified, data = util.unpack_request(request, str(server_nr)) if not verified: return make_response("Could not verify", 400) vote_ = data['vote'] vote = util.string_to_vote(vote_) assert type(vote) == np.ndarray id_ = data['id'] type_ = data['round'] client = data['client'] server_name = data['server'] if type_ == 'row': db.insert_row(vote, id_, type_, client, server_name, my_name) elif type_ == 'column': db.insert_col(vote, id_, type_, client, server_name, my_name) return Response(status=200)
def save_result(): verified, data = util.unpack_request(request, str(server_nr)) if not verified: return make_response("Could not verify", 400) try: result_ = data['result'] server_name = data['server'] result = util.string_to_vote(result_) assert type(result) == np.ndarray db.insert_result(result, server_name, my_name) except TypeError as e: print("save_result: ", result_) print("save_result: ", e) return Response(status=400) return Response(status=200)
def zerocheck(): verified, data = util.unpack_request(request, str(server_nr)) if not verified: return make_response("Could not verify", 400) try: vote_ = data['vote'] vote = util.string_to_vote(vote_) assert type(vote) == np.ndarray client = data['client'] server_name = data['server'] db.insert_zero_check(vote, client, server_name, my_name) except TypeError as e: print("zerocheck: ", vote_) print("zerocheck: ", e) return Response(status=400) return Response(status=200)
def sum_product_receive(): verified, data = util.unpack_request(request, str(server_nr)) if not verified: return make_response("Could not verify", 400) try: sum_matrix_ = data['sum_matrix'] sum_matrix_ = util.string_to_vote(sum_matrix_) client_ = data['client'] server_ = data['server'] # Save on database db.insert_zero_partition_sum(matrix=sum_matrix_, client=client_, server=server_, db_name=my_name) except TypeError as e: print("zeroone_sum_partition: ", "ERROR") return Response(status=200)
def zeroonepartions(): verified, data = util.unpack_request(request, str(server_nr)) if not verified: return make_response("Could not verify", 400) try: partitions_ = data['ss'] partitions_ = [(x, util.string_to_vote(y)) for (x, y) in partitions_] i_ = data['i'] j_ = data['j'] server_ = data['server'] id_ = data['id'] client_ = data['client'] for x, ss in partitions_: db.insert_zero_partition(ss, x, i_, j_, client_, server_, my_name) except TypeError as e: print("zeroonepartitions: ", data) print("zeroonepartitions: ", e) return Response(status=400) return Response(status=200)
def vote(): global communication_number verified, data = util.unpack_request(request, str(server_nr)) if not verified: return make_response("Could not verify", 400) try: # Unpack data votes_ = data['votes'] if type(votes_) == str: votes_ = [votes_] ids_ = data['ids'] if type(ids_) in [str, int]: ids_ = [ids_] server_name = data['server'] client = data['client'] # Convert votes_ to list of np.array votes = [] for num, v_ in enumerate(votes_): if num in cheating_nums and cheat_id == 1: votes.append(cheat_util.col_row_cheat(util.string_to_vote(v_))) else: votes.append(util.string_to_vote(v_)) # Attach each share to its proper id id_vote_tuple = list(zip(ids_, votes)) # Insert votes, row and column in db and broadcast for (id, vote) in id_vote_tuple: row_sum = server_util.create_sum_of_row(vote) col_sum = server_util.create_sum_of_row(vote.T) db.insert_vote(vote, id, 1, client, server_name, my_name) db.insert_row(row_sum, id, 'row', client, server_name, my_name) db.insert_col(col_sum, id, 'column', client, server_name, my_name) server_util.broadcast_rows_and_cols(row_sum, col_sum, id, servers, my_name, client) # Insert zero check and broadcast my_id = servers.index(my_name) votes_dict = dict() for id, v in id_vote_tuple: if (len(cheating_nums) > 0 and id == cheating_nums[0] and cheat_id == util.Protocol.sum_difference_zero_one.value): v = np.zeros(v.shape) votes_dict[id] = v local_parts, communcations = server_util.matrix_zero_one_check( my_id, servers, votes_dict, my_name, client) communication_number += communcations for local_part in local_parts: for x, ss in enumerate(local_part[3]): db.insert_zero_partition(matrix=ss, x=x, i=local_part[1], j=local_part[2], client_name=local_part[5], server=my_name, db_name=my_name) except TypeError as e: print("vote", e) return Response(status=400) return Response(status=200)