def test_encrypt_decrypt(self):
with tf.Session() as sess:
inp = np.array([[44.44, 55.55], [66.66, 77.77]], np.float32)
pub_key, sec_key = seal_key_gen()
variant = seal_encrypt(inp, pub_key)
ans = seal_decrypt(variant, sec_key, tf.float32)
np.testing.assert_equal(sess.run(ans), inp)
def test_eval(self):
public_keys, secret_key = seal_key_gen()
x_raw = np.array([[1234, 1234]]).astype(np.float64)
x = convert_to_tensor(x_raw, secret_key, public_keys)
with tf.Session() as sess:
res = x.eval(session=sess)
np.testing.assert_array_almost_equal(res, x_raw.astype(np.float64),
0.1)
def _core_test(self, in_np, out_np, convert_to_tf_tensor):
public_keys, secret_key = seal_key_gen()
if convert_to_tf_tensor:
in_tf = tf.convert_to_tensor(in_np)
x = convert_to_tensor(in_tf, secret_key, public_keys)
else:
x = convert_to_tensor(in_np, secret_key, public_keys)
with tf.Session() as sess:
res = sess.run(x)
np.testing.assert_array_almost_equal(res, out_np, 0.1)
def test_add_plain(self):
with tf.Session() as sess:
a = np.array([[44.44, 55.55], [66.66, 77.77]], np.float32)
b = np.array([[44.44, 55.55], [66.66, 77.77]], np.float32)
ans = a + b
pub_key, sec_key = seal_key_gen()
a_var = seal_encrypt(a, pub_key)
c_var = seal_add_plain(a_var, b)
c = seal_decrypt(c_var, sec_key, tf.float32)
np.testing.assert_almost_equal(sess.run(c), ans, 0.1)
def test_poly_eval(self):
with tf.Session() as sess:
x = np.array([[1, 2, 3], [4, 5, 5]], np.float32)
coeffs = np.array([0.5, 0.197, 0.0, -0.004])
ans = tf.sigmoid(x)
pub_key, sec_key = seal_key_gen(gen_relin=True, gen_galois=True)
x_var = seal_encrypt(x, pub_key)
c_var = seal_poly_eval(x_var, coeffs, pub_key)
c = seal_decrypt(c_var, sec_key, tf.float32)
np.testing.assert_almost_equal(sess.run(c), sess.run(ans), 0.1)
def test_incompatible_shape(self):
with tf.Session() as sess:
a = np.array([[1, 2, 3], [4, 5, 6]], np.float32)
b = np.array([[1, 2], [3, 4], [5, 6]], np.float32)
pub_key, _ = seal_key_gen()
a_var = seal_encrypt(a, pub_key)
b_var = seal_encrypt(b, pub_key)
tmp = seal_mat_mul(a_var, b_var, pub_key)
try:
sess.run(tmp)
except InvalidArgumentError:
pass
def test_matmul_plain(self):
with tf.Session() as sess:
a = np.array([[1, 2, 3], [4, 5, 6]], np.float32)
b = np.array([[1, 2], [3, 4], [5, 6]], np.float32)
ans = a.dot(b)
pub_key, sec_key = seal_key_gen(gen_galois=True)
a_var = seal_encrypt(a, pub_key)
c_var = seal_mat_mul_plain(a_var, b.transpose(), pub_key)
c = seal_decrypt(c_var, sec_key, tf.float32)
np.testing.assert_almost_equal(sess.run(c), ans, 0.1)
def test_add(self):
with tf.Session() as sess:
a = np.array([[44.44]], np.float64)
b = np.array([[44.44]], np.float64)
ans = a + b
pub_key, sec_key = seal_key_gen()
a_var = seal_encrypt(a, pub_key)
b_var = seal_encrypt(b, pub_key)
c_var = seal_add(a_var, b_var)
c = seal_decrypt(c_var, sec_key, tf.float64)
np.testing.assert_almost_equal(sess.run(c), ans, 0.1)
def test_log_reg(self):
public_keys, secret_key = seal_key_gen(gen_relin=True, gen_galois=True)
# encrypted input -> tf_seal.Tensor
a = constant(
np.random.normal(size=(10, 10)).astype(np.float32), secret_key,
public_keys)
print(a)
# public weights
b = np.random.normal(size=(10, 10)).astype(np.float32)
# TODO tfs.matmul(a, b)????
c = a.matmul(b)
print(c)
with tf.Session() as sess:
sess.run(c)
def _core_test(self, op, plain=False):
public_keys, secret_key = seal_key_gen(gen_relin=True)
x_raw = np.array([[1234, 1234]]).astype(np.float64)
y_raw = np.array([[1234, 1234]]).astype(np.float64)
z_raw = op(x_raw, y_raw)
x = convert_to_tensor(x_raw, secret_key, public_keys)
if not plain:
y = convert_to_tensor(y_raw, secret_key, public_keys)
else:
y = y_raw
z = op(x, y)
with tf.Session() as sess:
res = sess.run(z)
np.testing.assert_array_almost_equal(res, z_raw.astype(np.float64),
0.1)
def test_mul_then_add(self):
with tf.Session() as sess:
a = np.array([[44.44, 55.55], [66.66, 77.77]], np.float64)
b = np.array([[44.44, 55.55], [66.66, 77.77]], np.float64)
c = np.array([[44.44, 55.55], [66.66, 77.77]], np.float64)
ans = a * b + c
pub_key, sec_key = seal_key_gen(gen_relin=True)
a_var = seal_encrypt(a, pub_key)
b_var = seal_encrypt(b, pub_key)
c_var = seal_encrypt(c, pub_key)
tmp = seal_mul(a_var, b_var, pub_key)
d_var = seal_add(tmp, c_var)
d = seal_decrypt(d_var, sec_key, tf.float64)
np.testing.assert_almost_equal(sess.run(d), ans, 0.1)
def test_matmul_then_add(self):
with tf.Session() as sess:
a = np.array([[1, 2, 3], [4, 5, 6]], np.float32)
b = np.array([[1, 2], [3, 4], [5, 6]], np.float32)
c = np.array([[1, 2], [4, 5]], np.float32)
ans = a.dot(b) + c
pub_key, sec_key = seal_key_gen(gen_relin=True, gen_galois=True)
a_var = seal_encrypt(a, pub_key)
b_var = seal_encrypt(b.transpose(), pub_key)
c_var = seal_encrypt(c, pub_key)
tmp = seal_mat_mul(a_var, b_var, pub_key)
d_var = seal_add(tmp, c_var)
d = seal_decrypt(d_var, sec_key, tf.float32)
np.testing.assert_almost_equal(sess.run(d), ans, 0.1)
def test_matmul_poly_eval(self):
with tf.Session() as sess:
x = np.array([[0.02, 0.04, 0.05], [0.06, 1, 0.0005]], np.float32)
y = np.array([[0.02, 0.04], [0.05, 0.06], [1, 0.0005]], np.float32)
coeffs = np.array([0.5, 0.197, 0.0, -0.004])
m = tf.matmul(x, y)
ans = tf.sigmoid(m)
pub_key, sec_key = seal_key_gen(gen_relin=True, gen_galois=True)
x_var = seal_encrypt(x, pub_key)
z_var = seal_mat_mul_plain(x_var, y.transpose(), pub_key)
c_var = seal_poly_eval(z_var, coeffs, pub_key)
c = seal_decrypt(c_var, sec_key, tf.float32)
np.testing.assert_almost_equal(
sess.run(c).transpose(), sess.run(ans), 0.1)
