def mult(F, a, b, t, n):
r = ss.basispoly(F, n)
h = a * b
hs = []
for i in range(n):
hs.append(ss.share(F, h[i], t, n))
s = ss.share(F, 0, t, n)
for i in range(n):
s += np.array(r[i]) * np.array(hs[i])
return np.array(s)
def randomBitsDealer(F, n, t, l):
bits = [np.random.choice([1, 0]) for i in range(l)]
bits.insert(0, 0)
r = ''
for i in bits:
r += str(i)
rshares = ss.share(F, int(r, 2), t, n)
bitshares = [ss.share(F, i, t, n) for i in bits]
res = []
for i in range(n):
temp = []
for j in range(len(bits)):
temp.append(bitshares[j][i])
res.append(temp)
return rshares, res
def triplet(F, n, t):
matA = []
matB = []
for i in range(n):
a = F.random_element()
b = F.random_element()
matA.append(ss.share(F, a, t, n))
matB.append(ss.share(F, b, t, n))
matrixA = np.array(matA)
matrixB = np.array(matB)
sharesA = np.sum(matrixA, 0)
sharesB = np.sum(matrixB, 0)
sharesC = mult(F, sharesA, sharesB, t, n)
return [[int(str(i)), int(str(j)), int(str(k))]
for i, j, k in zip(sharesA, sharesB, sharesC)]
def __init__(self, F, n, t, numTrip):
self.n = n
b = ss.share(F, np.random.choice([-1, 1]), t, n)
self.distribute_shares('b', b)
triplets = [proc.triplet(F, n, t) for i in range(numTrip)]
for i in range(n):
l = []
for j in range(numTrip):
l.append(triplets[j][i])
sock.TCPclient(party_addr[i][0], party_addr[i][1], ['triplets', l])
def distribute_shares(self, sec):
shares = ss.share(self.F, sec, self.t, self.n)
for i in range(self.n):
sock.TCPclient(self.party_addr[i][0], self.party_addr[i][1],
['input' + str(self.i),
int(str(shares[i]))])
def distribute_shares(self, name):
shares = ss.share(self.F, self.x, self.t, self.n)
s = name + str(self.name)
self.server.securecom[s] = shares
self.server.A11.append(self.x)
if self.name == '1':
self.server.A22.append(self.x)
if self.name == '2':
self.server.A33.append(self.x)
self.x = int(100 * self.x)
self.distribute_shares('x' + str(i))
##################### MAIN ################################
pp = 7979490791
F = field.GF(pp)
n = 3
t = 1
a = 3
H = [[ss.share(F, -1, t, n),
ss.share(F, 2, t, n),
ss.share(F, -1, t, n)],
[ss.share(F, 5, t, n),
ss.share(F, 7, t, n),
ss.share(F, -3, t, n)]]
b = [ss.share(F, -2, t, n), ss.share(F, -5, t, n)]
Hs = []
for j in range(n):
temp = []
for i in range(2):
temp.append([H[i][0][j], H[i][1][j], H[i][2][j]])
Hs.append(temp)
bs = []
def run(self):
n=3
m = 2 # number of A rows
nn = 2 # number of A coloums
l = 1 # number of b rows
mu=min(nn,m)
#obs, must be randomly generated in real life
L=np.array(([1,0],[11,11]))
U=np.array(([1,8],[0,1]))
A00=2
A01=3
A10=4
A11=9
b0=6
b1=15
I00= 1
I01= 0
I10= 0
I11= 1
shareh=1
sharet=1
ran=7
AA=np.array([[A00, A01],[A10, A11]])
bb= np.array([[b0],[b1]])
print(' ')
print('Input matrix A:')
print(AA)
print('Observation vector b:')
print(bb)
AB=np.hstack((AA,bb))
rankAB=np.array(matrix_rank(AB))
rankA= np.array(matrix_rank(AA))
if rankA == rankAB:
print('Preconditions satisfied: the system is solvable')
else:
print('Preconditioning fails, system not solvable')
s_A00= ss.share(self.F, A00, self.t, self.n)
s_A01= ss.share(self.F, A01, self.t, self.n)
s_A10= ss.share(self.F, A10, self.t, self.n)
s_A11= ss.share(self.F, A11, self.t, self.n)
s_b0= ss.share(self.F, b0, self.t, self.n)
s_b1= ss.share(self.F, b1, self.t, self.n)
s_h= ss.share(self.F, shareh, self.t, self.n)
s_t= ss.share(self.F, sharet, self.t, self.n)
s_r= ss.share(self.F, ran, self.t, self.n)
s_I00=ss.share(self.F, I00, self.t, self.n)
s_I01=ss.share(self.F, I01, self.t, self.n)
s_I10=ss.share(self.F, I10, self.t, self.n)
s_I11= ss.share(self.F, I11, self.t, self.n)
for i in range(n):
sock.TCPclient(self.party_addr[i][0], self.party_addr[i][1], ['hh'+str(i) , int(str(s_h[i]))])
sock.TCPclient(self.party_addr[i][0], self.party_addr[i][1], ['tt'+str(i) , int(str(s_t[i]))])
sock.TCPclient(self.party_addr[i][0], self.party_addr[i][1], ['ran'+str(i) , int(str(s_r[i]))])
sock.TCPclient(self.party_addr[i][0], self.party_addr[i][1], ['b0'+str(i) , int(str(s_b0[i]))])
sock.TCPclient(self.party_addr[i][0], self.party_addr[i][1], ['b1'+str(i) , int(str(s_b1[i]))])
sock.TCPclient(self.party_addr[i][0], self.party_addr[i][1], ['A00'+str(i) , int(str(s_A00[i]))])
sock.TCPclient(self.party_addr[i][0], self.party_addr[i][1], ['A01'+str(i) , int(str(s_A01[i]))])
sock.TCPclient(self.party_addr[i][0], self.party_addr[i][1], ['A10'+str(i) , int(str(s_A10[i]))])
sock.TCPclient(self.party_addr[i][0], self.party_addr[i][1], ['A11'+str(i) , int(str(s_A11[i]))])
sock.TCPclient(self.party_addr[i][0], self.party_addr[i][1], ['I00'+str(i) , int(str(s_I00[i]))])
sock.TCPclient(self.party_addr[i][0], self.party_addr[i][1], ['I01'+str(i) , int(str(s_I01[i]))])
sock.TCPclient(self.party_addr[i][0], self.party_addr[i][1], ['I10'+str(i) , int(str(s_I10[i]))])
sock.TCPclient(self.party_addr[i][0], self.party_addr[i][1], ['I11'+str(i) , int(str(s_I11[i]))])
print(' ')
print('Shares have been send to cloud servers')
resx1= self.get_shares('x1')
resx2= self.get_shares('x2')
print('...')
print('...')
print('Shares of computed result received')
x1_res=ss.rec(self.F, resx1)
x2_res=ss.rec(self.F, resx2)
res1=int(str(x1_res))
res2=int(str(x2_res))
dummy3 =10E13
if res1 > dummy3:
res1 = res1 -792606555396977
if res2 > dummy3:
res2 = res2 -792606555396977
finalX1=res1/10E10
finalX2=res2/10E10
print(' ')
print('Solution:')
print(np.array([[finalX1],[finalX2]]))
def distribute_shares(self,var, name):
shares = ss.share(self.F, var, self.t, self.n) # create shares
s = name # identify share
self.server.securecom[s] = shares
def __init__(self,F, n, t, numTrip):
self.b = ss.share(F,np.random.choice([-1,1]), t, n)
self.triplets = [proc.triplet(F,n,t) for i in range(numTrip)]
def distribute_shares(self,var, name):
shares = ss.share(self.F, var, self.t, self.n)
s = name
self.server.securecom[s] = shares
