def test_encryptionparams_scheme_settings(scheme):
testcase = sealapi.EncryptionParameters(scheme)
testcase.set_poly_modulus_degree(32768)
assert testcase.poly_modulus_degree() == 32768
testcase = sealapi.EncryptionParameters(scheme)
testcase.set_coeff_modulus([sealapi.Modulus(1023), sealapi.Modulus(234)])
assert len(testcase.coeff_modulus()) == 2
assert testcase.coeff_modulus()[0].value() == 1023
assert testcase.coeff_modulus()[1].value() == 234
left = sealapi.EncryptionParameters(scheme)
left.set_poly_modulus_degree(32768)
left.set_coeff_modulus([sealapi.Modulus(1023), sealapi.Modulus(234)])
right = sealapi.EncryptionParameters(scheme)
right.set_poly_modulus_degree(32768)
assert left != right
right.set_coeff_modulus([sealapi.Modulus(1023), sealapi.Modulus(234)])
assert left == right
testcase = sealapi.EncryptionParameters(scheme)
testcase.set_poly_modulus_degree(32768)
testcase.set_coeff_modulus([sealapi.Modulus(1023), sealapi.Modulus(234)])
def save_load(path):
testcase.save(path)
saved = sealapi.EncryptionParameters(scheme)
saved.load(path)
assert saved.poly_modulus_degree() == 32768
assert saved.coeff_modulus()[0].value() == 1023
tmp_file(save_load)
def test_encryptionparams_scheme_sanity(scheme_id, scheme):
assert int(scheme) == scheme_id
testcase = sealapi.EncryptionParameters(scheme)
assert testcase.scheme() == scheme
testcase = sealapi.EncryptionParameters(scheme_id)
assert testcase.scheme() == scheme
def helper_params_ckks(poly_modulus_degree=8192):
parms = sealapi.EncryptionParameters(sealapi.SCHEME_TYPE.CKKS)
parms.set_poly_modulus_degree(poly_modulus_degree)
coeff = sealapi.CoeffModulus.Create(poly_modulus_degree, [60, 40, 40, 60])
parms.set_coeff_modulus(coeff)
return parms
def save_load(path):
testcase.save(path)
saved = sealapi.EncryptionParameters(scheme)
saved.load(path)
assert saved.poly_modulus_degree() == 32768
assert saved.coeff_modulus()[0].value() == 1023
def test_encryptionparams_scheme_specific():
testcase = sealapi.EncryptionParameters(sealapi.SCHEME_TYPE.NONE)
with pytest.raises(BaseException):
testcase.set_poly_modulus_degree(10)
testcase.set_poly_modulus_degree(0)
assert testcase.poly_modulus_degree() == 0
testcase.set_coeff_modulus([])
testcase = sealapi.EncryptionParameters(sealapi.SCHEME_TYPE.BFV)
testcase.set_plain_modulus(sealapi.Modulus(1023))
assert testcase.plain_modulus().value() == 1023
testcase.set_random_generator(sealapi.BlakePRNGFactory())
generator = testcase.random_generator().create()
assert generator.generate() != generator.generate()
def test_evaluator_galois():
parms = sealapi.EncryptionParameters(sealapi.SCHEME_TYPE.BFV)
parms.set_poly_modulus_degree(8)
parms.set_plain_modulus(257)
coeff = sealapi.CoeffModulus.Create(8, [40, 40])
parms.set_coeff_modulus(coeff)
ctx = sealapi.SEALContext(parms, False, sealapi.SEC_LEVEL_TYPE.NONE)
keygen = sealapi.KeyGenerator(ctx)
public_key = sealapi.PublicKey()
keygen.create_public_key(public_key)
secret_key = keygen.secret_key()
galois_keys = sealapi.GaloisKeys()
keygen.create_galois_keys([1, 3, 5], galois_keys)
decryptor = sealapi.Decryptor(ctx, secret_key)
encryptor = sealapi.Encryptor(ctx, public_key)
evaluator = sealapi.Evaluator(ctx)
plain = sealapi.Plaintext("1x^2")
encrypted = sealapi.Ciphertext(ctx)
encryptor.encrypt(plain, encrypted)
evaluator.apply_galois_inplace(encrypted, 1, galois_keys)
decryptor.decrypt(encrypted, plain)
assert plain.to_string() == "1x^2"
out = sealapi.Ciphertext(ctx)
evaluator.apply_galois(encrypted, 3, galois_keys, out)
decryptor.decrypt(out, plain)
assert plain.to_string() == "1x^6"
def test_util_galois():
with pytest.raises(BaseException):
util.GaloisTool(0)
gtool = util.GaloisTool(3)
assert gtool.get_elt_from_step(0) == 15
assert gtool.get_elts_from_steps([0, 1, -3, 2, -2, 3,
-1]) == [15, 3, 3, 9, 9, 11, 11]
assert gtool.get_elts_all() == [15, 3, 11, 9, 9]
poly_modulus_degree = 8
parms = sealapi.EncryptionParameters(sealapi.SCHEME_TYPE.CKKS)
parms.set_poly_modulus_degree(poly_modulus_degree)
coeff = sealapi.CoeffModulus.Create(poly_modulus_degree, [17])
parms.set_coeff_modulus(coeff)
ctx = sealapi.SEALContext.Create(parms, False, sealapi.SEC_LEVEL_TYPE.NONE)
gtool = ctx.key_context_data().galois_tool()
assert gtool.apply_galois([0, 1, 2, 3, 4, 5, 6, 7], 3, sealapi.Modulus(17),
poly_modulus_degree -
1)[:8] == [0, 14, 6, 1, 13, 7, 2, 12]
assert gtool.apply_galois_ntt([0, 1, 2, 3, 4, 5, 6, 7], 3,
poly_modulus_degree - 1)[:8] == [
4,
5,
7,
6,
1,
0,
2,
3,
]
assert 7 == util.GaloisTool.GetIndexFromElt(15)
def helper_params_bfv(poly_modulus_degree=4096, plain_modulus=1032193):
parms = sealapi.EncryptionParameters(sealapi.SCHEME_TYPE.BFV)
parms.set_poly_modulus_degree(poly_modulus_degree)
parms.set_plain_modulus(plain_modulus)
coeff = sealapi.CoeffModulus.BFVDefault(poly_modulus_degree, sealapi.SEC_LEVEL_TYPE.TC128)
parms.set_coeff_modulus(coeff)
return parms
def test_evaluator_rotate_vector():
testcase = [complex(i, i) for i in range(4)]
slot_size = len(testcase)
delta = 1 << 30
parms = sealapi.EncryptionParameters(sealapi.SCHEME_TYPE.CKKS)
poly_modulus = 2 * slot_size
parms.set_poly_modulus_degree(poly_modulus)
parms.set_plain_modulus(0)
coeff = sealapi.CoeffModulus.Create(poly_modulus, [40, 40, 40, 40])
parms.set_coeff_modulus(coeff)
ctx = sealapi.SEALContext(parms, False, sealapi.SEC_LEVEL_TYPE.NONE)
ctx = helper_context_ckks()
keygen = sealapi.KeyGenerator(ctx)
galois_keys = sealapi.GaloisKeys()
keygen.create_galois_keys(galois_keys)
pk = sealapi.PublicKey()
keygen.create_public_key(pk)
decryptor = sealapi.Decryptor(ctx, keygen.secret_key())
encryptor = sealapi.Encryptor(ctx, pk)
evaluator = sealapi.Evaluator(ctx)
encoder = sealapi.CKKSEncoder(ctx)
plain = sealapi.Plaintext()
encoder.encode(testcase, ctx.first_parms_id(), delta, plain)
encrypted = sealapi.Ciphertext(ctx)
encryptor.encrypt(plain, encrypted)
# inplace
steps = 1
evaluator.rotate_vector_inplace(encrypted, steps, galois_keys)
decryptor.decrypt(encrypted, plain)
decoded = encoder.decode_complex(plain)[:slot_size]
for idx in range(slot_size):
off = (idx + steps) % slot_size
assert abs(testcase[off].real - decoded[idx].real) < 0.1
assert abs(testcase[off].imag - decoded[idx].imag) < 0.1
# to another ciphertext
steps = -steps
out = sealapi.Ciphertext(ctx)
evaluator.rotate_vector(encrypted, steps, galois_keys, out)
decryptor.decrypt(out, plain)
decoded = encoder.decode_complex(plain)[:slot_size]
for idx in range(slot_size):
assert abs(testcase[idx].real - decoded[idx].real) < 0.1
assert abs(testcase[idx].imag - decoded[idx].imag) < 0.1
def test_evaluator_rotate_bfv():
parms = sealapi.EncryptionParameters(sealapi.SCHEME_TYPE.BFV)
parms.set_poly_modulus_degree(8)
parms.set_plain_modulus(257)
coeff = sealapi.CoeffModulus.Create(8, [40, 40])
parms.set_coeff_modulus(coeff)
ctx = sealapi.SEALContext.Create(parms, False, sealapi.SEC_LEVEL_TYPE.NONE)
keygen = sealapi.KeyGenerator(ctx)
galois_keys = keygen.galois_keys_local()
decryptor = sealapi.Decryptor(ctx, keygen.secret_key())
encryptor = sealapi.Encryptor(ctx, keygen.public_key())
evaluator = sealapi.Evaluator(ctx)
encoder = sealapi.BatchEncoder(ctx)
testcase = [1, 2, 3, 4, 5, 6, 7, 8]
# Input
# 1, 2, 3, 4,
# 5, 6, 7, 8
plain = sealapi.Plaintext()
encoder.encode(testcase, plain)
encrypted = sealapi.Ciphertext(ctx)
encryptor.encrypt(plain, encrypted)
evaluator.rotate_columns_inplace(encrypted, galois_keys)
decryptor.decrypt(encrypted, plain)
# Rotate columns
# 5, 6, 7, 8,
# 1, 2, 3, 4
assert encoder.decode_int64(plain) == [5, 6, 7, 8, 1, 2, 3, 4]
evaluator.rotate_rows_inplace(encrypted, -1, galois_keys)
decryptor.decrypt(encrypted, plain)
# Shift rows -1
# 8, 5, 6, 7,
# 4, 1, 2, 3,
assert encoder.decode_int64(plain) == [8, 5, 6, 7, 4, 1, 2, 3]
cout = sealapi.Ciphertext(ctx)
evaluator.rotate_rows(encrypted, 2, galois_keys, cout)
decryptor.decrypt(cout, plain)
# Shift rows +2
# 6, 7, 8, 5,
# 2, 3, 4, 1,
assert encoder.decode_int64(plain) == [6, 7, 8, 5, 2, 3, 4, 1]
evaluator.rotate_columns(cout, galois_keys, encrypted)
decryptor.decrypt(encrypted, plain)
# Rotate columns
# 2, 3, 4, 1,
# 6, 7, 8, 5,
assert encoder.decode_int64(plain) == [2, 3, 4, 1, 6, 7, 8, 5]
def test_context_scheme_ckks_sanity(sec_level):
poly_modulus_degree = 8192
plaintext_modulus = 1032193
parms = sealapi.EncryptionParameters(sealapi.SCHEME_TYPE.CKKS)
parms.set_poly_modulus_degree(poly_modulus_degree)
coeff = sealapi.CoeffModulus.Create(poly_modulus_degree, [60, 40, 40, 60])
parms.set_coeff_modulus(coeff)
sealctx = sealapi.SEALContext(parms, True, sealapi.SEC_LEVEL_TYPE.TC128)
assert sealctx.parameters_set() is True
context_asserts(sealctx, sec_level, sealapi.SCHEME_TYPE.CKKS)
def test_evaluator_conjugate():
testcase = [complex(i, i) for i in range(32)]
slot_size = len(testcase)
delta = 1 << 30
parms = sealapi.EncryptionParameters(sealapi.SCHEME_TYPE.CKKS)
poly_modulus = 2 * slot_size
parms.set_poly_modulus_degree(poly_modulus)
parms.set_plain_modulus(0)
coeff = sealapi.CoeffModulus.Create(poly_modulus, [40, 40, 40, 40])
parms.set_coeff_modulus(coeff)
ctx = sealapi.SEALContext.Create(parms, False, sealapi.SEC_LEVEL_TYPE.NONE)
ctx = helper_context_ckks()
keygen = sealapi.KeyGenerator(ctx)
galois_keys = keygen.galois_keys_local()
decryptor = sealapi.Decryptor(ctx, keygen.secret_key())
encryptor = sealapi.Encryptor(ctx, keygen.public_key())
evaluator = sealapi.Evaluator(ctx)
encoder = sealapi.CKKSEncoder(ctx)
plain = sealapi.Plaintext()
encoder.encode(testcase, ctx.first_parms_id(), delta, plain)
encrypted = sealapi.Ciphertext(ctx)
encryptor.encrypt(plain, encrypted)
evaluator.complex_conjugate_inplace(encrypted, galois_keys)
decryptor.decrypt(encrypted, plain)
decoded = encoder.decode_complex(plain)[:slot_size]
for idx in range(slot_size):
assert abs(testcase[idx].real - decoded[idx].real) < 0.1
assert abs(testcase[idx].imag + decoded[idx].imag) < 0.1
out = sealapi.Ciphertext(ctx)
evaluator.complex_conjugate(encrypted, galois_keys, out)
decryptor.decrypt(out, plain)
decoded = encoder.decode_complex(plain)[:slot_size]
for idx in range(slot_size):
assert abs(testcase[idx].real - decoded[idx].real) < 0.1
assert abs(testcase[idx].imag - decoded[idx].imag) < 0.1
def test_context_scheme_bfv_sanity(sec_level):
poly_modulus_degree = 8192
plaintext_modulus = 1032193
parms = sealapi.EncryptionParameters(sealapi.SCHEME_TYPE.BFV)
parms.set_poly_modulus_degree(poly_modulus_degree)
parms.set_plain_modulus(plaintext_modulus)
coeff = sealapi.CoeffModulus.Create(poly_modulus_degree, [32, 32])
parms.set_coeff_modulus(coeff)
sealctx = sealapi.SEALContext.Create(parms, True, sec_level)
assert sealctx.parameters_set() is True
coeff = sealapi.CoeffModulus.BFVDefault(poly_modulus_degree, sec_level)
parms.set_coeff_modulus(coeff)
sealctx = sealapi.SEALContext.Create(parms, True, sec_level)
context_asserts(sealctx, sec_level, sealapi.SCHEME_TYPE.BFV)
def helper_context_invalid():
parms = sealapi.EncryptionParameters(sealapi.SCHEME_TYPE.BFV)
return sealapi.SEALContext(parms, True, sealapi.SEC_LEVEL_TYPE.TC128)
def test_context_failure(scheme, sec_level):
parms = sealapi.EncryptionParameters(scheme)
sealctx = sealapi.SEALContext.Create(parms, True, sec_level)
assert sealctx.parameters_set() is False
def test_evaluator_mod_switch():
scheme = sealapi.SCHEME_TYPE.BFV
parms = sealapi.EncryptionParameters(scheme)
parms.set_poly_modulus_degree(128)
parms.set_plain_modulus(1 << 6)
coeff = sealapi.CoeffModulus.Create(128, [30, 30, 30])
parms.set_coeff_modulus(coeff)
ctx = sealapi.SEALContext.Create(parms, True, sealapi.SEC_LEVEL_TYPE.NONE)
intenc = sealapi.IntegerEncoder(ctx)
keygen = sealapi.KeyGenerator(ctx)
public_key = keygen.public_key()
secret_key = keygen.secret_key()
decryptor = sealapi.Decryptor(ctx, secret_key)
encryptor = sealapi.Encryptor(ctx, public_key)
evaluator = sealapi.Evaluator(ctx)
# cphertext mod switch to next
expected_value = 1234
plain = intenc.encode(expected_value)
out = sealapi.Plaintext()
enc = sealapi.Ciphertext(ctx)
encryptor.encrypt(plain, enc)
before = decryptor.invariant_noise_budget(enc)
evaluator.mod_switch_to_next_inplace(enc)
after = decryptor.invariant_noise_budget(enc)
assert before > after
decryptor.decrypt(enc, out)
assert intenc.decode_int64(out) == expected_value
# ciphertext mod switch to next
plain = intenc.encode(expected_value)
out = sealapi.Plaintext()
enc = sealapi.Ciphertext(ctx)
cout = sealapi.Ciphertext(ctx)
encryptor.encrypt(plain, enc)
before = decryptor.invariant_noise_budget(enc)
evaluator.mod_switch_to_next(enc, cout)
after = decryptor.invariant_noise_budget(cout)
assert before > after
decryptor.decrypt(cout, out)
assert intenc.decode_int64(out) == expected_value
# cphertext mod switch to inplace
parms_id = ctx.last_parms_id()
plain = intenc.encode(expected_value)
out = sealapi.Plaintext()
enc = sealapi.Ciphertext(ctx)
cout = sealapi.Ciphertext(ctx)
encryptor.encrypt(plain, enc)
before = decryptor.invariant_noise_budget(enc)
evaluator.mod_switch_to_inplace(enc, parms_id)
after = decryptor.invariant_noise_budget(enc)
assert before > after
decryptor.decrypt(enc, out)
assert intenc.decode_int64(out) == expected_value
assert enc.parms_id() == parms_id
# ciphertext mod switch to
parms_id = ctx.last_parms_id()
plain = intenc.encode(expected_value)
out = sealapi.Plaintext()
enc = sealapi.Ciphertext(ctx)
cout = sealapi.Ciphertext(ctx)
encryptor.encrypt(plain, enc)
before = decryptor.invariant_noise_budget(enc)
evaluator.mod_switch_to(enc, parms_id, cout)
after = decryptor.invariant_noise_budget(cout)
assert before > after
decryptor.decrypt(cout, out)
assert intenc.decode_int64(out) == expected_value
assert cout.parms_id() == parms_id
pol_str = "1x^3 + 1x^1 + 3"
# plaintext mod switch to next inplace
plain = sealapi.Plaintext(pol_str)
evaluator.transform_to_ntt_inplace(plain, ctx.first_parms_id())
assert plain.is_ntt_form() is True
evaluator.mod_switch_to_next_inplace(plain)
assert plain.parms_id() != ctx.first_parms_id()
# plaintext mod switch to next inplace failure
plain = sealapi.Plaintext(pol_str)
evaluator.transform_to_ntt_inplace(plain, ctx.last_parms_id())
assert plain.is_ntt_form() is True
with pytest.raises(BaseException):
evaluator.mod_switch_to_next_inplace(plain)
# plaintext mod switch to inplace
plain = sealapi.Plaintext(pol_str)
evaluator.transform_to_ntt_inplace(plain, ctx.first_parms_id())
assert plain.is_ntt_form() is True
evaluator.mod_switch_to_inplace(plain, ctx.last_parms_id())
assert plain.parms_id() == ctx.last_parms_id()
# plaintext mod switch to next
plain = sealapi.Plaintext(pol_str)
plain_out = sealapi.Plaintext()
evaluator.transform_to_ntt(plain, ctx.first_parms_id(), plain_out)
assert plain_out.is_ntt_form() is True
plain_next = sealapi.Plaintext()
evaluator.mod_switch_to_next(plain_out, plain_next)
assert plain_out.parms_id() == ctx.first_parms_id()
assert plain_next.parms_id() != ctx.first_parms_id()
# plaintext mod switch to
plain = sealapi.Plaintext(pol_str)
plain_out = sealapi.Plaintext()
evaluator.transform_to_ntt(plain, ctx.first_parms_id(), plain_out)
assert plain_out.is_ntt_form() is True
plain_next = sealapi.Plaintext()
evaluator.mod_switch_to(plain_out, ctx.last_parms_id(), plain_next)
assert plain_out.parms_id() == ctx.first_parms_id()
assert plain_next.parms_id() == ctx.last_parms_id()
