def is_smaller(x_bits, y_bits, HE, alpha, n=1000, f=f):
#takes in input 2 encrypted number (st 0=< x,y < n) given in their binary form
#coded on alpha bits
#returns [1] iff y<x , [0] otherwise (where [1]= encrypt(1))
#HE is the Homomorphic Encryption scheme (Pyfhel object)
#Initialisation of same_prefix and same_bit
#f.write("Initisalisation")
c_1 = HE.encrypt(PyPtxt([1], HE))
same_prefix = [c_1]
same_bit = []
res = (c_1 - y_bits[0]) * x_bits[0]
for i in range(alpha): #min(alpha,int(math.floor(math.log(n))+1))):
same_bit.append(
HE.encrypt(PyPtxt([1], HE)) - ((x_bits[i] - y_bits[i])**2))
tmp = HE.encrypt(PyPtxt([1], HE))
for j in range(i + 1):
#f.write("same_bit : "+str(j),HE.decrypt(same_bit[j]))
tmp *= same_bit[j]
#f.write("tmp : ",HE.decrypt(tmp))
same_prefix.append(tmp)
if i > 0: #since the 1st term of the sum is already computed before the loop
res += (HE.encrypt(PyPtxt([1], HE)) -
y_bits[i]) * x_bits[i] * same_prefix[i]
#f.write("res : ",HE.decrypt(res))
return res
def is_smaller_fast2(x_bits, y_bits, HE, alpha):
def product(l, i):
res = 1
for j in range(i + 1):
res *= l[j]
return res
def somme(l, i):
res = 0
for j in range(i):
res += l[j]
return res
num_cores = multiprocessing.cpu_count() #number of cores
print("number of cores : ", num_cores)
same_prefix = [HE.encrypt(PyPtxt([1], HE))]
same_bit = Parallel(n_jobs=num_cores - 1)(
delayed(Computable1.f1)(x_bits[i], y_bits[i]) for i in range(alpha))
same_prefix += Parallel(n_jobs=num_cores - 1)(delayed(product)(same_bit, i)
for i in range(alpha))
to_sum = Parallel(n_jobs=num_cores - 1)(delayed(lambda j: (HE.encrypt(
PyPtxt([1], HE)) - y_bits[j]) * x_bits[j] * same_prefix[j])(i)
for i in range(alpha))
res = somme(to_sum, len(to_sum))
return res
def Psqrt(x, p, HE):
def coeffs_Psqrt(p):
#Returns the coefficients ri that will help compute the polynomial P_sqrt that interpolates the function f:x-->floor(sqrt(x)) on [p]
l1 = range(0, p)
l2 = [int(math.floor(math.sqrt(i))) for i in l1]
#find the coeffs ri (in Zp) that help construct the polynomial
r = []
for i in range(p):
num = l2[i]
den = 1
for j in range(p):
if i != j:
den *= i - j
tmp = (num * inv_modulo(den, p)) % p
r.append(int(tmp))
return r
coeffs = coeffs_Psqrt(p)
#x encrypted as a single Ctxt
#0=< x =< p , p prime
res = HE.encrypt(PyPtxt([0], HE))
for i in range(0, p):
if coeffs[i] != 0:
tmp = HE.encrypt(PyPtxt([coeffs[i]], HE))
for j in range(p):
if i != j:
tmp *= (x - HE.encrypt(PyPtxt([j], HE)))
res += tmp
return res
def is_smaller_fast1(x_bits,y_bits,HE,alpha):
c_1=HE.encrypt(PyPtxt([1], HE))
same_bit =np.subtract(np.asarray(x_bits),np.asarray(y_bits))**2
same_bit=np.subtract(np.asarray([c_1.copy(c_1) for i in range(alpha)]),same_bit)
same_prefix=np.asarray([c_1.copy(c_1)]+[np.prod(same_bit[0:i+1]) for i in range(alpha-1)])
to_sum=np.multiply(same_prefix,np.multiply(np.subtract(np.asarray([HE.encrypt(PyPtxt([1], HE)) for i in range(alpha)]),np.asarray(y_bits)),np.asarray(x_bits)))
res = np.sum(to_sum)
return res
def compute_Pbit_i(x, p, coeffs_i, HE):
#0=< x =< 2^alpha-1 < p , p prime
#returns [1] if the ith bit of x is 1, otherwise 0 (x coded on alpha bits)
res = HE.encrypt(PyPtxt([0], HE))
for i in range(0, p):
tmp = HE.encrypt(PyPtxt([coeffs_i[i]], HE))
for j in range(p):
if i != j:
tmp *= (x - HE.encrypt(PyPtxt([j], HE)))
res += tmp
return res
def l1_norm(a_enc, a_enc_bits, b, b_bits, HE, alpha):
#a_enc : encrypted vector a (list of Ctxt where each Ctxt is an encrypted coefficient of a)
#a_enc : encrypted bits of each elt of a (list of lists of Ctxt)
#same for b and b_bits
res = HE.encrypt(PyPtxt([0], HE))
c_2 = HE.encrypt(PyPtxt([2], HE))
for i in range(len(b)):
iss = is_smaller_fast1(b_bits[i], a_enc_bits[i], HE, alpha)
tmp = (b[i] - a_enc[i]) * iss * c_2
tmp += a_enc[i]
tmp = tmp - b[i]
res += tmp
return res
def knn(q_enc, q_bits_enc, X_train, Y_train, HE_scheme, p, n, d, k, alpha,
a_class):
#q_enc =(enc(q1), ,enc(qd)) : list of the encrypted components of q
#q_bits=([[q1_bits]], ,[[qd_bits]]) : list of lists, where [[q1_bits]] is the list of each encrypted bit of q1
#X_train : training set (list of rows, each row being a list itself)
#Y_train : labels associated with X_train
#n,d : dimensions of X_train (n : nb of rows, d : nb of columns)
#k : nb of nearest neighbors to output
#alpha : nb of bits recquired to encode the input data
#a_class : nb of bits recquired to encode the number of classes (ex : if 2 classes, a_class=1)
#p : prime number such that each value in X_train and q are between 0 and sqrt(p)/d
#HE_scheme : scheme used for encryption (Pyfhel object)
#Compute the distances (q to each row of X_train)
distances = dist(q_enc, q_bits_enc, X_train, HE_scheme, alpha)
distances_bit = []
for i in range(len(distances)):
distances_bit.append(convert_to_bits(distances[i], p, alpha,
HE_scheme))
#Compute Xi (position of the k-nearest neighbours)
XI = k_smallest_values(distances_bit, k, p, HE_scheme, alpha)
#Multiply by the auxiliary data
y_enc = [HE_scheme.encrypt(PyPtxt([elt], HE_scheme)) for elt in X_train[i]]
res = np.multiply(np.asarray(XI), np.asarray(y_enc))
return res
def l1_norm(a_enc, a_enc_bits, b, b_bits, HE, alpha):
#a_enc : encrypted vector a (list of Ctxt where each Ctxt is an encrypted coefficient of a)
#a_enc : encrypted bits of each elt of a (list of lists of Ctxt)
#same for b and b_bits
p_0 = PyPtxt([0], HE)
res = HE.encrypt(p_0)
p_2 = PyPtxt([2], HE)
c_2 = HE.encrypt(p_2)
for i in range(len(b)):
iss = is_smaller(b_bits[i], a_enc_bits[i], HE, alpha=alpha, n=1000)
tmp = (b[i] - a_enc[i]) * iss * c_2 ##peut etre besoin de copier c_2
#f.write("tmp ",HE.decrypt(tmp))
tmp += a_enc[i]
tmp = tmp - b[i]
res += tmp
return res
def dist(q_enc, q_bits_enc, X_train, HE, alpha, f=f):
#q_enc =(enc(q1), ,enc(qd)) : list of the encrypted components of q
#q_bits=([[q1_bits]], ,[[qd_bits]]) : list of lists, where [[q1_bits]] is the list of each encrypted bit of q1
#X_train : training set (list of rows, each row being a list itself)
#Y_train : labels associated with X_train
#n,d : dimensions of X_train (n : nb of rows, d : nb of columns)
#k : nb of nearest neighbors to output
#alpha : nb of bits recquired to encode the input data
#a_class : nb of bits recquired to encode the number of classes (??) (ex : if 2 classes, a_class=1)
#p : prime number such that each value in X_train and q are between 0 and sqrt(p)/d
#HE_scheme : scheme used for encryption (Pyfhel object)
#Step 1 : calculate distances between q and the rows of X_train
#initialize distances
distances = []
n = len(X_train)
for i in range(n):
#encrypt each elt of X_train[i]
b_enc = [HE.encrypt(PyPtxt([elt], HE)) for elt in X_train[i]]
#also encrypt each elt of X_train[i] as a list of encrypted bits
b_bits_enc = [encrypt_as_bits(elt, alpha, HE, f) for elt in X_train[i]]
#compute dist(q,X_train[i])
dist = l1_norm(q_enc,
q_bits_enc,
b_enc,
b_bits_enc,
HE=HE,
alpha=alpha)
distances.append(dist)
return distances
def probabilisticAverage(list_x_bits,n,HE,deg,alpha):
#Takes in input a list of integers (each integer is a list of encrypted bits)
#n=size of the vector input
#alpha=number of bits on which each elt of the vector is encoded
#deg is the degree of the moment to compute (deg=1 : average, deg=2 : second order moment)
#HE is the Homomorphic Encryption scheme (Pyfhel object)
#Returns an approximation of the statistical function (ie : average, 2nd order moment..) computed on the integer list
#Initialize
L=2**alpha
print("L="+str(L))
c=int(math.ceil((L**deg)/float(n)))
print("c="+str(c))
res=HE.encrypt(PyPtxt([0], HE))
print("c*n="+str(c*n))
for i in range(c*n): #rq : pour L=8 et n=3, c=3 et c*n=9 (environ 440sec)
tmp=int(math.floor(i/float(c))) #(rq le dernier i sera c*n-1 donc le dernier tmp sera n-1)
#print("")
#print("tmp="+str(tmp))
#print("")
tmp=coinToss(list_x_bits[tmp],c*n,HE,deg=deg,alpha=alpha)
#print("result of the coin toss : ",HE.decrypt(tmp))
res+=tmp #peut etre pas besoin d'une liste (sommer directement les elts dans res)
return res
def Psqrt2(x, p, HE, f):
#attempt to improve computation using the polynomialMult method
def coeffs_Psqrt(p):
#Returns the coefficients ri that will help compute the polynomial P_sqrt that interpolates the function f:x-->floor(sqrt(x)) on [p]
l1 = range(0, p)
l2 = [int(math.floor(math.sqrt(i))) for i in l1]
f.write("l2 : " + str(l2))
#find the coeffs ri (in Zp) that help construct the polynomial
r = []
f.write("\n")
f.write("Computing coefficients of Psqrt")
f.write("\n")
f.flush()
for i in range(p):
num = l2[i]
den = 1
for j in range(p):
if i != j:
den *= i - j
tmp = (num * inv_modulo(den, p)) % p
r.append(int(tmp))
return r
coeffs = coeffs_Psqrt(p)
#x encrypted as a single Ctxt
#0=< x =< p , p prime
coeffs_ctxt = []
for i in range(p):
coeffs_ctxt.append(HE.encrypt(PyPtxt([coeffs[i]], HE)))
res = x.polynomialMult(coeffs_ctxt)
return res
def probabilisticAverage_fast(list_x_bits,n,HE,deg,alpha,f):
#Takes in input a list of integers (each integer is a list of encrypted bits)
#n=size of the vector input
#alpha=number of bits on which each elt of the vector is encoded
#deg is the degree of the moment to compute (deg=1 : average, deg=2 : second order moment)
#HE is the Homomorphic Encryption scheme (Pyfhel object)
#Returns an approximation of the statistical function (ie : average, 2nd order moment..) computed on the integer list
#Initialize
L=2**alpha
print("L="+str(L))
c=int(math.ceil((L**deg)/float(n)))
print("c="+str(c))
res=HE.encrypt(PyPtxt([0], HE))
print("c*n="+str(c*n))
list_elts=np.asarray([list_x_bits[int(math.floor(i/float(c)))] for i in range(c*n)])
print("len(list_elts)"+str(len(list_elts)))
def fct(x):
return coinToss(x,c*n,HE,deg=deg,alpha=alpha)
def array_map(x):
return np.array(list(map(fct, x)))
#vf=np.vectorize(f)
#print("to_sum")
#to_sum=vf(list_elts)
to_sum=array_map(list_elts)
#print ("res")
res = np.sum(to_sum)
return res
def k_smallest_values(list_d_bits, p, k, HE, alpha, f=f):
#Takes in input a list of data (each encrypted as a list of bits)
#a prime p such that each datapoint 0=< d =< sqrt(p)
n = len(list_d_bits)
#Compute average, 2nd order moment and std
f.write("Compute average")
f.write("\n")
avg = probabilisticAverage(
list_d_bits, n, HE, 1,
alpha=alpha) #L=sqrt(p) ?? donc alpha = log2(sqrt(p) ?????
f.write("average : " + str(HE.decrypt(avg)))
f.flush()
f.write("\n")
f.write("\n")
f.write("Compute second_moment")
second_moment = probabilisticAverage(list_d_bits, n, HE, 2, alpha=alpha)
f.flush()
f.write("\n")
f.write("\n")
f.write("second_moment : " + str(HE.decrypt(second_moment)))
f.flush()
f.write("\n")
A = (avg**2) + second_moment
f.write("A : " + str(HE.decrypt(A)))
f.flush()
f.write("\n")
f.write("Compute std")
f.write("\n")
std = Psqrt(A, p, HE)
f.write("std : " + str(HE.decrypt(std)))
f.flush()
f.write("\n")
#Compute threshold
f.write("Compute threshold and convert to bits")
f.write("\n")
phi_ = HE.encrypt(PyPtxt([int(round(1 / phi(float(k / n) / 100), 0))], HE))
f.write(int(round(1 / phi(float(k / n) / 100), 0)))
f.write("phi : " + str(HE.decrypt(phi_)))
f.flush()
f.write("\n")
T = avg + phi_ * std
f.write("threshold : " + str(HE.decrypt(T)))
f.flush()
f.write("\n")
T_bits = convert_to_bits(T, p, alpha, HE)
f.flush()
f.write("threshold bit by bit : ")
f.write("\n")
for bit in T_bits:
f.write(str(HE.decrypt(bit)))
f.flush()
f.write("\n")
res = []
for i in range(n):
res.append(is_smaller(T_bits, list_d_bits[i], HE, alpha=alpha))
f.write("dist(" + str(i) + ") : " + str(HE.decrypt(res[i])))
f.flush()
f.write("\n")
return res
def encrypt_as_bits(x, alpha, HE):
#takes in input a plaintext integer x =< 2^alpha -1
#returns a list of the encrypted bits of x
a = '{0:0' + str(alpha) + 'b}'
x_bits = [int(i) for i in list(a.format(x))]
x_bits_enc = []
for i in x_bits:
x_bits_enc.append(HE.encrypt(PyPtxt([i], HE)))
return x_bits_enc
def run(self, x, y, alpha):
pool = Pool().map
same_prefix = [HE.encrypt(PyPtxt([1], HE))]
same_bit = pool(self.f1, x, y)
for i in range(alpha):
same_prefix.append(product(same_bit, i))
to_sum = pool(self.f2, x, y, same_prefix)
result = somme(to_sum, len(to_sum))
return result
def test_PyPtxt_creation_deletion(self):
try:
self.ptxt = PyPtxt()
self.ptxt2 = PyPtxt(other_ptxt=self.ptxt)
self.pyfhel = Pyfhel()
self.ptxt3 = PyPtxt(pyfhel=self.pyfhel)
self.ptxt4 = PyPtxt(other_ptxt=self.ptxt3)
except Exception as err:
self.fail("PyPtxt() creation failed unexpectedly: ", err)
self.assertEqual(self.ptxt._encoding, ENCODING_t.UNDEFINED)
self.ptxt._encoding = ENCODING_t.INTEGER
self.assertEqual(self.ptxt._encoding, ENCODING_t.INTEGER)
del (self.ptxt._encoding)
self.assertEqual(self.ptxt._encoding, ENCODING_t.UNDEFINED)
self.ptxt._pyfhel = self.pyfhel
self.ptxt2._pyfhel = self.ptxt._pyfhel
try:
del (self.ptxt)
except Exception as err:
self.fail("PyPtxt() deletion failed unexpectedly: ", err)
def encrypt_as_bits(x, alpha, HE, f=f):
#takes in input a plaintext integer x =< 2^alpha -1
#returns a list of the encrypted bits of x
a = '{0:0' + str(alpha) + 'b}'
x_bits = [int(i) for i in list(a.format(x))]
x_bits_enc = []
f.write("Encrypting " + str(x) + " in bits " + str(x_bits))
f.write("\n")
f.flush()
for i in x_bits:
x_bits_enc.append(HE.encrypt(PyPtxt([i], HE)))
return x_bits_enc
def test_Pyfhel_2a_encode_decode_int(self):
self.pyfhel = Pyfhel()
self.pyfhel.contextGen(p=65537)
self.pyfhel.keyGen()
self.ptxt = self.pyfhel.encodeInt(127)
self.assertEqual(self.ptxt.to_string(),
b'1x^6 + 1x^5 + 1x^4 + 1x^3 + 1x^2 + 1x^1 + 1')
self.assertEqual(self.pyfhel.decodeInt(self.ptxt), 127)
self.ptxt2 = PyPtxt(self.ptxt)
self.pyfhel.encodeInt(-2, self.ptxt)
self.assertEqual(self.ptxt.to_string(), b'10000x^1')
self.assertEqual(self.pyfhel.decodeInt(self.ptxt), -2)
self.assertEqual(self.pyfhel.decodeInt(self.ptxt2), 127)
def test_Pyfhel_2a_encode_decode_int(self):
pyfhel = Pyfhel()
pyfhel.contextGen(p=65537)
pyfhel.keyGen()
ptxt = pyfhel.encodeInt(127)
self.assertEqual(ptxt.to_poly_string(),
b"1x^6 + 1x^5 + 1x^4 + 1x^3 + 1x^2 + 1x^1 + 1")
self.assertEqual(pyfhel.decodeInt(ptxt), 127)
ptxt2 = PyPtxt(ptxt)
pyfhel.encodeInt(-2, ptxt)
self.assertEqual(ptxt.to_poly_string(), b"10000x^1")
self.assertEqual(pyfhel.decodeInt(ptxt), -2)
self.assertEqual(pyfhel.decodeInt(ptxt2), 127)
def is_smaller(x_bits, y_bits, HE, alpha):
#takes in input 2 encrypted number (st 0=< x,y < n) given in their binary form
#coded on alpha bits
#returns [1] iff y<x , [0] otherwise (where [1]= encrypt(1))
#HE is the Homomorphic Encryption scheme (Pyfhel object)
#Initialisation of same_prefix and same_bit
c_1 = HE.encrypt(PyPtxt([1], HE))
same_prefix = [c_1]
same_bit = []
res = (c_1 - y_bits[0]) * x_bits[0]
for i in range(alpha):
same_bit.append(
HE.encrypt(PyPtxt([1], HE)) - ((x_bits[i] - y_bits[i])**2))
tmp = HE.encrypt(PyPtxt([1], HE))
for j in range(i + 1):
tmp *= same_bit[j]
same_prefix.append(tmp)
if i > 0: #since the 1st term of the sum is already computed before the loop
res += (HE.encrypt(PyPtxt([1], HE)) -
y_bits[i]) * x_bits[i] * same_prefix[i]
return res
def Psqrt(x, p, HE, f):
def coeffs_Psqrt(p):
#Returns the coefficients ri that will help compute the polynomial P_sqrt that interpolates the function f:x-->floor(sqrt(x)) on [p]
l1 = range(0, p)
l2 = [int(math.floor(math.sqrt(i))) for i in l1]
#print("l2 : ",l2)
#find the coeffs ri (in Zp) that help construct the polynomial
r = []
for i in range(p):
num = l2[i]
den = 1
for j in range(p):
if i != j:
den *= i - j
tmp = (num * inv_modulo(den, p)) % p
r.append(int(tmp))
return r
f.write("Computing coefficients of Psqrt")
f.write("\n")
f.flush()
coeffs = coeffs_Psqrt(p)
#x encrypted as a single Ctxt
#0=< x =< p , p prime
res = HE.encrypt(PyPtxt([0], HE))
for i in range(0, p):
if coeffs[i] != 0:
tmp = HE.encrypt(PyPtxt([coeffs[i]], HE))
for j in range(p):
if i != j:
#print("j ",j)
#print("x-"+str(j)+" : ",HE.decrypt(x-HE.encrypt(PyPtxt([j], HE))))
tmp *= (x - HE.encrypt(PyPtxt([j], HE))
) # tmp*=(x-HE.encrypt(PyPtxt([j], HE)))
#print 'coeffs[i]',type(coeffs[i]),coeffs[i]
#print "tmp",type(tmp),HE.decrypt(tmp)
#print("")
res += tmp
return res
def coinToss(x_bits,n,HE,deg,alpha):
#Takes in input an integer n, and an encrypted number 0=< x_bits <n as a list of alpha bits
#generates a random number r between 0 and n (potentially drawn from a distribution D)
#Returns an encrypted bit b=[1] if r^(1/deg)<x (ie : with probability x/n) otherwise [0]
#print("Random number between 0 and "+str(n))
r=randint(0, n)
#print("r : ",r)
r=int(math.floor((r**(1/float(deg)))))
if r>((2**alpha) -1) : #rq : x=< 2**alpha -1 so if r>2**alpha-1, then r>x
c_0=HE.encrypt(PyPtxt([0], HE))
return c_0
else :
#encrypt r as a list of bits
r_bits_enc=encrypt_as_bits(r,alpha,HE)
#compare r_bits and x_bits
return is_smaller_fast1(x_bits,r_bits_enc,HE,alpha=alpha)
def k_smallest_values(list_d_bits, p, k, HE, alpha):
#Takes in input a list of data (each encrypted as a list of bits)
#a prime p such that each datapoint 0=< d =< sqrt(p)
n = len(list_d_bits)
#Compute average, 2nd order moment and std
avg = probabilisticAverage(
list_d_bits, n, HE, 1,
alpha=alpha) #L=sqrt(p) ?? donc alpha = log2(sqrt(p) ?????
second_moment = probabilisticAverage(list_d_bits, n, HE, 2, alpha=alpha)
A = (avg**2) + second_moment
std = Psqrt(A, p, HE)
#Compute threshold
phi_ = HE.encrypt(PyPtxt([int(round(1 / phi(float(k / n) / 100), 0))], HE))
T = avg + phi_ * std
T_bits = convert_to_bits(T, p, alpha, HE)
res = []
for i in range(n):
res.append(is_smaller(T_bits, list_d_bits[i], HE, alpha=alpha))
return res
def probabilisticAverage(list_x_bits, n, HE, deg, alpha):
#Takes in input a list of integers (each integer is a list of encrypted bits)
#n=size of the vector input
#alpha=number of bits on which each elt of the vector is encoded
#deg is the degree of the moment to compute (deg=1 : average, deg=2 : second order moment)
#HE is the Homomorphic Encryption scheme (Pyfhel object)
#Returns an approximation of the statistical function (ie : average, 2nd order moment..) computed on the integer list
#Initialize
L = 2**alpha
c = int(math.ceil((L**deg) / float(n)))
a = []
res = HE.encrypt(PyPtxt([0], HE))
for i in range((c * n)):
tmp = int(math.floor(i / c))
a.append(coinToss(list_x_bits[tmp], c * n, HE, deg=deg, alpha=alpha))
res += a[i]
return res
print("Pyfhel DEMO")
print(" Running KeyGen with params:")
print(KEYGEN_PARAMS)
start = time.time()
HE.keyGen(KEYGEN_PARAMS)
end=time.time()
print(" KeyGen completed in "+str(end-start)+" sec." )
#save and restore the key with saveEnv method
filename='filename.aenv'
start = time.time()
HE.saveEnv(filename)
end=time.time()
c1=HE.encrypt(PyPtxt([1], HE))
HE2=Pyfhel()
start2 = time.time()
HE2.restoreEnv(filename)
end2=time.time()
print "key saved in "+str(end-start)+" sec, and restored in "+str(end2-start2)+" sec."
print HE2.decrypt(c1)
#store the Key as a pickle object
filename='filename_pi.obj'
file_ = open(filename, 'w')
pickle.dump(HE, file_)
file_.close()
file_pi2 = open(filename, 'r')
key = pickle.load(file_pi2)
def knn(q_enc,
q_bits_enc,
X_train,
Y_train,
HE_scheme,
p,
n,
d,
k,
alpha,
a_class,
file=f):
#q_enc =(enc(q1), ,enc(qd)) : list of the encrypted components of q
#q_bits=([[q1_bits]], ,[[qd_bits]]) : list of lists, where [[q1_bits]] is the list of each encrypted bit of q1
#X_train : training set (list of rows, each row being a list itself)
#Y_train : labels associated with X_train
#n,d : dimensions of X_train (n : nb of rows, d : nb of columns)
#k : nb of nearest neighbors to output
#alpha : nb of bits recquired to encode the input data
#a_class : nb of bits recquired to encode the number of classes (ex : if 2 classes, a_class=1)
#p : prime number such that each value in X_train and q are between 0 and sqrt(p)/d
#HE_scheme : scheme used for encryption (Pyfhel object)
#compute the distances between q and elements of X_train
f.write("Distances between q and elements of X_train : ")
f.write("\n")
start1 = time.time()
distances = dist(q_enc, q_bits_enc, X_train, HE_scheme, alpha, f)
f.write("len(distances) : " + str(len(distances)))
f.write("\n")
for res in distances:
f.write(str(HE_scheme.decrypt(res)))
f.flush()
end1 = time.time()
f.write(str(end1 - start1) + " sec to compute distances.")
f.write("\n")
f.write("\n")
#convert distances to bits
f.write("Convert distances to bits ")
f.write("\n")
f.flush()
start2 = time.time()
distances_bit = []
for i in range(len(distances)):
distances_bit.append(
convert_to_bits(distances[i], p, alpha, HE_scheme, f))
f.write("convert distance " + str(i))
f.write("\n")
f.flush()
end2 = time.time()
f.write(str(end2 - start2) + " sec to convert distances to bits.")
f.flush()
f.write("\n")
f.write("\n")
f.write("\n")
#Find the position of the k nearest neighbours
f.write("Compute Xi (position of the k-nearest neighbours) :")
f.write("\n")
start3 = time.time()
XI = k_smallest_values(distances_bit, k, p, HE_scheme, alpha, f)
end3 = time.time()
f.write(
str(end3 - start3) +
" sec to compute the position of the k nearest neighbours.")
f.flush()
f.write("\n")
f.write("\n")
#Multiply by the auxiliary data
f.write("Multiply by the auxiliary data")
f.write("\n")
y_enc = [HE_scheme.encrypt(PyPtxt([elt], HE_scheme)) for elt in X_train[i]]
res = np.multiply(np.asarray(XI), np.asarray(y_enc))
return res
"gens": [],
"ords": []
}
print(" Running KeyGen with params:")
print(KEYGEN_PARAMS)
HE.keyGen(KEYGEN_PARAMS)
end = time.time()
print(" KeyGen completed in " + str(end - start) + " sec.")
n = 7
alpha = 3
p = KEYGEN_PARAMS["p"]
print("Converting " + str(n) + " to bits (alpha = " + str(alpha) + ")")
start = time.time()
x = HE.encrypt(PyPtxt([n], HE))
bits_x = convert_to_bits(x, p, alpha, HE)
end = time.time()
print("Result : ", [HE.decrypt(res) for res in bits_x])
print(str(end - start) + " sec.")
#i=1
#x=HE.encrypt(PyPtxt([n], HE))
#print("Compute the "+str(i)+"th bit of "+str(n)+" (written on "+str(alpha)+" bits)")
#start = time.time()
#coeffs_i=coeffs_Pbit_i(i=i,p=17,alpha=alpha)
#result=compute_Pbit_i(x,p=17,coeffs_i=coeffs_i,HE=HE)
#decrypted_res=HE.decrypt(result)
#print("Result : ",decrypted_res)
#end=time.time()
for j in range(d):
tmp.append(randint(0, (2**alpha) - 1))
X_train.append(tmp)
Y_train.append(randint(0, a_class) + 1)
f.write("X_train : " + str(X_train))
f.write("\n")
f.write("\n")
f.write("Y_train : " + str(Y_train))
f.write("\n")
f.flush()
f.write("Encrypting q")
f.write("\n")
f.write("\n")
f.flush()
q_enc = [HE.encrypt(PyPtxt([elt], HE)) for elt in q]
q_bits_enc = [encrypt_as_bits(elt, alpha, HE, f) for elt in q]
f.write("Encrypting X1")
f.write("\n")
f.flush()
x1_enc = [HE.encrypt(PyPtxt([elt], HE)) for elt in X_train[0]]
x1_bits_enc = [encrypt_as_bits(elt, alpha, HE, f) for elt in X_train[0]]
f.flush()
f.write("\n")
f.write("\n")
f.write("Test l1-norm")
f.write("\n")
f.write("\n")
print("==============================================================")
print("====================== Pyfhel ENCODING =======================")
print("==============================================================")
print("1. Creating Context and KeyGen in a Pyfhel Object ")
HE = Pyfhel() # Creating empty Pyfhel object
HE.contextGen(p=65537, m=1024, flagBatching=True) # Generating context.
# The values of p and m are chosen to enable batching (see Demo_Batching_SIMD.py)
HE.keyGen() # Key Generation.
print("2. Encoding integers with encodeInt")
integer1 = 45
integer2 = -32
ptxt_i1 = HE.encodeInt(integer1) # Encoding integer1 in a new PyPtxt
ptxt_i2 = PyPtxt() # Empty plaintexts have no encoding type.
print(" Empty created ptxt_i2: ", str(ptxt_i2))
HE.encodeInt(integer2, ptxt_i2) # Encoding integer2 in an existing PyPtxt
print(" int ", integer1, '-> ptxt_i1 ', str(ptxt_i1))
print(" int ", integer2, '-> ptxt_i2 ', str(ptxt_i2))
print("3. Encoding floating point values with encodeFrac")
float1 = 3.5
float2 = -7.8
ptxt_f1 = HE.encodeInt(
float1) # Encoding float1 in a new PyPtxt with encodeFrac
ptxt_f2 = PyPtxt()
HE.encodeFrac(float2, ptxt_f2) # Encoding float2 in an existing PyPtxt
print(" float ", float1, '-> ptxt_f1 ', str(ptxt_f1))
print(" float ", float2, '-> ptxt_f2 ', str(ptxt_f2))
import Pyfhel
from Pyfhel import PyCtxt,PyPtxt,Pyfhel
import time
start = time.time()
HE = Pyfhel()
#Generate Key
KEYGEN_PARAMS={ "p":17, "r":1,
"d":0, "c":2,
"sec":128, "w":64,
"L":50, "m":-1,
"R":3, "s":0,
"gens":[], "ords":[]}
print(" Running KeyGen with params:")
print(str(KEYGEN_PARAMS))
HE.keyGen(KEYGEN_PARAMS)
end=time.time()
print(" KeyGen completed in "+str(end-start)+" sec." )
a=HE.encrypt(PyPtxt([1], HE))
b=HE.encrypt(PyPtxt([2], HE))
start = time.time()
a*=b
end= time.time()
print("Multiplication in "+str(end-start)+" sec.")
