def send_extra_data_to_mediator(data: dict, complaint, my_name): util.get_keys(my_name.split(":")[-1]) util.post_url( dict(complaint=util.vote_to_string(complaint), data=util.vote_to_string(data), server=my_name, sender=my_name), util.mediator + "/extra_data")
def insert_mediator_inconsistency_extra_data(sender: str, complaint: util.Complaint, protocol: util.Protocol, data: dict): complaint = util.vote_to_string(complaint) data = util.vote_to_string(data) cur = db_execute_extra( conn, 'INSERT INTO "' + mediator + '/inconsistency_extra_data' + '" (sender, complaint, protocol, data) VALUES (%s, %s, %s, %s)', (sender, complaint, protocol.value, data)) cur.close() conn.commit() return 1
def broadcast_rows_and_cols(row, col, id_, servers, my_name, client_name): # slet servers = list_remove(servers, my_name) broadcast( dict(vote=(util.vote_to_string(row)), id=id_, round="row", server=my_name, client=client_name), servers, '/server_comm') broadcast( dict(vote=(util.vote_to_string(col)), id=id_, round="column", server=my_name, client=client_name), servers, '/server_comm')
def sum_product_zero_one_check(): global communication_number zero_partitions_dict = db.get_zero_partitions(my_name) zero_partitions_clients = zero_partitions_dict.keys() for c in zero_partitions_clients: sum_partition_array = [[[0 for x in range(len(servers))] for j in range(len(servers))] for i in range(len(servers))] client_parts = zero_partitions_dict[c] used_parts = set() for part in client_parts: matrix = part['matrix'] i = part['i'] j = part['j'] x = part['x'] if (i, j, x) not in used_parts: used_parts.add((i, j, x)) sum_partition_array[i][j][x] = np.mod( np.add(sum_partition_array[i][j][x], matrix), util.get_prime()) communication_number += 4 server_util.broadcast(data=dict( sum_matrix=util.vote_to_string(sum_partition_array), server=my_name, client=c), servers=servers, url="/zeroone_sum_partition")
def zero_one_partitions_consistency_check( ): # Create differences for secret shared values, sum later # Create three dimensional list which contains lists for each share of a part of a product global communication_number partition_dict = db.get_zero_partitions(my_name) partition_dict_clients = partition_dict.keys() for client in partition_dict_clients: partition_matrix_list = [[[[] for h in range(len(servers))] for j in range(len(servers))] for i in range(len(servers))] for partition in partition_dict[client]: partition_matrix_list[partition['i']][partition['j']][ partition['x']].append( (partition['matrix'], partition['server'])) # Ensure that two should-be-identical parts from different servers are, indeed, identical, that a - b = 0. datas = [] for i in range(len(servers)): for j in range(len(servers)): for x in range(len(servers)): matrix_server_pairs = enumerate( partition_matrix_list[i][j][x]) for y, (matrix_y, server_y) in matrix_server_pairs: for z, (matrix_z, server_z) in matrix_server_pairs: if (y < z): difference = np.subtract( np.array(matrix_y), np.array(matrix_z)) # broadcast_difference_share if (cheat_id == util.Protocol. sum_difference_zero_one_partition.value and i == cheating_nums[0] and j == cheating_nums[0] and x == cheating_nums[0]): difference = cheat_util.col_row_cheat( difference) datas.append( dict(diff=util.vote_to_string(difference), x=x, i=i, j=j, server_a=server_y, server_b=server_z, server=my_name, client=client)) db.insert_zero_consistency_check( diff=difference, x=x, i=i, j=j, server_a=server_y, server_b=server_z, server=my_name, client_name=client, db_name=my_name) communication_number += 4 server_util.broadcast(data=dict(datas=datas, server=my_name), servers=servers, url="/differenceshareforzeroone") return Response(status=200)
def test_message_inconsistency(self): for num, server in enumerate(local_servers): util.post_url(dict(complaint=util.vote_to_string(util.Complaint( server, dict(test="test1"), util.Protocol.check_votes, num+1 % 4 )), server=server, sender=server.split(":")[-1]), mediator + "/messageinconsistency") time.sleep(0.2) print(requests.get(mediator + "/test/printcomplaints"))
def answer_complaint(complaint, malicious_server, votes_for_deletion): for server in util.servers: util.post_url( dict(complaint=util.vote_to_string(complaint), malicious_server=malicious_server, sender=my_name, votes_for_deletion=votes_for_deletion), server + "/mediator_answer_votes")
def insert_result(matrix: np.ndarray, server: str, db_name: str): matrix = util.vote_to_string(matrix) cur = db_execute_extra( conn, 'INSERT INTO "' + db_name + '/result" (matrix, server) ' + 'VALUES (%s, %s)', (matrix, server)) cur.close() conn.commit() return 1
def complain_consistency(complaint: util.Complaint, servers, mediator, my_name): util.get_keys(my_name.split(":")[-1]) for server in servers + [mediator]: util.post_url( dict(complaint=util.vote_to_string(complaint), server=my_name, sender=my_name), server + "/messageinconsistency")
def broadcast_values(values, round_, servers, my_name): servers = list_remove(servers, my_name) for j, vote_partition in enumerate(values): broadcast( dict(vote=(util.vote_to_string(vote_partition['vote_partition'])), id=vote_partition["id"], round=round_, server=my_name, client=my_name), servers, '/summed_votes')
def insert_zero_partition_sum(matrix: np.ndarray, server: str, client: str, db_name: str): matrix = util.vote_to_string(matrix) cur = db_execute_extra( conn, 'INSERT INTO "' + db_name + '/zeropartitionsum" (matrix, client, server) VALUES (%s, %s, %s)', (matrix, client, server)) cur.close() conn.commit() return 1
def insert_summed_diffs(diffs: list, client_name: str, i: int, j: int, server: str): diffs = util.vote_to_string(diffs) cur = db_execute_extra( conn, 'INSERT INTO "' + server + '/summed_diffs" (diffs, client, i, j, server) VALUES (%s, %s, %s, %s, %s)', (diffs, client_name, i, j, server)) cur.close() conn.commit() return 1
def insert_summed_votes(matrix: np.ndarray, id: int, client_name: str, server: str, db_name: str): matrix = util.vote_to_string(matrix) cur = db_execute_extra( conn, 'INSERT INTO "' + db_name + '/summed_votes" (matrix, id, client, server) VALUES (%s, %s, %s, %s)', (matrix, id, client_name, server)) cur.close() conn.commit() return 1
def insert_zero_consistency_check(diff: np.ndarray, x: int, i: int, j: int, server_a: str, server_b: str, client_name: str, server: str, db_name: str): diff = util.vote_to_string(diff) cur = db_execute_extra( conn, 'INSERT INTO "' + db_name + '/zeroconsistency" (diff, x, i, j, server_a, server_b, client, server) VALUES (%s, %s, %s, %s, %s, %s, %s, %s)', (diff, x, i, j, server_a, server_b, client_name, server)) cur.close() conn.commit() return 1
def verify_result(): res_count = db.get_results_count(my_name) if res_count == 1: return make_response( util.vote_to_string(db.get_results(db_name=my_name)[0][0]), 200) results = db.get_results(my_name) results_to_verify = [(x[0], 0, x[1]) for x in results] _, v1, v2 = server_util.verify_consistency(results_to_verify) server_util.complain_consistency( util.Complaint(my_name, dict(results=results), util.Protocol.compute_result, -1), server_util.list_remove(util.servers, my_name), util.mediator, my_name) return make_response("Error, multiple results", 400)
def send_zero_one_secret_shares(id, i, j, ss: list, servers: list, my_name, client): communcations = 0 for x, server in enumerate(servers): communcations += 3 broadcast(data=dict(ss=[(y, util.vote_to_string(s)) for y, s in enumerate(ss) if y != x], id=id, i=i, j=j, server=my_name, client=client), servers=servers, url="/zeroonepartitions") return communcations
def compute_result(): global communication_number all_votes = db.round_two(my_name) legal_votes = [x for x in all_votes if x[3] != malicious_server] s = server_util.calculate_result(legal_votes) if cheat_id == util.Protocol.compute_result.value: s = cheat_util.col_row_cheat(s) # Calculate Dowdall result. dowdall_result = np.array([ sum([s[i][j] * (1 / (j + 1)) for j in range(s.shape[0])]) for i in range(s.shape[1]) ]) communication_number += 3 server_util.broadcast( dict(server=my_name, result=util.vote_to_string(dowdall_result), sender=my_name), util.servers, "/save_result") return make_response("ok", 200)
def insert_row(row: np.ndarray, id: int, type_: str, client_name, server, my_name): row = util.vote_to_string(row) cur = db_execute( conn, 'SELECT row FROM "' + my_name + '/rows" WHERE id = ' + str(id) + ' AND client = \'' + str(client_name) + '\' AND server = \'' + str(server) + '\'') if len(cur.fetchall()) == 0: cur = db_execute_extra( conn, 'INSERT INTO "' + my_name + '/rows" (row, id, type_, client, server) VALUES (%s, %s, %s, %s, %s)', (row, id, type_, client_name, server)) else: cur.execute('UPDATE "' + my_name + '/rows" SET row = \'' + row + '\' WHERE id = ' + str(id) + ' AND client = \'' + str(client_name) + '\' AND server = \'' + str(server) + '\'') cur.close() conn.commit() return 1
def insert_zero_check(matrix: np.ndarray, client_name: str, server: str, db_name: str): matrix = util.vote_to_string(matrix) cur = db_execute( conn, 'SELECT matrix FROM "' + db_name + '/zerocheck" WHERE client = \'' + str(client_name) + '\' AND server = \'' + str(server) + '\'') if len(cur.fetchall()) == 0: cur = db_execute_extra( conn, 'INSERT INTO "' + db_name + '/zerocheck' + '" (matrix, client, server) VALUES (%s, %s, %s)', (matrix, client_name, server)) else: cur = db_execute( conn, 'UPDATE "' + db_name + '/zerocheck" SET matrix = \'' + matrix + '\' WHERE client = \'' + str(client_name) + '\' AND server = \'' + str(server) + '\'') cur.close() conn.commit() return 1
def insert_col(col: np.ndarray, id: int, type_: str, client_name, server, my_name): col = util.vote_to_string(col) cur = db_execute( conn, 'SELECT col FROM "' + my_name + '/columns" WHERE id = ' + str(id) + ' AND client = \'' + str(client_name) + '\' AND server = \'' + str(server) + '\'') if len(cur.fetchall()) == 0: cur = db_execute_extra( conn, 'INSERT INTO "' + my_name + '/columns" (col, id, type_, client, server) VALUES (%s, %s, %s, %s, %s)', (col, id, type_, client_name, server)) else: cur = db_execute( conn, 'UPDATE "' + my_name + '/columns" SET col = \'' + col + '\' WHERE id = ' + str(id) + ' AND client = \'' + str(client_name) + '\' AND server = \'' + str(server) + '\'') cur.close() conn.commit() return 1
def postvote(client_name: str, vote: list, servers: list): ### Parameters: ### client_name: unique identifier for client ### vote: a list consisting of matrices containing the different secret shared r_i-element of the vote ### servers: a list with all servers which the secrets should be distributed to ### ### Returns: ### void. Should only distribute secret shares to servers for i,share in enumerate(vote): rest = vote.copy() rest.pop(i) ids = [0,1,2,3] ids.remove(i) rest_strings = [] for vote_partition in rest: rest_strings.append(util.vote_to_string(vote_partition)) m = dict(client=client_name, ids=ids, server=servers[i], votes=rest_strings, sender=client_name) util.get_keys(client_name) util.post_url(m, servers[i] + '/vote')
def insert_vote(matrix: np.ndarray, id: int, round: int, client_name: str, server: str, db_name: str): matrix = util.vote_to_string(matrix) cur = db_execute( conn, 'SELECT matrix FROM "' + db_name + '" WHERE id = ' + str(id) + ' AND client = \'' + str(client_name) + '\' AND server = \'' + str(server) + '\' AND round = ' + str(round)) if len(cur.fetchall()) == 0: cur = db_execute_extra( conn, 'INSERT INTO "' + db_name + '" (matrix, id, round, client, server) VALUES (%s, %s, %s, %s, %s)', (matrix, id, round, client_name, server)) else: cur = db_execute( conn, 'UPDATE "' + db_name + '" SET matrix = \'' + matrix + '\' WHERE id = ' + str(id) + ' AND client = \'' + str(client_name) + '\' AND server = \'' + str(server) + '\' AND round = ' + str(round)) cur.close() conn.commit() return 1
def insert_zero_partition(matrix: np.ndarray, x: int, i: int, j: int, client_name: str, server: str, db_name: str): matrix = util.vote_to_string(matrix) cur = db_execute( conn, 'SELECT matrix FROM "' + db_name + '/zeropartition" WHERE client = \'' + str(client_name) + '\' AND x = \'' + str(x) + '\' AND i = \'' + str(i) + '\' AND j = \'' + str(j) + '\' AND server = \'' + str(server) + '\'') if len(cur.fetchall()) == 0: cur = db_execute_extra( conn, 'INSERT INTO "' + db_name + '/zeropartition" (matrix, client, server, x, i, j) VALUES (%s, %s, %s, %s, %s, %s)', (matrix, client_name, server, x, i, j)) else: cur = db_execute( conn, 'UPDATE "' + db_name + '/zeropartition" SET matrix = \'' + matrix + '\' WHERE client = \'' + str(client_name) + '\' AND server = \'' + str(server) + '\' AND x = \'' + str(x) + '\' AND i = \'' + str(i) + '\' AND j = \'' + str(j) + '\'') cur.close() conn.commit() return 1