phantom-zone/src/multi_party.rs
src/multi_party.rsRaw
1use itertools::izip;
2
3use crate::{
4 backend::{GetModulus, VectorOps},
5 ntt::{self, Ntt},
6 random::{NewWithSeed, RandomFillGaussianInModulus, RandomFillUniformInModulus},
7 utils::TryConvertFrom1,
8 Decomposer, Matrix, MatrixEntity, MatrixMut, Row, RowEntity, RowMut,
9};
10
11pub(crate) fn public_key_share<
12 R: Row + RowMut + RowEntity,
13 S,
14 ModOp: VectorOps<Element = R::Element> + GetModulus<Element = R::Element>,
15 NttOp: Ntt<Element = R::Element>,
16 Rng: RandomFillGaussianInModulus<[R::Element], ModOp::M>,
17 PRng: RandomFillUniformInModulus<[R::Element], ModOp::M>,
18>(
19 share_out: &mut R,
20 s_i: &[S],
21 modop: &ModOp,
22 nttop: &NttOp,
23 p_rng: &mut PRng,
24 rng: &mut Rng,
25) where
26 R: TryConvertFrom1<[S], ModOp::M>,
27{
28 let ring_size = share_out.as_ref().len();
29 assert!(s_i.len() == ring_size);
30
31 let q = modop.modulus();
32
33 // sample a
34 let mut a = {
35 let mut a = R::zeros(ring_size);
36 RandomFillUniformInModulus::random_fill(p_rng, &q, a.as_mut());
37 a
38 };
39
40 // s*a
41 nttop.forward(a.as_mut());
42 let mut s = R::try_convert_from(s_i, &q);
43 nttop.forward(s.as_mut());
44 modop.elwise_mul_mut(s.as_mut(), a.as_ref());
45 nttop.backward(s.as_mut());
46
47 RandomFillGaussianInModulus::random_fill(rng, &q, share_out.as_mut());
48 modop.elwise_add_mut(share_out.as_mut(), s.as_ref()); // s*e + e
49}
50
51fn non_interactive_rgsw_ct<
52 M: MatrixMut + MatrixEntity,
53 S,
54 PRng: RandomFillUniformInModulus<[M::MatElement], ModOp::M>,
55 Rng: RandomFillGaussianInModulus<[M::MatElement], ModOp::M>,
56 NttOp: Ntt<Element = M::MatElement>,
57 ModOp: VectorOps<Element = M::MatElement> + GetModulus<Element = M::MatElement>,
58>(
59 s: &[S],
60 ephemeral_u: &[S],
61 m: &[M::MatElement],
62 gadget_vec: &[M::MatElement],
63 p_rng: &mut PRng,
64 rng: &mut Rng,
65 nttop: &NttOp,
66 modop: &ModOp,
67) -> (M, M)
68where
69 <M as Matrix>::R: RowMut + TryConvertFrom1<[S], ModOp::M> + RowEntity,
70 M::MatElement: Copy,
71{
72 assert_eq!(s.len(), ephemeral_u.len());
73 assert_eq!(s.len(), m.len());
74 let q = modop.modulus();
75 let d = gadget_vec.len();
76 let ring_size = s.len();
77
78 let mut s_poly_eval = M::R::try_convert_from(s, q);
79 let mut u_poly_eval = M::R::try_convert_from(ephemeral_u, q);
80 nttop.forward(s_poly_eval.as_mut());
81 nttop.forward(u_poly_eval.as_mut());
82
83 // encryptions of a_i*u + e + \beta m
84 let mut enc_beta_m = M::zeros(d, ring_size);
85 // zero encrypition: a_i*s + e'
86 let mut zero_encryptions = M::zeros(d, ring_size);
87
88 let mut scratch_space = M::R::zeros(ring_size);
89
90 izip!(
91 enc_beta_m.iter_rows_mut(),
92 zero_encryptions.iter_rows_mut(),
93 gadget_vec.iter()
94 )
95 .for_each(|(e_beta_m, e_zero, beta)| {
96 // sample a_i
97 RandomFillUniformInModulus::random_fill(p_rng, q, e_beta_m.as_mut());
98 e_zero.as_mut().copy_from_slice(e_beta_m.as_ref());
99
100 // a_i * u + \beta m + e //
101 // a_i * u
102 nttop.forward(e_beta_m.as_mut());
103 modop.elwise_mul_mut(e_beta_m.as_mut(), u_poly_eval.as_ref());
104 nttop.backward(e_beta_m.as_mut());
105 // sample error e
106 RandomFillGaussianInModulus::random_fill(rng, q, scratch_space.as_mut());
107 // a_i * u + e
108 modop.elwise_add_mut(e_beta_m.as_mut(), scratch_space.as_ref());
109 // beta * m
110 modop.elwise_scalar_mul(scratch_space.as_mut(), m.as_ref(), beta);
111 // a_i * u + e + \beta m
112 modop.elwise_add_mut(e_beta_m.as_mut(), scratch_space.as_ref());
113
114 // a_i * s + e //
115 // a_i * s
116 nttop.forward(e_zero.as_mut());
117 modop.elwise_mul_mut(e_zero.as_mut(), s_poly_eval.as_ref());
118 nttop.backward(e_zero.as_mut());
119 // sample error e
120 RandomFillGaussianInModulus::random_fill(rng, q, scratch_space.as_mut());
121 // a_i * s + e
122 modop.elwise_add_mut(e_zero.as_mut(), scratch_space.as_ref());
123 });
124
125 (enc_beta_m, zero_encryptions)
126}
127
128fn non_interactive_ksk_gen<
129 M: MatrixMut + MatrixEntity,
130 S,
131 PRng: RandomFillUniformInModulus<[M::MatElement], ModOp::M>,
132 Rng: RandomFillGaussianInModulus<[M::MatElement], ModOp::M>,
133 NttOp: Ntt<Element = M::MatElement>,
134 ModOp: VectorOps<Element = M::MatElement> + GetModulus<Element = M::MatElement>,
135>(
136 s: &[S],
137 ephemeral_u: &[S],
138 gadget_vec: &[M::MatElement],
139 p_rng: &mut PRng,
140 rng: &mut Rng,
141 nttop: &NttOp,
142 modop: &ModOp,
143) where
144 <M as Matrix>::R: RowMut + TryConvertFrom1<[S], ModOp::M> + RowEntity,
145 M::MatElement: Copy,
146{
147 assert_eq!(s.len(), ephemeral_u.len());
148
149 let q = modop.modulus();
150 let d = gadget_vec.len();
151 let ring_size = s.len();
152
153 let mut s_poly_eval = M::R::try_convert_from(s, q);
154 nttop.forward(s_poly_eval.as_mut());
155 let u_poly = M::R::try_convert_from(ephemeral_u, q);
156
157 // a_i * s + \beta u + e
158 // a_i * s + e
159 let mut ksk = M::zeros(d, ring_size);
160 let mut zero_encs = M::zeros(d, ring_size);
161
162 let mut scratch_space = M::R::zeros(ring_size);
163
164 izip!(
165 ksk.iter_rows_mut(),
166 zero_encs.iter_rows_mut(),
167 gadget_vec.iter()
168 )
169 .for_each(|(e_ksk, e_zero, beta)| {
170 // sample a_i
171 RandomFillUniformInModulus::random_fill(p_rng, q, e_ksk.as_mut());
172 e_zero.as_mut().copy_from_slice(e_ksk.as_ref());
173
174 // a_i * s + e + beta u
175 nttop.forward(e_ksk.as_mut());
176 modop.elwise_mul_mut(e_ksk.as_mut(), s_poly_eval.as_ref());
177 nttop.backward(e_ksk.as_mut());
178 // sample error e
179 RandomFillGaussianInModulus::random_fill(rng, q, scratch_space.as_mut());
180 // a_i * s + e
181 modop.elwise_add_mut(e_ksk.as_mut(), scratch_space.as_ref());
182 // \beta * u
183 modop.elwise_scalar_mul(scratch_space.as_mut(), u_poly.as_ref(), beta);
184 // a_i * s + e + \beta * u
185 modop.elwise_add_mut(e_ksk.as_mut(), scratch_space.as_ref());
186
187 // a_i * s + e
188 nttop.forward(e_zero.as_mut());
189 modop.elwise_mul_mut(e_zero.as_mut(), s_poly_eval.as_ref());
190 nttop.backward(e_zero.as_mut());
191 // sample error e
192 RandomFillGaussianInModulus::random_fill(rng, q, scratch_space.as_mut());
193
194 });
195}