def storeKeys(): public_key, private_key = paillier.generate_paillier_keypair() keys = {} keys['public_key'] = {'n': public_key.n} keys['private_key'] = {'p': private_key.p, 'q': private_key.q} with open('custkeys.json', 'w') as file: json.dump(keys, file)
def test_from_keypair(): public_key, private_key = generate_paillier_keypair() p = Paillier(public_key, private_key) keypair = p.keypair_to_dict() Paillier._keypair_from_dict(keypair) p2 = Paillier.from_keypair_dict(keypair) assert (p2.public_key == p.public_key)
def storeKeys(): '''This function is intended to create the both public and private key.''' public_key, private_key = paillier.generate_paillier_keypair() keys = {} keys['public_key'] = {'n': public_key.n} keys['private_key'] = {'p': private_key.p, 'q': private_key.q} with open('custkeys.json', 'w') as file: json.dump(keys, file)
def __init__(self): self.n = 128 [self.pk, self.sk] = phe.generate_paillier_keypair(n_length=self.n) self.nsqu = self.n * self.n self.Y = [] self.A = [np.array([[-0.82, -0.35], [0.35, -0.85]])] self.C = [[0, 1]] self.x_est = None self.y_est = None self.noise = None
def test_get_keys(): public_key, private_key = generate_paillier_keypair() p = Paillier(public_key, private_key) public_key_dict = p._public_key_to_dict(p.public_key) private_key_dict = p._private_key_to_dict(p._private_key) public = p._public_key_from_dict(public_key_dict) private = p._private_key_from_dict(public_key_dict, private_key_dict) assert (public == p.public_key) assert (private == p._private_key)
def he_key_gen(private_keyring=None, n_length=phe.paillier.DEFAULT_KEYSIZE): """ Key generation of the paillier homomorphic encryption. The key_gen can take a private_key and n_length as parameters. The default key length is 2048 :param private_keyring: this parameter is the private key that used to generate the public key. We usually do not set up this parameter. :param n_length: the key length -- the default key size is set to 2048. :return: public/private key pair """ public_key, private_key = phe.generate_paillier_keypair( private_keyring, n_length) return public_key, private_key
def generate_keypair(keysize, id, output): """Generate a paillier private key. Output as JWK to given output file. Use "-" to output the private key to stdout. See the extract command to extract the public component of the private key. Note: The default ID text includes the current time. """ log("Generating a paillier keypair with keysize of {}".format(keysize)) pub, priv = phe.generate_paillier_keypair(n_length=keysize) log("Keys generated") date = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") jwk_public = { 'kty': "DAJ", 'alg': "PAI-GN1", "key_ops": ["encrypt"], 'n': phe.util.int_to_base64(pub.n), 'kid': "Paillier public key generated by pheutil on {}".format(date) } jwk_private = { 'kty': "DAJ", 'key_ops': ["decrypt"], 'p': phe.util.int_to_base64(priv.p), 'q': phe.util.int_to_base64(priv.q), 'pub': jwk_public, 'kid': "Paillier private key generated by pheutil on {}".format(date) } json.dump(jwk_private, output) output.write('\n') log("Private key written to {}".format(output.name))
def generate_keypair(keysize, id, output): """Generate a paillier private key. Output as JWK to given output file. Use "-" to output the private key to stdout. See the extract command to extract the public component of the private key. Note: The default ID text includes the current time. """ log("Generating a paillier keypair with keysize of {}".format(keysize)) pub, priv = phe.generate_paillier_keypair(n_length=keysize) log("Keys generated") date = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") jwk_public = { "kty": "DAJ", "alg": "PAI-GN1", "key_ops": ["encrypt"], "n": phe.util.int_to_base64(pub.n), "kid": "Paillier public key generated by pheutil on {}".format(date), } jwk_private = { "kty": "DAJ", "key_ops": ["decrypt"], "lambda": phe.util.int_to_base64(priv.Lambda), "mu": phe.util.int_to_base64(priv.mu), "pub": jwk_public, "kid": "Paillier private key generated by pheutil on {}".format(date), } json.dump(jwk_private, output) output.write("\n") log("Private key written to {}".format(output.name))
print(bobs_input) bobs_output = np.array([[0]]) model = Embedding(vocab_size=len(vocab), dim=1) model.weight.data *= 0 bobs_model = train(copy.deepcopy(model), bobs_input, bobs_output, iterations=1, batch_size=1) for i, val in enumerate(bobs_model.weight.data): if val != 0: print(vocab[i]) import phe public_key, private_key = phe.generate_paillier_keypair(n_length=1024) a = public_key.encrypt(5) b = public_key.encrypt(4) z = a + b print(z) c = 6 + 4 c = public_key.encrypt(c) print(c) z = private_key.decrypt(c) print(z) public_key, private_key = phe.generate_paillier_keypair(n_length=128) def train_encrypted(model, inpu_data, target_data, public_key): encrypted_weights = list()
import numpy as np from sklearn.datasets import load_diabetes import phe as paillier keypair = paillier.generate_paillier_keypair(n_length=1024) pubkey, privkey = keypair import pickle tt = pickle.dumps(pubkey) print(tt, 666666666666666666) tt = pickle.loads(tt) tmp = np.array([tt.encrypt(i) for i in x]) print(tmp) tmp2 = np.array([privkey.decrypt(i) for i in tmp]) print(tmp2[0]) print(tmp2[1]) print(tmp2[2]) print(tmp2[3])
def generate_paillier_keypair(self, n_length): self.pubkey, self.privkey = \ paillier.generate_paillier_keypair(n_length=n_length)
def generate_paillier_keypair(self, n_length): self.pubkey, self.privkey = paillier.generate_paillier_keypair( n_length=n_length)
def __init__(self, port = 5555): self.port = port key_length = 20 keypair = paillier.generate_paillier_keypair(n_length=key_length) self.public_key, self.private_key = keypair
import numpy as np from sklearn.datasets import load_diabetes import phe as paillier import pandas as pd import os pubKey, privKey = paillier.generate_paillier_keypair(n_length=1024) seed = 42 np.random.seed(seed) """ data = pd.read_csv(os.path.abspath(os.path.join( os.path.dirname(__file__), 'data', "diabetes_input.csv"))).values target = pd.read_csv(os.path.abspath(os.path.join( os.path.dirname(__file__), 'data', "diabetes_target.csv"))).values """ """ f = open(os.path.abspath(os.path.join( os.path.dirname(__file__), 'data', "diabetes_input.csv"))) f.readline() # skip the header data = np.loadtxt(f) g = open(os.path.abspath(os.path.join( os.path.dirname(__file__), 'data', "diabetes_target.csv"))) g.readline() # skip the header target = np.loadtxt(g) """ def get_data(n_clients): data, target = load_diabetes(return_X_y=True) y = target X = data
import phe import numpy as np from fir import FIR import matplotlib.pyplot as plt a = 10 [pk, sk] = phe.generate_paillier_keypair(n_length=256) plaintxt = [[1, 2 ]] ciphertxt = [[pk.encrypt(a)], [pk.encrypt(1.2 * a)]] def dot(plain, cipher): # calculate dot() dim_row = len(plain) dim_line = len(cipher[0]) length = len(cipher) ans = [[] for i in range(dim_row)] for i in range(dim_row): for j in range(dim_line): tmp = 0 for k in range(length): tmp = tmp + cipher[k][j] * plain[i][k] ans[i].append(tmp) return ans ans = dot(plaintxt, ciphertxt) for row in ans: for data in row: print(sk.decrypt(data))
def __init__(self): self.pubkey, self.privkey = paillier.generate_paillier_keypair(n_length=3072)
def __init__(self, n_length=64, precision = 4): self.pubkey, self.private_key = paillier.generate_paillier_keypair(n_length=64) self.precision = precision
import phe import math import random import gmpy2 from gmpy2 import * #m = [4,45,345,345,123,545,234] pk,sk = phe.generate_paillier_keypair(n_length=1024) def encrypt(m): #print(pk.n) #print(pk.g) r = random.randint(1,pk.n) n2 = pk.nsquare rn = pow(r,pk.n,n2) #print('rn',rn) gm = pow(pk.g,m,n2)#pk.g**m%n2 #print('gm',gm) c = gm * rn %n2 return c def decrypt(c): #print('sk',sk.p) #print(gmpy2.is_prime(sk.p)) lambda1 = mpz(sk.p-1)*mpz(sk.q-1) mu = gmpy2.invert(lambda1,mpz(pk.n)) #if pk.n == mpz(sk.p)*mpz(sk.q): #print('dui le')
def __init__(self, key_length=1024): self.pubkey, self.privkey = \ paillier.generate_paillier_keypair(n_length=key_length)
def __init__(self, key_length): keypair = paillier.generate_paillier_keypair(n_length=key_length) self.pubkey, self.privkey = keypair
from flask import Flask,render_template, request import phe as paillier import numpy as np from collections import Counter app = Flask(__name__) np.random.seed(12345) print("Generating paillier keypair") pubkey, prikey = paillier.generate_paillier_keypair(n_length=64) print("Importing dataset from disk...") with open('data/spam.txt','r') as f: raw = f.readlines() spam = list() for row in raw: spam.append(row[:-2].split(" ")) with open('data/ham.txt','r') as f: raw = f.readlines() ham = list() for row in raw: ham.append(row[:-2].split(" ")) class HomomorphicLogisticRegression(object):
def generate_key_pair(self, key_length): return paillier.generate_paillier_keypair(n_length=key_length)
# -*- coding: utf-8 -*- """ Created on Wed May 20 16:24:38 2020 @author: zhangtianxia """ import numpy as np import phe as paillier import time key_length = 128 pub_key, private_key = paillier.generate_paillier_keypair(n_length=key_length) a = 10 b = 20 c = 30 encrypted_a = pub_key.encrypt(float(a)) encrypted_b = pub_key.encrypt(float(b)) encrypted_c = pub_key.encrypt(float(c)) encrypted_sum = (encrypted_a + encrypted_b + encrypted_c) / 3 decrypted_sum = private_key.decrypt(encrypted_sum)
def generate(self, n_length=1024): pubkey, prikey = paillier.generate_paillier_keypair(n_length=n_length) self.public_key = PublicKey(pubkey) self.secret_key = SecretKey(prikey) return (self.public_key, self.secret_key)
import random import requests import phe as paillier # Exercise 1 print("Exercise 1") # Generate a public/private key pair pubkey, privkey = paillier.generate_paillier_keypair(n_length=2048) def encrypt_vector(x): return [pubkey.encrypt(i, precision=2**-16).ciphertext() for i in x] def decrypt_value(x): return privkey.decrypt(x) def query_pred(feature_vector): encrypted_vector = encrypt_vector(feature_vector) response = requests.post('http://hw7prediction:8000/prediction', json={'pub_key_n': pubkey.n, 'enc_feature_vector': encrypted_vector}) prediction = paillier.EncryptedNumber(pubkey, response.json()['enc_prediction'], exponent=-8) decrypted_prediction = decrypt_value(prediction) return decrypted_prediction assert 2**(-16) > abs(query_pred([0.48555949, 0.29289251, 0.63463107, 0.41933057, 0.78672205, 0.58910837, 0.00739207, 0.31390802, 0.37037496, 0.3375726 ]) - 0.44812144746653826) print("SUCCESS")