diff --git a/Cargo.toml b/Cargo.toml index 732d164..20aae5f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -14,10 +14,15 @@ num-bigint-dig = { version = "0.8.4", features = ["prime"] } [dev-dependencies] criterion = "0.5.1" +[features] +default = ["interactive_mp"] +interactive_mp = [] +non_interactive_mp = [] + [[bench]] name = "ntt" harness = false [[bench]] name = "modulus" -harness = false \ No newline at end of file +harness = false diff --git a/src/bool/evaluator.rs b/src/bool/evaluator.rs index b10f4b4..2456fcf 100644 --- a/src/bool/evaluator.rs +++ b/src/bool/evaluator.rs @@ -2180,7 +2180,7 @@ mod tests { }, parameters::{ MP_BOOL_PARAMS, NON_INTERACTIVE_SMALL_MP_BOOL_PARAMS, SMALL_MP_BOOL_PARAMS, - SP_BOOL_PARAMS, + SP_TEST_BOOL_PARAMS, }, }, ntt::NttBackendU64, @@ -2204,7 +2204,7 @@ mod tests { ModularOpsU64>, ModularOpsU64>, ShoupServerKeyEvaluationDomain>>, - >::new(SP_BOOL_PARAMS); + >::new(SP_TEST_BOOL_PARAMS); let client_key = bool_evaluator.client_key(); let mut m = true; @@ -2216,243 +2216,6 @@ mod tests { } } - #[test] - fn bool_nand() { - let mut bool_evaluator = BoolEvaluator::< - Vec>, - NttBackendU64, - ModularOpsU64>, - ModularOpsU64>, - ShoupServerKeyEvaluationDomain<_>, - >::new(SP_BOOL_PARAMS); - - // println!("{:?}", bool_evaluator.nand_test_vec); - let client_key = bool_evaluator.client_key(); - let seeded_server_key = bool_evaluator.single_party_server_key(&client_key); - let runtime_server_key = - ShoupServerKeyEvaluationDomain::from(ServerKeyEvaluationDomain::< - _, - _, - DefaultSecureRng, - NttBackendU64, - >::from(&seeded_server_key)); - - let mut m0 = false; - let mut m1 = true; - - let mut ct0 = bool_evaluator.sk_encrypt(m0, &client_key); - let mut ct1 = bool_evaluator.sk_encrypt(m1, &client_key); - - for _ in 0..500 { - let ct_back = bool_evaluator.nand(&ct0, &ct1, &runtime_server_key); - - let m_out = !(m0 && m1); - - let m_back = bool_evaluator.sk_decrypt(&ct_back, &client_key); - assert!(m_out == m_back, "Expected {m_out}, got {m_back}"); - - m1 = m0; - m0 = m_out; - - ct1 = ct0; - ct0 = ct_back; - } - } - - #[test] - fn bool_xor() { - let mut bool_evaluator = BoolEvaluator::< - Vec>, - NttBackendU64, - ModularOpsU64>, - ModularOpsU64>, - ShoupServerKeyEvaluationDomain<_>, - >::new(SP_BOOL_PARAMS); - - // println!("{:?}", bool_evaluator.nand_test_vec); - let client_key = bool_evaluator.client_key(); - let seeded_server_key = bool_evaluator.single_party_server_key(&client_key); - let runtime_server_key = - ShoupServerKeyEvaluationDomain::from(ServerKeyEvaluationDomain::< - _, - _, - DefaultSecureRng, - NttBackendU64, - >::from(&seeded_server_key)); - - let mut m0 = false; - let mut m1 = true; - - let mut ct0 = bool_evaluator.sk_encrypt(m0, &client_key); - let mut ct1 = bool_evaluator.sk_encrypt(m1, &client_key); - - for _ in 0..1000 { - let ct_back = bool_evaluator.xor(&ct0, &ct1, &runtime_server_key); - let m_out = (m0 ^ m1); - - let m_back = bool_evaluator.sk_decrypt(&ct_back, &client_key); - assert!(m_out == m_back, "Expected {m_out}, got {m_back}"); - - m1 = m0; - m0 = m_out; - - ct1 = ct0; - ct0 = ct_back; - } - } - - #[test] - fn multi_party_encryption_decryption() { - let bool_evaluator = BoolEvaluator::< - Vec>, - NttBackendU64, - ModularOpsU64>, - ModularOpsU64>, - ShoupServerKeyEvaluationDomain>>, - >::new(MP_BOOL_PARAMS); - - let no_of_parties = 500; - let parties = (0..no_of_parties) - .map(|_| bool_evaluator.client_key()) - .collect_vec(); - - let mut ideal_rlwe_sk = vec![0i32; bool_evaluator.pbs_info.rlwe_n()]; - parties.iter().for_each(|k| { - izip!( - ideal_rlwe_sk.iter_mut(), - InteractiveMultiPartyClientKey::sk_rlwe(k).iter() - ) - .for_each(|(ideal_i, s_i)| { - *ideal_i = *ideal_i + s_i; - }); - }); - - let mut m = true; - for i in 0..100 { - let pk_cr_seed = [0u8; 32]; - - let public_key_share = parties - .iter() - .map(|k| bool_evaluator.multi_party_public_key_share(pk_cr_seed, k)) - .collect_vec(); - - let collective_pk = PublicKey::< - Vec>, - DefaultSecureRng, - ModularOpsU64>, - >::from(public_key_share.as_slice()); - let lwe_ct = bool_evaluator.pk_encrypt(collective_pk.key(), m); - - let decryption_shares = parties - .iter() - .map(|k| bool_evaluator.multi_party_decryption_share(&lwe_ct, k)) - .collect_vec(); - - let m_back = bool_evaluator.multi_party_decrypt(&decryption_shares, &lwe_ct); - - { - let ideal_m = if m { - bool_evaluator.pbs_info.parameters.rlwe_q().true_el() - } else { - bool_evaluator.pbs_info.parameters.rlwe_q().false_el() - }; - let noise = measure_noise_lwe( - &lwe_ct, - &ideal_rlwe_sk, - &bool_evaluator.pbs_info.rlwe_modop, - &ideal_m, - ); - println!("Noise: {noise}"); - } - - assert_eq!(m_back, m); - m = !m; - } - } - - #[test] - fn interactive_multi_party_nand() { - let mut bool_evaluator = BoolEvaluator::< - Vec>, - NttBackendU64, - ModularOpsU64>, - ModularOpsU64>, - ShoupServerKeyEvaluationDomain>>, - >::new(MP_BOOL_PARAMS); - - let multi_party_crs = MultiPartyCrs::random(); - - // let (parties, collective_pk, _, _, server_key_eval, ideal_client_key) = - // _multi_party_all_keygen(&bool_evaluator, 2); - - let no_of_parties = 2; - let parties = (0..no_of_parties) - .map(|_| bool_evaluator.client_key()) - .collect_vec(); - - // generate public key - let pk_shares = parties - .iter() - .map(|k| { - bool_evaluator.multi_party_public_key_share( - multi_party_crs.public_key_share_seed::(), - k, - ) - }) - .collect_vec(); - let collective_pk = - PublicKey::<_, DefaultSecureRng, ModularOpsU64>>::from( - pk_shares.as_slice(), - ); - - // generate server key - let server_key_shares = parties - .iter() - .map(|k| { - bool_evaluator.multi_party_server_key_share( - multi_party_crs.server_key_share_seed::(), - collective_pk.key(), - k, - ) - }) - .collect_vec(); - let seeded_server_key = - bool_evaluator.aggregate_multi_party_server_key_shares(&server_key_shares); - let server_key_eval = - ShoupServerKeyEvaluationDomain::from(ServerKeyEvaluationDomain::< - _, - _, - DefaultSecureRng, - NttBackendU64, - >::from(&seeded_server_key)); - - let mut m0 = true; - let mut m1 = false; - - let mut lwe0 = bool_evaluator.pk_encrypt(collective_pk.key(), m0); - let mut lwe1 = bool_evaluator.pk_encrypt(collective_pk.key(), m1); - - for _ in 0..2000 { - let lwe_out = bool_evaluator.nand(&lwe0, &lwe1, &server_key_eval); - - let m_expected = !(m0 & m1); - - // multi-party decrypt - let decryption_shares = parties - .iter() - .map(|k| bool_evaluator.multi_party_decryption_share(&lwe_out, k)) - .collect_vec(); - let m_back = bool_evaluator.multi_party_decrypt(&decryption_shares, &lwe_out); - - assert!(m_expected == m_back, "Expected {m_expected}, got {m_back}"); - m1 = m0; - m0 = m_expected; - - lwe1 = lwe0; - lwe0 = lwe_out; - } - } - #[test] fn noise_tester() { let bool_evaluator = BoolEvaluator::< diff --git a/src/bool/mod.rs b/src/bool/mod.rs index e9b4152..b8224d9 100644 --- a/src/bool/mod.rs +++ b/src/bool/mod.rs @@ -4,14 +4,41 @@ mod mp_api; mod ni_mp_api; mod noise; pub(crate) mod parameters; -mod sp_api; pub(crate) use keys::PublicKey; +#[cfg(feature = "non_interactive_mp")] pub use ni_mp_api::*; + +#[cfg(feature = "interactive_mp")] +pub use mp_api::*; + pub type ClientKey = keys::ClientKey<[u8; 32], u64>; pub enum ParameterSelector { MultiPartyLessThanOrEqualTo16, NonInteractiveMultiPartyLessThanOrEqualTo16, } + +mod common_mp_enc_dec { + use super::BoolEvaluator; + use crate::{utils::WithLocal, Matrix, MultiPartyDecryptor}; + + type Mat = Vec>; + + impl MultiPartyDecryptor::R> for super::keys::ClientKey<[u8; 32], E> { + type DecryptionShare = ::MatElement; + + fn gen_decryption_share(&self, c: &::R) -> Self::DecryptionShare { + BoolEvaluator::with_local(|e| e.multi_party_decryption_share(c, self)) + } + + fn aggregate_decryption_shares( + &self, + c: &::R, + shares: &[Self::DecryptionShare], + ) -> bool { + BoolEvaluator::with_local(|e| e.multi_party_decrypt(shares, c)) + } + } +} diff --git a/src/bool/mp_api.rs b/src/bool/mp_api.rs index fb62e68..7bb20af 100644 --- a/src/bool/mp_api.rs +++ b/src/bool/mp_api.rs @@ -43,25 +43,6 @@ pub fn set_mp_seed(seed: [u8; 32]) { ) } -fn set_server_key(key: ShoupServerKeyEvaluationDomain>>) { - assert!( - BOOL_SERVER_KEY.set(key).is_ok(), - "Attempted to set server key twice." - ); -} - -pub(crate) fn gen_keys() -> ( - ClientKey, - SeededSinglePartyServerKey>, BoolParameters, [u8; 32]>, -) { - BoolEvaluator::with_local_mut(|e| { - let ck = e.client_key(); - let sk = e.single_party_server_key(&ck); - - (ck, sk) - }) -} - pub fn gen_client_key() -> ClientKey { BoolEvaluator::with_local(|e| e.client_key()) } @@ -107,14 +88,6 @@ pub fn aggregate_server_key_shares( BoolEvaluator::with_local(|e| e.aggregate_multi_party_server_key_shares(shares)) } -// SERVER KEY EVAL (/SHOUP) DOMAIN // -impl SeededSinglePartyServerKey>, BoolParameters, [u8; 32]> { - pub fn set_server_key(&self) { - let eval = ServerKeyEvaluationDomain::<_, _, DefaultSecureRng, NttBackendU64>::from(self); - set_server_key(ShoupServerKeyEvaluationDomain::from(eval)); - } -} - impl SeededMultiPartyServerKey< Vec>, @@ -123,9 +96,14 @@ impl > { pub fn set_server_key(&self) { - set_server_key(ShoupServerKeyEvaluationDomain::from( - ServerKeyEvaluationDomain::<_, _, DefaultSecureRng, NttBackendU64>::from(self), - )) + assert!( + BOOL_SERVER_KEY + .set(ShoupServerKeyEvaluationDomain::from( + ServerKeyEvaluationDomain::<_, _, DefaultSecureRng, NttBackendU64>::from(self), + )) + .is_ok(), + "Attempted to set server key twice." + ); } } @@ -243,3 +221,290 @@ mod impl_enc_dec { } } } + +#[cfg(test)] +mod tests { + use itertools::Itertools; + use rand::{thread_rng, RngCore}; + + use crate::{bool::evaluator::BooleanGates, Encryptor, MultiPartyDecryptor}; + + use super::*; + + #[test] + fn multi_party_bool_gates() { + set_parameter_set(ParameterSelector::MultiPartyLessThanOrEqualTo16); + let mut seed = [0u8; 32]; + thread_rng().fill_bytes(&mut seed); + set_mp_seed(seed); + + let parties = 2; + let cks = (0..parties).map(|_| gen_client_key()).collect_vec(); + + // round 1 + let pk_shares = cks.iter().map(|k| gen_mp_keys_phase1(k)).collect_vec(); + + // collective pk + let pk = aggregate_public_key_shares(&pk_shares); + + // round 2 + let server_key_shares = cks.iter().map(|k| gen_mp_keys_phase2(k, &pk)).collect_vec(); + + // server key + let server_key = aggregate_server_key_shares(&server_key_shares); + server_key.set_server_key(); + + let mut m0 = false; + let mut m1 = true; + + let mut ct0 = pk.encrypt(&m0); + let mut ct1 = pk.encrypt(&m1); + + for _ in 0..500 { + let ct_out = + BoolEvaluator::with_local_mut(|e| e.nand(&ct0, &ct1, RuntimeServerKey::global())); + + let m_expected = !(m0 && m1); + + let decryption_shares = cks + .iter() + .map(|k| k.gen_decryption_share(&ct_out)) + .collect_vec(); + let m_out = cks[0].aggregate_decryption_shares(&ct_out, &decryption_shares); + + assert!(m_out == m_expected, "Expected {m_expected}, got {m_out}"); + + m1 = m0; + m0 = m_expected; + + ct1 = ct0; + ct0 = ct_out; + } + + for _ in 0..500 { + let ct_out = + BoolEvaluator::with_local_mut(|e| e.xnor(&ct0, &ct1, RuntimeServerKey::global())); + + let m_expected = !(m0 ^ m1); + + let decryption_shares = cks + .iter() + .map(|k| k.gen_decryption_share(&ct_out)) + .collect_vec(); + let m_out = cks[0].aggregate_decryption_shares(&ct_out, &decryption_shares); + + assert!(m_out == m_expected, "Expected {m_expected}, got {m_out}"); + + m1 = m0; + m0 = m_expected; + + ct1 = ct0; + ct0 = ct_out; + } + } + + mod sp_api { + use crate::{ + backend::ModulusPowerOf2, utils::WithLocal, Decryptor, ModularOpsU64, NttBackendU64, + }; + + use super::*; + + pub(crate) fn set_single_party_parameter_sets(parameter: BoolParameters) { + BOOL_EVALUATOR.with_borrow_mut(|e| *e = Some(BoolEvaluator::new(parameter))); + } + + // SERVER KEY EVAL (/SHOUP) DOMAIN // + impl SeededSinglePartyServerKey>, BoolParameters, [u8; 32]> { + pub fn set_server_key(&self) { + assert!( + BOOL_SERVER_KEY + .set( + ShoupServerKeyEvaluationDomain::from(ServerKeyEvaluationDomain::< + _, + _, + DefaultSecureRng, + NttBackendU64, + >::from( + self + ),) + ) + .is_ok(), + "Attempted to set server key twice." + ); + } + } + + pub(crate) fn gen_keys() -> ( + ClientKey, + SeededSinglePartyServerKey>, BoolParameters, [u8; 32]>, + ) { + super::BoolEvaluator::with_local_mut(|e| { + let ck = e.client_key(); + let sk = e.single_party_server_key(&ck); + + (ck, sk) + }) + } + + impl> Encryptor> for K { + fn encrypt(&self, m: &bool) -> Vec { + BoolEvaluator::with_local(|e| e.sk_encrypt(*m, self)) + } + } + + impl> Decryptor> for K { + fn decrypt(&self, c: &Vec) -> bool { + BoolEvaluator::with_local(|e| e.sk_decrypt(c, self)) + } + } + + #[test] + #[cfg(feature = "interactive_mp")] + fn all_uint8_apis() { + use num_traits::Euclid; + + set_single_party_parameter_sets(SP_TEST_BOOL_PARAMS); + + let (ck, sk) = gen_keys(); + sk.set_server_key(); + + for i in 144..=255 { + for j in 100..=255 { + let m0 = i; + let m1 = j; + let c0 = ck.encrypt(&m0); + let c1 = ck.encrypt(&m1); + + assert!(ck.decrypt(&c0) == m0); + assert!(ck.decrypt(&c1) == m1); + + // Arithmetic + { + { + // Add + let c_add = &c0 + &c1; + let m0_plus_m1 = ck.decrypt(&c_add); + assert_eq!( + m0_plus_m1, + m0.wrapping_add(m1), + "Expected {} but got {m0_plus_m1} for {i}+{j}", + m0.wrapping_add(m1) + ); + } + { + // Sub + let c_sub = &c0 - &c1; + let m0_sub_m1 = ck.decrypt(&c_sub); + assert_eq!( + m0_sub_m1, + m0.wrapping_sub(m1), + "Expected {} but got {m0_sub_m1} for {i}-{j}", + m0.wrapping_sub(m1) + ); + } + + { + // Mul + let c_m0m1 = &c0 * &c1; + let m0m1 = ck.decrypt(&c_m0m1); + assert_eq!( + m0m1, + m0.wrapping_mul(m1), + "Expected {} but got {m0m1} for {i}x{j}", + m0.wrapping_mul(m1) + ); + } + + // Div & Rem + { + let (c_quotient, c_rem) = c0.div_rem(&c1); + let m_quotient = ck.decrypt(&c_quotient); + let m_remainder = ck.decrypt(&c_rem); + if j != 0 { + let (q, r) = i.div_rem_euclid(&j); + assert_eq!( + m_quotient, q, + "Expected {} but got {m_quotient} for {i}/{j}", + q + ); + assert_eq!( + m_remainder, r, + "Expected {} but got {m_quotient} for {i}%{j}", + r + ); + } else { + assert_eq!( + m_quotient, 255, + "Expected 255 but got {m_quotient}. Case div by zero" + ); + assert_eq!( + m_remainder, i, + "Expected {i} but got {m_quotient}. Case div by zero" + ) + } + } + } + + // Comparisons + { + { + let c_eq = c0.eq(&c1); + let is_eq = ck.decrypt(&c_eq); + assert_eq!( + is_eq, + i == j, + "Expected {} but got {is_eq} for {i}=={j}", + i == j + ); + } + + { + let c_gt = c0.gt(&c1); + let is_gt = ck.decrypt(&c_gt); + assert_eq!( + is_gt, + i > j, + "Expected {} but got {is_gt} for {i}>{j}", + i > j + ); + } + + { + let c_lt = c0.lt(&c1); + let is_lt = ck.decrypt(&c_lt); + assert_eq!( + is_lt, + i < j, + "Expected {} but got {is_lt} for {i}<{j}", + i < j + ); + } + + { + let c_ge = c0.ge(&c1); + let is_ge = ck.decrypt(&c_ge); + assert_eq!( + is_ge, + i >= j, + "Expected {} but got {is_ge} for {i}>={j}", + i >= j + ); + } + + { + let c_le = c0.le(&c1); + let is_le = ck.decrypt(&c_le); + assert_eq!( + is_le, + i <= j, + "Expected {} but got {is_le} for {i}<={j}", + i <= j + ); + } + } + } + } + } + } +} diff --git a/src/bool/ni_mp_api.rs b/src/bool/ni_mp_api.rs index 62460a9..e26cc40 100644 --- a/src/bool/ni_mp_api.rs +++ b/src/bool/ni_mp_api.rs @@ -348,24 +348,6 @@ mod impl_enc_dec { BatchedFheBools { data } } } - - impl MultiPartyDecryptor::R> - for super::super::keys::ClientKey<[u8; 32], E> - { - type DecryptionShare = ::MatElement; - - fn gen_decryption_share(&self, c: &::R) -> Self::DecryptionShare { - BoolEvaluator::with_local(|e| e.multi_party_decryption_share(c, self)) - } - - fn aggregate_decryption_shares( - &self, - c: &::R, - shares: &[Self::DecryptionShare], - ) -> bool { - BoolEvaluator::with_local(|e| e.multi_party_decrypt(shares, c)) - } - } } #[cfg(test)] diff --git a/src/bool/parameters.rs b/src/bool/parameters.rs index f13a98b..851c5fb 100644 --- a/src/bool/parameters.rs +++ b/src/bool/parameters.rs @@ -442,25 +442,6 @@ where } } -pub(crate) const SP_BOOL_PARAMS: BoolParameters = BoolParameters:: { - rlwe_q: CiphertextModulus::new_non_native(268369921u64), - lwe_q: CiphertextModulus::new_non_native(1 << 16), - br_q: 1 << 10, - rlwe_n: PolynomialSize(1 << 10), - lwe_n: LweDimension(500), - lwe_decomposer_params: (DecompostionLogBase(4), DecompositionCount(4)), - rlrg_decomposer_params: ( - DecompostionLogBase(7), - (DecompositionCount(4), DecompositionCount(4)), - ), - rgrg_decomposer_params: None, - auto_decomposer_params: (DecompostionLogBase(7), DecompositionCount(4)), - non_interactive_ui_to_s_key_switch_decomposer: None, - g: 5, - w: 5, - variant: ParameterVariant::SingleParty, -}; - pub(crate) const MP_BOOL_PARAMS: BoolParameters = BoolParameters:: { rlwe_q: CiphertextModulus::new_non_native(1152921504606830593), lwe_q: CiphertextModulus::new_non_native(1 << 20), @@ -529,6 +510,27 @@ pub(crate) const NON_INTERACTIVE_SMALL_MP_BOOL_PARAMS: BoolParameters = Boo w: 10, variant: ParameterVariant::NonInteractiveMultiParty, }; + +#[cfg(test)] +pub(crate) const SP_TEST_BOOL_PARAMS: BoolParameters = BoolParameters:: { + rlwe_q: CiphertextModulus::new_non_native(268369921u64), + lwe_q: CiphertextModulus::new_non_native(1 << 16), + br_q: 1 << 9, + rlwe_n: PolynomialSize(1 << 9), + lwe_n: LweDimension(100), + lwe_decomposer_params: (DecompostionLogBase(4), DecompositionCount(4)), + rlrg_decomposer_params: ( + DecompostionLogBase(7), + (DecompositionCount(4), DecompositionCount(4)), + ), + rgrg_decomposer_params: None, + auto_decomposer_params: (DecompostionLogBase(7), DecompositionCount(4)), + non_interactive_ui_to_s_key_switch_decomposer: None, + g: 5, + w: 5, + variant: ParameterVariant::SingleParty, +}; + #[cfg(test)] mod tests { diff --git a/src/bool/sp_api.rs b/src/bool/sp_api.rs deleted file mode 100644 index 5ad39da..0000000 --- a/src/bool/sp_api.rs +++ /dev/null @@ -1,25 +0,0 @@ -mod impl_enc_dec { - use crate::{Decryptor, Encryptor}; - - use super::super::keys::SinglePartyClientKey; - - impl Encryptor> for K - where - K: SinglePartyClientKey, - { - fn encrypt(&self, m: &bool) -> Vec { - todo!() - // BoolEvaluator::with_local(|e| e.sk_encrypt(*m, self)) - } - } - - impl Decryptor> for K - where - K: SinglePartyClientKey, - { - fn decrypt(&self, c: &Vec) -> bool { - todo!() - // BoolEvaluator::with_local(|e| e.sk_decrypt(c, self)) - } - } -} diff --git a/src/shortint/mod.rs b/src/shortint/mod.rs index 4f625ff..8e26783 100644 --- a/src/shortint/mod.rs +++ b/src/shortint/mod.rs @@ -1,12 +1,3 @@ -use itertools::Itertools; - -use crate::{ - bool::{parameters::CiphertextModulus, ClientKey, PublicKey}, - random::{DefaultSecureRng, NewWithSeed, RandomFillUniformInModulus}, - utils::{TryConvertFrom1, WithLocal}, - Decryptor, Encryptor, Matrix, MatrixEntity, MatrixMut, MultiPartyDecryptor, Row, RowMut, -}; - mod enc_dec; mod ops; mod types; @@ -14,6 +5,8 @@ mod types; pub type FheUint8 = enc_dec::FheUint8>; pub type FheBool = Vec; +use crate::bool::{evaluator::BooleanGates, BoolEvaluator, RuntimeServerKey}; + mod frontend { use super::ops::{ arbitrary_bit_adder, arbitrary_bit_division_for_quotient_and_rem, arbitrary_bit_subtractor, @@ -24,7 +17,6 @@ mod frontend { use super::*; mod arithetic { - use crate::bool::{evaluator::BooleanGates, BoolEvaluator, RuntimeServerKey}; use super::*; use std::ops::{Add, AddAssign, Div, Mul, Rem, Sub}; @@ -149,11 +141,8 @@ mod frontend { } mod booleans { - use crate::{ - bool::{evaluator::BooleanGates, BoolEvaluator, RuntimeServerKey}, - shortint::ops::{ - arbitrary_bit_comparator, arbitrary_bit_equality, arbitrary_signed_bit_comparator, - }, + use crate::shortint::ops::{ + arbitrary_bit_comparator, arbitrary_bit_equality, arbitrary_signed_bit_comparator, }; use super::*; @@ -223,155 +212,9 @@ mod tests { use num_traits::Euclid; use crate::{ - bool::set_parameter_set, shortint::enc_dec::FheUint8, Decryptor, Encryptor, - MultiPartyDecryptor, + bool::set_parameter_set, shortint::enc_dec::FheUint8, utils::WithLocal, Decryptor, + Encryptor, MultiPartyDecryptor, }; - // #[test] - // fn all_uint8_apis() { - // set_parameter_set(crate::ParameterSelector::MultiPartyLessThanOrEqualTo16); - - // let (ck, sk) = gen_keys(); - // sk.set_server_key(); - - // for i in 144..=255 { - // for j in 100..=255 { - // let m0 = i; - // let m1 = j; - // let c0 = ck.encrypt(&m0); - // let c1 = ck.encrypt(&m1); - - // assert!(ck.decrypt(&c0) == m0); - // assert!(ck.decrypt(&c1) == m1); - - // // Arithmetic - // { - // { - // // Add - // let mut c_m0_plus_m1 = FheUint8 { - // data: c0.data().to_vec(), - // }; - // c_m0_plus_m1 += &c1; - // let m0_plus_m1 = ck.decrypt(&c_m0_plus_m1); - // assert_eq!( - // m0_plus_m1, - // m0.wrapping_add(m1), - // "Expected {} but got {m0_plus_m1} for {i}+{j}", - // m0.wrapping_add(m1) - // ); - // } - // { - // // Sub - // let c_sub = &c0 - &c1; - // let m0_sub_m1 = ck.decrypt(&c_sub); - // assert_eq!( - // m0_sub_m1, - // m0.wrapping_sub(m1), - // "Expected {} but got {m0_sub_m1} for {i}-{j}", - // m0.wrapping_sub(m1) - // ); - // } - - // { - // // Mul - // let c_m0m1 = &c0 * &c1; - // let m0m1 = ck.decrypt(&c_m0m1); - // assert_eq!( - // m0m1, - // m0.wrapping_mul(m1), - // "Expected {} but got {m0m1} for {i}x{j}", - // m0.wrapping_mul(m1) - // ); - // } - - // // Div & Rem - // { - // let (c_quotient, c_rem) = c0.div_rem(&c1); - // let m_quotient = ck.decrypt(&c_quotient); - // let m_remainder = ck.decrypt(&c_rem); - // if j != 0 { - // let (q, r) = i.div_rem_euclid(&j); - // assert_eq!( - // m_quotient, q, - // "Expected {} but got {m_quotient} for - // {i}/{j}", q - // ); - // assert_eq!( - // m_remainder, r, - // "Expected {} but got {m_quotient} for - // {i}%{j}", r - // ); - // } else { - // assert_eq!( - // m_quotient, 255, - // "Expected 255 but got {m_quotient}. Case div - // by zero" ); - // assert_eq!( - // m_remainder, i, - // "Expected {i} but got {m_quotient}. Case div - // by zero" ) - // } - // } - // } - - // // Comparisons - // { - // { - // let c_eq = c0.eq(&c1); - // let is_eq = ck.decrypt(&c_eq); - // assert_eq!( - // is_eq, - // i == j, - // "Expected {} but got {is_eq} for {i}=={j}", - // i == j - // ); - // } - - // { - // let c_gt = c0.gt(&c1); - // let is_gt = ck.decrypt(&c_gt); - // assert_eq!( - // is_gt, - // i > j, - // "Expected {} but got {is_gt} for {i}>{j}", - // i > j - // ); - // } - - // { - // let c_lt = c0.lt(&c1); - // let is_lt = ck.decrypt(&c_lt); - // assert_eq!( - // is_lt, - // i < j, - // "Expected {} but got {is_lt} for {i}<{j}", - // i < j - // ); - // } - - // { - // let c_ge = c0.ge(&c1); - // let is_ge = ck.decrypt(&c_ge); - // assert_eq!( - // is_ge, - // i >= j, - // "Expected {} but got {is_ge} for {i}>={j}", - // i >= j - // ); - // } - - // { - // let c_le = c0.le(&c1); - // let is_le = ck.decrypt(&c_le); - // assert_eq!( - // is_le, - // i <= j, - // "Expected {} but got {is_le} for {i}<={j}", - // i <= j - // ); - // } - // } - // } - // } - // } + use super::*; }