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)
