[research/mpc] fix scalar_share multiplication

script/research/mpc/mul.sage

@@ -0,0 +1,32 @@
+load('share.sage')
+load('beaver.sage')
+import random
+
+party0_val = 2
+party1_val = 3
+source = Source(p)
+
+# additive share distribution, and communication of private values
+party0_random = 1
+alpha1 = AuthenticatedShare(party0_random, source, 0)
+alpha2 = AuthenticatedShare(party0_val - party0_random, source, 0)
+assert (alpha1.authenticated_open(alpha2) == party0_val)
+
+party1_random = 1
+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)
+
+assert (res == party0_val*party1_val), 'mul: {}, expected mul: {}'.format(res, party0_val*party1_val)

script/research/mpc/share.sage

@@ -1,3 +1,5 @@
+import random
+load('../mpc/curve.sage')
 load('../mpc/ec_share.sage')
 
 def open_2pc(party0_share, party1_share):
@@ -12,10 +14,13 @@ class AuthenticatedShare(object):
       """
       additive share
       """
-      def __init__(self, share, mac=None, modifier=None):
+      def __init__(self, share, source, party_id, mac=None, modifier=None):
           self.share = share
           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
+          self.party_id = party_id
+          self.source = source
+
 
       def __repr__(self):
           return "share: %s, mac: %s"%(self.share, self.mac)
@@ -56,7 +61,7 @@ class AuthenticatedShare(object):
           '''
           return AuthenticatedShare(self.share - rhs.share, self.mac - rhs.mac, self.public_modifier - rhs.public_modifier)
 
-
+'''
 class MultiplicationAuthenticatedShares(object):
       def __init__(self, alpha, beta, triplet, party_id):
           # authenticated shares
@@ -77,3 +82,35 @@ class MultiplicationAuthenticatedShares(object):
           e = open_2pc(masked_e_share.share, peer_masked_e_share.share)
 
           return (self.b_as.mul_scalar(d) + self.a_as.mul_scalar(e) + self.c_as).add_scalar(d*e, self.party_id)
+'''
+
+class MultiplicationAuthenticatedShares(object):
+      def __init__(self, alpha, beta, triplet, party_id):
+          # authenticated shares
+          self.alpha_as = alpha
+          self.beta_as = beta
+          self.a_as = triplet[0]
+          self.b_as = triplet[1]
+          self.c_as = triplet[2]
+          self.party_id = party_id
+
+          d1 = self.alpha_as - self.a_as
+          e1 = self.beta_as - self.b_as
+          print('[{}] beta: {}, b: {}'.format(self.party_id, self.beta_as, self.b_as))
+          print('[{}] e: {}'.format(self.party_id, e1))
+          self.d = d1
+          self.e = e1
+
+
+      def mul(self, d2, e2):
+          d = open_2pc(self.d.share, d2.share)
+          e = open_2pc(self.e.share, e2.share)
+          if self.party_id==0:
+              bd = self.b_as.mul_scalar(d)
+              ae = self.a_as.mul_scalar(e)
+              return (bd + ae + self.c_as).add_scalar(d*e, self.party_id)
+          else:
+              bd = self.b_as.mul_scalar(d)
+              ae = self.a_as.mul_scalar(e)
+              #return (bd + ae + self.c_as).add_scalar(d*e, self.party_id)
+              return  bd + ae + self.c_as

script/research/mpc/spdz.sage

@@ -1,21 +1,22 @@
+load('share.sage')
 load('beaver.sage')
 from random import randint
 
-p = 10
 
 party0_val = 3
 party1_val = 22
 public_scalar = 2
+source = Source(p)
 
 # additive share distribution, and communication of private values
 party0_random = randint(0,p)
-alpha1 = AuthenticatedShare(party0_random)
-alpha2 = AuthenticatedShare(party0_val - party0_random)
+alpha1 = AuthenticatedShare(party0_random, source, 0)
+alpha2 = AuthenticatedShare(party0_val - party0_random, source, 1)
 assert (alpha1.authenticated_open(alpha2) == party0_val)
 
 party1_random = randint(0,p)
-beta1 = AuthenticatedShare(party1_random)
-beta2 = AuthenticatedShare(party1_val - party1_random)
+beta1 = AuthenticatedShare(party1_random, source, 1)
+beta2 = AuthenticatedShare(party1_val - party1_random, source, 1)
 assert (beta1.authenticated_open(beta2) == party1_val)
 
 # mul_scalar by public scalar
@@ -61,11 +62,12 @@ assert (lhs == (party0_val - party1_val))
 mul_res = party0_val * party1_val
 
 s = Source(p)
-alpha1beta1_share = MultiplicationAuthenticatedShares(alpha1, beta1, s.triplet(0), 0)
-alpha2beta2_share = MultiplicationAuthenticatedShares(alpha2, beta2, s.triplet(1), 1)
-
-lhs_share = alpha1beta1_share*alpha2beta2_share
-rhs_share = alpha2beta2_share*alpha1beta1_share
+a1b1 = MultiplicationAuthenticatedShares(alpha1, beta1, s.triplet(0), 0)
+a2b2 = MultiplicationAuthenticatedShares(alpha2, beta2, s.triplet(1), 1)
+print('d1: {}'.format(a1b1.d))
+print('d2: {}'.format(a2b2.d))
+lhs_share = a1b1.mul(a2b2.d, a2b2.e)
+rhs_share = a2b2.mul(a1b1.d, a1b1.e)
 lhs = lhs_share.authenticated_open(rhs_share)
 
 assert (lhs == (party0_val * party1_val)), 'lhs: {}, rhs: {}'.format(lhs, party0_val * party1_val)