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_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])
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 = 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()
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_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))
# 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 equality(cls, p, q): # return type is self.sectype
return seclist(p.share) == seclist(q.share)
def inversion(cls, p):
n = len(p.share)
q = seclist(p.share) # use p.share as dummy of the right type
for i in range(n):
q[p.share[i]] = i
return cls(tuple(q))
def operation(cls, p, q):
"""First p then q."""
q = seclist(q.share)
return cls(tuple(q[j] for j in p.share))
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])
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 = [5, 13, 8]
s.reverse() # s = [8, 13, 5]
s.insert(secint(0), 9) # s = [9, 8, 13, 5]
del s[secint(1)] # s = [9, 13, 5]
s.pop(secint(2)) # s = [9, 13]
s.insert(0, 99) # s = [99, 9, 13]
s.pop(0) # s = [9, 13]
self.assertRaises(ValueError, s.remove, secint(11))
s *= 2 # s = [9, 13, 9, 13]
s.remove(9) # s = [13, 9, 13]
s[0:1] = [] # s = [9, 13]
s = 1 * s + s * 0 # s = [9, 13]
self.assertEqual(mpc.run(mpc.output(list(s))), [9, 13])
self.assertEqual(mpc.run(mpc.output(s[secint(1)])), 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])
with self.assertRaises(NotImplementedError):
0 in s
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)
s.sort()
self.assertEqual(mpc.run(mpc.output(list(s))), 5 * [0] + [3, 4])
self.assertFalse(mpc.run(mpc.output(s < s)))
self.assertTrue(mpc.run(mpc.output(s <= s)))
self.assertTrue(mpc.run(mpc.output(s == s)))
self.assertFalse(mpc.run(mpc.output(s > s)))
self.assertTrue(mpc.run(mpc.output(s >= s)))
self.assertFalse(mpc.run(mpc.output(s != s)))
self.assertFalse(mpc.run(mpc.output(s < [])))
self.assertFalse(mpc.run(mpc.output(s <= [])))
self.assertTrue(mpc.run(mpc.output(s >= [])))
self.assertTrue(mpc.run(mpc.output(s > [])))
self.assertFalse(mpc.run(mpc.output(s < s[:-1])))
self.assertTrue(mpc.run(mpc.output(s[:-1] < s)))
self.assertTrue(mpc.run(mpc.output(s[:-1] != s)))
t = s.copy()
t[-1] += 1
self.assertTrue(mpc.run(mpc.output(s < t)))
t[1] -= 1
self.assertFalse(mpc.run(mpc.output(s < t)))
self.assertFalse(mpc.run(mpc.output(s[:-1] <= t)))
