def test_decrypt():
    for i in range(5):
        priv, pub = paillier.generate_keypair(64)
        for j in range(5):
            pt = long(random.randint(0, 1000000))
            ct = paillier.encrypt(pub, pt)
            assert pt == paillier.decrypt(priv, pub, ct)
예제 #2
0
def test_decrypt():
    for i in range(5):
        priv, pub = paillier.generate_keypair(64)
        for j in range(5):
            pt = long(random.randint(0, 1000000))
            ct = paillier.encrypt(pub, pt)
            assert pt == paillier.decrypt(priv, pub, ct)
예제 #3
0
def test_e_mul_const():
    for i in range(5):
        priv, pub = paillier.generate_keypair(128)
        for j in range(5):
            a = long(random.randint(0, 1000000))
            c = paillier.encrypt(pub, a)
            for n in range(0, 11):
                cs = paillier.e_mul_const(pub, c, n)
                s = paillier.decrypt(priv, pub, cs)
                assert a * n == s
예제 #4
0
def test_e_add():
    for i in range(5):
        priv, pub = paillier.generate_keypair(128)
        for j in range(5):
            a = long(random.randint(0, 1000000))
            b = long(random.randint(0, 1000000))
            ca, cb = paillier.encrypt(pub, a), paillier.encrypt(pub, b)
            cs = paillier.e_add(pub, ca, cb)
            s = paillier.decrypt(priv, pub, cs)
            assert a + b == s
예제 #5
0
 def generate_keypair(self):
     cs = self.cipher_suite
     scheme = cs.scheme
     if scheme == "Paillier":
         sk, pk = paillier.generate_keypair(cs.modulus_length)
         # print(pk.n)
     elif scheme == "ElGamal":
         sk, pk = elgamal.generate_keys(cs.modulus_length)
         # print(pk.p)
     return sk, pk
def test_e_mul_const():
    for i in range(5):
        priv, pub = paillier.generate_keypair(128)
        for j in range(5):
            a = long(random.randint(0, 1000000))
            c = paillier.encrypt(pub, a)
            for n in range(0, 11):
                cs = paillier.e_mul_const(pub, c, n)
                s = paillier.decrypt(priv, pub, cs)
                assert a * n == s
def test_e_add():
    for i in range(5):
        priv, pub = paillier.generate_keypair(128)
        for j in range(5):
            a = long(random.randint(0, 1000000))
            b = long(random.randint(0, 1000000))
            ca, cb = paillier.encrypt(pub, a), paillier.encrypt(pub, b)
            cs = paillier.e_add(pub, ca, cb)
            s = paillier.decrypt(priv, pub, cs)
            assert a + b == s
예제 #8
0
def createPass(user, pa):
    username = sha.encrypt(user)
    password = sha.encrypt(pa)
    priv, pub = pail.generate_keypair(256)

    userD = {}

    if os.path.isfile('UserDB.pkl'):
        with open('UserDB.pkl', 'rb') as fb:
            userD = pickle.load(fb)

    if 'USER_DICT' in userD:
        print("ADDING NEW USER")
        userD['USER_DICT'].append({username: (password, priv, pub)})

    else:
        userD = {'USER_DICT': [{username: (password, priv, pub)}]}

    with open('UserDB.pkl', 'wb') as fw:
        pickle.dump(userD, fw)
예제 #9
0
파일: kmeans.py 프로젝트: DataPrivacyB/A5
import matplotlib.pyplot as plt
from matplotlib import style

style.use('ggplot')
import numpy as np
import paillier as p

priv, pub = p.generate_keypair(128)

X = np.array([[1, 2], [1.5, 1.8], [5, 8]])
X = np.int_(X)
X = X.tolist()
Y = []
# array = np.arange().reshape(X.shape[0],X.shape[1])
# Y = np.zeros((X.shape[0],X.shape[1]))
# Y.astype(int)
# X = X.astype(int)
# X = np.int_(X)
# print(X.shape)
i = 0
print(X)
for x in X:
    x = p.encryptArray(pub, x)
    Y.append(x)
    i += 1
# print(Y)
i = 0
z = []  # np.zeros((X.shape[0],X.shape[1]))
for y in Y:
    y = p.decryptArray(priv, pub, y)
    z.append(y)
예제 #10
0
def test_keys_long():
    priv, pub = paillier.generate_keypair(256)
    for i in range(5):
        assert paillier.invmod(priv.m, pub.n) == priv.l
예제 #11
0
def central_server_oblivious(x):
    """
    :param
    x: A 2-D array
            each column correspond to the result from one subsystem
    :return:
    x_mean : 1-D array
            the mean value across subsystems
    enc_time: float
            the average time for each subsystem to encrypt its result
    collect_time: float
            the time for the central server to compute the average
    dec_time: float
            the average time for each subsystem to decrypt the average send
            back from the central server.
    """

    # Get dimension
    num_subsys = x.shape[0]
    num_feature = x.shape[1]

    # cx intermediate encrypted version of x
    cx = []
    cxn = []

    # x_mean : a list, this is the returned value
    x_mean = []
    x_meann = []

    # private key and public key, the private key is a pair of prime numbers, each about 512 bits
    sk, pk = paillier.generate_keypair(512)

    t0 = time.clock()
    for i in range(0, num_subsys):
        for j in range(0, num_feature):
            if x[i,j] < 0:
                x[i,j] = -x[i,j]
                cxn.append(paillier.encrypt(pk, x[i,j]))
                cx.append(1)
            else:
                cxn.append(1)
                cx.append(paillier.encrypt(pk,x[i,j]))
    t1 = time.clock()
    enc_time = t1 - t0
    # enc_time, encryption time for all sub-system, the final reported time is for each subsystem, i.e. enc_time/num_subsys

    t0 = time.clock()
    for i in range(0, num_subsys):
        for j in range(0, num_feature):
            if j == 0:
                x_mean.append(cx[i*num_feature+j])
                x_meann.append(cxn[i*num_feature+j])
            else:
                x_mean[i] = paillier.e_add(pk, x_mean[i],cx[i*num_feature+j])
                x_meann[i] = paillier.e_add(pk, x_meann[i],cxn[i*num_feature+j])
    t1 = time.clock()
    collect_time = t1 - t0
    # collect_time : time for averaging feature values among users

    t0 = time.clock()
    x_mean = [paillier.decrypt(sk,pk,x)/num_feature for x in x_mean]
    x_meann = [paillier.decrypt(sk,pk,x)/num_feature for x in x_meann]
    t1 = time.clock()
    dec_time = t1 - t0
    # dec_time : decryption time

    x_mean = [x_mean[i] - x_meann[i] for i in range(0,len(x_mean))]

    return (x_mean, enc_time/num_subsys, collect_time, dec_time)
예제 #12
0
 def key_gen(self, n_length):
     self.pk, self.sk = generate_keypair(n_length=n_length)
def test_keys_long():
    priv, pub = paillier.generate_keypair(256)
    for i in range(5):
        assert paillier.invmod(priv.m, pub.n) == priv.l
예제 #14
0
 def generate_keypair(self):
     cs = self.cipher_suite
     return paillier.generate_keypair(cs.modulus_length)