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)
