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 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()
async def main():
if sys.argv[1:]:
n = int(sys.argv[1])
else:
n = 5
print('Setting input to default =', n)
s = [(-1)**i * (i + n//2)**2 for i in range(n)]
secnum = mpc.SecInt()
print('Using secure integers:', secnum)
x = list(map(secnum, s))
async with mpc:
mpc.random.shuffle(secnum, x) # secret in-place random shuffle
print('Randomly shuffled input:', await mpc.output(x))
x = mpc.sorted(x, key=lambda a: a**2) # sort on absolute value
print('Sorted by absolute value:', await mpc.output(x))
secnum = mpc.SecFxp()
print('Using secure fixed-point numbers:', secnum)
x = list(map(secnum, s))
async with mpc:
mpc.random.shuffle(secnum, x) # secret in-place random shuffle
print('Randomly shuffled input:', await mpc.output(x))
x = mpc.seclist(x)
x.sort(reverse=True) # in-place sort in descending order
print('Sorted by descending value:', await mpc.output(list(x)))
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)))
self.assertEqual(mpc.run(mpc.output(quantiles(x[:2], n=3))),
statistics.quantiles(y[:2], n=3))
self.assertEqual(mpc.run(mpc.output(quantiles(x, n=1))), statistics.quantiles(y, n=1))
self.assertEqual(mpc.run(mpc.output(quantiles(x))), statistics.quantiles(y))
x = list(range(16))
y = list(reversed(x))
self.assertAlmostEqual(covariance(x, y), -22.667, 3)
x = list(map(secint, x))
y = list(map(secint, y))
self.assertEqual(mpc.run(mpc.output(covariance(x, y))), -23)
self.assertRaises(ValueError, quantiles, x, method='wrong')
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_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.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)
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)))
async def main():
# initialize mpc, define secure int type
await mpc.start()
secint = mpc.SecInt(64)
# initialize inputs
# 3 parties: random value for each party
# any other number of parties: just use player 0's value 3 times.
value = np.random.randint(1,10000)
print("player {} input: {}".format(mpc.pid, value))
n = len(mpc.parties)
if n != 3:
inputs = [secint(value), secint(value), secint(value)]
print("expected: {}".format(value ** 3))
else:
inputs = mpc.input(secint(value), senders=[0,1,2])
# compute product
prod = mpc.prod(inputs)
# output result
result = await mpc.output(prod)
print("result:", result)
await mpc.shutdown()
async def main():
# initialize mpc, define secure int type
LEN = 100000
await mpc.start()
secint = mpc.SecInt(128)
# party 0 samples the inputs locally...
if mpc.pid == 0:
vec1 = [np.random.randint(1, 1000) for _ in range(LEN)]
vec2 = [np.random.randint(1, 1000) for _ in range(LEN)]
# ...and secret-shares them with the others
result_type = [secint()] * LEN
sec_vec1 = mpc.input([secint(v)
for v in vec1] if mpc.pid == 0 else result_type,
senders=0)
sec_vec2 = mpc.input([secint(v)
for v in vec2] if mpc.pid == 0 else result_type,
senders=0)
# compute inner product
ip = mpc.in_prod(sec_vec1, sec_vec2)
# output result (to everybody)
result = await mpc.output(ip)
print("result:", result)
if mpc.pid == 0:
assert (result == np.dot(vec1, vec2))
await mpc.shutdown()
async def main():
if sys.argv[1:]:
n = int(sys.argv[1])
else:
n = 5
print('Setting input to default =', n)
s = [(-1)**i * (i + (n // 2))**2 for i in range(n)]
await mpc.start()
global secnum
secnum = mpc.SecInt()
print('Using secure integers:', secnum)
x = list(map(secnum, s))
print('Array:', await mpc.output(x))
print('Sorted array:', await mpc.output(bsort(x)))
secnum = mpc.SecFxp()
print('Using secure fixed-point numbers:', secnum)
x = list(map(secnum, s))
print('Input array:', await mpc.output(x))
print('Sorted array:', await mpc.output(bsort(x)))
await mpc.shutdown()
async def main():
if sys.argv[1:]:
N = int(sys.argv[1])
else:
N = 8
print('Setting input to default =', N)
await mpc.start()
secint = mpc.SecInt()
print('Using secure integers:', secint)
for n in range(2, N + 1):
print(n, await mpc.output(random_derangement(n, secint)))
secfxp = mpc.SecFxp()
print('Using secure fixed-point numbers:', secfxp)
for n in range(2, N + 1):
print(n, await mpc.output(random_derangement(n, secfxp)))
secpfld = mpc.SecFld(l=max(len(mpc.parties), (N - 1)).bit_length())
print('Using secure prime fields:', secpfld)
for n in range(2, N + 1):
print(n, await mpc.output(random_derangement(n, secpfld)))
secbfld = mpc.SecFld(char2=True,
l=max(len(mpc.parties), (N - 1)).bit_length())
print('Using secure binary fields:', secbfld)
for n in range(2, N + 1):
print(n, await mpc.output(random_derangement(n, secbfld)))
await mpc.shutdown()
def test_if_else_if_swap(self):
secfld = mpc.SecFld()
a = secfld(0)
b = secfld(1)
c = secfld(1)
self.assertEqual(mpc.run(mpc.output(c.if_else(a, b))), 0)
self.assertEqual(mpc.run(mpc.output(mpc.if_swap(1 - c, a, b))), [0, 1])
self.assertEqual(mpc.run(mpc.output(mpc.if_else(c, [a, b], [b, a]))),
[0, 1])
self.assertEqual(mpc.run(mpc.output((1 - c).if_swap(a, b))), [0, 1])
secint = mpc.SecInt()
a = secint(-1)
b = secint(1)
c = secint(1)
self.assertEqual(mpc.run(mpc.output(c.if_swap([a, b], [b, a])[0])),
[1, -1])
self.assertEqual(mpc.run(mpc.output(mpc.if_else(1 - c, b, b))), 1)
self.assertEqual(mpc.run(mpc.output(mpc.if_swap(c, a, b))), [1, -1])
self.assertEqual(mpc.run(mpc.output((1 - c).if_else([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(c.if_else([a, a], [b, b]))),
[-1.0, -1.0])
self.assertEqual(mpc.run(mpc.output(mpc.if_swap(1 - c, a, b))),
[-1.0, 1.0])
self.assertEqual(mpc.run(mpc.output(mpc.if_swap(c, 0.0, 1.0))),
[1.0, 0.0])
self.assertEqual(mpc.run(mpc.output((1 - c).if_else(0.0, 1.0))), 1.0)
def test_io(self):
x = ({4, 3}, [1 - 1j, 2.5], 0, range(7))
self.assertEqual(mpc.run(mpc.transfer(x))[0], x)
self.assertEqual(mpc.run(mpc.transfer(x, senders=0)), x)
self.assertEqual(mpc.run(mpc.transfer(x, senders=[0]))[0], x)
self.assertEqual(
mpc.run(mpc.transfer(x, senders=iter(range(1))))[0], x)
self.assertEqual(mpc.run(mpc.transfer(x, receivers=0))[0], x)
self.assertEqual(mpc.run(mpc.transfer(x, receivers=[0]))[0], x)
self.assertEqual(
mpc.run(mpc.transfer(x, receivers=iter(range(1))))[0], x)
self.assertEqual(mpc.run(mpc.transfer(x, senders=0, receivers=0)), x)
self.assertEqual(
mpc.run(mpc.transfer(x, senders=[0], receivers=[0]))[0], x)
self.assertEqual(
mpc.run(mpc.transfer(x, sender_receivers=[(0, 0)]))[0], x)
self.assertEqual(
mpc.run(mpc.transfer(x, sender_receivers={0: {0}}))[0], x)
a = mpc.SecInt()(7)
self.assertEqual(mpc.run(mpc.output(mpc.input(a)))[0], 7)
self.assertEqual(mpc.run(mpc.output(mpc.input(a)[0])), 7)
self.assertEqual(mpc.run(mpc.output(mpc.input(a, senders=0))), 7)
self.assertEqual(mpc.run(mpc.output(mpc.input(a, senders=[0])))[0], 7)
self.assertEqual(
mpc.run(mpc.output(mpc.input(a, senders=iter(range(1)))))[0], 7)
self.assertEqual(mpc.run(mpc.output(mpc.input(a, senders=[0])))[0], 7)
self.assertEqual(mpc.run(mpc.output(mpc.input(a, senders=[0])[0])), 7)
self.assertEqual(mpc.run(mpc.output(mpc.input(a), receivers=0))[0], 7)
self.assertEqual(mpc.run(mpc.output(mpc.input(a)[0], receivers=0)), 7)
self.assertEqual(
mpc.run(mpc.output(mpc.input(a), receivers=[0]))[0], 7)
self.assertEqual(
mpc.run(mpc.output(mpc.input(a), receivers=iter(range(1))))[0], 7)
self.assertEqual(mpc.run(mpc.output(mpc.input(a)[0], receivers=[0])),
7)
self.assertEqual(
mpc.run(mpc.output(mpc.input(a, senders=0), receivers=0)), 7)
self.assertEqual(
mpc.run(mpc.output(mpc.input(a, senders=[0]), receivers=[0]))[0],
7)
self.assertEqual(
mpc.run(mpc.output(mpc.input(a, senders=[0])[0], receivers=[0])),
7)
x = [a, a]
self.assertEqual(mpc.run(mpc.output(mpc.input(x)[0])), [7, 7])
self.assertEqual(mpc.run(mpc.output(mpc.input(x, senders=0))), [7, 7])
self.assertEqual(mpc.run(mpc.output(mpc.input(x, senders=[0])[0])),
[7, 7])
self.assertEqual(mpc.run(mpc.output(mpc.input(x)[0], receivers=0)),
[7, 7])
self.assertEqual(mpc.run(mpc.output(mpc.input(x)[0], receivers=[0])),
[7, 7])
self.assertEqual(
mpc.run(mpc.output(mpc.input(x, senders=0), receivers=0)), [7, 7])
self.assertEqual(
mpc.run(mpc.output(mpc.input(x, senders=[0])[0], receivers=[0])),
[7, 7])
def test_errors(self):
secint = mpc.SecInt()
self.assertRaises(ValueError, randrange, secint, 0)
self.assertRaises(IndexError, choice, secint, [])
self.assertRaises(TypeError, choices, secint, [], weights=[1], cum_weights=[1])
self.assertRaises(ValueError, choices, secint, [], weights=[1])
self.assertRaises(ValueError, sample, secint, [], 1)
self.assertRaises(TypeError, random, secint)
self.assertRaises(TypeError, uniform, secint, -0.5, 0.5)
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_pickle(self):
xsecfld = mpc.SecFld(256)
psecfld = mpc.SecFld(257)
secint = mpc.SecInt()
secfxp = mpc.SecFxp()
secflt = mpc.SecFlt()
seccl = mpc.SecClassGroup(-23)
a = seccl.group((2, 1))
# 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.output(mpc.run(mpc.transfer(seccl((2, 1, 3)),
senders=0)))), a)
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),
seccl((2, 1, 3))),
[
xsecfld.field(12),
psecfld.field(12),
secint.field(12),
secfxp.field(13), a
], 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_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_gcd(self):
secint = mpc.SecInt(16)
self.assertEqual(mpc.run(mpc.output(mpc.trailing_zeros(secint(0)))),
[0] * 16)
self.assertEqual(mpc.run(mpc.output(mpc.trailing_zeros(secint(7))[0])),
1)
self.assertEqual(
mpc.run(mpc.output(mpc.trailing_zeros(secint(-6))[:2])), [0, 1])
self.assertEqual(
mpc.run(mpc.output(mpc.trailing_zeros(secint(4))[:3])), [0, 0, 1])
self.assertEqual(
mpc.run(mpc.output(mpc.trailing_zeros(secint(-5664))[:6])),
[0] * 5 + [1])
self.assertEqual(mpc.run(mpc.output(mpc.gcp2(secint(0), secint(0)))),
1 << 16)
self.assertEqual(mpc.run(mpc.output(mpc.gcp2(secint(0), secint(-64)))),
64)
self.assertEqual(
mpc.run(mpc.output(mpc.gcp2(secint(5664), secint(64)))), 32)
self.assertEqual(mpc.run(mpc.output(mpc.gcp2(secint(1), secint(-64)))),
1)
self.assertEqual(mpc.run(mpc.output(mpc.gcd(secint(0), secint(0)))), 0)
self.assertEqual(
mpc.run(mpc.output(mpc.gcd(secint(0), secint(3), l=3))), 3)
self.assertEqual(mpc.run(mpc.output(mpc.gcd(secint(-33), secint(30)))),
3)
self.assertEqual(mpc.run(mpc.output(mpc.lcm(secint(0), secint(0)))), 0)
self.assertEqual(mpc.run(mpc.output(mpc.lcm(secint(-33), secint(0)))),
0)
self.assertEqual(mpc.run(mpc.output(mpc.lcm(secint(-66), secint(30)))),
330)
self.assertEqual(
mpc.run(mpc.output(mpc.lcm(secint(-120), secint(60), l=8))), 120)
self.assertEqual(
mpc.run(mpc.output(mpc.inverse(secint(10), secint(1)))), 0)
self.assertEqual(
mpc.run(mpc.output(mpc.inverse(secint(11), secint(16), l=6))), 3)
self.assertEqual(
mpc.run(mpc.output(mpc.inverse(secint(1234), secint(6789)))), 5089)
self.assertEqual(
mpc.run(mpc.output(mpc.inverse(secint(1234 + 6789),
secint(6789)))), 5089)
self.assertEqual(
mpc.run(mpc.output(list(mpc.gcdext(secint(0), secint(0))))),
[0, 0, 0])
for a, b in ((-300, -300), (2345, 2345), (60, -88), (-360, 9), (0,
256)):
g, s, t = mpc.run(
mpc.output(list(mpc.gcdext(secint(a), secint(b)))))
self.assertTrue(g == math.gcd(a, b) and g == s * a + t * b)
def prepare_list(input_bits):
# define placeholder type as int
sec_int = mpc.SecInt()
# distribute secret data
input_list = [None] * len(input_bits)
for i in range(len(input_bits)):
# each process finds its own data at the position of its id and writes it in its own secret version of the list
if mpc.pid == i:
input_list[i] = input_bits[i]
# prepare special internal list with placeholders and secret data
sec_vec_l = [None] * len(input_bits)
for i in range(len(input_bits)):
sec_vec_l[i] = mpc.input(
sec_int(input_list[i]) if mpc.pid == i else sec_int(), senders=i)
return sec_vec_l
async def main():
if sys.argv[1:]:
n = int(sys.argv[1])
else:
n = 10
print('Setting input to default =', n)
secfld = mpc.SecFld(min_order=max(len(mpc.parties) + 1, n))
secint = mpc.SecInt()
secfxp = mpc.SecFxp()
await xprint(n, mpc.unit_vector, secfld)
# NB: secret_index does not work with secfld
await xprint(n, mpc.unit_vector, secint)
await xprint(n, secret_index, secint)
await xprint(n, mpc.unit_vector, secfxp)
await xprint(n, secret_index, secfxp)
async def keygen(g):
"""Threshold ElGamal key generation."""
group = type(g)
secgrp = mpc.SecGrp(group)
n = group.order
if n is not None and is_prime(n):
secnum = mpc.SecFld(n)
else:
l = isqrt(-group.discriminant).bit_length()
secnum = mpc.SecInt(l)
while True:
x = mpc._random(secnum)
h = await secgrp.repeat_public(g, x) # g^x
if h != group.identity:
# NB: this branch will always be followed unless n is artificially small
return x, h
def test_secint(self):
secint = mpc.SecInt()
s = seclist([], secint)
self.assertEqual(s, [])
s = seclist(sectype=secint)
self.assertEqual(s, [])
s.append(False)
s.append(secint(7))
s[0] = secint(13)
self.assertEqual(mpc.run(mpc.output(list(s))),
[13, 7]) # NB: list to convert from seclist
i = [secint(0), secint(1)]
s[i] = 5
self.assertEqual(mpc.run(mpc.output(s[1])), 5)
i0 = [secint(1), secint(0)]
i1 = [secint(0), secint(1)]
s[i0], s[i1] = s[i1], s[i0]
self.assertEqual(mpc.run(mpc.output(list(s))), [5, 13])
s[i0], s[i1] = s[i1], s[i0]
self.assertEqual(mpc.run(mpc.output(list(s))), [13, 5])
s[0], s[1] = s[1], s[0]
self.assertEqual(mpc.run(mpc.output(list(s))), [5, 13])
s.append(secint(8))
s.reverse()
self.assertEqual(mpc.run(mpc.output(list(s))), [8, 13, 5])
a = s[secint(1)]
self.assertEqual(mpc.run(mpc.output(a)), 13)
s[secint(1)] = secint(21)
self.assertEqual(mpc.run(mpc.output(s[1])), 21)
s = seclist([0] * 7, secint)
for a in [secint(3)] * 3 + [secint(4)] * 4:
s[a] += 1
self.assertEqual(mpc.run(mpc.output(list(s))), [0, 0, 0, 3, 4, 0, 0])
self.assertTrue(mpc.run(mpc.output(s.__contains__(0))))
self.assertFalse(mpc.run(mpc.output(s.__contains__(9))))
self.assertEqual(mpc.run(mpc.output(s.count(0))), 5)
self.assertEqual(mpc.run(mpc.output(s.index(4))), 4)
self.assertRaises(ValueError, s.index, 9)
self.assertRaises(ValueError, seclist([], secint).index, 0)
s.sort(lambda a: -a**2, reverse=True)
self.assertEqual(mpc.run(mpc.output(list(s))), 5 * [0] + [3, 4])
def test_misc(self):
secint = mpc.SecInt()
secfxp = mpc.SecFxp()
secfld = mpc.SecFld()
for secnum in (secint, secfxp, secfld):
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.min(secint(i) for i in range(-1, 2, 1)))),
-1)
self.assertEqual(
mpc.run(mpc.output(mpc.max(secfxp(i) for i in range(-1, 2, 1)))),
1)
self.assertEqual(
mpc.run(mpc.output(list(mpc.min_max(map(secfxp, range(5)))))),
[0, 4])
self.assertEqual(mpc.run(mpc.output(mpc.sum(map(secint, range(5))))),
10)
self.assertEqual(
mpc.run(mpc.output(mpc.sum([secfxp(2.72)], start=3.14))), 5.86)
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)
async def main():
if sys.argv[1:]:
N = int(sys.argv[1])
else:
N = 8
print('Setting input to default =', N)
await mpc.start()
await xprint(N, 'integers', mpc.SecInt())
await xprint(N, 'fixed-point numbers:', mpc.SecFxp())
bound = max(len(mpc.parties) + 1, N)
await xprint(N, 'prime fields', mpc.SecFld(min_order=bound))
await xprint(N, 'binary fields', mpc.SecFld(char=2, min_order=bound))
await xprint(N, 'quinary fields', mpc.SecFld(char=5, min_order=bound))
await xprint(N, 'extension fields (medium prime)', mpc.SecFld(order=11**7))
await xprint(N, 'extension fields (larger prime)', mpc.SecFld(order=1031**3))
await mpc.shutdown()
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])
async def main():
"""
mpyc benötigt eigene sichere Datenpypen
die sicheren Datentypen werden als Platzhalter verwendet
beim Start von mpc werden die Partein sich mit einem Platzhalter verbinden und ihre geheime Information eintragen
"""
secint = mpc.SecInt()
# damit können wir ints umwandeln in die sicheren Datentypen von mpyc
input_bits = [secint(-1), secint(1), secint(1), secint(1)]
# start mpc und Verbinden der Partein durch lokale TCP- Kommunikation
await mpc.start()
erg = signumsum(input_bits)
# holen des Ergebnisses
result = await mpc.output(erg)
print("result:", result)
# schließen der TCP-Verbindungen
await mpc.shutdown()
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)
async def main():
# initialize mpc, define secure int type
LEN = 10
await mpc.start()
secint = mpc.SecInt(64)
# initialize inputs
values = [np.random.randint(1,1000) for _ in range(LEN)]
n = len(mpc.parties)
inputs = mpc.input([secint(v)for v in values], senders=list(range(n)))
# compute pairwise products
prod = inputs[0]
for inp in inputs[1:]:
prod = mpc.schur_prod(prod, inp)
ip = mpc.sum(prod)
# output result
result = await mpc.output(ip)
print("result:", result)
await mpc.shutdown()
async def main():
# Use 32-bit (default) secure integers:
secint = mpc.SecInt()
# Each party locally generates LOAD random entries of type secint:
my_entries_for_vec_x = [secint(randint(-1000, 1000)) for _ in range(LOAD)]
my_entries_for_vec_y = [secint(randint(-1000, 1000)) for _ in range(LOAD)]
# Start MPyC runtime to let all parties connect:
await mpc.start()
# The entries for vectors x and y are secret-shared between all parties:
vec_x = flatten(mpc.input(my_entries_for_vec_x))
vec_y = flatten(mpc.input(my_entries_for_vec_y))
# Secure dot products are supported natively and *very* efficiently:
c = mpc.in_prod(vec_x, vec_y)
# Open the secret-shared value c and let all parties print the result:
print('Dot product:', await mpc.output(c))
# Shutdown MPyC runtime to close all connections:
await mpc.shutdown()
async def synthesize_data(n_samples, n_features, n_targets):
rnd = int(await mpc.output(mpc.random.randrange(mpc.SecInt(), 2**31)))
X, Y = sklearn.datasets.make_regression(
n_samples=n_samples,
n_features=n_features,
n_informative=max(1, n_features - 5),
n_targets=n_targets,
bias=42,
effective_rank=max(1, n_features - 3),
tail_strength=0.5,
noise=1.2,
random_state=rnd) # all parties use same rnd
if n_targets == 1:
Y = np.transpose([Y])
X = np.concatenate((X, Y), axis=1)
b_m = np.min(X, axis=0)
b_M = np.max(X, axis=0)
coef_add = [-(m + M) / 2 for m, M in zip(b_m, b_M)]
coef_mul = [2 / (M - m) for m, M in zip(b_m, b_M)]
for xi in X:
for j in range(len(xi)):
# map to [-1,1] range
xi[j] = (xi[j] + coef_add[j]) * coef_mul[j]
return X
