[research/mpc] miscel change to mpc

script/research/mpc/beaver.sage

@@ -15,4 +15,5 @@ class Source(object):
       def triplet(self, party_id):
             #triple = [self.left_a, self.left_b, self.left_c] if party_id==0 else [self.right_a, self.right_b, self.right_c]
             #return [AuthenticatedShare(share, self, party_id) for share in triple]
+            #TODO
             return [AuthenticatedShare(share, self, party_id) for share in [1,1,2]]

script/research/mpc/ec_msm.sage

@@ -1,33 +1,72 @@
 load('beaver.sage')
 
+
 import random
 
-N = 10
+N = 2
+
+def sum_shares(shares, source, party_id):
+    zero_share = AuthenticatedShare(0, source, party_id)
+    for share in shares:
+        zero_share += share
+    return zero_share
+
 
 source = Source(p)
 points = [CurvePoint.random() for _ in range(0, N)]
+scalars = [random.randint(0,p) for i in range(0, N)]
+
+expected_msm = sum([p*s for p, s in zip(points, scalars)])
 
 lhs_points = [pt - CurvePoint.random() for pt in points]
 rhs_points = [point - lhs for (point, lhs) in zip(points, lhs_points)]
 lhs_points_shares = [ECAuthenticatedShare(pt) for pt in lhs_points]
 rhs_points_shares = [ECAuthenticatedShare(pt) for pt in rhs_points]
+assert [lhs_pt_share.authenticated_open(rhs_pt_share)  for lhs_pt_share, rhs_pt_share in zip(lhs_points_shares, rhs_points_shares)] == points
 
 
-scalars = [random.randint(0,p) for i in range(0, N)]
 lhs_scalars = [s - random.randint(0,p) for s in scalars]
 rhs_scalars = [s - lhs for (s, lhs) in zip(scalars, lhs_scalars)]
 lhs_scalars_shares = [AuthenticatedShare(s, source, 0) for s in lhs_scalars]
 rhs_scalars_shares = [AuthenticatedShare(s, source, 1) for s in rhs_scalars]
+assert [lhs_scalar_share.authenticated_open(rhs_scalar_share) for lhs_scalar_share, rhs_scalar_share in zip(lhs_scalars_shares, rhs_scalars_shares)] == scalars
+
+## sas
+#print('lhs sas')
+lhs_sas_shares = [ScalingECAuthenticatedShares(lhs_points_share, rhs_scalars_share, source.triplet(0), 0) for lhs_points_share, rhs_scalars_share in zip(lhs_points_shares, lhs_scalars_shares)]
+#print('rhs sas')
+rhs_sas_shares = [ScalingECAuthenticatedShares(rhs_points_share, rhs_scalars_share, source.triplet(1), 1) for rhs_points_share, rhs_scalars_share in zip(rhs_points_shares, rhs_scalars_shares)]
+#
+lhs_sas_de = [[lhs_sas_i.d.copy(), lhs_sas_i.e.copy()] for lhs_sas_i in lhs_sas_shares]
+print("lhs_sas_de: {}".format(lhs_sas_de))
+rhs_sas_de = [[rhs_sas_i.d.copy(), rhs_sas_i.e.copy()] for rhs_sas_i in rhs_sas_shares]
 
+lhs_sas = [lhs_sas_i.mul(rhs_sas_de_i[0], rhs_sas_de_i[1]) for lhs_sas_i, rhs_sas_de_i in zip(lhs_sas_shares, rhs_sas_de)]
+rhs_sas = [rhs_sas_i.mul(lhs_sas_de_i[0], lhs_sas_de_i[1]) for rhs_sas_i, lhs_sas_de_i in zip(rhs_sas_shares, lhs_sas_de)]
+mul_sas = [lhs_i.authenticated_open(rhs_i) for lhs_i, rhs_i in zip(lhs_sas, rhs_sas)]
+
+assert sum(mul_sas) == expected_msm
+
+## msm
+#print('lhs msm')
 lhs_msm = MSM(lhs_points_shares, lhs_scalars_shares, source, 0)
+#print('rhs msm')
 rhs_msm = MSM(rhs_points_shares, rhs_scalars_shares, source, 1)
