def deserialize(b):
seckey_dict = json.loads(b)
sk_record = seckey_dict['secret_key']
sk = paillier.PaillierPrivateKey(
public_key=paillier.PaillierPublicKey(n=int(sk_record['n'])),
p=sk_record['p'],
q=sk_record['q'])
return SecretKey(sk)
def computeData():
data = getData()
mycoef = LinModel().getCoef()
pk = data['public_key']
pubkey = paillier.PaillierPublicKey(n=int(pk['n']))
enc_nums_rec = [paillier.EncryptedNumber(pubkey, int(x[0], int(x[1]))) for x in data['values']]
results = sum([mycoef[i] * enc_nums_rec[i] for i in range(len(mycoef))])
return results, pubkey
def getKeys():
with open('custkeys.json', 'r') as file:
keys = json.load(file)
pub_key = paillier.PaillierPublicKey(n=int(keys['public_key']['n']))
priv_key = paillier.PaillierPrivateKey(pub_key,
keys['private_key']['p'],
keys['private_key']['q'])
return pub_key, priv_key
def load_public_key(public_key_data):
error_msg = "Invalid public key"
assert 'alg' in public_key_data, error_msg
assert public_key_data['alg'] == 'PAI-GN1', error_msg
assert public_key_data['kty'] == 'DAJ', error_msg
n = phe.util.base64_to_int(public_key_data['n'])
pub = phe.PaillierPublicKey(n)
return pub
def loadAnswer():
with open('answer.json', 'r') as file:
ans=json.load(file)
answer=json.loads(ans)
return answer
pub_key, priv_key = getKeys()
data = age, he, al, gen = [24,4,6,1]
serializeData(pub_key, data)
datafile=serializeData(pub_key, data)
with open('data.json', 'w') as file:
json.dump(datafile, file)
answer_file=loadAnswer()
answer_key=paillier.PaillierPublicKey(n=int(answer_file['pubkey']['n']))
answer = paillier.EncryptedNumber(answer_key, int(answer_file['values'][0]), int(answer_file['values'][1]))
if (answer_key==pub_key):
print(priv_key.decrypt(answer))
def __init__(self):
if not config.use_he:
# pubkey mock
self.pubkey = phe.PaillierPublicKey(1)
return
Key, _, _, _, PublicKey, _, _, SecretKeyShares, theta = generate_shared_paillier_key(
keyLength=config.key_length,
n=config.n_parties,
t=config.threshold,
)
self.prikey = Key
self.pubkey = PublicKey
# decrypt takes one argument -- ciphertext to decode
self.decrypt = partial(Key.decrypt,
n=config.n_parties,
t=config.threshold,
PublicKey=PublicKey,
SecretKeyShares=SecretKeyShares,
theta=theta)
def deserialize(b):
pubkey_dict = json.loads(b)
pk_record = pubkey_dict['public_key']
pk = paillier.PaillierPublicKey(n=int(pk_record['n']))
return PublicKey(pk)
def main():
linmodel.mainLinModel()
servercalc.mainServerCalc()
print(
"Saisissez les donnees sous la forme a,b,c,d avec a,b,c et d 4 entiers"
)
input1 = input()
pub_key, priv_key = cust.getKeys()
data = []
for i in range(4):
print(
input1.split(',')[i], " est chiffré par ",
servercalc.getData().get('values')[i][0][0:12], '...')
data.append(int(input1.split(',')[i]))
cust.serializeData(pub_key, data)
datafile = cust.serializeData(pub_key, data)
with open('data.json', 'w') as file:
json.dump(datafile, file)
answer_file = cust.loadAnswer()
answer_key = paillier.PaillierPublicKey(n=int(answer_file['pubkey']['n']))
answer = paillier.EncryptedNumber(answer_key,
int(answer_file['values'][0]),
int(answer_file['values'][1]))
print(priv_key.decrypt(answer))
# Affichage
window = Tk()
window.title("Simulation")
window.geometry("1920x1060")
window.iconbitmap("hash.ico")
window.config(background='grey')
# premier texte
label_title = Label(window,
text="Simulation",
font=("Courrier, 30"),
bg='Grey',
fg='white')
label_title.grid(row=0, column=2)
label_title = Label(window,
text="Chiffrement homomorphe",
font=("Courrier, 30"),
bg='Grey',
fg='white')
label_title.grid(row=1, column=2)
# second texte
label_subtitle1 = Label(window,
text="① Utilisateur",
font=("Courrier, 25"),
bg='white',
fg='grey')
label_subtitle1.grid(row=2, column=1)
#troisieme texte
label_subtitle3 = Label(
window,
text="Les données entrées par l'utilisateur sont :",
font=("Courrier,25"),
bg='grey',
fg='white')
label_subtitle3.grid(row=3, column=1)
label_subtitle4 = Label(window,
text=data,
font=("Courrier,500"),
bg='grey',
fg='white')
label_subtitle4.grid(row=4, column=1)
label_subtitle3 = Label(window,
text="et sont chiffrées respectivement par :",
font=("Courrier,25"),
bg='grey',
fg='white')
label_subtitle3.grid(row=5, column=1)
label_subtitle5 = Label(
window,
text=servercalc.getData().get('values')[0][0][0:12] + "...",
font=("Courrier, 25"),
bg='grey',
fg='white')
label_subtitle5.grid(row=6, column=1)
label_subtitle5 = Label(
window,
text=servercalc.getData().get('values')[1][0][0:12] + "...",
font=("Courrier, 25"),
bg='grey',
fg='white')
label_subtitle5.grid(row=7, column=1)
label_subtitle5 = Label(
window,
text=servercalc.getData().get('values')[2][0][0:12] + "...",
font=("Courrier, 25"),
bg='grey',
fg='white')
label_subtitle5.grid(row=8, column=1)
label_subtitle5 = Label(
window,
text=servercalc.getData().get('values')[3][0][0:12] + "...",
font=("Courrier, 25"),
bg='grey',
fg='white')
label_subtitle5.grid(row=9, column=1)
label_subtitle2 = Label(window,
text="② Serveur externe (cloud)",
font=("Courrier, 25"),
bg='white',
fg='grey')
label_subtitle2.grid(row=10, column=3)
label_subtitle5 = Label(
window,
text=
"Les coefficients donnés par l'algorithme de Machine Learning à appliqués aux données sont :",
font=("Courrier,25"),
bg='grey',
fg='white')
label_subtitle5.grid(row=11, column=3)
label_subtitle5 = Label(window,
text=linmodel.LinModel().getCoef(),
font=("Courrier,25"),
bg='grey',
fg='white')
label_subtitle5.grid(row=12, column=3)
label_subtitle5 = Label(
window,
text=
"L'opération \"coefficient i\" multiplié par l'élément i des données chiffrées donne :",
font=("Courrier,25"),
bg='grey',
fg='white')
label_subtitle5.grid(row=13, column=3)
label_subtitle6 = Label(window,
text=answer_file['values'][0][0:12] + "...",
font=("Courrier, 25"),
bg='grey',
fg='white')
label_subtitle6.grid(row=14, column=3)
#computeData()[0].ciphertext()
label_subtitle1 = Label(window,
text="③ Utilisateur",
font=("Courrier, 25"),
bg='white',
fg='grey')
label_subtitle1.grid(row=15, column=1)
label_subtitle1 = Label(window,
text="Récupération du résultat chiffré",
font=("Courrier, 25"),
bg='grey',
fg='white')
label_subtitle1.grid(row=16, column=1)
label_subtitle1 = Label(window,
text="Après déchiffrement, on obtient :",
font=("Courrier, 25"),
bg='grey',
fg='white')
label_subtitle1.grid(row=17, column=1)
label_subtitle7 = Label(window,
text=priv_key.decrypt(answer),
font=("Courrier,35"),
bg='grey',
fg='white')
label_subtitle7.grid(row=18, column=1)
# window.grid_rowconfigure(0, minsize=150)
# window.grid_rowconfigure(8, minsize=150)
# window.grid_rowconfigure(5, minsize=150)
# afficher
window.mainloop()
def get_deserialized_public_key(self, public_key):
return paillier.PaillierPublicKey(n=int(public_key))
encrypted_data['values'] = [(str(x.ciphertext()), x.exponent)
for x in encrypted_data_list]
serialized = json.dumps(encrypted_data)
return serialized
def loadAnswer():
'''This function is intended to load the encrypted data coming from the server.'''
with open('answer.json', 'r') as file:
ans = json.load(file)
answer = json.loads(ans)
return answer
pub_key, priv_key = getKeys()
data = age, he, al, gen = [24, 4, 6, 1]
serializeData(pub_key, data)
datafile = serializeData(pub_key, data)
with open('data.json', 'w') as file:
json.dump(datafile, file)
answer_file = loadAnswer()
answer_key = paillier.PaillierPublicKey(n=int(answer_file['pubkey']['n']))
answer = paillier.EncryptedNumber(answer_key, int(answer_file['values'][0]),
int(answer_file['values'][1]))
# Decrypted Result
if (answer_key == pub_key):
print(priv_key.decrypt(answer))
def generate_shared_paillier_key(
keyLength=DEFAULT_KEYSIZE,
n=NUMBER_PLAYERS,
t=CORRUPTION_THRESHOLD,
threshold=PRIME_THRESHOLD,
it=MAX_ITERATIONS,
correctParamPrime=CORRECTNESS_PARAMETER_BIPRIMALITY,
statSecShamir=STATISTICAL_SECURITY_SECRET_SHARING):
"""
Main code to obtain a Paillier public key N
and shares of the private key.
"""
primeLength = keyLength // 2
length = 2 * (primeLength + math.ceil((math.log2(n))))
shamirP = sympy.nextprime(2**length)
smallPrimeTest = True
if primeLength < math.log(threshold, 2):
threshold = 1
print('Bit-length of primes: ', primeLength)
Key = PaillierSharedKey(primeLength, n, t, threshold, it)
print('Starting generation of p, q and N...')
success = 0
counter_smallPrime = 0
counter_biprime = 0
startTime = time.time()
# Here we define the small primes considered in small prime test.
# The generated p and q are both 3 mod 4, hence we do not have to check for divisibility by 2.
primeList = [p for p in sympy.primerange(3, threshold + 1)]
while success == 0:
# Generate the factors p and q
pShares = Key.generate_prime_vector(n, primeLength)
qShares = Key.generate_prime_vector(n, primeLength)
# Then obtain N
N = compute_product(pShares, qShares, n, t, shamirP)
# Test bi-primality of N
[success, smallPrimeTestFail] = is_biprime(n, N, pShares, qShares,
correctParamPrime,
smallPrimeTest, primeList)
if smallPrimeTestFail:
counter_smallPrime += 1
elif not (success):
counter_biprime += 1
print('Generation successful.')
print('Number of insuccesfull trials small prime test: ',
counter_smallPrime)
print('Number of insuccesfull trials biprime test: ', counter_biprime)
print('Elapsed time: ', math.floor(time.time() - startTime), 'seconds.')
PublicKey = phe.PaillierPublicKey(N)
# So long for the public key. Let's look at the secret key(s):
# Instatiate secret-sharing scheme for lambda and beta.
Int_SS_Scheme = IntegerShamir(statSecShamir, N, n, t)
LambdaShares = obtain_lambda_shares(Int_SS_Scheme, pShares, qShares, N)
success = 0
while success == 0:
# Generate shares of random mask
BetaShares = share_random_element(N, Int_SS_Scheme)
# Obtain shares of secret key.
# Notice that here we mask lambda over the integers:
# since we will only reveal this product modulo N, this product perfectly masks lambda mod N.
SecretKeyShares = LambdaShares * BetaShares
success, theta = compute_theta(SecretKeyShares, N)
# Hack
Key.public_key = PublicKey
Key.SecretKeyShares = SecretKeyShares
Key.theta = theta
return Key, pShares, qShares, N, PublicKey, LambdaShares, BetaShares, SecretKeyShares, theta
