def testIssue62(self):
pub, priv = paillier.generate_paillier_keypair()
a = pub.encrypt(445)
# Force big exponent.
b = pub.encrypt(0.16413409062205825) + pub.encrypt(2 ** -965)
# This will raise OverflowError without bugfix #73.
priv.decrypt(a + b)
def bench_time(test_size, key_size=128):
print('Paillier Benchmarks with key size of {} bits'.format(key_size))
pubkey, prikey = paillier.generate_paillier_keypair(n_length=key_size)
nums1 = [random.random() for _ in range(test_size)]
nums2 = [random.random() for _ in range(test_size)]
nums1_enc = [pubkey.encrypt(n) for n in nums1]
nums2_enc = [pubkey.encrypt(n) for n in nums2]
ones = [1.0 for _ in range(test_size)]
times = [
time_method(bench_encrypt, pubkey, nums1),
time_method(bench_decrypt, prikey, nums1_enc),
time_method(bench_add, nums1_enc, nums2),
time_method(bench_add, nums1_enc, nums2_enc),
time_method(bench_add, nums1_enc, ones),
time_method(bench_mul, nums1_enc, nums2)
]
times = [t / test_size for t in times]
ops = [int(1.0 / t) for t in times]
print(
'operation: time in seconds (# operations per second)\n'
'encrypt: {:.6f} s ({} ops/s)\n'
'decrypt: {:.6f} s ({} ops/s)\n'
'add unencrypted and encrypted: {:.6f} s ({} ops/s)\n'
'add encrypted and encrypted: {:.6f} s ({} ops/s)\n'
'add encrypted and 1: {:.6f} s ({} ops/s)\n'
'multiply encrypted and unencrypted: {:.6f} s ({} ops/s)'.format(
times[0], ops[0], times[1], ops[1], times[2], ops[2],
times[3], ops[3], times[4], ops[4], times[5], ops[5]
)
)
return times
def testStaticPrivateKeyConstructor(self):
public_key, private_key = paillier.generate_paillier_keypair()
p = private_key.p
q = private_key.q
private_key_from_static = PaillierPrivateKey.from_totient(public_key, (p-1) * (q-1))
c = public_key.encrypt(4242)
self.assertEqual(private_key, private_key_from_static, "The private keys should be the same.")
self.assertEqual(private_key_from_static.decrypt(c), 4242, "Result of the decryption should be 4242")
def testCreateKeypairLengths(self):
for key_length in [8, 16, 32, 64, 128, 256, 512, 1024, 2048]:
public_key, private_key = paillier.generate_paillier_keypair(n_length=key_length)
self.assertTrue(hasattr(public_key, 'g'))
self.assertTrue(hasattr(public_key, 'n'))
self.assertTrue(hasattr(private_key, 'mu'))
self.assertTrue(hasattr(private_key, 'Lambda'))
def testKeyUniqueness(self):
repeats = 100
public_keys = set()
private_keys = set()
for i in range(repeats):
public_key, private_key = paillier.generate_paillier_keypair(n_length=256)
self.assertNotIn(public_key, public_keys, "Managed to generate the same public key")
self.assertNotIn(private_key, private_keys, "Managed to generate the same private key")
public_keys.add(public_key)
private_keys.add(private_key)
def bench_mem(test_size):
r_init = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
pubkey, prikey = paillier.generate_paillier_keypair()
nums = []
for i in range(test_size):
if not i % 10000:
# This is probably KB (i.e. 1000 bytes) when run on linux
r = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss - r_init
print('Memory usage for {:,} encrypted numbers = {:,} ({:.4f} per '
'number)'.format(i, r, i and r / i))
nums.append(pubkey.encrypt(random.random()))
def setUpClass(cls):
# Could move this into setUpModule() if we get too many classes
cls.public_key, cls.private_key = paillier.generate_paillier_keypair()
enc_flt = cls.public_key.encrypt
cls.vec4_1_non_neg = [0.3, 1.7, 6857.6, 1e-6]
cls.vec4_2 = [-68, 1.8, 34, 1.5e6]
cls.e_vec4_1 = [enc_flt(x) for x in cls.vec4_1_non_neg]
cls.e_vec4_2 = [enc_flt(x) for x in cls.vec4_2]
def testDefaultCreateKeypair(self):
public_key, private_key = paillier.generate_paillier_keypair()
self.assertTrue(hasattr(public_key, 'g'))
self.assertTrue(hasattr(public_key, 'n'))
self.assertTrue(hasattr(private_key, 'mu'))
self.assertTrue(hasattr(private_key, 'Lambda'))
self.assertTrue(hasattr(private_key, 'public_key'))
self.assertTrue(str(public_key).startswith('<PaillierPublicKey '))
self.assertTrue(str(private_key).startswith('<PaillierPrivateKey '))
def testKeyUniqueness(self):
repeats = 100
public_keys = set()
private_keys = set()
for _ in range(repeats):
public_key, private_key = paillier.generate_paillier_keypair(
n_length=256)
self.assertNotIn(public_key, public_keys,
"Managed to generate the same public key")
self.assertNotIn(private_key, private_keys,
"Managed to generate the same private key")
public_keys.add(public_key)
private_keys.add(private_key)
def testCreateKeypairLengths(self):
for key_length in [8, 16, 32, 64, 128, 256, 512, 1024, 2048, 3072, 4096]:
public_key, private_key = paillier.generate_paillier_keypair(n_length=key_length)
self.assertTrue(hasattr(public_key, 'g'))
self.assertTrue(hasattr(public_key, 'n'))
self.assertTrue(hasattr(private_key, 'p'))
self.assertTrue(hasattr(private_key, 'q'))
# Check that no exceptions are raised representing these keys
repr(public_key)
repr(private_key)
def testKeyring(self):
keyring1 = paillier.PaillierPrivateKeyring()
public_key1, private_key1 = paillier.generate_paillier_keypair(keyring1)
public_key2, private_key2 = paillier.generate_paillier_keypair(keyring1)
self.assertEqual(private_key1, keyring1[public_key1])
self.assertEqual(private_key2, keyring1[public_key2])
ciphertext1 = public_key1.encrypt(5318008)
ciphertext2 = public_key2.encrypt(1337)
self.assertEqual(5318008, keyring1.decrypt(ciphertext1))
self.assertEqual(1337, keyring1.decrypt(ciphertext2))
keyring2 = paillier.PaillierPrivateKeyring([private_key1, private_key2])
self.assertEqual(keyring1, keyring2)
self.assertRaises(TypeError, keyring1.add, public_key1)
keyring1.add(private_key1)
self.assertEqual(2, len(keyring1))
del keyring1[public_key1]
self.assertEqual(1, len(keyring1))
self.assertRaises(KeyError, keyring1.decrypt, ciphertext1)
def testCreateKeypairLengths(self):
for key_length in [8, 16, 32, 64, 128, 256, 512, 1024, 2048, 3072, 4096]:
public_key, private_key = paillier.generate_paillier_keypair(n_length=key_length)
self.assertTrue(hasattr(public_key, 'g'))
self.assertTrue(hasattr(public_key, 'n'))
self.assertTrue(hasattr(private_key, 'mu'))
self.assertTrue(hasattr(private_key, 'Lambda'))
# Check that no exceptions are raised representing these keys
repr(public_key)
repr(private_key)
def testKeyring(self):
keyring1 = paillier.PaillierPrivateKeyring()
public_key1, private_key1 = paillier.generate_paillier_keypair(keyring1)
public_key2, private_key2 = paillier.generate_paillier_keypair(keyring1)
self.assertEqual(private_key1, keyring1[public_key1])
self.assertEqual(private_key2, keyring1[public_key2])
ciphertext1 = public_key1.encrypt(5318008)
ciphertext2 = public_key2.encrypt(1337)
self.assertEqual(5318008, keyring1.decrypt(ciphertext1))
self.assertEqual(1337, keyring1.decrypt(ciphertext2))
keyring2 = paillier.PaillierPrivateKeyring([private_key1, private_key2])
self.assertEqual(keyring1, keyring2)
self.assertRaises(TypeError, keyring1.add, public_key1)
keyring1.add(private_key1)
self.assertEqual(2, len(keyring1))
del keyring1[public_key1]
self.assertEqual(1, len(keyring1))
self.assertRaises(KeyError, keyring1.decrypt, ciphertext1)
def init_encryption(dec_server_ip, dec_server_port):
'''
Initialization of encryption:
1. connect to decryption server
2. deliver the private key
'''
global private_key
start_ts = time.perf_counter()
public_key, private_key = paillier.generate_paillier_keypair()
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.connect((dec_server_ip, dec_server_port))
send(server, {'type': 'key', 'content': private_key})
resp = receive(server)
print('Time of delivering private key: %d, response: %s' %
(time.perf_counter() - start_ts, resp['content']))
return server, public_key
def decryption(key_size, plaintext):
pubkey, prikey = paillier.generate_paillier_keypair(n_length=key_size)
m = PLAINTEXTS[plaintext]
c = pubkey.encrypt(m)
start = time.time()
for _ in range(ITERATIONS):
n = prikey.decrypt(c)
stop = time.time()
diff = stop - start
diff = diff / ITERATIONS
print("decryption (%d, %s): %fms" % (key_size, plaintext, diff * 1000))
def encryption(key_size, plaintext):
pubkey, prikey = paillier.generate_paillier_keypair(n_length=key_size)
m = PLAINTEXTS[plaintext]
start = time.time()
for _ in range(ITERATIONS):
c = pubkey.encrypt(m)
c.ciphertext() # force obfuscation if not done so already
stop = time.time()
diff = stop - start
diff = diff / ITERATIONS
print("encryption (%d, %s): %fms" % (key_size, plaintext, diff * 1000))
def PPSVM_loo(file_path="../assets/breast_cancer_wisconsin.data",
verbose=False, p=2, c=3, s=4, l=9):
gamma = 10**s
line = False
t = 0.1
wbc_loader = DataLoader(file_path, t, need_normalize=False)
loo_list = wbc_loader.data_loo
n = len(loo_list)
y_test = np.zeros(n)
y_pred_SVM = np.zeros(n)
y_pred_PPSVM = np.zeros(n)
n_sv = np.zeros(n)
time_SVM = np.zeros(n)
time_PPSVM = np.zeros(n)
for i, train_test in enumerate(loo_list):
print(f"data point {i+1}/{n}")
y_test[i] = train_test[3]
# generate encryption/decryption keys
public_key, private_key = paillier.generate_paillier_keypair()
# initializing client and server with information that each entity is supposed to know
client = Client(public_key, private_key, train_test[1], train_test[3], p, gamma, l, verbose)
server = Server(public_key, train_test[0], train_test[2], p, c, gamma, l, verbose)
client.server = server
server.client = client
# start predicting/testing
client.test(line)
n_sv[i] = server.train_y.size
y_pred_SVM[i] = client.y_SVM
y_pred_PPSVM[i] = client.y_PPSVM
time_SVM[i] = client.time_SVM
time_PPSVM[i] = client.time_PPSVM
print("loo average number of support vectors:", np.mean(n_sv))
acc_SVM, acc_per_cls_SVM = accuracy_per_class(y_test, y_pred_SVM)
acc_PPSVM, acc_per_cls_PPSVM = accuracy_per_class(y_test, y_pred_PPSVM)
similarity = np.sum(y_pred_SVM == y_pred_PPSVM) / n
print("SVM total time:", np.sum(time_SVM))
print("PPSVM total time:", np.sum(time_PPSVM))
print("similarity:", similarity)
result_SVM = [y_pred_SVM, acc_SVM, acc_per_cls_SVM, time_SVM]
result_PPSVM = [y_pred_PPSVM, acc_PPSVM, acc_per_cls_PPSVM, time_PPSVM]
return n_sv, result_SVM, result_PPSVM, similarity
def main():
with open('housing.csv', newline='') as csvfile:
reader = csv.DictReader(csvfile)
median_house_values = []
for row in reader:
median_house_values.append(float(row['median_house_value']))
#Generate private and public keys
public_key, private_key = paillier.generate_paillier_keypair()
inp_size = int(input("First n median house values: "))
secret_number_list = median_house_values[:inp_size]
print(f"Numbers to be encrypted: {secret_number_list}")
#Time the encrypt function with different input sizes
start = time.perf_counter()
encrypted_number_list = enc_median_housing_values(public_key,
secret_number_list)
stop = time.perf_counter()
print(f"Encrypted numbers: {encrypted_number_list}")
print(f"Time to encrypt {inp_size} values: {stop - start:0.4f} seconds")
#Time the decrypt func with different input sizes
start = time.perf_counter()
res = dec_median_housing_values(private_key, encrypted_number_list)
stop = time.perf_counter()
print(f"Decrypted numbers: {res}")
print(f"Time to decrypt {inp_size} values: {stop - start:0.4f} seconds")
#Calculate average of plaintext data
start = time.perf_counter()
unenc_avg = sum(secret_number_list) / len(secret_number_list)
stop = time.perf_counter()
print(f"Calculate average of plaintext data: {unenc_avg}")
print(f"Time to calc avg on plaintext data: {stop - start:0.4f} seconds")
#Calculate average of encrypted data
start = time.perf_counter()
average = sum(encrypted_number_list) / len(encrypted_number_list)
stop = time.perf_counter()
print(f"Time to calc avg on encrypted data: {stop - start:0.4f} seconds")
#Decrypting the calculation result
print(
f"Decrypting the calculation result on the encrypted data: {private_key.decrypt(average)}"
)
def logistic_regression():
'''
This function shows example of training and running logistic regression implemented by using Paillier scheme.
'''
#getting keys for paillier
public_key, private_key = pl.generate_paillier_keypair(n_length=256)
x_train, x_test, y_train, y_test, X_max, X_min = load_dataset()
print('=========== Training logistic regression ===========')
weights = training_logistic_regression(x_train, y_train, epoch=3000, learning_rate=0.1) #simple training function
print('Trained weights > ', weights)
print('=========== Encrypted test data ===========')
start = time.time()
encrypted_x_test = encrypt_logistic_regression_dataset(public_key, x_test)
encrypted_time = time.time() - start
print("encrypt time:{0}".format(encrypted_time) + "[sec]")
"""
for row in range(3):
for col in range(encrypted_x_test.shape[1]):
print(encrypted_x_test[row,col].ciphertext(), '|')
"""
print('=========== Prediction part #1 ===========')
start = time.time()
pre_prediction_results = pre_prediction(encrypted_x_test, weights)
pre_prediction_time = time.time() - start
print("pre prediction tine:{0}".format(pre_prediction_time) + "[sec]")
print('=========== Prediction part #2 (client side)===========')
strat = time.time()
results, results_classes = calcualte_sigmoid_and_decrypt_result(private_key, pre_prediction_results)
client_elapsed_time = time.time() - start
print("client elapsed time:{0}".format(client_elapsed_time) + "[sec]")
print('Predicted values:\t', results)
print('Predicted classes:\t', results_classes)
print('Actual classes:\t', y_test)
print('Accuracy :\t', calculate_accuracy(y_test, results_classes))
return weights, X_max, X_min
def addition(key_size, plaintext1, plaintext2):
pubkey, prikey = paillier.generate_paillier_keypair(n_length=key_size)
m1 = PLAINTEXTS[plaintext1]
m2 = PLAINTEXTS[plaintext2]
c1 = pubkey.encrypt(m1)
c2 = pubkey.encrypt(m2)
start = time.time()
for _ in range(ITERATIONS):
c = c1 + c2 # this does NOT rerandomise the ciphertext
stop = time.time()
diff = stop - start
diff = diff / ITERATIONS
print("addition (%d): %fms" % (key_size, diff * 1000))
def main():
PreProcess()
sparksn = SparkSession.builder.appName("fee_calc").getOrCreate()
print("app start")
#generate public key and private key
public_key, private_key = paillier.generate_paillier_keypair()
# 创建SparkConf和SparkContext
sc = sparksn.sparkContext
fee_rdd = sc.textFile(fee_filepath)
header = fee_rdd.first()
res_rdd = fee_rdd.filter(lambda hline: hline != header)\
.map(lambda cline: cline.strip().split(','))\
.map(lambda listline: [public_key.encrypt(float(ele)) for ele in listline])
#save rdd results, public key and private key
JsonSerialisation(res_rdd, public_key, private_key)
def __init__(self,
name,
hashes,
data=np.array([]),
tables=4,
d=8,
k=None,
subscribers=None) -> None:
"""
构造计算平台
:param name: 平台ID
:param hashes: 局部敏感哈希函数组所依赖的矩阵组，不同平台必须传入相同矩阵组才能正常参与协同工作
:param data: 平台的数据矩阵
:param tables: 使用的哈希表数量
:param d: 局部敏感哈希映射后的向量维度
:param k: 平台在每次产生推荐时来自自身的结果容量
:param subscribers: 协助计算平台列表
"""
self.id = name
self.data = data
_, cols = data.shape
assert len(hashes) > 0
self.hashes = hashes
d = len(hashes[0])
tables = len(hashes)
if k is None:
k = len(data)
self.k = k
if subscribers is None:
subscribers = []
self.subscribers = subscribers
self.public_key, self._private_key = paillier.generate_paillier_keypair(
)
table_size = int('1' * d, 2) + 1
self.hash_tables = [[set() for _ in range(table_size)]
for _ in range(tables)]
self.init_lsh()
def Encrypt_data():
# 加密数据，存到encrypted_data.txt
public_key, private_key = paillier.generate_paillier_keypair()
file = open('data.txt', 'r')
outfile = open('encrypted_data.txt', 'w')
msg = 'public key:{}\nprivate key:{}\n'.format(public_key, private_key)
outfile.write(msg)
lines = file.readlines()
for line in lines:
outline = []
line = line.split(',')
outline.append(line[0])
for each in line[1:]:
new = public_key.encrypt(float(each))
outline.append(new)
str = '{},'.format(outline[0])
for every in outline[1:]:
every = '{}'.format(every)
str = str + every[-11:-2] + ','
str = str[:-1] + '\n'
outfile.write(str)
def test_mp():
from multiprocessing import Array, Manager, RawArray
import multiprocessing as mp
from phe import paillier
keyring = paillier.PaillierPrivateKeyring()
public_key, private_key = paillier.generate_paillier_keypair(keyring,
n_length=128)
g = Gradient()
grads = g.grads
print(grads.shape)
begin_time = time.time()
grads_e = np.zeros(grads.shape, dtype=object)
for index, x in np.ndenumerate(grads):
grads_e[index] = public_key.encrypt(float(x))
end_time = time.time()
print('Base time: {}'.format(end_time - begin_time))
# Multiprocessing
grads_e = np.zeros(grads.shape, dtype=object)
pool = mp.Pool(mp.cpu_count())
grads_e = np.zeros(grads.shape, dtype=object)
# sa.delete("shm://test")
# a = sa.create("shm://test", grads.shape, dtype=object)
# print(a)
begin_time = time.time()
nargs = [(public_key, index, x, grads_e)
for index, x in np.ndenumerate(grads)]
grads_e = np.reshape(pool.map(encrypt, nargs), grads.shape)
end_time = time.time()
print('MP time: {}'.format(end_time - begin_time))
pool.close()
def __init__(self, poly: List[Polynomial], t, n):
self.t = t
self.n = n
self.shards = [0] * n
self.pub = O
self.proof_ni_x_i = []
self.paillier = [paillier.generate_paillier_keypair()
for _ in range(n)]
self.paillier_proof = [squarefree_proof(
x[1].p, x[1].q) for x in self.paillier]
for i in range(n):
for pp in poly:
self.shards[i] += pp.yval[i]
self.shards[i] %= order
assert pub_key_from_priv(
self.shards[i]) == self.calc_vss_proof(i+1, poly)
self.pub = ec_add(poly[i].pub, self.pub)
self.proof_ni_x_i.append(proove(self.shards[i]))
# In a real implementation all the other parties would verify this proof for this i.
assert verify(self.proof_ni_x_i[-1])
assert squarefree_verify(
self.paillier_proof[i], self.paillier[i][0].n)
def mapper():
preProcess()
#generate public key and private key
public_key, private_key = paillier.generate_paillier_keypair()
JsonSerialisation(public_key, private_key)
def processLine(set):
for line in set:
if line.startswith("name,fee"):
continue
fee_line = line.split(',')[1].strip()
fee_encry = public_key.encrypt(float(fee_line))
print(str(fee_encry.ciphertext())+","+str(fee_encry.exponent))
if isLocal:
with open(fee_filepath, 'r') as f:
processLine(f)
else:
processLine(sys.stdin)
print("All done!")
def test_pailler(data):
print('===================================')
# print('paillier - data:', data)
# print('pailler - data_length:', len(data))
paillier_public_key, paillier_private_key = paillier.generate_paillier_keypair(
n_length=1024) # 初始化paillier公钥，私钥 begin_time = time.clock()
begin_time = time.clock()
encrypt_data = [paillier_public_key.encrypt(x) for x in data]
end_time = time.clock()
encrypt_time = (end_time - begin_time)
begin_time = time.clock()
decrypt_data = [paillier_private_key.decrypt(x) for x in encrypt_data]
end_time = time.clock()
decrypt_time = (end_time - begin_time)
total_time = encrypt_time + decrypt_time
print('pailler - encrypt_time:', encrypt_time)
print('paillier - decrypt_time:', decrypt_time)
print('pailler - encrypt_time / decrypt_time:', encrypt_time / decrypt_time)
print('pailler - encrypt_time / total_time:', encrypt_time / total_time)
print('pailler - decrypt_time / total_time:', decrypt_time / total_time)
# print('paillier - decrypt_data:', decrypt_data)
return total_time
def generate_keypair(opt=None, basename=None):
print("## Interactive Key Generation ##")
if opt is None:
print("How would you like to generate your key?")
opt = input("(b) by bit-length, or (p) from p and q: ").lower()
pk = sk = None
if 'b' in opt:
blen = input("Enter a bit-length for n (default: 2048): ").strip()
blen = int(blen) if blen else paillier.DEFAULT_KEYSIZE
pk, sk = paillier.generate_paillier_keypair(None, blen)
pk.max_int = sk.public_key.max_int = _pick_max_int(pk)
elif 'p' in opt:
p = int(input("Enter private secret 'p': ").strip())
q = int(input("Enter private secret 'q': ").strip())
n = p * q
sk = make_sk(n, p, q)
pk = sk.public_key
else:
raise ValueError("Bad input option {!r}".format(opt))
if basename is None:
basename = input("Enter a basename for the key files: ")
pkname = '{}.public.json'.format(basename)
skname = '{}.private.json'.format(basename)
with open(pkname, 'w') as pkfile:
pk_to_file(pk, pkfile)
print("Wrote pk to {!r}".format(pkname))
with open(skname, 'w') as skfile:
sk_to_file(sk, skfile)
print("Wrote sk to {!r}".format(skname))
return pk, sk
def num(s):
try:
return int(s)
except ValueError:
return float(s)
if (len(sys.argv) > 1):
vote1 = num(sys.argv[1])
if (len(sys.argv) > 2):
vote2 = num(sys.argv[2])
public_key, private_key = paillier.generate_paillier_keypair()
keyring = paillier.PaillierPrivateKeyring()
keyring.add(private_key)
public_key1, private_key1 = paillier.generate_paillier_keypair(keyring)
print 'Votes 1=', vote1
print 'Votes 2=', vote2
encrypted1 = public_key.encrypt(vote1)
print 'Encrypted1=', encrypted1
encrypted2 = public_key.encrypt(vote2)
import socketserver
import pickle
from phe import paillier
# 生成秘钥对
pbk, pvk = paillier.generate_paillier_keypair(n_length=1024)
pbk.max_int = pbk.n // 2
# 乘法
def multiply(conn):
conn.sendall(bytes(1))
m1 = pvk.decrypt(pickle.loads(conn.recv(9999)))
conn.sendall(bytes(1))
m2 = pvk.decrypt(pickle.loads(conn.recv(9999)))
res = m1 * m2 % pbk.n
if res > pbk.max_int:
res -= pbk.n
conn.sendall(pickle.dumps(pbk.encrypt(res)))
def multiply_with_quantizer(conn):
conn.sendall(bytes(1))
m1 = pvk.decrypt(pickle.loads(conn.recv(9999)))
conn.sendall(bytes(1))
m2 = pvk.decrypt(pickle.loads(conn.recv(9999)))
conn.sendall(bytes(1))
q = int(pickle.loads(conn.recv(9999)))
res = m1 * m2 // q % pbk.n
if res > pbk.max_int:
res -= pbk.n
from phe import paillier hidden_dim = 100 max_iteration = 1 reg_u = 1e-4 reg_v = 1e-4 lr = 1e-3 band_width = 1 # Gb/s public_key, private_key = paillier.generate_paillier_keypair(n_length=1024, )
#%matplotlib qt
#%% Import libraries
from phe import paillier as phe
import numpy as np
import control
import binMPC as mpc
import pheMat
import random
import time
import matplotlib.pyplot as plt
#%% Init
t0 = time.time() # Timer 0
public_key, private_key = phe.generate_paillier_keypair(
n_length=2048) # Public and private keypair
r = random.SystemRandom().randrange(1, 2**16) # Random obfuscation variable
T = 20 # Control horizon
n = 20 # Optimization horizon
eta = 1 # Some optimiation stepsize variable
N = 3 # Control horizon
#%% Definitions
G = mpc.LTI() # State-space system
G.A = np.array([[1, 0, .1, 0], [0, 1, 0, .1], [0, 0, 1, 0], [0, 0, 0, 1]])
G.B = np.array([[0, 0], [0, 0], [1, 0], [0, 1]])
G.C = np.array([[1, 0, 0, 0], [0, 1, 0, 0]])
G.D = np.array([[0, 0], [0, 0]])
x0 = np.array([[0], [0], [0], [0]]) # Initial state
WP = np.array([[5], [0], [0], [0]]) # Waypoint
def __init__(self, num):
self.num = num
self.public_key, self.private_key = paillier.generate_paillier_keypair(
n_length=128)
import phe.paillier as paillier, math, pickle pubkey, prikey = paillier.generate_paillier_keypair(n_length=1024) encrypted = pubkey.encrypt(math.pi) pickledEncrypted = pickle.dumps(encrypted) encrypted2 = pickle.loads(pickledEncrypted) decrypted = prikey.decrypt(encrypted2) print(type(encrypted2)) print(decrypted)
print('Position is in Colorado')
elif match_x:
print('Position is in between longitude boundaries')
elif match_y:
print('Position is in between latitude boundaries')
else:
print('Position is elsewhere')
def send_to_server(x, y, public_key):
encrypted_lat = public_key.encrypt(normalize_deg_x(x))
encrypted_lng = public_key.encrypt(normalize_deg_y(y))
return requests.get("http://127.0.0.1:5000/calculate?g="+str(public_key.g)+"&n="+str(public_key.n)+"&lat="+str(encrypted_lat.ciphertext())+"&lng="+str(encrypted_lng.ciphertext()))
if __name__ == '__main__':
# generate a small paillier keypair
public_key, private_key = paillier.generate_paillier_keypair(n_length=1024)
print('testing position outside all boundaries')
response_outside = send_to_server(outside_all_boundaries_x, outside_all_boundaries_y, public_key)
evaluate_response(public_key, private_key, response_outside)
print('')
print('testing position inside x boundaries')
response_inside_x = send_to_server(inside_x_boundaries_x, inside_x_boundaries_y, public_key)
evaluate_response(public_key, private_key, response_inside_x)
print('')
print('testing position inside y boundaries')
response_inside_y = send_to_server(inside_y_boundaries_x, inside_y_boundaries_y, public_key)
evaluate_response(public_key, private_key, response_inside_y)
print('')
def setUpClass(cls):
# Could move this into setUpModule() if we get too many classes
cls.public_key, cls.private_key = paillier.generate_paillier_keypair()
cls.other_public_key, cls.other_private_key = paillier.generate_paillier_keypair()
import math
from phe import paillier
public_key, private_key = paillier.generate_paillier_keypair()
def linear_regression(y, x, xx, yy, xy):
lr = {"slope": 0, "intercept": 0, "r2": 0}
n = len(y)
sum_x = 0
sum_y = 0
sum_xy = 0
sum_xx = 0
sum_yy = 0
for i in range(n):
sum_x += x[i]
sum_y += y[i]
sum_xx += xx[i]
sum_yy += yy[i]
sum_xy += xy[i]
lr["slope"] = (n * sum_xy - sum_x * sum_y) / (n * sum_xx - sum_x * sum_x)
lr['intercept'] = (sum_y - lr["slope"] * sum_x) / n
lr['r2'] = (n * sum_xy - sum_x * sum_y) / math.sqrt(
(n * sum_xx - sum_x * sum_x) * (n * sum_yy - sum_y * sum_y))**2
return lr
def __init__(self, public_key, private_key):
if not public_key and not private_key:
public_key, private_key = paillier.generate_paillier_keypair()
self.public_key = public_key
self._private_key = private_key
def __init__(self, master, name):
super().__init__(master)
self.pack()
self.name = name
self.pk, self.sk = pl.generate_paillier_keypair(n_length=256)
self.score = [0] * N
self.encScore = [0] * N
self.decScore = [0] * N
self.resultScore = [0] * N
self.subList = ["プログラマー", "暗号学者", "データサイエンティスト"]
master.geometry("300x300")
master.title("進路評価システム")
master.config(bg=BG)
self.lblUser = tk.Label(master,
text="【ユーザ" + self.name + "】",
bg=BG,
font=FONT)
self.lblUser.place(x=20, y=10)
self.lbl1 = tk.Label(master,
width=20,
text="プログラミングの成績：",
anchor='e',
justify='right',
bg=BG,
font=FONT)
self.lbl1.place(x=20, y=50)
self.com1 = ttk.Combobox(master, state='readonly', width=5)
self.com1["values"] = (1, 2, 3, 4)
self.com1.current(0)
self.com1.place(x=185, y=50)
self.lbl2 = tk.Label(master,
width=20,
text="数学の成績：",
anchor='e',
justify='right',
bg=BG,
font=FONT)
self.lbl2.place(x=20, y=80)
self.com2 = ttk.Combobox(master, state='readonly', width=5)
self.com2["values"] = (1, 2, 3, 4)
self.com2.current(0)
self.com2.place(x=185, y=80)
self.lbl3 = tk.Label(master,
width=20,
text="専門科目の成績：",
anchor='e',
justify='right',
bg=BG,
font=FONT)
self.lbl3.place(x=20, y=110)
self.com3 = ttk.Combobox(master, state='readonly', width=5)
self.com3["values"] = (1, 2, 3, 4)
self.com3.current(0)
self.com3.place(x=185, y=110)
self.button = tk.Button(master,
text="送信",
command=self.buttonClick,
width=10,
font=FONT)
self.button.place(x=110, y=170)
self.button.config(fg="black", bg="skyblue")
self.lblDec = tk.Label(master, text="復号結果：", bg=BG, font=FONT)
self.lblDec.place(x=30, y=230)
self.entDec = tk.Entry(master, width=10)
self.entDec.place(x=30, y=260)
self.lblJob = tk.Label(master,
text=self.name + "さんのおすすめは：",
bg=BG,
font=FONT)
self.lblJob.place(x=150, y=230)
self.entJob = tk.Entry(master, width=20)
self.entJob.place(x=150, y=260)
from phe import paillier
from HEBenchMark import HEBenchMark
args_parser = argparse.ArgumentParser()
args_parser.add_argument('--key_size', '-k', type=int, default=1024)
args_parser.add_argument('--precision', '-p', type=float, default=1e-5)
args_parser.add_argument('--int_max', '-i', type=int, default=10000)
args_parser.add_argument('--float_max', '-f', type=float, default=1.0)
args_parser.add_argument('--sample_size', '-s', type=int, default=100)
args = args_parser.parse_args()
key_size = args.key_size
precision = args.precision
print(key_size, precision)
public_key, private_key = paillier.generate_paillier_keypair(n_length=key_size)
he_benchmark = HEBenchMark(pub_key=public_key,
sec_key=private_key,
encrypt_params={'precision': precision},
output_file_name='results/paillier.csv',
output_infos=('paillier',
'%s-%s' % (key_size, precision)))
he_benchmark.run(test_objects=['c+c', 'c+p', 'c*p'],
SIMD=False,
sample_size=args.sample_size,
int_max=args.int_max,
float_max=args.float_max)
#!/usr/bin/env python3.4
import math
from phe import paillier
class ExampleEncodedNumber(paillier.EncodedNumber):
BASE = 64
LOG2_BASE = math.log(BASE, 2)
print("Generating paillier keypair")
public_key, private_key = paillier.generate_paillier_keypair()
def encode_and_encrypt_example():
print("Encoding a large positive number. With a BASE 64 encoding scheme")
encoded = ExampleEncodedNumber.encode(public_key, 2.1 ** 20)
print("Checking that decoding gives the same number...")
assert 2.1 ** 20 == encoded.decode()
print("Encrypting the encoded number")
encrypted = public_key.encrypt(encoded)
print("Decrypting...")
decrypted_but_encoded = private_key.decrypt_encoded(encrypted, ExampleEncodedNumber)
print("Checking the decrypted number is what we started with")
assert abs(2.1 ** 20 - decrypted_but_encoded.decode()) < 1e-12
def math_example():
print("Encoding two large positive numbers. With a BASE 64 encoding scheme")
def __init__(self, model, key_size=2048):
self.public_key, self.private_key = paillier.generate_paillier_keypair(
n_length=key_size)
self.model = model
from server.server import Server
from phe import paillier, EncryptedNumber, PaillierPublicKey
server = Server()
pub_key, priv_key = paillier.generate_paillier_keypair()
X = [22, 53, 61, 62, 74]
V = [11, 40, 45]
X_transformed = [22, 53, 61, 62, 74, 11, 40, 45, 1, 1, 16334, 3746]
encrypted_X = [pub_key.encrypt(i) for i in X_transformed]
server.store_template(encrypted_X, pub_key.n)
Y = [21, 52, 61, 62, 74]
V = [11, 40, 45]
Y_transformed = [-42, -104, -122, -124, -148, -22, -80, -90, 16186, 3746, 1, 1]
eucledian_distance = server.compute_euclidean(Y_transformed, server.tid)
eucledian_distance = priv_key.decrypt(
EncryptedNumber(pub_key, eucledian_distance))
print(eucledian_distance)
res = server.make_decision(eucledian_distance)
if res == True:
print("Authenticated")
else:
print("Not Authenticated")
def testCantEncryptDecryptIntWithDifferentSizeKey(self):
public_key, private_key = paillier.generate_paillier_keypair(n_length=128)
data = 1564
ciphertext = self.public_key.encrypt(data)
self.assertRaises(ValueError, private_key.decrypt, ciphertext)