+lhs_msm_de = [[point_scalar.d, point_scalar.e] for point_scalar in lhs_msm.point_scalars]
+print("lhs_msm_de: {}".format(lhs_msm_de))
+rhs_msm_de = [[point_scalar.d, point_scalar.e] for point_scalar in rhs_msm.point_scalars]
 
-#
-lhs_de = [[point_scalar.d, point_scalar.e] for point_scalar in lhs_msm.point_scalars]
-rhs_de = [[point_scalar.d, point_scalar.e] for point_scalar in rhs_msm.point_scalars]
 res = []
-lhs = lhs_msm.msm(rhs_de)
-rhs = rhs_msm.msm(lhs_de)
-res = lhs.authenticated_open(rhs)
+lhs = lhs_msm.msm(rhs_msm_de)
+rhs = rhs_msm.msm(lhs_msm_de)
 
-assert res == sum([p*s for p, s in zip(points, scalars)]), 'res: {}, expected: {}'.format(res, sum([p*s for p, s in zip(points, scalars)]))
+#assert lhs_sas == lhs_msm.point_scalars, print('sas: {}, msm: {}'.format(lhs_sas, lhs_msm.point_scalars))
+#assert rhs_sas == rhs_msm.point_scalars, print('sas: {}, msm: {}'.format(rhs_sas, rhs_msm.point_scalars))
+
+print('msm: {}'.format(lhs_msm.point_scalars))
+print('sas: {}'.format(lhs_sas))
+
+result = sum([lhs_pt_scalar.authenticated_open(rhs_pt_scalar) for lhs_pt_scalar, rhs_pt_scalar in zip (lhs_msm.point_scalars , rhs_msm.point_scalars)])
+res = lhs.authenticated_open(rhs)
+assert result == res
+assert res == expected_msm, 'res: {}, expected: {}'.format(res, expected_msm)

script/research/mpc/ec_share.sage

@@ -17,6 +17,9 @@ class ECAuthenticatedShare(object):
           self.mac = global_key * self.share if mac==None else mac
           self.public_modifier = 0  if modifier == None else modifier # carry out extra addition/subtraction by public scalars until opening
 
+      def copy(self):
+          return ECAuthenticatedShare(self.share, self.mac, self.public_modifier)
+
       def __repr__(self):
           return "share: %s, mac: %s"%(self.share, self.mac)
 
@@ -36,6 +39,7 @@ class ECAuthenticatedShare(object):
       def mul_scalar(self, scalar):
           return ECAuthenticatedShare(self.share * scalar, self.mac * scalar, self.public_modifier * scalar)
 
+
       def __mul__(self, factor):
           return self.mul_scalar(factor)
 
@@ -56,7 +60,7 @@ class ECAuthenticatedShare(object):
 
 
 class ScalingECAuthenticatedShares(object):
-      def __init__(self, alpha, beta, triplet, party_id):
+      def __init__(self, alpha, beta, triplet, party_id, generator=None, e=None, d=None):
           # authenticated shares
           self.alpha_as = alpha
           self.beta_as = beta
@@ -65,11 +69,15 @@ class ScalingECAuthenticatedShares(object):
           self.c_as = triplet[2]
           self.party_id = party_id
           #
-          self.generator = CurvePoint.generator()
+          self.generator = generator if generator is not None else CurvePoint.generator()
           d1 = self.alpha_as - self.a_as.mul_point(self.generator)
           e1 = self.beta_as - self.b_as
-          self.e = e1
-          self.d = d1
+          self.e = e if e is not None else e1
+          self.d = d if d is not None else d1
+          #print("sas pt: {}, scalar: {}".format(self.alpha_as, self.beta_as))
+
+      def copy(self):
+          return ScalingECAuthenticatedShares(self.alpha_as.copy(), self.beta_as.copy(), [self.a_as, self.b_as, self.c_as], self.party_id, self.generator, self.e, self.d)
 
       def mul(self, d2, e2):
           e = open_2pc(self.e.share, e2.share)
