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)
def __init__(self, key_length):
keypair = paillier.generate_paillier_keypair(n_length=key_length)
self.pubkey, self.privkey = keypair
# -*- 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")
