def binop_test(self, binop): for i in range(ITERATIONS): a = self.rand() b = self.rand() self.assertAlmostEqual(decrypt(binop(encrypt(a), encrypt(b))), binop(a, b), places=3)
def test_running_sum(self): true = 0 target = 0 for i in range(ITERATIONS): x = self.rand() true += x target += encrypt(x) self.assertAlmostEqual(decrypt(target), true, places=3)
generate_keypair, set_public_key, set_private_key, set_relin_keys, display_config ) # In a real application, the keypair would be generated once, # and only the public key would be provided to the server. # A more realistic example is given later. display_config() public_key, private_key, relin_keys = generate_keypair() set_public_key(public_key) set_relin_keys(relin_keys) display_config() set_private_key(private_key) display_config() # The server def process(x): return x**3 - 3*x + 1 # The client sensitive_data = [-30, -5, 17, 28] for entry in sensitive_data: encrypted = encrypt(entry) # Encrypt the data... result = process(encrypted) # Process the encrypted data on the server... print(entry, decrypt(result)) # Decrypt the result on the client.
def test_pow(self): for i in range(ITERATIONS): a = self.rand() / 500 b = random.randint(0, 4) self.assertAlmostEqual(decrypt(encrypt(a)**b), a**b, places=3)
def test_div(self): for i in range(ITERATIONS): a = self.rand() b = (2 * random.randint(0, 1) - 1) * random.uniform(1, 100) self.assertAlmostEqual(decrypt(encrypt(a) / b), a / b, places=3)
def test_pow(self): for i in range(ITERATIONS): a = random.randint(-7, 7) b = random.randint(0, 6) self.assertEqual(decrypt(encrypt(a)**b), a**b)
def binop_test(self, binop): for i in range(ITERATIONS): a = self.randint() b = self.randint() self.assertEqual(decrypt(binop(encrypt(a), encrypt(b))), binop(a, b))
from simplefhe import (load_private_key, load_relin_keys, display_config, decrypt, load_encrypted_value) # Note: this is the only step at which the private key is used! load_private_key('keys/private.key') load_relin_keys('keys/relin.key') display_config() # Decrypt results from the server (client-side) sensitive_data = [-30, -5, 17, 28] for i, entry in enumerate(sensitive_data): encrypted = load_encrypted_value(f'outputs/{i}.dat') result = decrypt(encrypted) print(f'[CLIENT] Result for {entry}: {result}')
from simplefhe import (encrypt, decrypt, generate_keypair, set_public_key, set_private_key, set_relin_keys, initialize, display_config) initialize('int') public_key, private_key, relin_key = generate_keypair() set_private_key(private_key) set_public_key(public_key) set_relin_keys(relin_key) display_config() # The server def process(x): return x**21 # The client sensitive_data = [-3, 1, 3, 10] for entry in sensitive_data: insecure_result = process(entry) secure_result = decrypt(process(encrypt(entry))) print(entry, insecure_result, secure_result)
def test_plaintext_init(self): N = 109023 a = EncryptedValue(N) b = EncryptedValue(a) self.assertEqual(decrypt(a), N) self.assertEqual(decrypt(b), N)
# Client-side script to decrypt the server's results import numpy as np from simplefhe import (initialize, decrypt, load_encrypted_value, load_private_key, load_relin_keys) # Initialization and keys initialize('float') load_private_key('keys/private.key') load_relin_keys('keys/relin.key') # Decrypt server's results XtX = np.zeros(shape=[3, 3]) XtY = np.zeros(shape=3) for i in range(3): XtY[i] = decrypt(load_encrypted_value(f'outputs/XtY-{i}.dat')) for j in range(3): XtX[i, j] = decrypt(load_encrypted_value(f'outputs/XtX-{i}-{j}.dat')) # Some post-processing coefficients = np.linalg.inv(XtX) @ XtY # Display results GROUND_TRUTH = [3.2, -1.7, 0.8] for i, pair in enumerate(zip(GROUND_TRUTH, coefficients)): a, b = pair print(f'Coefficient {i}: Expected {a:.4f}, Computed {b:.4f}')