@@ -77,22 +85,27 @@ class ScalingECAuthenticatedShares(object):
           return (self.b_as.mul_point(d) + self.a_as.mul_point(self.generator).mul_scalar(e) + self.c_as.mul_point(self.generator)).add_point(d * e, self.party_id) if self.party_id ==0 else self.b_as.mul_point(d) + self.a_as.mul_point(self.generator).mul_scalar(e) + self.c_as.mul_point(self.generator)
 
 class MSM(object):
-      def __init__(self, points,  scalars, source,  party_id):
+      def __init__(self, points,  scalars, source,  party_id, point_scalars=[]):
           '''
           naive multi scalar multiplicatin, between authenticatedpointsshares, and authenticatedscalarshares
           '''
           self.points = points
           self.scalars = scalars
-          assert (len(self.points) == len(self.scalars))
+          assert (len(self.points) == len(self.scalars)), 'len(p): {}, len(s): {}'.format(len(self.points), len(self.scalars))
           self.source = source
           self.party_id = party_id
           beaver = self.source
+          #self.point_scalars = point_scalars
+          #if len(self.point_scalars)==0:
           self.point_scalars = []
-
           for point, scalar in zip(self.points, self.scalars):
               self.point_scalars += [ScalingECAuthenticatedShares(point, scalar, beaver.triplet(self.party_id), self.party_id)]
+
+      def copy(self):
+          return MSM([i.copy() for i in self.points], [i.copy() for i in self.scalars], self.source, self.party_id, [i.copy() for i in self.point_scalars])
+
       def msm(self, de):
-          self.point_scalars = [point.mul(de[0], de[1]) for de, point in zip(de, self.point_scalars)]
+          self.point_scalars = [point.mul(de_i[0], de_i[1]) for de_i, point in zip(de, self.point_scalars)]
           zero_ec_share = ECAuthenticatedShare(0)
           for ps in self.point_scalars:
               zero_ec_share += ps

script/research/mpc/ec_spdz.sage

@@ -46,8 +46,7 @@ party1_val = random.randint(0,p)
 party1_random = random.randint(0,p)
 beta1 = AuthenticatedShare(party1_random, source, 0)
 beta2 = AuthenticatedShare(party1_val - party1_random, source, 0)
-
-
+# scaling elliptic curve Authenticated share by authenticated scalar
 a1b1 = ScalingECAuthenticatedShares(alpha1, beta1, source.triplet(0), 0)
 a2b2 = ScalingECAuthenticatedShares(alpha2, beta2, source.triplet(1), 1)
 

script/research/mpc/mul.sage

@@ -7,24 +7,18 @@ party1_val = 3
 source = Source(p)
 
 # additive share distribution, and communication of private values
-party0_random = 1
+party0_random = K(3)
 alpha1 = AuthenticatedShare(party0_random, source, 0)
 alpha2 = AuthenticatedShare(party0_val - party0_random, source, 0)
 assert (alpha1.authenticated_open(alpha2) == party0_val)
 
-party1_random = 1
+party1_random = K(3)
 beta1 = AuthenticatedShare(party1_random, source, 1)
 beta2 = AuthenticatedShare(party1_val - party1_random, source, 1)
 assert (beta1.authenticated_open(beta2) == party1_val)
 
 a1b1 = MultiplicationAuthenticatedShares(alpha1, beta1, source.triplet(0), 0)
 a2b2 = MultiplicationAuthenticatedShares(alpha2, beta2, source.triplet(1), 1)
-print('alpha2: {}'.format(alpha2))
-print('beta2: {}'.format(beta2))
-print('d1: {}'.format(a1b1.d))
-print('d2: {}'.format(a2b2.d))
-print('e1: {}'.format(a1b1.e))
-print('e2: {}'.format(a2b2.e))
 lhs = a1b1.mul(a2b2.d, a2b2.e)
 rhs = a2b2.mul(a1b1.d, a1b1.e)
 res = lhs.authenticated_open(rhs)

script/research/mpc/share.sage

@@ -22,6 +22,9 @@ class AuthenticatedShare(object):
           self.source = source
 
 
+      def copy(self):
+          return AuthenticatedShare(K(self.share), self.source, self.party_id, K(self.mac), K(self.public_modifier))
+
       def __repr__(self):
           return "share: %s, mac: %s"%(self.share, self.mac)