phantom-zone/src/bool/mp_api.rs
src/bool/mp_api.rsRaw
1use std::{cell::RefCell, sync::OnceLock};
2
3use crate::{
4 backend::{ModularOpsU64, ModulusPowerOf2},
5 ntt::NttBackendU64,
6 random::{DefaultSecureRng, NewWithSeed},
7 utils::{Global, WithLocal},
8};
9
10use super::{evaluator::MultiPartyCrs, keys::*, parameters::*, ClientKey, ParameterSelector};
11
12pub type BoolEvaluator = super::evaluator::BoolEvaluator<
13 Vec<Vec<u64>>,
14 NttBackendU64,
15 ModularOpsU64<CiphertextModulus<u64>>,
16 ModulusPowerOf2<CiphertextModulus<u64>>,
17 ShoupServerKeyEvaluationDomain<Vec<Vec<u64>>>,
18>;
19
20thread_local! {
21 static BOOL_EVALUATOR: RefCell<Option<BoolEvaluator>> = RefCell::new(None);
22
23}
24static BOOL_SERVER_KEY: OnceLock<ShoupServerKeyEvaluationDomain<Vec<Vec<u64>>>> = OnceLock::new();
25
26static MULTI_PARTY_CRS: OnceLock<MultiPartyCrs<[u8; 32]>> = OnceLock::new();
27
28pub fn set_parameter_set(select: ParameterSelector) {
29 match select {
30 ParameterSelector::MultiPartyLessThanOrEqualTo16 => {
31 BOOL_EVALUATOR.with_borrow_mut(|v| *v = Some(BoolEvaluator::new(SMALL_MP_BOOL_PARAMS)));
32 }
33 _ => {
34 panic!("Paramerters not supported")
35 }
36 }
37}
38
39pub fn set_mp_seed(seed: [u8; 32]) {
40 assert!(
41 MULTI_PARTY_CRS.set(MultiPartyCrs { seed: seed }).is_ok(),
42 "Attempted to set MP SEED twice."
43 )
44}
45
46pub fn gen_client_key() -> ClientKey {
47 BoolEvaluator::with_local(|e| e.client_key())
48}
49
50pub fn gen_mp_keys_phase1(
51 ck: &ClientKey,
52) -> CommonReferenceSeededCollectivePublicKeyShare<Vec<u64>, [u8; 32], BoolParameters<u64>> {
53 let seed = MultiPartyCrs::global().public_key_share_seed::<DefaultSecureRng>();
54 BoolEvaluator::with_local(|e| {
55 let pk_share = e.multi_party_public_key_share(seed, ck);
56 pk_share
57 })
58}
59
60pub fn gen_mp_keys_phase2<R, ModOp>(
61 ck: &ClientKey,
62 pk: &PublicKey<Vec<Vec<u64>>, R, ModOp>,
63) -> CommonReferenceSeededMultiPartyServerKeyShare<Vec<Vec<u64>>, BoolParameters<u64>, [u8; 32]> {
64 let seed = MultiPartyCrs::global().server_key_share_seed::<DefaultSecureRng>();
65 BoolEvaluator::with_local_mut(|e| {
66 let server_key_share = e.multi_party_server_key_share(seed, pk.key(), ck);
67 server_key_share
68 })
69}
70
71pub fn aggregate_public_key_shares(
72 shares: &[CommonReferenceSeededCollectivePublicKeyShare<
73 Vec<u64>,
74 [u8; 32],
75 BoolParameters<u64>,
76 >],
77) -> PublicKey<Vec<Vec<u64>>, DefaultSecureRng, ModularOpsU64<CiphertextModulus<u64>>> {
78 PublicKey::from(shares)
79}
80
81pub fn aggregate_server_key_shares(
82 shares: &[CommonReferenceSeededMultiPartyServerKeyShare<
83 Vec<Vec<u64>>,
84 BoolParameters<u64>,
85 [u8; 32],
86 >],
87) -> SeededMultiPartyServerKey<Vec<Vec<u64>>, [u8; 32], BoolParameters<u64>> {
88 BoolEvaluator::with_local(|e| e.aggregate_multi_party_server_key_shares(shares))
89}
90
91impl
92 SeededMultiPartyServerKey<
93 Vec<Vec<u64>>,
94 <DefaultSecureRng as NewWithSeed>::Seed,
95 BoolParameters<u64>,
96 >
97{
98 pub fn set_server_key(&self) {
99 assert!(
100 BOOL_SERVER_KEY
101 .set(ShoupServerKeyEvaluationDomain::from(
102 ServerKeyEvaluationDomain::<_, _, DefaultSecureRng, NttBackendU64>::from(self),
103 ))
104 .is_ok(),
105 "Attempted to set server key twice."
106 );
107 }
108}
109
110// MULTIPARTY CRS //
111impl Global for MultiPartyCrs<[u8; 32]> {
112 fn global() -> &'static Self {
113 MULTI_PARTY_CRS
114 .get()
115 .expect("Multi Party Common Reference String not set")
116 }
117}
118
119// BOOL EVALUATOR //
120impl WithLocal for BoolEvaluator {
121 fn with_local<F, R>(func: F) -> R
122 where
123 F: Fn(&Self) -> R,
124 {
125 BOOL_EVALUATOR.with_borrow(|s| func(s.as_ref().expect("Parameters not set")))
126 }
127
128 fn with_local_mut<F, R>(func: F) -> R
129 where
130 F: Fn(&mut Self) -> R,
131 {
132 BOOL_EVALUATOR.with_borrow_mut(|s| func(s.as_mut().expect("Parameters not set")))
133 }
134
135 fn with_local_mut_mut<F, R>(func: &mut F) -> R
136 where
137 F: FnMut(&mut Self) -> R,
138 {
139 BOOL_EVALUATOR.with_borrow_mut(|s| func(s.as_mut().expect("Parameters not set")))
140 }
141}
142
143pub(crate) type RuntimeServerKey = ShoupServerKeyEvaluationDomain<Vec<Vec<u64>>>;
144impl Global for RuntimeServerKey {
145 fn global() -> &'static Self {
146 BOOL_SERVER_KEY.get().expect("Server key not set!")
147 }
148}
149
150mod impl_enc_dec {
151 use crate::{
152 bool::evaluator::BoolEncoding,
153 pbs::{sample_extract, PbsInfo},
154 rgsw::public_key_encrypt_rlwe,
155 Encryptor, Matrix, MatrixEntity, MultiPartyDecryptor, RowEntity,
156 };
157 use itertools::Itertools;
158 use num_traits::{ToPrimitive, Zero};
159
160 use super::*;
161
162 type Mat = Vec<Vec<u64>>;
163
164 impl<Rng, ModOp> Encryptor<[bool], Vec<Mat>> for PublicKey<Mat, Rng, ModOp> {
165 fn encrypt(&self, m: &[bool]) -> Vec<Mat> {
166 BoolEvaluator::with_local(|e| {
167 DefaultSecureRng::with_local_mut(|rng| {
168 let parameters = e.parameters();
169 let ring_size = parameters.rlwe_n().0;
170
171 let rlwe_count = ((m.len() as f64 / ring_size as f64).ceil())
172 .to_usize()
173 .unwrap();
174
175 // encrypt `m` into ceil(len(m)/N) RLWE ciphertexts
176 let rlwes = (0..rlwe_count)
177 .map(|index| {
178 let mut message = vec![<Mat as Matrix>::MatElement::zero(); ring_size];
179 m[(index * ring_size)..std::cmp::min(m.len(), (index + 1) * ring_size)]
180 .iter()
181 .enumerate()
182 .for_each(|(i, v)| {
183 if *v {
184 message[i] = parameters.rlwe_q().true_el()
185 } else {
186 message[i] = parameters.rlwe_q().false_el()
187 }
188 });
189
190 // encrypt message
191 let mut rlwe_out =
192 <Mat as MatrixEntity>::zeros(2, parameters.rlwe_n().0);
193
194 public_key_encrypt_rlwe::<_, _, _, _, i32, _>(
195 &mut rlwe_out,
196 self.key(),
197 &message,
198 e.pbs_info().modop_rlweq(),
199 e.pbs_info().nttop_rlweq(),
200 rng,
201 );
202
203 rlwe_out
204 })
205 .collect_vec();
206 rlwes
207 })
208 })
209 }
210 }
211
212 impl<Rng, ModOp> Encryptor<bool, <Mat as Matrix>::R> for PublicKey<Mat, Rng, ModOp> {
213 fn encrypt(&self, m: &bool) -> <Mat as Matrix>::R {
214 let m = vec![*m];
215 let rlwe = &self.encrypt(m.as_slice())[0];
216 BoolEvaluator::with_local(|e| {
217 let mut lwe = <Mat as Matrix>::R::zeros(e.parameters().rlwe_n().0 + 1);
218 sample_extract(&mut lwe, rlwe, e.pbs_info().modop_rlweq(), 0);
219 lwe
220 })
221 }
222 }
223}
224
225#[cfg(test)]
226mod tests {
227 use itertools::Itertools;
228 use rand::{thread_rng, RngCore};
229
230 use crate::{bool::evaluator::BooleanGates, Encryptor, MultiPartyDecryptor};
231
232 use super::*;
233
234 #[test]
235 fn multi_party_bool_gates() {
236 set_parameter_set(ParameterSelector::MultiPartyLessThanOrEqualTo16);
237 let mut seed = [0u8; 32];
238 thread_rng().fill_bytes(&mut seed);
239 set_mp_seed(seed);
240
241 let parties = 2;
242 let cks = (0..parties).map(|_| gen_client_key()).collect_vec();
243
244 // round 1
245 let pk_shares = cks.iter().map(|k| gen_mp_keys_phase1(k)).collect_vec();
246
247 // collective pk
248 let pk = aggregate_public_key_shares(&pk_shares);
249
250 // round 2
251 let server_key_shares = cks.iter().map(|k| gen_mp_keys_phase2(k, &pk)).collect_vec();
252
253 // server key
254 let server_key = aggregate_server_key_shares(&server_key_shares);
255 server_key.set_server_key();
256
257 let mut m0 = false;
258 let mut m1 = true;
259
260 let mut ct0 = pk.encrypt(&m0);
261 let mut ct1 = pk.encrypt(&m1);
262
263 for _ in 0..500 {
264 let ct_out =
265 BoolEvaluator::with_local_mut(|e| e.nand(&ct0, &ct1, RuntimeServerKey::global()));
266
267 let m_expected = !(m0 && m1);
268
269 let decryption_shares = cks
270 .iter()
271 .map(|k| k.gen_decryption_share(&ct_out))
272 .collect_vec();
273 let m_out = cks[0].aggregate_decryption_shares(&ct_out, &decryption_shares);
274
275 assert!(m_out == m_expected, "Expected {m_expected}, got {m_out}");
276
277 m1 = m0;
278 m0 = m_expected;
279
280 ct1 = ct0;
281 ct0 = ct_out;
282 }
283
284 for _ in 0..500 {
285 let ct_out =
286 BoolEvaluator::with_local_mut(|e| e.xnor(&ct0, &ct1, RuntimeServerKey::global()));
287
288 let m_expected = !(m0 ^ m1);
289
290 let decryption_shares = cks
291 .iter()
292 .map(|k| k.gen_decryption_share(&ct_out))
293 .collect_vec();
294 let m_out = cks[0].aggregate_decryption_shares(&ct_out, &decryption_shares);
295
296 assert!(m_out == m_expected, "Expected {m_expected}, got {m_out}");
297
298 m1 = m0;
299 m0 = m_expected;
300
301 ct1 = ct0;
302 ct0 = ct_out;
303 }
304 }
305
306 mod sp_api {
307 use crate::{
308 backend::ModulusPowerOf2, utils::WithLocal, Decryptor, ModularOpsU64, NttBackendU64,
309 };
310
311 use super::*;
312
313 pub(crate) fn set_single_party_parameter_sets(parameter: BoolParameters<u64>) {
314 BOOL_EVALUATOR.with_borrow_mut(|e| *e = Some(BoolEvaluator::new(parameter)));
315 }
316
317 // SERVER KEY EVAL (/SHOUP) DOMAIN //
318 impl SeededSinglePartyServerKey<Vec<Vec<u64>>, BoolParameters<u64>, [u8; 32]> {
319 pub fn set_server_key(&self) {
320 assert!(
321 BOOL_SERVER_KEY
322 .set(
323 ShoupServerKeyEvaluationDomain::from(ServerKeyEvaluationDomain::<
324 _,
325 _,
326 DefaultSecureRng,
327 NttBackendU64,
328 >::from(
329 self
330 ),)
331 )
332 .is_ok(),
333 "Attempted to set server key twice."
334 );
335 }
336 }
337
338 pub(crate) fn gen_keys() -> (
339 ClientKey,
340 SeededSinglePartyServerKey<Vec<Vec<u64>>, BoolParameters<u64>, [u8; 32]>,
341 ) {
342 super::BoolEvaluator::with_local_mut(|e| {
343 let ck = e.client_key();
344 let sk = e.single_party_server_key(&ck);
345
346 (ck, sk)
347 })
348 }
349
350 impl<K: SinglePartyClientKey<Element = i32>> Encryptor<bool, Vec<u64>> for K {
351 fn encrypt(&self, m: &bool) -> Vec<u64> {
352 BoolEvaluator::with_local(|e| e.sk_encrypt(*m, self))
353 }
354 }
355
356 impl<K: SinglePartyClientKey<Element = i32>> Decryptor<bool, Vec<u64>> for K {
357 fn decrypt(&self, c: &Vec<u64>) -> bool {
358 BoolEvaluator::with_local(|e| e.sk_decrypt(c, self))
359 }
360 }
361
362 #[test]
363 #[cfg(feature = "interactive_mp")]
364 fn all_uint8_apis() {
365 use num_traits::Euclid;
366
367 set_single_party_parameter_sets(SP_TEST_BOOL_PARAMS);
368
369 let (ck, sk) = gen_keys();
370 sk.set_server_key();
371
372 for i in 144..=255 {
373 for j in 100..=255 {
374 let m0 = i;
375 let m1 = j;
376 let c0 = ck.encrypt(&m0);
377 let c1 = ck.encrypt(&m1);
378
379 assert!(ck.decrypt(&c0) == m0);
380 assert!(ck.decrypt(&c1) == m1);
381
382 // Arithmetic
383 {
384 {
385 // Add
386 let c_add = &c0 + &c1;
387 let m0_plus_m1 = ck.decrypt(&c_add);
388 assert_eq!(
389 m0_plus_m1,
390 m0.wrapping_add(m1),
391 "Expected {} but got {m0_plus_m1} for {i}+{j}",
392 m0.wrapping_add(m1)
393 );
394 }
395 {
396 // Sub
397 let c_sub = &c0 - &c1;
398 let m0_sub_m1 = ck.decrypt(&c_sub);
399 assert_eq!(
400 m0_sub_m1,
401 m0.wrapping_sub(m1),
402 "Expected {} but got {m0_sub_m1} for {i}-{j}",
403 m0.wrapping_sub(m1)
404 );
405 }
406
407 {
408 // Mul
409 let c_m0m1 = &c0 * &c1;
410 let m0m1 = ck.decrypt(&c_m0m1);
411 assert_eq!(
412 m0m1,
413 m0.wrapping_mul(m1),
414 "Expected {} but got {m0m1} for {i}x{j}",
415 m0.wrapping_mul(m1)
416 );
417 }
418
419 // Div & Rem
420 {
421 let (c_quotient, c_rem) = c0.div_rem(&c1);
422 let m_quotient = ck.decrypt(&c_quotient);
423 let m_remainder = ck.decrypt(&c_rem);
424 if j != 0 {
425 let (q, r) = i.div_rem_euclid(&j);
426 assert_eq!(
427 m_quotient, q,
428 "Expected {} but got {m_quotient} for {i}/{j}",
429 q
430 );
431 assert_eq!(
432 m_remainder, r,
433 "Expected {} but got {m_quotient} for {i}%{j}",
434 r
435 );
436 } else {
437 assert_eq!(
438 m_quotient, 255,
439 "Expected 255 but got {m_quotient}. Case div by zero"
440 );
441 assert_eq!(
442 m_remainder, i,
443 "Expected {i} but got {m_quotient}. Case div by zero"
444 )
445 }
446 }
447 }
448
449 // Comparisons
450 {
451 {
452 let c_eq = c0.eq(&c1);
453 let is_eq = ck.decrypt(&c_eq);
454 assert_eq!(
455 is_eq,
456 i == j,
457 "Expected {} but got {is_eq} for {i}=={j}",
458 i == j
459 );
460 }
461
462 {
463 let c_gt = c0.gt(&c1);
464 let is_gt = ck.decrypt(&c_gt);
465 assert_eq!(
466 is_gt,
467 i > j,
468 "Expected {} but got {is_gt} for {i}>{j}",
469 i > j
470 );
471 }
472
473 {
474 let c_lt = c0.lt(&c1);
475 let is_lt = ck.decrypt(&c_lt);
476 assert_eq!(
477 is_lt,
478 i < j,
479 "Expected {} but got {is_lt} for {i}<{j}",
480 i < j
481 );
482 }
483
484 {
485 let c_ge = c0.ge(&c1);
486 let is_ge = ck.decrypt(&c_ge);
487 assert_eq!(
488 is_ge,
489 i >= j,
490 "Expected {} but got {is_ge} for {i}>={j}",
491 i >= j
492 );
493 }
494
495 {
496 let c_le = c0.le(&c1);
497 let is_le = ck.decrypt(&c_le);
498 assert_eq!(
499 is_le,
500 i <= j,
501 "Expected {} but got {is_le} for {i}<={j}",
502 i <= j
503 );
504 }
505 }
506 }
507 }
508 }
509 }
510}