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
