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()