def encrypt(m, roundkeys, linmatrices, roundconstants):
m = mpc.vector_add(m, roundkeys[0])
for r in range(rounds):
m = substitute(m)
m = [mpc.in_prod(linmatrices[r][i], m) for i in range(blocksize)]
m = mpc.vector_add(m, roundconstants[r])
m = mpc.vector_add(m, roundkeys[r + 1])
return m
def decrypt(m, roundkeys, invlinmatrices, roundconstants):
for r in range(rounds, 0, -1):
m = mpc.vector_add(m, roundkeys[r])
m = mpc.vector_add(m, roundconstants[r - 1])
m = [
mpc.in_prod(invlinmatrices[r - 1][i], m) for i in range(blocksize)
]
m = invsubstitute(m)
return mpc.vector_add(m, roundkeys[0])
def vector_add_all(vectors):
if len(vectors) == 1:
return vectors[0]
v = mpc.vector_add(vectors[0], vectors[1])
for i in range(2, len(vectors)):
v = mpc.vector_add(v, vectors[i])
return v
map(float, np.random.normal(0, SIGMA2, NB_CLASSES)))
# Convert it to secure type
sec_noise_vector_sigma2 = list(map(secfxp, noise_vector_sigma2))
else:
# Clients no not generate a noise vector
sec_noise_vector_sigma2 = list(map(secfxp, [None] * NB_CLASSES))
# The server secret-shares this noise vector with every other party
# (take the 0th element because list only has 1 element: [[x,x,x]])
sec_noise_vector_sigma2 = mpc.input(sec_noise_vector_sigma2,
senders=[SERVER_ID])[0]
# Add this secure noise vector to the secure total votes vector
total_sec_noisy_votes = mpc.vector_add(total_sec_votes,
sec_noise_vector_sigma2)
# Compute the secure argmax on this vector of aggregated noisy votes
sec_argmax = argmax(total_sec_noisy_votes)
# Our label is the revealed (=recombined) argmax
label = mpc.run(mpc.output(sec_argmax, receivers=[SERVER_ID]))
if label and IS_SERVER: # Should be a tautology as the server is the ONLY one receiving the 'label' variable
label = int(label)
print(f'[*] Sample {sample_id}: {label}')
LABELS[sample_id] = label
elapsed = time.time() - last_time
# print('time elapsed:', elapsed)
csv_writer.writerow([sample_id, label, elapsed])
async def main():
parser = argparse.ArgumentParser()
parser.add_argument('-d', '--data', help='filename for tableau')
parser.add_argument('options', nargs='*')
parser.set_defaults(data='default')
args = parser.parse_args()
if not args.options:
certificate_filename = f'c{mpc.pid}.cert'
logging.info(
f'Setting certificate file to default = {certificate_filename}')
else:
certificate_filename = args.options[0]
T = load_tableau(args.data)
m = len(T) - 1
n = len(T[0]) - 1
l = mpc.options.bit_length
secfxp = mpc.SecFxp(l)
for i in range(m + 1):
for j in range(n + 1):
T[i][j] = secfxp(T[i][j])
basis = [secfxp(i + n) for i in range(m)]
cobasis = [secfxp(j) for j in range(n)]
await mpc.start()
iteration = 0
logging.info(f'{iteration} Termination?...')
p_col_index, minimum = argmin_int(T[-1][:-1])
while await mpc.output(minimum < 0):
iteration += 1
logging.info(f'{iteration} Determining pivot...')
p_col = index_matrix_prod(p_col_index + [secfxp(0)], T, True)
constraints = [(T[i][-1] + (p_col[i] <= 0), p_col[i])
for i in range(m)]
p_row_index, _ = argmin_rat(constraints)
pivot = mpc.in_prod(p_row_index, p_col)
logging.info(f'{iteration} Updating tableau...')
h = mpc.scalar_mul(1 / pivot, mpc.vector_sub(p_row_index + [0], p_col))
p_row = index_matrix_prod(p_row_index, T[:-1])
v = mpc.vector_add(p_row, p_col_index + [0])
for i in range(m + 1):
T[i] = mpc.vector_add(T[i], mpc.scalar_mul(h[i], v))
# swap basis entries
delta = mpc.in_prod(basis, p_row_index) - mpc.in_prod(
cobasis, p_col_index)
p_row_index = mpc.scalar_mul(delta, p_row_index)
basis = mpc.vector_sub(basis, p_row_index)
p_col_index = mpc.scalar_mul(delta, p_col_index)
cobasis = mpc.vector_add(cobasis, p_col_index)
logging.info(f'{iteration} Termination?...')
p_col_index, minimum = argmin_int(T[-1][:-1])
logging.info('Termination...')
mx = await mpc.output(T[-1][-1])
print(' max(f) =', mx)
logging.info('Computing solution...')
solution = [secfxp(0) for _ in range(n)]
for i in range(m):
x = mpc.unit_vector(basis[i], m + n)[:n]
y = mpc.scalar_mul(T[i][-1], x)
solution = mpc.vector_add(solution, y)
solution = await mpc.output(solution)
logging.info('Computing dual solution...')
dual_solution = [secfxp(0) for _ in range(m)]
for j in range(n):
x = mpc.unit_vector(cobasis[j], m + n)[n:]
y = mpc.scalar_mul(T[-1][j], x)
dual_solution = mpc.vector_add(dual_solution, y)
dual_solution = await mpc.output(dual_solution)
await mpc.shutdown()
logging.info(f'Writing output to {certificate_filename}')
tab = '\t'
with open(os.path.join('data', 'lp', certificate_filename), 'w') as f:
f.write(f'# tableau =\n{args.data}\n')
f.write(f'# bit-length =\n{mpc.options.bit_length}\n')
f.write(f'# security parameter =\n{mpc.options.sec_param}\n')
f.write(f'# threshold =\n{mpc.threshold}\n')
f.write(f'# solution =\n{tab.join(x.__repr__() for x in solution)}\n')
f.write(
f'# dual solution =\n{tab.join(x.__repr__() for x in dual_solution)}\n'
)
async def main():
await mpc.start()
with open(f"icissp2020-{len(mpc.parties)}_parties-output.csv", 'w', newline='') as csvfile:
print(f"running benchmarks; output will be in {csvfile.name}")
print("clearing netem delay just in case ...")
subprocess.run(["sudo", "tc", "qdisc","del","dev","lo","root","netem","delay", '0ms'])
subprocess.run(["sudo", "tc", "qdisc","del","dev","lo","root","netem","loss", '0%'])
fieldnames = ["length","delay","loss","addition","mpc.vector_add()","summation","mpc.sum()","multiplication","mpc.schur_prod()","product","mpc.prod()"]
writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
writer.writeheader()
for d in range(0,55,5):
for p in range(0,11,1):
for length in [1,10,100]:
print("generating random inputs ...")
a = [ [ mpc.input(sec(secrets.randbits(sec.bit_length)))[0] for _ in range(length) ] for _ in range(loop) ]
b = [ [ mpc.input(sec(secrets.randbits(sec.bit_length)))[0] for _ in range(length) ] for _ in range(loop) ]
r1 = [None] * loop
r2 = [None] * loop
res = [None] * 8
for i in range(loop):
await mpc.output(a[i])
await mpc.output(b[i])
time.sleep(1)
print(f"comparing {loop} runs on vectors of length {length} with latency {d*2}ms and {p}% loss\n")
subprocess.run(["sudo", "tc", "qdisc","add","dev","lo","root","netem","delay", f"{d}ms"])
subprocess.run(["sudo", "tc", "qdisc","add","dev","lo","root","netem","loss", f"{p}%"])
print("elementwise addition".ljust(32), end='', flush=True)
t1 = time.perf_counter()
for i in range(loop):
r = list(map(operator.add, a[i], b[i]))
r1[i] = await mpc.gather(r)
t2 = time.perf_counter()
print(f"{(t2 - t1):.5} seconds")
res[0] = f"{(t2 - t1):f}"
time.sleep(1)
print("mpc.vector_add()".ljust(32), end='', flush=True)
t1 = time.perf_counter()
for i in range(loop):
r = mpc.vector_add(a[i], b[i])
r2[i] = await mpc.gather(r)
t2 = time.perf_counter()
print(f"{(t2 - t1):.5} seconds")
res[1] = f"{(t2 - t1):f}"
time.sleep(1)
print("summation".ljust(32), end='', flush=True)
t1 = time.perf_counter()
for i in range(loop):
r = functools.reduce(operator.add, a[i])
r1[i] = await mpc.gather(r)
t2 = time.perf_counter()
print(f"{(t2 - t1):.5} seconds")
res[2] = f"{(t2 - t1):f}"
time.sleep(1)
print("mpc.sum()".ljust(32), end='', flush=True)
t1 = time.perf_counter()
for i in range(loop):
r = mpc.sum(a[i])
r2[i] = await mpc.gather(r)
t2 = time.perf_counter()
print(f"{(t2 - t1):.5} seconds")
res[3] = f"{(t2 - t1):f}"
time.sleep(1)
print("elementwise multiplication".ljust(32), end='', flush=True)
t1 = time.perf_counter()
for i in range(loop):
r = list(map(operator.mul, a[i], b[i]))
r1[i] = await mpc.gather(r)
t2 = time.perf_counter()
print(f"{(t2 - t1):.5} seconds")
res[4] = f"{(t2 - t1):f}"
time.sleep(1)
print("mpc.schur_prod()".ljust(32), end='', flush=True)
t1 = time.perf_counter()
for i in range(loop):
r = mpc.schur_prod(a[i], b[i])
r2[i] = await mpc.gather(r)
t2 = time.perf_counter()
print(f"{(t2 - t1):.5} seconds")
res[5] = f"{(t2 - t1):f}"
time.sleep(1)
print("product".ljust(32), end='', flush=True)
t1 = time.perf_counter()
for i in range(loop):
r = functools.reduce(operator.mul, a[i])
r1[i] = await mpc.gather(r)
t2 = time.perf_counter()
print(f"{(t2 - t1):.5} seconds")
res[6] = f"{(t2 - t1):f}"
time.sleep(1)
print("mpc.prod()".ljust(32), end='', flush=True)
t1 = time.perf_counter()
for i in range(loop):
r = mpc.prod(a[i])
r2[i] = await mpc.gather(r)
t2 = time.perf_counter()
print(f"{(t2 - t1):.5} seconds")
res[7] = f"{(t2 - t1):f}"
time.sleep(1)
subprocess.run(["sudo", "tc", "qdisc","del","dev","lo","root","netem","delay", "0ms"])
subprocess.run(["sudo", "tc", "qdisc","del","dev","lo","root","netem","loss", "0%"])
writer.writerow({
'length': f"{length}",
'delay': f"{d*2}",
'loss': f"{p}",
'addition': res[0],
'mpc.vector_add()': res[1],
'summation': res[2],
'mpc.sum()': res[3],
'multiplication': res[4],
'mpc.schur_prod()': res[5],
'product': res[6],
'mpc.prod()': res[7]
})
await mpc.shutdown()
