def test_Pyfhel_4c_operations_batch_array(self):
pyfhel = Pyfhel()
pyfhel.contextGen(p=1964769281, m=8192, base=2, sec=192, flagBatching=True)
pyfhel.keyGen()
pyfhel.rotateKeyGen(60)
ctxti = pyfhel.encryptBatch([1, 2, 3, 4, 5, 6])
ctxti2 = pyfhel.encryptArray(np.array([-6, -5, -4, -3, -2, -1], dtype=np.int64))
ptxti = pyfhel.encodeArray(np.array([12, 15, 18, 21, 24, 27], dtype=np.int64))
ctxt_add = pyfhel.add(ctxti, ctxti2, in_new_ctxt=True)
ctxt_add2 = pyfhel.add_plain(ctxti, ptxti, in_new_ctxt=True)
ctxt_sub = pyfhel.sub(ctxti, ctxti2, in_new_ctxt=True)
ctxt_sub2 = pyfhel.sub_plain(ctxti, ptxti, in_new_ctxt=True)
ctxt_mult = pyfhel.multiply(ctxti, ctxti2, in_new_ctxt=True)
ctxt_mult2 = pyfhel.multiply_plain(ctxti, ptxti, in_new_ctxt=True)
ctxt_rotate = pyfhel.rotate(ctxti, -2, in_new_ctxt=True)
ctxt_rotate2 = pyfhel.rotate(ctxti, 2, in_new_ctxt=True)
self.assertEqual(pyfhel.decryptBatch(ctxt_add)[:6], [-5, -3, -1, 1, 3, 5])
self.assertEqual(pyfhel.decryptBatch(ctxt_add2)[:6], [13, 17, 21, 25, 29, 33])
self.assertEqual(pyfhel.decryptBatch(ctxt_sub)[:6], [7, 7, 7, 7, 7, 7])
self.assertEqual(
pyfhel.decryptBatch(ctxt_sub2)[:6], [-11, -13, -15, -17, -19, -21]
)
self.assertEqual(
pyfhel.decryptBatch(ctxt_mult)[:6], [-6, -10, -12, -12, -10, -6]
)
self.assertEqual(
pyfhel.decryptBatch(ctxt_mult2)[:6], [12, 30, 54, 84, 120, 162]
)
self.assertEqual(pyfhel.decryptBatch(ctxt_rotate)[:6], [0, 0, 1, 2, 3, 4])
self.assertEqual(pyfhel.decryptBatch(ctxt_rotate2)[:6], [3, 4, 5, 6, 0, 0])
def test_Pyfhel_4a_operations_integer(self):
pyfhel = Pyfhel()
pyfhel.contextGen(p=1964769281, m=8192, base=3, sec=192)
pyfhel.keyGen()
# self.pyfhel.rotateKeyGen(60)
# self.pyfhel.relinKeyGen(60)
ctxti = pyfhel.encryptInt(127)
ctxti2 = pyfhel.encryptInt(-2)
ptxti = pyfhel.encodeInt(3)
ctxt_add = pyfhel.add(ctxti, ctxti2, in_new_ctxt=True)
ctxt_add2 = pyfhel.add_plain(ctxti, ptxti, in_new_ctxt=True)
ctxt_sub = pyfhel.sub(ctxti, ctxti2, in_new_ctxt=True)
ctxt_sub2 = pyfhel.sub_plain(ctxti, ptxti, in_new_ctxt=True)
ctxt_mult = pyfhel.multiply(ctxti, ctxti2, in_new_ctxt=True)
ctxt_mult2 = pyfhel.multiply_plain(ctxti, ptxti, in_new_ctxt=True)
# self.ctxt_rotate = self.pyfhel.rotate(self.ctxti, 2)
# self.ctxt_expon = self.pyfhel.power(self.ctxti, 3)
# self.ctxt_expon2 = self.pyfhel.power(self.ctxti2, 3)
# self.ctxt_polyEval = self.pyfhel.polyEval(self.ctxti, [1, 2, 1], in_new_ctxt=True)
self.assertEqual(pyfhel.decryptInt(ctxt_add), 125)
self.assertEqual(pyfhel.decryptInt(ctxt_add2), 130)
self.assertEqual(pyfhel.decryptInt(ctxt_sub), 129)
self.assertEqual(pyfhel.decryptInt(ctxt_sub2), 124)
self.assertEqual(pyfhel.decryptInt(ctxt_mult), -254)
self.assertEqual(pyfhel.decryptInt(ctxt_mult2), 381)
def HE(self):
HE = Pyfhel()
HE.contextGen(m=2048, p=65537)
HE.keyGen()
HE.relinKeyGen(60, 3)
return HE
def test_call(self):
HE = Pyfhel()
HE.contextGen(65537)
HE.keyGen()
HE.relinKeyGen(30, 100)
new_weights = np.array([
[1, 2, 3, 4]
,[2, 3, 4, 5]
,[3, 4, 5, 6]
])
new_bias = np.array([1, 2, 3])
linear_layer = lin.LinearLayer(HE, new_weights, new_bias)
flattened_input = np.array([
[1, 2, 3, 4]
, [5, 6, 7, 8]
])
encrypted_input = cr.encrypt_matrix(HE, flattened_input)
encrypted_result = linear_layer(encrypted_input)
result = cr.decrypt_matrix(HE, encrypted_result)
expected_result = np.array([
[31, 42, 53]
,[71, 98, 125]
])
assert np.allclose(result, expected_result)
def test_Pyfhel_3b_encrypt_decrypt_float(self):
pyfhel = Pyfhel()
pyfhel.contextGen(p=65537, m=8192, base=2, intDigits=80, fracDigits=20)
pyfhel.keyGen()
ctxt = pyfhel.encryptFrac(19.30)
self.assertEqual(round(pyfhel.decryptFrac(ctxt), 2), 19.30)
pyfhel.encryptFrac(-2.25, ctxt)
self.assertEqual(round(pyfhel.decryptFrac(ctxt), 2), -2.25)
def test_Pyfhel_3c_encrypt_decrypt_batch(self):
pyfhel = Pyfhel()
pyfhel.contextGen(p=1964769281, m=8192, base=2, sec=192, flagBatching=True)
pyfhel.keyGen()
self.assertTrue(pyfhel.batchEnabled())
ctxt = pyfhel.encryptBatch([1, 2, 3, 4, 5, 6])
self.assertEqual(pyfhel.getnSlots(), 8192)
self.assertEqual(pyfhel.decryptBatch(ctxt)[:6], [1, 2, 3, 4, 5, 6])
def test_Pyfhel_1c_rotate_key_generation(self):
pyfhel = Pyfhel()
pyfhel.contextGen(65537)
pyfhel.keyGen()
pyfhel.rotateKeyGen(30)
pyfhel.rotateKeyGen(1)
pyfhel.rotateKeyGen(60)
self.assertRaises(SystemError, lambda: pyfhel.rotateKeyGen(61))
self.assertRaises(SystemError, lambda: pyfhel.rotateKeyGen(0))
def test_Pyfhel_1d_relin_key_generation(self):
pyfhel = Pyfhel()
pyfhel.contextGen(65537)
pyfhel.keyGen()
pyfhel.relinKeyGen(30, 5)
pyfhel.relinKeyGen(1, 5)
pyfhel.relinKeyGen(60, 5)
self.assertRaises(SystemError, lambda: pyfhel.relinKeyGen(61, 5))
self.assertRaises(SystemError, lambda: pyfhel.relinKeyGen(0, 5))
def test_Pyfhel_5c_save_restore_all(self):
pyfhel = Pyfhel()
pyfhel.contextGen(p=1964769281,
m=8192,
base=2,
sec=192,
flagBatching=True)
pyfhel.keyGen()
pyfhel.rotateKeyGen(60)
pyfhel.relinKeyGen(60, 4)
# save all keys into temporary directory
tmp_dir = tempfile.TemporaryDirectory()
pyfhel.saveContext(tmp_dir.name + "/context")
pyfhel.savepublicKey(tmp_dir.name + "/pub.key")
pyfhel.savesecretKey(tmp_dir.name + "/sec.key")
pyfhel.saverelinKey(tmp_dir.name + "/relin.key")
pyfhel.saverotateKey(tmp_dir.name + "/rotate.key")
# restore all keys
pyfhel2 = Pyfhel()
pyfhel.contextGen(p=1964769281,
m=8192,
base=2,
sec=192,
flagBatching=True)
pyfhel2.restoreContext(tmp_dir.name + "/context")
pyfhel2.restorepublicKey(tmp_dir.name + "/pub.key")
pyfhel2.restoresecretKey(tmp_dir.name + "/sec.key")
pyfhel2.restorerelinKey(tmp_dir.name + "/relin.key")
pyfhel2.restorerotateKey(tmp_dir.name + "/rotate.key")
# test encryption decryption
ctxt1 = pyfhel.encryptBatch([42])
self.assertEqual(
pyfhel2.decryptBatch(ctxt1)[0],
42,
"decrypting with restored keys should work",
)
try:
pyfhel2.rotate(ctxt1, -1)
self.assertEqual(
pyfhel2.decryptBatch(ctxt1)[1],
42,
"decrypting with restored keys should work",
)
except Exception as err:
self.fail("PyPtxt() creation failed unexpectedly: ", err)
# test ciphertext storing
ctxt2 = pyfhel.encryptInt(42)
ctxt2.save(tmp_dir.name + "/ctxt2")
ctxt_restored = PyCtxt()
ctxt_restored.load(tmp_dir.name + "/ctxt2", "int")
self.assertEqual(pyfhel2.decryptInt(ctxt_restored), 42,
"decrypting ciphertext should work")
tmp_dir.cleanup()
def test_Pyfhel_3d_encrypt_decrypt_array(self):
pyfhel = Pyfhel()
pyfhel.contextGen(p=1964769281, m=8192, base=2, sec=192, flagBatching=True)
pyfhel.keyGen()
self.assertTrue(pyfhel.batchEnabled())
ctxt = pyfhel.encryptArray(np.array([1, 2, 3, 4, 5, 6], dtype=np.int64))
self.assertEqual(pyfhel.getnSlots(), 8192)
self.assertTrue(
np.alltrue(pyfhel.decryptArray(ctxt)[:6] == np.array([1, 2, 3, 4, 5, 6], dtype=np.int64))
)
def test_Pyfhel_2d_encode_decode_array(self):
pyfhel = Pyfhel()
pyfhel.contextGen(p=1964769281, m=8192, base=2, sec=192, flagBatching=True)
pyfhel.keyGen()
self.assertTrue(pyfhel.batchEnabled())
ptxt = pyfhel.encodeArray(np.array([1, 2, 3, 4, 5, 6]))
self.assertEqual(pyfhel.getnSlots(), 8192)
self.assertTrue(
np.alltrue(pyfhel.decodeArray(ptxt)[:6] == np.array([1, 2, 3, 4, 5, 6]))
)
def test_Pyfhel_2b_encode_decode_float(self):
pyfhel = Pyfhel()
pyfhel.contextGen(p=65537, m=8192, base=2, intDigits=80, fracDigits=20)
pyfhel.keyGen()
ptxt = pyfhel.encodeFrac(19.30)
self.assertTrue(ptxt.to_poly_string(), b"9x^8190 + 1x^4 + 1x^1 + 1")
self.assertEqual(round(pyfhel.decodeFrac(ptxt), 2), 19.30)
pyfhel.encodeFrac(-2.25, ptxt)
self.assertEqual(ptxt.to_poly_string(), b"1x^8190 + 10000x^1")
self.assertEqual(round(pyfhel.decodeFrac(ptxt), 2), -2.25)
def test_Pyfhel_3a_encrypt_decrypt_int(self):
pyfhel = Pyfhel()
pyfhel.contextGen(p=65537)
pyfhel.keyGen()
ctxt = pyfhel.encryptInt(127)
self.assertEqual(pyfhel.decryptInt(ctxt), 127)
ctxt2 = PyCtxt(ctxt)
pyfhel.encryptInt(-2, ctxt)
self.assertEqual(pyfhel.decryptInt(ctxt), -2)
self.assertEqual(pyfhel.decryptInt(ctxt), -2)
self.assertEqual(pyfhel.decryptInt(ctxt2), 127)
def test_Pyfhel_5a_save_objects(self):
pyfhel = Pyfhel()
pyfhel.contextGen(p=1964769281, m=8192, base=2, sec=192, flagBatching=True)
pyfhel.keyGen()
pyfhel.rotateKeyGen(60)
pyfhel.relinKeyGen(60,3)
self.assertTrue(pyfhel.saveContext("context.pycon"))
self.assertTrue(pyfhel.savepublicKey("public_k.pypk"))
self.assertTrue(pyfhel.savesecretKey("secret_k.pysk"))
self.assertTrue(pyfhel.saverelinKey("relin_k.pyrlk"))
self.assertTrue(pyfhel.saverotateKey("rotate_k.pyrok"))
def test_get_min_noise(self):
HE = Pyfhel()
HE.contextGen(65537)
HE.keyGen()
plain_image = np.array([[[1, 2, 3], [1, 3, 4], [1, 3, 4]]])
cipher_image = encrypt_matrix(HE, plain_image)
cipher_image[0][1][1] = cipher_image[0][1][1] * HE.encryptFrac(2)
assert get_min_noise(HE, cipher_image) == HE.noiseLevel(
cipher_image[0][1][1])
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 test_init(self):
HE = Pyfhel()
HE.contextGen(65537)
HE.keyGen()
HE.relinKeyGen(30, 100)
new_weights = np.array([
[1, 2, 3, 4]
,[2, 3, 4, 5]
,[3, 4, 5, 6]
])
linear_layer = lin.LinearLayer(HE, new_weights)
assert HE.decodeFrac(linear_layer.weights[0][0]) == 1
assert HE.decodeFrac(linear_layer.weights[0][1]) == 2
assert HE.decodeFrac(linear_layer.weights[0][2]) == 3
assert HE.decodeFrac(linear_layer.weights[0][3]) == 4
assert HE.decodeFrac(linear_layer.weights[1][0]) == 2
assert HE.decodeFrac(linear_layer.weights[1][1]) == 3
assert HE.decodeFrac(linear_layer.weights[1][2]) == 4
assert HE.decodeFrac(linear_layer.weights[1][3]) == 5
assert HE.decodeFrac(linear_layer.weights[2][0]) == 3
assert HE.decodeFrac(linear_layer.weights[2][1]) == 4
assert HE.decodeFrac(linear_layer.weights[2][2]) == 5
assert HE.decodeFrac(linear_layer.weights[2][3]) == 6
assert linear_layer.bias == None
bias = np.array([2, 2, 2])
linear_layer2 = lin.LinearLayer(HE, new_weights, bias)
assert HE.decodeFrac(linear_layer.weights[0][0]) == 1
assert HE.decodeFrac(linear_layer.weights[0][1]) == 2
assert HE.decodeFrac(linear_layer.weights[0][2]) == 3
assert HE.decodeFrac(linear_layer.weights[0][3]) == 4
assert HE.decodeFrac(linear_layer.weights[1][0]) == 2
assert HE.decodeFrac(linear_layer.weights[1][1]) == 3
assert HE.decodeFrac(linear_layer.weights[1][2]) == 4
assert HE.decodeFrac(linear_layer.weights[1][3]) == 5
assert HE.decodeFrac(linear_layer.weights[2][0]) == 3
assert HE.decodeFrac(linear_layer.weights[2][1]) == 4
assert HE.decodeFrac(linear_layer.weights[2][2]) == 5
assert HE.decodeFrac(linear_layer.weights[2][3]) == 6
assert HE.decodeFrac(linear_layer2.bias[0]) == 2
assert HE.decodeFrac(linear_layer2.bias[1]) == 2
assert HE.decodeFrac(linear_layer2.bias[2]) == 2
def test_get_max_error(self):
HE = Pyfhel()
HE.contextGen(65537)
HE.keyGen()
plain_image = np.array([[1, 2, 3], [1, 3, 4], [1, 3, 4]])
cipher_image = encrypt_matrix(HE, plain_image)
cipher_image[2][0] = HE.encryptFrac(-1)
max_error, position = get_max_error(HE, plain_image, cipher_image)
assert max_error == 2
assert position, (2 == 0)
def test_Pyfhel_5d_save_restore_batch(self):
pyfhel = Pyfhel()
pyfhel.contextGen(p=1964769281, m=8192, base=2, sec=192, flagBatching=True)
pyfhel.keyGen()
pyfhel.rotateKeyGen(60)
pyfhel.relinKeyGen(60, 4)
# encrypt something
ctxt = pyfhel.encryptBatch([1, 2, 3, 4])
# save to temporary file
tmp = tempfile.NamedTemporaryFile()
ctxt.save(tmp.name)
# load from temporary file
loaded = PyCtxt()
loaded.load(tmp.name, "batch")
self.assertEqual(pyfhel.decryptBatch(loaded)[:4], [1, 2, 3, 4])
def encryptImg(Img):
Img_shape = Img.shape
print(Img_shape)
encImg = [[0 for j in range(Img_shape[1])] for i in range(Img_shape[0])]
pyfhel = Pyfhel() # Creating empty Pyfhel object
pyfhel.contextGen(p=65537, m=1024,
flagBatching=True) # Generating context. (encrypt pixel)
pyfhel.keyGen() # keygeneration
for py in range(Img_shape[0]):
for px in range(Img_shape[1]):
temp_pxl = Img[py, px]
cxt_pxl = pyfhel.encryptFrac(temp_pxl) # test floating number
dec_pxl = pyfhel.decryptFrac(cxt_pxl) # decrypt
encImg[py][px] = cxt_pxl
return encImg, pyfhel
def test_Pyfhel_5f_save_restore_batch(self):
pyfhel = Pyfhel()
pyfhel.contextGen(p=1964769281, m=8192, base=2, sec=192, flagBatching=True)
pyfhel.keyGen()
pyfhel.rotateKeyGen(60)
pyfhel.relinKeyGen(60, 4)
# encrypt something
ctxt = pyfhel.encryptBatch([1, 2, 3, 4])
# save to temporary file
tmp_dir = tempfile.TemporaryDirectory()
tmp_file = os.path.join(tmp_dir.name, "ctxt")
ctxt.save(tmp_file)
# load from temporary file
loaded = PyCtxt()
loaded.load(tmp_file, "batch")
self.assertEqual(pyfhel.decryptBatch(loaded)[:4], [1, 2, 3, 4])
tmp_dir.cleanup()
class customer():
def __init__(self, p):
self.HE = Pyfhel()
self.HE.contextGen(p=p)
self.HE.keyGen()
def save(self, context_path, pk_path, sk_path):
self.HE.saveContext(context_path)
self.HE.savepublicKey(pk_path)
self.HE.savesecretKey(sk_path)
def ecnypt(self, arr):
'''
:param arr: should be float numpy matrix
:return: encrypted numpy matrix
'''
row, col = arr.shape[0], arr.shape[1]
new_a = []
for i in range(row):
row_val = []
for j in range(col):
row_val.append(self.HE.encryptFrac(arr[i, j]))
new_a.append(row_val)
new_a = np.asarray(new_a)
return new_a.reshape(row, col)
def decrypt(self, enc_arr):
'''
:param enc_arr: encrypted numpy matrix
:return: float numpy matrix
'''
row, col = enc_arr.shape[0], enc_arr.shape[1]
new_a = []
for i in range(row):
row_val = []
for j in range(col):
row_val.append(self.HE.decryptFrac(enc_arr[i, j]))
new_a.append(row_val)
new_a = np.asarray(new_a)
return new_a.reshape(row, col)
def decrypt_scalar(self, enc_scalar):
return self.HE.decryptFrac(enc_scalar)
def index():
if request.method == "POST":
details = request.form
firstName = details['fname']
lastName = details['lname']
HE = Pyfhel()
HE.contextGen(p=65537)
HE.keyGen()
HE.saveContext('data/Konteks_file')
HE.savepublicKey('data/kunci_file')
HE.savesecretKey('data/KunciSec.key')
c1 = HE.encryptInt(int(firstName))
q1 = str(c1)
cur = mysql.connection.cursor()
cur.execute("INSERT INTO Pengguna(noID,umur) VALUES (%s,%s)",
(q1, lastName))
mysql.connection.commit()
cur.close()
q1 = (str(c1)).replace('<', '')
q1 = q1.replace('>', '')
return q1
return render_template('InputUser.html')
def test_Pyfhel_4b_operations_frac(self):
pyfhel = Pyfhel()
pyfhel.contextGen(p=1964769281, m=8192, base=3, sec=192)
pyfhel.keyGen()
ctxti = pyfhel.encryptFrac(19.37)
ctxti2 = pyfhel.encryptFrac(-2.25)
ptxti = pyfhel.encodeFrac(3.12)
ctxt_add = pyfhel.add(ctxti, ctxti2, in_new_ctxt=True)
ctxt_add2 = pyfhel.add_plain(ctxti, ptxti, in_new_ctxt=True)
ctxt_sub = pyfhel.sub(ctxti, ctxti2, in_new_ctxt=True)
ctxt_sub2 = pyfhel.sub_plain(ctxti, ptxti, in_new_ctxt=True)
ctxt_mult = pyfhel.multiply(ctxti, ctxti2, in_new_ctxt=True)
ctxt_mult2 = pyfhel.multiply_plain(ctxti, ptxti, in_new_ctxt=True)
self.assertEqual(round(pyfhel.decryptFrac(ctxt_add), 2), 17.12)
self.assertEqual(round(pyfhel.decryptFrac(ctxt_add2), 2), 22.49)
self.assertEqual(round(pyfhel.decryptFrac(ctxt_sub), 2), 21.62)
self.assertEqual(round(pyfhel.decryptFrac(ctxt_sub2), 2), 16.25)
self.assertEqual(round(pyfhel.decryptFrac(ctxt_mult), 2), -43.58)
self.assertEqual(round(pyfhel.decryptFrac(ctxt_mult2), 2), 60.43)
def test_Pyfhel_4a_operations_integer(self):
pyfhel = Pyfhel()
pyfhel.contextGen(p=1964769281, m=8192, base=3, sec=192)
pyfhel.keyGen()
ctxti = pyfhel.encryptInt(127)
ctxti2 = pyfhel.encryptInt(-2)
ptxti = pyfhel.encodeInt(3)
ctxt_add = pyfhel.add(ctxti, ctxti2, in_new_ctxt=True)
ctxt_add2 = pyfhel.add_plain(ctxti, ptxti, in_new_ctxt=True)
ctxt_sub = pyfhel.sub(ctxti, ctxti2, in_new_ctxt=True)
ctxt_sub2 = pyfhel.sub_plain(ctxti, ptxti, in_new_ctxt=True)
ctxt_mult = pyfhel.multiply(ctxti, ctxti2, in_new_ctxt=True)
ctxt_mult2 = pyfhel.multiply_plain(ctxti, ptxti, in_new_ctxt=True)
self.assertEqual(pyfhel.decryptInt(ctxt_add), 125)
self.assertEqual(pyfhel.decryptInt(ctxt_add2), 130)
self.assertEqual(pyfhel.decryptInt(ctxt_sub), 129)
self.assertEqual(pyfhel.decryptInt(ctxt_sub2), 124)
self.assertEqual(pyfhel.decryptInt(ctxt_mult), -254)
self.assertEqual(pyfhel.decryptInt(ctxt_mult2), 381)
import time
from Pyfhel import Pyfhel, PyPtxt, PyCtxt
# Pyfhel class contains most of the functions.
# PyPtxt is the plaintext class
# PyCtxt is the ciphertext class
print("==============================================================")
print("================== Pyfhel CONTEXT PARAMETERS =================")
print("==============================================================")
print("1. p (long): Plaintext modulus. All operations are modulo p. ")
HE = Pyfhel() # Creating empty Pyfhel object
HE.contextGen(p=65537) # Generating context. The value of p is important.
# There are many configurable parameters on this step
HE.keyGen() # Key Generation.
print("2. m (long=2048): Polynomial coefficient modulus.")
print(
" Higher allows more encrypted operations. In batch mode it is the number of integers per ciphertext."
)
def time_demo_helloworld(integer1=127, integer2=-2):
start = time.time()
ctxt1 = HE.encryptInt(integer1) # Encryption makes use of the public key
ctxt2 = HE.encryptInt(
integer2) # For integers, encryptInt function is used.
ctxtSum = ctxt1 + ctxt2 # `ctxt1 += ctxt2` for quicker inplace operation
ctxtSub = ctxt1 - ctxt2 # `ctxt1 -= ctxt2` for quicker inplace operation
ctxtMul = ctxt1 * ctxt2 # `ctxt1 *= ctxt2` for quicker inplace operation
from Pyfhel import Pyfhel,PyCtxt,PyPtxt
import numpy as np
import time
he=Pyfhel()
he.contextGen(p=1179649,m=32768,flagBatching=True,fracDigits=20)
he.keyGen()
a=PyCtxt()
b=PyCtxt()
q=0
cc=0
#加密文件
def PPctxt(name):
fil=open(name)
lines=fil.readlines()
strr=''.join(lines)
global l
l=len(strr)
l=l-1
arr=[]
for line in strr:
for ind in line:
arr.append(ind)
#arr.remove('\n')
brr=[]
for i in arr:
brr.append(ord(i))
crr=np.array(brr)
#列表数据转数组
err=he.encryptBatch(crr)
err.save(name)
# * PyPtxt is the plaintext class
# * PyCtxt is the ciphertext class
import numpy as np
from Pyfhel import Pyfhel
print("1. Import Pyfhel class, and numpy for the inputs to encrypt.")
# %%
# 2. Context and key setup
# ---------------------------
# We will start the Helloworld by generating a context and a public/secret key pair.
# This is all managed by a Pyfhel instance under the hood.
HE = Pyfhel() # Creating empty Pyfhel object
HE.contextGen(scheme='bfv', n=2**14, t_bits=20) # Generate context for 'bfv'/'ckks' scheme
# The n defines the number of plaintext slots.
# There are many configurable parameters on this step
# More info in Demo_2, Demo_3, and Pyfhel.contextGen()
HE.keyGen() # Key Generation: generates a pair of public/secret keys
# %%
# The best way to obtain information from a created Pyfhel object is to print it:
print("2. Context and key setup")
print(HE)
# %%
# 3. Integer Encryption
# ---------------------------
# we will define two integers and encrypt them using `encryptInt`:
integer1 = np.array([127], dtype=np.int64)
integer2 = np.array([-2], dtype=np.int64)
ctxt1 = HE.encryptInt(integer1) # Encryption makes use of the public key
ctxt2 = HE.encryptInt(integer2) # For integers, encryptInt function is used.
print("3. Integer Encryption, ")
print(" int ",integer1,'-> ctxt1 ', type(ctxt1))
def remote_execution_aws(data, parameters):
def encode_ciphertext(c, temp_file):
with (open(temp_file.name, "w+b")) as f:
c.save(temp_file.name)
bc = f.read()
b64 = str(base64.b64encode(bc))[2:-1]
return b64
def decode_ciphertext(b64, temp_file):
with (open(temp_file.name, "w+b")) as f:
x = bytes(b64, encoding='utf-8')
x = base64.decodebytes(x)
f.write(x)
c = HE.encryptFrac(0)
c.load(temp_file.name, "float")
return c
def crypt_and_encode(HE, t, ret_dict, ind):
temp_file = tempfile.NamedTemporaryFile()
enc_image = encrypt_matrix(HE, t)
data = [[[[encode_ciphertext(value, temp_file) for value in row]
for row in column] for column in layer]
for layer in enc_image]
ret_dict[ind] = data
def decode_and_decrypt(HE, t, ret_dict, ind):
temp_file = tempfile.NamedTemporaryFile()
enc_res = np.array(
[[[[decode_ciphertext(value, temp_file) for value in row]
for row in column] for column in layer] for layer in t])
dec_res = decrypt_matrix(HE, enc_res)
ret_dict[ind] = dec_res
def uploadS3(msg_path, bucket, ak, sk):
s3c = boto3.client('s3',
aws_access_key_id=ak,
aws_secret_access_key=sk)
if '/' in msg_path:
pos = len(msg_path) - 1
c = msg_path[pos]
while (c != '/'):
pos -= 1
c = msg_path[pos]
pos += 1
ts = str(datetime.datetime.now()).replace(' ', '_').replace(
':', '-').replace('.', '-')
try:
in_file_name = 'input_payload_{}'.format(ts)
s3c.upload_file(msg_path, bucket, 'input/{}'.format(in_file_name))
return in_file_name
except:
raise Exception("error while uploading {}".format(msg_path))
address = parameters["address"]
ak = parameters["ak"]
sk = parameters["sk"]
bk = parameters["bk"]
encryption_parameters = parameters["encryption_parameters"]
max_threads = parameters["max_threads"]
temp_file_payload = tempfile.NamedTemporaryFile()
HE = Pyfhel()
HE.contextGen(m=encryption_parameters[0]["m"],
p=encryption_parameters[0]["p"],
sec=encryption_parameters[0]["sec"],
base=encryption_parameters[0]["base"])
HE.keyGen()
manager = multiprocessing.Manager()
return_dict = manager.dict()
processes = []
distributions = []
if len(data) % max_threads == 0:
n_threads = max_threads
subtensors_dim = len(data) // n_threads
for i in range(0, n_threads):
distributions.append(
[i * subtensors_dim, i * subtensors_dim + subtensors_dim])
else:
n_threads = min(max_threads, len(data))
subtensors_dim = len(data) // n_threads
for i in range(0, n_threads):
distributions.append(
[i * subtensors_dim, i * subtensors_dim + subtensors_dim])
for k in range(0, (len(data) % n_threads)):
distributions[k][1] += 1
distributions[k + 1::] = [[x + 1, y + 1]
for x, y in distributions[k + 1::]]
for i in range(0, n_threads):
processes.append(
multiprocessing.Process(
target=crypt_and_encode,
args=(HE, data[distributions[i][0]:distributions[i][1]],
return_dict, i)))
processes[-1].start()
for p in processes:
p.join()
data = np.array(return_dict[0])
for i in range(1, n_threads):
data = np.concatenate((data, return_dict[i]))
payload = parameters
payload["data"] = data.tolist()
with open(temp_file_payload.name, 'w') as fp:
json.dump(payload, fp)
remote_filename = uploadS3(temp_file_payload.name, bk, ak, sk)
msg = {
"access_key": ak,
"secret_key": sk,
"bucket": bk,
"filename": remote_filename
}
jmsg = json.dumps(msg)
r = requests.post(address, jmsg)
if r.status_code == 200:
print("Done.")
out_file = r.json()
print("Downloading response...")
s3r = boto3.resource('s3', aws_access_key_id=ak, aws_secret_access_key=sk)
obj = s3r.Object(bk, 'output/{}'.format(out_file))
resp_payload = json.load(obj.get()['Body'])
print("Cleaning S3 support files...")
inp_tbd = s3r.Object(bk, "input/{}".format(remote_filename))
out_tbd = s3r.Object(bk, "output/{}".format(out_file))
inp_tbd.delete()
out_tbd.delete()
print("Done.")
enc_result = resp_payload["data"]
return_dict = manager.dict()
processes = []
for i in range(0, n_threads):
processes.append(
multiprocessing.Process(
target=decode_and_decrypt,
args=(HE, enc_result[distributions[i][0]:distributions[i][1]],
return_dict, i)))
processes[-1].start()
for p in processes:
p.join()
result = np.array(return_dict[0])
for i in range(1, n_threads):
result = np.concatenate((result, return_dict[i]))
return result
def remote_execution_rest(data, parameters):
encryption_parameters = parameters["encryption_parameters"]
address = parameters["address"]
max_threads = parameters["max_threads"]
def encode_ciphertext(c, temp_file):
with (open(temp_file.name, "w+b")) as f:
c.save(temp_file.name)
bc = f.read()
b64 = str(base64.b64encode(bc))[2:-1]
return b64
def decode_ciphertext(b64, temp_file):
with (open(temp_file.name, "w+b")) as f:
x = bytes(b64, encoding='utf-8')
x = base64.decodebytes(x)
f.write(x)
c = HE.encryptFrac(0)
c.load(temp_file.name, "float")
return c
def crypt_and_encode(HE, t, ret_dict=None, ind=None):
temp_file = tempfile.NamedTemporaryFile()
enc_image = encrypt_matrix(HE, t)
if len(enc_image.shape) > 2:
data = [[[[encode_ciphertext(value, temp_file) for value in row]
for row in column] for column in layer]
for layer in enc_image]
else:
data = [[encode_ciphertext(value, temp_file) for value in row]
for row in enc_image]
data = np.array(data)
if ret_dict is not None:
ret_dict[ind] = data
else:
return data
def decode_and_decrypt(HE, t, ret_dict=None, ind=None):
temp_file = tempfile.NamedTemporaryFile()
t = np.array(t)
if len(t.shape) > 2:
enc_res = np.array(
[[[[decode_ciphertext(value, temp_file) for value in row]
for row in column] for column in layer] for layer in t])
else:
enc_res = np.array(
[[decode_ciphertext(value, temp_file) for value in row]
for row in t])
dec_res = decrypt_matrix(HE, enc_res)
if ret_dict is not None:
ret_dict[ind] = dec_res
else:
return dec_res
HE = Pyfhel()
HE.contextGen(m=encryption_parameters[0]["m"],
p=encryption_parameters[0]["p"],
sec=encryption_parameters[0]["sec"],
base=encryption_parameters[0]["base"])
HE.keyGen()
if max_threads == 1:
data = crypt_and_encode(HE, data)
payload = parameters
payload["data"] = data.tolist()
json_payload = jsonpickle.encode(payload)
res = requests.post(address, json=json_payload)
enc_result = jsonpickle.decode(res.content)["data"]
result = decode_and_decrypt(HE, enc_result)
return result
else:
manager = multiprocessing.Manager()
return_dict = manager.dict()
processes = []
distributions = []
if len(data) % max_threads == 0:
n_threads = max_threads
subtensors_dim = len(data) // n_threads
for i in range(0, n_threads):
distributions.append(
[i * subtensors_dim, i * subtensors_dim + subtensors_dim])
else:
n_threads = min(max_threads, len(data))
subtensors_dim = len(data) // n_threads
for i in range(0, n_threads):
distributions.append(
[i * subtensors_dim, i * subtensors_dim + subtensors_dim])
for k in range(0, (len(data) % n_threads)):
distributions[k][1] += 1
distributions[k + 1::] = [[x + 1, y + 1]
for x, y in distributions[k + 1::]]
for i in range(0, n_threads):
processes.append(
multiprocessing.Process(
target=crypt_and_encode,
args=(HE, data[distributions[i][0]:distributions[i][1]],
return_dict, i)))
processes[-1].start()
for p in processes:
p.join()
data = np.array(return_dict[0])
for i in range(1, n_threads):
data = np.concatenate((data, return_dict[i]))
payload = parameters
payload["data"] = data.tolist()
json_payload = jsonpickle.encode(payload)
res = requests.post(address, json=json_payload)
enc_result = jsonpickle.decode(res.content)["data"]
return_dict = manager.dict()
processes = []
for i in range(0, n_threads):
processes.append(
multiprocessing.Process(
target=decode_and_decrypt,
args=(HE,
enc_result[distributions[i][0]:distributions[i][1]],
return_dict, i)))
processes[-1].start()
for p in processes:
p.join()
result = np.array(return_dict[0])
for i in range(1, n_threads):
result = np.concatenate((result, return_dict[i]))
return result