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 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)