-
Notifications
You must be signed in to change notification settings - Fork 0
/
honest-but-curiout-union-and-intersection.py
168 lines (111 loc) · 4.2 KB
/
honest-but-curiout-union-and-intersection.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
# coding: utf-8
# In[ ]:
from paillier import *
# In[ ]:
import math
import random
from random import shuffle
import sys
import gmpy2
from time import time
from Crypto.Util.number import getPrime
import numpy as np
# In[ ]:
# In[4]:
#UNION SET FOR HONEST BUT CURIOUS
def enc_function(s1):
#using this function P1 can generate his encrypted polynomial
p=np.poly1d(s1, True)
enc_coef=[]
for i in range(len(p),-1,-1):
enc_coef.append(encrypt(pub,int(p.c[i])))
return enc_coef
# In[5]:
def s2calcfun(s1,x,enc_coef):
#P2 uses this function to evaluate a value from s2 in the encrypted polynomial
p=np.poly1d(s1, True)
mulfac=[]
f1=1
for i in range(0,len(enc_coef)):
mulfac.append(multime(pub, enc_coef[i], f1))#multiply each coefficient with the proper x
f1=f1*x
#we created the list which has the values of the encrypted coef multiplied with each x
#now we need to add everything together
init=encrypt(pub,0)#value which everything will be added there
for i in range(0,len(enc_coef)):
init=addemup(pub,init,mulfac[i])
return init
# In[6]:
#now p2 using the s2calcfun should generate the encrypted output for every element
#in the s2 and return it to p1
def gen_tuples(s2,enc_coef):
en1=[]
en2=[]
r=random.getrandbits(64)
for i in range(0,len(s2)):
val=s2calcfun(s1,s2[i],enc_coef)
en1.append(multime(pub, val, r*s2[i]))#multiply with the random value and a value from s2
en2.append(multime(pub, val,r)) #multiply only with the random value
c = list(zip(en1, en2))
random.shuffle(c)
en1, en2 = zip(*c)#shuffle and send the pairs
return en1,en2
# In[7]:
def output(s1,en1,en2):
output_values=s1 #P1 initially set the output to be s1
for i in range(0,len(s2)):
a=decrypt(priv,pub,en1[i])
b=decrypt(priv,pub,en2[i])
if(a!=0)and(b!=0):
output_values.append(int(gmpy2.f_div(a,b)))
return output_values
# In[8]:
priv, pub = generate_keypair(2048)#generate crypto scheme to work on
s1=[9,32,17,45,98,23,54,234,87] # P1 defines the his set s1
s2=[19,65,17,54,8,76,29,81,87,36,23]#P2 defines his set s2
def test_function():
print "running test function for the union of the 2 sets (question 2)"
alice=enc_function(s1) #P1(alice) creates the encrypted coefficients of the polynomial
#and grants access to it to P2 along with the pub value generated above
en1,en2=gen_tuples(s2,alice) #P2(bob) is now generating the tuples according to the
#Two-party HBC protocol for Set Union, and sends them to P1
return output(s1,en1,en2) #P1 returns the union of s1 and s2
# In[9]:
print test_function()
# In[10]:
#INTERSECTION SET FOR HONEST BUT CURIOUS
# In[11]:
def gen_tuples_q3(s1,s2,enc_coef):
en=[]
r=random.getrandbits(64)
for i in range(0,len(s2)):
val=s2calcfun(s1,s2[i],enc_coef)
val2=encrypt(pub,s2[i])
val=multime(pub,val,r)
en.append(addemup(pub, val, val2))
random.shuffle(en)
return en
# In[12]:
def outputq3(s1,s2,en):
output_values=[]
temp=[]
for i in range(0,len(s2)):
a=decrypt(priv,pub,en[i])
temp.append(a)
for i in range(0,len(temp)):
if temp[i] in s1:
output_values.append(int(temp[i]))
return output_values
# In[13]:
#priv, pub = generate_keypair(2048)#generate crypto scheme to work on
pets1=[9,32,17,45,98,23,54,234,87] # P1 defines the his set s1
pets2=[19,65,17,54,8,76,29,81,87,36,23]#P2 defines his set s2
def test_functionq3():
print "running the test function for the intersection of the 2 sets (question 3)"
alice=enc_function(pets1) #P1(alice) creates the encrypted coefficients of the polynomial
#and grants access to it to P2 along with the pub value generated above
en=gen_tuples_q3(pets1,pets2,alice) #P2(bob) is now generating the tuples according to the
#Two-party HBC protocol for Set Union, and sends them to P1
return outputq3(pets1,pets2,en)
# In[14]:
print test_functionq3()