def test_Cl(self): Cl23 = fg.ClassGroup(Delta=-23) secgrp = mpc.SecGrp(Cl23) secint = secgrp.sectype g = Cl23.generator self.assertFalse(mpc.run(mpc.output(secgrp(g) != g))) self.assertEqual(mpc.run(secgrp.repeat_public(g, -secint(2))), g) self.assertEqual(mpc.run(mpc.output(g**secint(-2))), g) self.assertEqual(mpc.run(mpc.output(g * secgrp(g))), Cl23((2, -1, 3))) Cl227 = fg.ClassGroup(Delta=-227) # Example 9.6.2 from Buchman&Vollmer secgrp = mpc.SecGrp(Cl227) g = Cl227((3, 1, 19)) self.assertEqual(mpc.run(mpc.output(secgrp(g) ^ 5)), g ^ 5) Cl1123 = fg.ClassGroup( Delta=-1123) # Example 9.7.5 from Buchman&Vollmer secgrp = mpc.SecGrp(Cl1123) self.assertEqual(Cl1123((1, 1, 281)), Cl1123.identity) g = Cl1123((7, 5, 41)) self.assertEqual(mpc.run(mpc.output(secgrp(g) ^ 5)), g ^ 5) self.assertEqual(mpc.run(mpc.output(secgrp(g)**3)), g ^ 3) group = fg.ClassGroup(l=28) secgrp = mpc.SecGrp(group) g = group.generator a = secgrp(g) ^ 6 self.assertEqual(mpc.run(mpc.output(a)), g ^ 6) self.assertEqual(mpc.run(mpc.output(a * (a ^ -1))), group.identity) m, z = group.encode(5) self.assertEqual( mpc.run(mpc.output(secgrp.decode(secgrp(m), secgrp(z)))), 5) self.assertRaises(ValueError, secgrp, [0])
def test_secint(self): secint = mpc.SecInt() y = [1, 3, -2, 3, 1, -2, -2, 4] * 5 random.shuffle(y) x = list(map(secint, y)) self.assertEqual(mpc.run(mpc.output(mean(x))), round(statistics.mean(y))) self.assertEqual(mpc.run(mpc.output(variance(x))), round(statistics.variance(y))) self.assertEqual(mpc.run(mpc.output(variance(x, mean(x)))), round(statistics.variance(y))) self.assertEqual(mpc.run(mpc.output(stdev(x))), round(statistics.stdev(y))) self.assertEqual(mpc.run(mpc.output(pvariance(x))), round(statistics.pvariance(y))) self.assertEqual(mpc.run(mpc.output(pstdev(x))), round(statistics.pstdev(y))) self.assertEqual(mpc.run(mpc.output(mode(x))), round(statistics.mode(y))) self.assertEqual(mpc.run(mpc.output(median(x))), round(statistics.median(y))) self.assertEqual(mpc.run(mpc.output(median_low(x))), round(statistics.median_low(y))) self.assertEqual(mpc.run(mpc.output(median_high(x))), round(statistics.median_high(y)))
def main(): if mpc.args: n = int(mpc.args[0]) else: n = 5 print('Setting input to default =', n) s = [(-1)**i * (i + (n//2))**2 for i in range(n)] mpc.start() global secnum secnum = mpc.SecInt() print('Using secure integers:', secnum) x = list(map(secnum, s)) print('Array:', mpc.run(mpc.output(x))) print('Sorted array:', mpc.run(mpc.output(bsort(x)))) secnum = mpc.SecFxp() print('Using secure fixed-point numbers:', secnum) x = list(map(secnum, s)) print('Input array:', mpc.run(mpc.output(x))) print('Sorted array:', mpc.run(mpc.output(bsort(x)))) mpc.shutdown()
def main(): if not mpc.args: m = 8 print('Setting input to default =', m) else: m = int(mpc.args[0]) mpc.start() secfld = mpc.SecFld(l=max(len(mpc.parties), (m - 1)).bit_length() + 1) print('Using secure fields:', secfld) for n in range(2, m + 1): print(n, mpc.run(mpc.output(random_derangement(n, secfld)))) secint = mpc.SecInt() print('Using secure integers:', secint) for n in range(2, m + 1): print(n, mpc.run(mpc.output(random_derangement(n, secint)))) secfxp = mpc.SecFxp() print('Using secure fixed-point numbers:', secfxp) for n in range(2, m + 1): print(n, mpc.run(mpc.output(random_derangement(n, secfxp)))) mpc.shutdown()
def test_qsecfld(self): secfld = mpc.SecFld(7**3) a = secfld(1) b = secfld(0) self.assertEqual(mpc.run(mpc.output(+a)), 1) self.assertNotEqual(id(a), id(+a)) # NB: +a creates a copy self.assertEqual(mpc.run(mpc.output(a + b)), 1) self.assertEqual(mpc.run(mpc.output(a * b)), 0)
def test_async(self): mpc.options.no_async = False a = mpc.SecInt()(7) b = a * a mpc.run(mpc.barrier()) self.assertEqual(mpc.run(mpc.output(b)), 49) self.assertEqual(mpc.run(mpc.output(mpc.scalar_mul(a, [-a, a]))), [-49, 49]) mpc.options.no_async = True
def test_secfxp(self): secfxp = mpc.SecFxp() a = getrandbits(secfxp, 10) self.assertTrue(a.integral) a = mpc.run(mpc.output(a)) self.assertGreaterEqual(int(a), 0) self.assertLessEqual(int(a), 2**10 - 1) x = mpc.run(mpc.output(random_unit_vector(secfxp, 6))) self.assertEqual(int(sum(x)), 1) x = mpc.run(mpc.output(random_permutation(secfxp, range(1, 9)))) self.assertSetEqual(set(range(1, 9)), set(map(int, x))) x = mpc.run(mpc.output(random_derangement(secfxp, [0.0, 1.0]))) self.assertListEqual([1, 0], list(map(int, x))) a = mpc.run(mpc.output(choice(secfxp, [0.8, 0.9, 1.0, 1.1, 1.2]))) self.assertAlmostEqual(float(a), 1.0, 0) a = mpc.run(mpc.output(choice(secfxp, [0.08, 0.09, 0.1, 0.11, 0.12]))) self.assertAlmostEqual(float(a), 0.1, 1) a = mpc.run(mpc.output(random(secfxp))) self.assertGreaterEqual(float(a), 0) self.assertLessEqual(float(a), 1) a = mpc.run(mpc.output(uniform(secfxp, 13.13, 13.17))) self.assertGreaterEqual(float(a), 13.13) self.assertLessEqual(float(a), 13.17) a = mpc.run(mpc.output(uniform(secfxp, -13.13, -13.17))) self.assertGreaterEqual(float(a), -13.17) self.assertLessEqual(float(a), -13.13)
def test_secfxp(self): secfxp = mpc.SecFxp() s = seclist([5, -3, 2, 5, 5], secfxp) self.assertFalse(mpc.run(mpc.output(s < s))) t = s[:] t[-1] += 1 self.assertTrue(mpc.run(mpc.output(s < t))) s = [[1, 0], [0, 1], [0, 0], [1, 1]] ss = mpc.sorted([[secfxp(a) for a in _] for _ in s], key=seclist) self.assertEqual([mpc.run(mpc.output(_)) for _ in ss], sorted(s))
def test_empty_input(self): secint = mpc.SecInt() self.assertEqual(mpc.run(mpc.gather([])), []) self.assertEqual(mpc.run(mpc.output([])), []) self.assertEqual(mpc._reshare([]), []) self.assertEqual(mpc.convert([], None), []) self.assertEqual(mpc.sum([]), 0) self.assertEqual(mpc.prod([]), 1) self.assertEqual(mpc.in_prod([], []), 0) self.assertEqual(mpc.vector_add([], []), []) self.assertEqual(mpc.vector_sub([], []), []) self.assertEqual(mpc.scalar_mul(secint(0), []), []) self.assertEqual(mpc.schur_prod([], []), []) self.assertEqual(mpc.from_bits([]), 0)
def test_secfld(self): secfld = mpc.SecFld() self.assertEqual(secfld.field.modulus, 2) secfld = mpc.SecFld(l=16) a = secfld(1) b = secfld(0) self.assertEqual(mpc.run(mpc.output(a + b)), 1) self.assertEqual(mpc.run(mpc.output(a * b)), 0) secfld = mpc.SecFld(101) a = secfld(1) b = secfld(-1) self.assertEqual(mpc.run(mpc.output(a + b)), 0) self.assertEqual(mpc.run(mpc.output(a * b)), 100) self.assertEqual(mpc.run(mpc.output(a == b)), 0) self.assertEqual(mpc.run(mpc.output(a == -b)), 1) self.assertEqual(mpc.run(mpc.output(a**2 == b**2)), 1) self.assertEqual(mpc.run(mpc.output(a != b)), 1) with self.assertRaises(TypeError): a < b with self.assertRaises(TypeError): a <= b with self.assertRaises(TypeError): a > b with self.assertRaises(TypeError): a >= b
def test_convert(self): secint = mpc.SecInt() secint8 = mpc.SecInt(8) secint16 = mpc.SecInt(16) secfld257 = mpc.SecFld(257) secfld263 = mpc.SecFld(263) secfxp = mpc.SecFxp() secfxp16 = mpc.SecFxp(16) x = [secint8(-100), secint8(100)] y = mpc.convert(x, secint) self.assertEqual(mpc.run(mpc.output(y)), [-100, 100]) y = mpc.convert(y, secint8) self.assertEqual(mpc.run(mpc.output(y)), [-100, 100]) x = [secint16(i) for i in range(10)] y = mpc.convert(x, secfld257) self.assertEqual(mpc.run(mpc.output(y)), list(range(10))) x = [secfld257(i) for i in range(10)] y = mpc.convert(x, secfld263) self.assertEqual(mpc.run(mpc.output(y)), list(range(10))) x = [secint(-100), secint(100)] y = mpc.convert(x, secfxp) self.assertEqual(mpc.run(mpc.output(y)), [-100, 100]) y = mpc.convert(y, secint) self.assertEqual(mpc.run(mpc.output(y)), [-100, 100]) x = [secfxp16(-100.25), secfxp16(100.875)] y = mpc.convert(x, secfxp) self.assertEqual(mpc.run(mpc.output(y)), [-100.25, 100.875]) y = mpc.convert(y, secfxp16) self.assertEqual(mpc.run(mpc.output(y)), [-100.25, 100.875])
def test_secfld(self): secfld = mpc.SecFld(101) s = seclist([], secfld) self.assertEqual(s, []) s = seclist(sectype=secfld) self.assertEqual(s, []) s.append(False) s.append(secfld(100)) s[1:2] = (1, ) s += [2, 3] s.reverse() s = [5, 4] + s s.reverse() s = s + [6, 7] del s[0] s.remove(4) s[5] = 9 del s[2:4] self.assertEqual(mpc.run(mpc.output(list(s))), [1, 2, 6, 9]) secfld2 = mpc.SecFld() self.assertRaises(TypeError, seclist, [secfld(1)], secfld2) self.assertRaises(ValueError, seclist, []) self.assertRaises(TypeError, operator.add, seclist([secfld(1)]), seclist([secfld2(1)]))
def test_QR_SG(self): for group in fg.QuadraticResidues(l=768), fg.SchnorrGroup(l=768): secgrp = mpc.SecGrp(group) g = group.generator g2 = mpc.run(mpc.output(secgrp(g) * g)) self.assertEqual(int(g), int(group.identity * g)) self.assertFalse( mpc.run(mpc.output(secgrp(g) / g != group.identity))) self.assertTrue(mpc.run(mpc.output(g * secgrp(g) == g2))) secfld = mpc.SecFld(modulus=secgrp.group.order) self.assertEqual(mpc.run(mpc.output(secgrp.repeat(g, -secfld(2)))), 1 / g2) self.assertEqual(mpc.run(mpc.output(secgrp.repeat(secgrp(g), 2))), g2) m, z = group.encode(15) self.assertEqual( mpc.run(mpc.output(secgrp.decode(secgrp(m), secgrp(z)))), 15) h = secgrp.if_else(secgrp.sectype(0), g, secgrp(g2)) self.assertEqual(mpc.run(mpc.output(h)), g2) a = secgrp(g) self.assertRaises(TypeError, operator.truediv, 2, a) self.assertRaises(TypeError, operator.add, a, a) self.assertRaises(TypeError, operator.add, g, a) self.assertRaises(TypeError, operator.neg, a) self.assertRaises(TypeError, operator.sub, a, a) self.assertRaises(TypeError, operator.sub, g, a)
def test_accumulate(self): secint = mpc.SecInt() r = range(1, 9) x = [secint(i) for i in r] for acc in itertools.accumulate, mpyc.mpctools.accumulate: self.assertEqual(mpc.run(mpc.output(list(acc(x)))), list(itertools.accumulate(r))) self.assertEqual(mpc.run(mpc.output(list(acc(x, mpc.mul)))), list(itertools.accumulate(r, operator.mul))) self.assertEqual(mpc.run(mpc.output(list(acc(x, mpc.min)))), list(itertools.accumulate(r, min))) self.assertEqual(mpc.run(mpc.output(list(acc(x, mpc.max)))), list(itertools.accumulate(r, max))) a = secint(10) self.assertEqual( mpc.run( mpc.output( list(acc(itertools.repeat(a, 5), mpc.mul, secint(1))))), [1, 10, 10**2, 10**3, 10**4, 10**5])
def test_Sn(self): group = fg.SymmetricGroup(5) a = group([3, 4, 2, 1, 0]) b = a @ a secgrp = mpc.SecGrp(group) c = secgrp(a) d = a @ c self.assertEqual(mpc.run(mpc.output(d)), b) e = ~c f = e @ b self.assertEqual(mpc.run(mpc.output(f)), a) self.assertTrue(mpc.run(mpc.output(f == c))) group = fg.SymmetricGroup(11) secgrp = mpc.SecGrp(group) a = group([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0]) secfld = mpc.SecFld(11) # ord(a) = 11 a7 = secgrp.repeat(a, secfld(7)) self.assertEqual(mpc.run(mpc.output(a7)), a ^ 7) a7 = secgrp.repeat_public(a, secfld(7)) self.assertEqual(mpc.run(a7), a ^ 7) a6 = a ^ 6 a12 = a6 @ a6 self.assertEqual(mpc.run(mpc.output(secgrp(a6).inverse())), a ^ 5) self.assertEqual( mpc.run(mpc.output((secgrp(a) ^ 6) @ secgrp.identity)), a6) self.assertEqual(mpc.run(mpc.output(secgrp.repeat(a6, secfld(2)))), a12) self.assertEqual( mpc.run(mpc.output(secgrp.repeat(secgrp(a), secfld(6)))), a6) p = secgrp(a) self.assertRaises(TypeError, operator.add, p, p) self.assertRaises(TypeError, operator.mul, p, p) self.assertRaises(TypeError, operator.mul, 1, p) group.is_multiplicative = True self.assertTrue(mpc.run(mpc.output(a * p == a ^ 2))) group.is_multiplicative = False self.assertRaises(ValueError, secgrp, [0, 1, 2, 3])
def run(args): model = None # 获取训练和测试数据 data = get_data(args.model)[0] test_data = get_data(args.model)[1] # 创建模型结果的目录 if not os.path.exists('results'): os.makedirs('results') if len(os.listdir('results')) > 0: shutil.rmtree('results') os.makedirs('results') # 初始化模型 model = GradientBoostingRegressor(learning_rate=args.lr, n_trees=args.trees, max_depth=args.depth, min_samples_split=args.count, is_log=args.log, is_plot=args.plot) # 训练模型 mpc.run(mpc.start()) model.fit(data) # 记录日志 logger.removeHandler(logger.handlers[-1]) logger.addHandler( logging.FileHandler('results/result.log'.format(iter), mode='w', encoding='utf-8')) logger.info(data) # 模型预测 model.predict(test_data) # 记录日志 logger.setLevel(logging.INFO) logger.info((test_data['predict_value'])) mpc.run(mpc.shutdown()) pass
def test_secfld(self): secfld = mpc.SecFld(101) s = seclist([], secfld) self.assertEqual(s, []) s = seclist(sectype=secfld) self.assertEqual(s, []) s.append(False) s.append(secfld(100)) s[1:2] = (1, ) s += [2, 3] s.reverse() s = [5, 4] + s s.reverse() s = s + [6, 7] del s[0] self.assertEqual(mpc.run(mpc.output(list(s))), [1, 2, 3, 4, 5, 6, 7])
def test_reduce(self): secint = mpc.SecInt() r = range(1, 9) x = [secint(i) for i in r] y = [[secint(i)] * 2 for i in r] z = [[[secint(i)] * 2] * 2 for i in r] for red in functools.reduce, mpyc.mpctools.reduce: self.assertEqual(mpc.run(mpc.output(red(mpc.add, x))), 36) self.assertEqual(mpc.run(mpc.output(red(mpc.mul, x))), 40320) self.assertEqual(mpc.run(mpc.output(red(mpc.max, x))), 8) self.assertEqual(mpc.run(mpc.output(red(mpc.min, x, secint(0)))), 0) self.assertEqual(mpc.run(mpc.output(red(mpc.max, x, secint(10)))), 10) self.assertEqual(mpc.run(mpc.output(red(mpc.vector_add, y))), [36] * 2) self.assertEqual(mpc.run(mpc.output(red(mpc.schur_prod, y))), [40320] * 2) self.assertEqual(mpc.run(mpc.output(red(mpc.matrix_add, z)[0])), [36] * 2) self.assertEqual(mpc.run(mpc.output(red(mpc.matrix_prod, z)[1])), [5160960] * 2)
def calculate_se(label): # square error #print("label:", label) new_list = label.values.tolist() #print("new list:", new_list) if len(new_list) > 0: mean_value = mean(new_list) #mean = label.mean() se = secnum(0) #for y in label: #se += (y - mean) * (y - mean) for ele in new_list: tmp = mpc.sub(ele, mean_value) tmp = mpc.mul(tmp, tmp) se = mpc.add(se, tmp) return mpc.run(mpc.output(se)) # should return cipher, deal it lator; else: return 0
def Perform_simple_lab_elections_1(self, election, special_input=None, regular_input_method=None, random_gen=None): if random_gen == None: random_gen = random.randint if regular_input_method == None: regular_input_method = self.Make_random_ballot #___Ballot Casting & (Sending & Tailler precompututaiton Phase___) (1, 2, (3, 4) steps): voters_i = 0 if special_input: for input_method, number in special_input.items(): for j in range(number): if voters_i >= len(election.voters): break election.voters[voters_i].take_part_in_elections( election, input_method, random_gen) voters_i += 1 while voters_i < len(election.voters): election.voters[voters_i].take_part_in_elections( election, regular_input_method, random_gen) voters_i += 1 #___MPC step ((3,4), 5 steps) : result = mpc.run(self._main_MPC(election)) print(result) #___Publishing Phase___ (6 step): if result == "illegal ballot by voter": return for win_indicator, candidate_index in zip(result, range(len(Candidates))): if win_indicator: for candidate in Candidates: if candidate.order_in_ballot == candidate_index: print( f'{candidate.name} is won elections №{election.uid}' )
def main(): data = pd.read_csv(DATA_PATH) mpc.run(mpc.start()) n = len(mpc.parties) s = [secint(x) for x in range(1, 11)] samples = [] for j in range(20): #s = [secint(x) for x in range(1, n + 1)] print("Iteration: %d, Sample %d" % (n, j)) start = time.time() mpc.run(mpc.output(many_secure_mul(s, 100))) end = time.time() samples.append(end - start) mpc.run(mpc.shutdown()) avg = np.average(samples) data.loc[data.shape[0]] = [n, avg] data.to_csv(DATA_PATH, index=False) return 0
Run with m parties to compute: - m = sum_{i=0}^{m-1} 1 = sum(1 for i in range(m)) - m**2 = sum_{i=0}^{m-1} 2i+1 = sum(2*i+1 for i in range(m)) - 2**m = prod_{i=0}^{m-1} 2 = prod(2 for i in range(m)) - m! = prod_{i=0}^{m-1} i+1 = prod(i+1 for i in range(m)) Bit lengths of secure integers ensure each result fits for any m >= 1. """ from mpyc.runtime import mpc m = len(mpc.parties) l = m.bit_length() mpc.run(mpc.start()) print('m =', mpc.run(mpc.output(mpc.sum(mpc.input(mpc.SecInt(l + 1)(1)))))) print( 'm**2 =', mpc.run( mpc.output(mpc.sum(mpc.input(mpc.SecInt(2 * l + 1)(2 * mpc.pid + 1)))))) print('2**m =', mpc.run(mpc.output(mpc.prod(mpc.input(mpc.SecInt(m + 2)(2)))))) print( 'm! =', mpc.run( mpc.output( mpc.prod(mpc.input( mpc.SecInt(int(m * (l - 1.4) + 3))(mpc.pid + 1)))))) mpc.run(mpc.shutdown())
index += 1 # solve A w = B w_det = linear_solve(A, B) w_det = await mpc.output(w_det) w_det = list(map(int, w_det)) w = np.reshape(w_det[:-1], (d, e)) w /= w_det[-1] timeEnd = time.process_time() logging.info(f'Total time {timeEnd - timeStart} = ' f'A and B in {timeMiddle - timeStart} + ' f'A^-1 B in {timeEnd - timeMiddle} seconds') error_train_mpyc = rmse(Y1, np.dot(X1, w[:-1]) + w[-1]) error_test_mpyc = rmse(Y2, np.dot(X2, w[:-1]) + w[-1]) print(f'MPyC train error: {error_train_mpyc}') print(f'MPyC test error: {error_test_mpyc}') print( f'relative train error: {(error_train_mpyc - error_train_skit) / error_train_skit}' ) print( f'relative test error: {(error_test_mpyc - error_test_skit) / error_test_skit}' ) await mpc.shutdown() if __name__ == '__main__': mpc.run(main())
to run the demo with m=3 parties on localhost. When run with m parties, a total of m(m-1)/2 TCP connections will be created between all parties, noting that TCP connections are full-duplex (bidirectional). So there are no connections when run with m=1 party only, there is one connection for m=2 parties, and there are three connections for m=3 parties. With all m parties running on localhost, your OS may run out of available ports for large m, and the program will therefore not terminate properly. For example, the default range for dynamic (private) ports on Windows is 49152-65535, which will take you to around m=180 parties, before exhausting the available ports. The range for dynamic ports can be increased like this, requiring administrator privileges: netsh int ipv4 set dynamicport tcp start=16000 num=48000 Now run the demo (as a nice stress test) with m=300, for a total of 44850 TCP connections: python helloworld.py -M300 -T0 It it essential to use threshold t=0 (or, maybe t=1). Otherwise the time needed to set up the PRSS keys, which is proportional to (m choose t) = m!/t!/(m-t)!, will be prohibitive. """ from mpyc.runtime import mpc mpc.run(mpc.start()) # connect to all other parties print(''.join(mpc.run(mpc.transfer('Hello world!')))) mpc.run(mpc.shutdown() ) # disconnect, but only once all other parties reached this point
# computes a database join function (sums by category) # this code is written as a script, so we call mpc.run() on each individual mpc operation instead of # calling it once on the whole operation as in mult3, innerprod # # this code was contributed by Berry Schoenmakers via private correspondence # from mpyc.runtime import mpc from mpyc.seclists import seclist secint = mpc.SecInt() N = 25 # number of samples C = 4 # number of categories # deterministic input data # (no mpc.input to assign different inputs to different parties) categories = [(secint(i), secint(i % C)) for i in range(N)] values = [(secint(i), secint(i)) for i in range(N)] mpc.run(mpc.start()) s = seclist([0] * C, secint) for i, c in categories: for j, v in values: s[c] += mpc.if_else(i == j, v, 0) print(mpc.run(mpc.output(list(s)))) mpc.run(mpc.shutdown())
def setUpClass(cls): mpc.logging(False) mpc.run(mpc.start())
def test_pickle(self): xsecfld = mpc.SecFld(256) psecfld = mpc.SecFld(257) secint = mpc.SecInt() secfxp = mpc.SecFxp() secflt = mpc.SecFlt() # NB: mpc.transfer() calls pickle.dumps() and pickle.loads() self.assertEqual( mpc.run(mpc.output(mpc.run(mpc.transfer(xsecfld(12), senders=0)))), 12) self.assertEqual( mpc.run(mpc.output(mpc.run(mpc.transfer(psecfld(12), senders=0)))), 12) self.assertEqual( mpc.run(mpc.output(mpc.run(mpc.transfer(secint(12), senders=0)))), 12) self.assertEqual( mpc.run(mpc.output(mpc.run(mpc.transfer(secfxp(12.5), senders=0)))), 12.5) self.assertEqual( mpc.run(mpc.output(mpc.run(mpc.transfer(secflt(12.5), senders=0)))), 12.5) self.assertEqual(mpc.run(mpc.transfer(xsecfld.field(12), senders=0)), 12) self.assertEqual(mpc.run(mpc.transfer(psecfld.field(12), senders=0)), 12) self.assertEqual(mpc.run(mpc.transfer(secint.field(12), senders=0)), 12) self.assertEqual(mpc.run(mpc.transfer(secfxp.field(13), senders=0)), 13) self.assertEqual(mpc.run(mpc.transfer(xsecfld.field.modulus, 0)), xsecfld.field.modulus) x = [(xsecfld(12), psecfld(12), secint(12), secfxp(12.5), secflt(12.5)), [ xsecfld.field(12), psecfld.field(12), secint.field(12), secfxp.field(13) ], xsecfld.field.modulus] y = mpc.run(mpc.transfer(x, senders=0)) self.assertTrue( all(mpc.run(mpc.output(a == b)) for a, b in zip(y[0], x[0]))) self.assertEqual(y[1], x[1]) self.assertEqual(y[2], x[2])
def test_misc(self): secint = mpc.SecInt() secfxp = mpc.SecFxp() secfld = mpc.SecFld() for secnum in (secint, secfxp, secfld): self.assertEqual(type(mpc.run(mpc.output(secnum(0), raw=True))), secnum.field) self.assertEqual(mpc.run(mpc.output(mpc._reshare([secnum(0)]))), [0]) self.assertEqual( mpc.run(mpc.output(mpc.all(secnum(1) for _ in range(5)))), True) self.assertEqual( mpc.run(mpc.output(mpc.all([secnum(1), secnum(1), secnum(0)]))), False) self.assertEqual( mpc.run(mpc.output(mpc.any(secnum(0) for _ in range(5)))), False) self.assertEqual( mpc.run(mpc.output(mpc.any([secnum(0), secnum(1), secnum(1)]))), True) self.assertEqual( mpc.run(mpc.output(mpc.sum([secnum(1)], start=1))), 2) self.assertEqual( mpc.run(mpc.output(mpc.prod([secnum(1)], start=1))), 1) self.assertEqual( mpc.run(mpc.output(mpc.sum([secnum(1)], start=secnum(1)))), 2) self.assertEqual( mpc.run(mpc.output(mpc.find([secnum(1)], 0, e=-1))), -1) self.assertEqual(mpc.run(mpc.output(mpc.find([secnum(1)], 1))), 0) self.assertEqual( mpc.run(mpc.output(mpc.find([secnum(1)], 1, f=lambda i: i))), 0) self.assertEqual( mpc.run(mpc.output(mpc.min(secint(i) for i in range(-1, 2, 1)))), -1) self.assertEqual( mpc.run( mpc.output(mpc.argmin(secint(i) for i in range(-1, 2, 1))[0])), 0) self.assertEqual( mpc.run(mpc.output(mpc.max(secfxp(i) for i in range(-1, 2, 1)))), 1) self.assertEqual( mpc.run( mpc.output(mpc.argmax(secfxp(i) for i in range(-1, 2, 1))[0])), 2) self.assertEqual( mpc.run(mpc.output(list(mpc.min_max(map(secfxp, range(5)))))), [0, 4]) x = (secint(i) for i in range(-3, 3)) s = [0, -1, 1, -2, 2, -3] self.assertEqual( mpc.run(mpc.output(mpc.sorted(x, key=lambda a: a * (2 * a + 1)))), s) x = (secfxp(i) for i in range(5)) self.assertEqual(mpc.run(mpc.output(mpc.sorted(x, reverse=True))), [4, 3, 2, 1, 0]) self.assertEqual(mpc.run(mpc.output(mpc.sum(map(secint, range(5))))), 10) self.assertEqual( mpc.run(mpc.output(mpc.sum([secfxp(2.75)], start=3.125))), 5.875) self.assertEqual( int(mpc.run(mpc.output(mpc.prod(map(secfxp, range(1, 5)))))), 24) self.assertEqual( int(mpc.run(mpc.output(mpc.prod([secfxp(1.414214)] * 4)))), 4) self.assertEqual(mpc.find([], 0), 0) self.assertEqual(mpc.find([], 0, e=None), (1, 0)) self.assertEqual( mpc.run(mpc.output(list(mpc.find([secfld(1)], 1, e=None)))), [0, 0]) self.assertEqual( mpc.run(mpc.output(mpc.find([secfld(2)], 2, bits=False))), 0) x = [secint(i) for i in range(5)] f = lambda i: [i**2, 3**i] self.assertEqual(mpc.run(mpc.output(mpc.find(x, 2, bits=False, f=f))), [4, 9]) cs_f = lambda b, i: [b * (2 * i + 1) + i**2, (b * 2 + 1) * 3**i] self.assertEqual( mpc.run(mpc.output(mpc.find(x, 2, bits=False, cs_f=cs_f))), [4, 9])
def test_if_else(self): secfld = mpc.SecFld() a = secfld(0) b = secfld(1) c = secfld(1) self.assertEqual(mpc.run(mpc.output(mpc.if_else(c, a, b))), 0) self.assertEqual(mpc.run(mpc.output(mpc.if_else(1 - c, a, b))), 1) self.assertEqual(mpc.run(mpc.output(mpc.if_else(c, [a, b], [b, a]))), [0, 1]) self.assertEqual( mpc.run(mpc.output(mpc.if_else(1 - c, [a, b], [b, a]))), [1, 0]) secint = mpc.SecInt() a = secint(-1) b = secint(1) c = secint(1) self.assertEqual(mpc.run(mpc.output(mpc.if_else(c, a, b))), -1) self.assertEqual(mpc.run(mpc.output(mpc.if_else(1 - c, a, b))), 1) self.assertEqual(mpc.run(mpc.output(mpc.if_else(c, [a, b], [b, a]))), [-1, 1]) self.assertEqual( mpc.run(mpc.output(mpc.if_else(1 - c, [a, b], [b, a]))), [1, -1]) secfxp = mpc.SecFxp() a = secfxp(-1.0) b = secfxp(1.0) c = secfxp(1) self.assertEqual(mpc.run(mpc.output(mpc.if_else(c, a, b))), -1.0) self.assertEqual(mpc.run(mpc.output(mpc.if_else(1 - c, a, b))), 1.0) self.assertEqual(mpc.run(mpc.output(mpc.if_else(c, 0.0, 1.0))), 0.0) self.assertEqual(mpc.run(mpc.output(mpc.if_else(1 - c, 0.0, 1.0))), 1.0)
def test_secflt(self): secflt = mpc.SecFlt() a = secflt(1.25) b = secflt(2.5) self.assertEqual(mpc.run(mpc.output(mpc.input(a, 0))), 1.25) self.assertEqual(mpc.run(mpc.output(a + b)), 3.75) self.assertEqual(mpc.run(mpc.output(-a + -b)), -3.75) self.assertEqual(mpc.run(mpc.output(a * 2**10 + 2**10 * b)), 3.75 * 2**10) self.assertEqual(mpc.run(mpc.output(-b + b)), 0) self.assertEqual(mpc.run(mpc.output(abs(1.25 - +b))), 1.25) self.assertEqual(mpc.run(mpc.output(a * b)), 1.25 * 2.5) self.assertAlmostEqual(mpc.run(mpc.output(a / b)), 0.5, delta=2**-21) self.assertTrue(mpc.run(mpc.output(a < b))) self.assertTrue(mpc.run(mpc.output(a <= b))) self.assertFalse(mpc.run(mpc.output(a == b))) self.assertFalse(mpc.run(mpc.output(a >= b))) self.assertFalse(mpc.run(mpc.output(a > b))) self.assertTrue(mpc.run(mpc.output(a != b))) self.assertFalse(mpc.run(mpc.eq_public(a, b))) self.assertTrue(mpc.run(mpc.eq_public(a, a))) phi = secflt((math.sqrt(5) + 1) / 2) self.assertAlmostEqual(mpc.run(mpc.output(phi**2 - phi - 1)), 0, delta=2**-21) @mpc.coroutine async def nop(a) -> secflt: return a self.assertEqual(mpc.run(mpc.output(nop(a))), 1.25)