phantom-zone/src/noise.rs
src/noise.rsRaw
1#[cfg(test)]
2mod tests {
3 use rand::{thread_rng, Rng};
4
5 use crate::{
6 backend::{ArithmeticOps, ModInit, ModularOpsU64},
7 decomposer::{Decomposer, DefaultDecomposer},
8 ntt::{Ntt, NttBackendU64, NttInit},
9 random::{DefaultSecureRng, RandomGaussianDist, RandomUniformDist},
10 rgsw::{
11 less1_rlwe_by_rgsw, measure_noise, rgsw_by_rgsw_inplace, rlwe_by_rgsw,
12 secret_key_encrypt_rgsw, secret_key_encrypt_rlwe, RgswCiphertext,
13 RgswCiphertextEvaluationDomain, RlweCiphertext, RlweSecret, SeededRgswCiphertext,
14 SeededRlweCiphertext,
15 },
16 utils::{generate_prime, negacyclic_mul},
17 Matrix, Row, Secret,
18 };
19
20 // // Test B part with limbd -1 when variance of m is 1
21 // #[test]
22 // fn trial() {
23 // let logq = 28;
24 // let ring_size = 1 << 10;
25 // let q = generate_prime(logq, (ring_size as u64) << 1, 1 <<
26 // logq).unwrap(); let logb = 7;
27 // let d0 = 3;
28 // let d1 = d0 - 1;
29
30 // let sk = RlweSecret::random((ring_size >> 1) as usize, ring_size as
31 // usize);
32
33 // let mut rng = DefaultSecureRng::new();
34 // let decomposer = DefaultDecomposer::new(q, logb, d0);
35 // let gadget_vector = decomposer.gadget_vector();
36
37 // for i in 0..100 {
38 // // m should have norm 1
39 // let mut m0 = vec![0u64; ring_size as usize];
40 // m0[thread_rng().gen_range(0..ring_size)] = 1;
41
42 // let modq_op = ModularOpsU64::new(q);
43 // let nttq_op = NttBackendU64::new(q, ring_size);
44
45 // // Encrypt RGSW(m0)
46 // let mut rgsw_seed = [0u8; 32];
47 // rng.fill_bytes(&mut rgsw_seed);
48 // let mut seeded_rgsw =
49 // SeededRgswCiphertext::<Vec<Vec<u64>>, _>::empty(ring_size,
50 // d0, rgsw_seed, q); let mut p_rng =
51 // DefaultSecureRng::new_seeded(rgsw_seed);
52 // secret_key_encrypt_rgsw(
53 // &mut seeded_rgsw.data,
54 // &m0,
55 // &gadget_vector,
56 // &gadget_vector,
57 // sk.values(),
58 // &modq_op,
59 // &nttq_op,
60 // &mut p_rng,
61 // &mut rng,
62 // );
63
64 // // Encrypt RLWE(m1)
65 // let mut m1 = vec![0u64; ring_size];
66 // RandomUniformDist::random_fill(&mut rng, &q, m1.as_mut_slice());
67 // let mut rlwe_seed = [0u8; 32];
68 // rng.fill_bytes(&mut rlwe_seed);
69 // let mut seeded_rlwe: SeededRlweCiphertext<Vec<u64>, [u8; 32]> =
70 // SeededRlweCiphertext::<Vec<u64>, _>::empty(ring_size,
71 // rlwe_seed, q); let mut p_rng =
72 // DefaultSecureRng::new_seeded(rlwe_seed);
73 // secret_key_encrypt_rlwe(
74 // &m1,
75 // &mut seeded_rlwe.data,
76 // sk.values(),
77 // &modq_op,
78 // &nttq_op,
79 // &mut p_rng,
80 // &mut rng,
81 // );
82
83 // let mut rlwe = RlweCiphertext::<Vec<Vec<u64>>,
84 // DefaultSecureRng>::from(&seeded_rlwe); let rgsw =
85 // RgswCiphertextEvaluationDomain::<_, DefaultSecureRng,
86 // NttBackendU64>::from( &seeded_rgsw,
87 // );
88
89 // // RLWE(m0m1) = RLWE(m1) x RGSW(m0)
90 // let mut scratch = vec![vec![0u64; ring_size]; d0 + 2];
91 // less1_rlwe_by_rgsw(
92 // &mut rlwe,
93 // &rgsw.data,
94 // &mut scratch,
95 // &decomposer,
96 // &nttq_op,
97 // &modq_op,
98 // 0,
99 // 1,
100 // );
101 // // rlwe_by_rgsw(
102 // // &mut rlwe,
103 // // &rgsw.data,
104 // // &mut scratch,
105 // // &decomposer,
106 // // &nttq_op,
107 // // &modq_op,
108 // // );
109
110 // // measure noise
111 // let mul_mod = |v0: &u64, v1: &u64| ((*v0 as u128 * *v1 as u128) %
112 // q as u128) as u64; let m0m1 = negacyclic_mul(&m0, &m1,
113 // mul_mod, q); let noise = measure_noise(&rlwe, &m0m1,
114 // &nttq_op, &modq_op, sk.values()); println!("Noise: {noise}");
115 // }
116 // }
117
118 // // Test B part with limbd -1 when variance of m is 1
119 // #[test]
120 // fn rgsw_saver() {
121 // let logq = 60;
122 // let ring_size = 1 << 11;
123 // let q = generate_prime(logq, (ring_size as u64) << 1, 1 <<
124 // logq).unwrap(); let logb = 12;
125 // let d0 = 4;
126
127 // let sk = RlweSecret::random((ring_size >> 1) as usize, ring_size as
128 // usize);
129
130 // let mut rng = DefaultSecureRng::new();
131
132 // let decomposer = DefaultDecomposer::new(q, logb, d0);
133 // let gadget_vector = decomposer.gadget_vector();
134
135 // for i in 0..100 {
136 // let modq_op = ModularOpsU64::new(q);
137 // let nttq_op = NttBackendU64::new(q, ring_size);
138
139 // // Encrypt RGSW(m0)
140 // let mut m0 = vec![0u64; ring_size as usize];
141 // m0[thread_rng().gen_range(0..ring_size)] = 1;
142 // let mut rgsw_seed = [0u8; 32];
143 // rng.fill_bytes(&mut rgsw_seed);
144 // let mut seeded_rgsw0 =
145 // SeededRgswCiphertext::<Vec<Vec<u64>>, _>::empty(ring_size,
146 // d0, rgsw_seed, q); let mut p_rng =
147 // DefaultSecureRng::new_seeded(rgsw_seed);
148 // secret_key_encrypt_rgsw(
149 // &mut seeded_rgsw0.data,
150 // &m0,
151 // &gadget_vector,
152 // &gadget_vector,
153 // sk.values(),
154 // &modq_op,
155 // &nttq_op,
156 // &mut p_rng,
157 // &mut rng,
158 // );
159
160 // // Encrypt RGSW(m1)
161 // let mut m1 = vec![0u64; ring_size as usize];
162 // m1[thread_rng().gen_range(0..ring_size)] = 1;
163 // let mut rgsw_seed = [0u8; 32];
164 // rng.fill_bytes(&mut rgsw_seed);
165 // let mut seeded_rgsw1 =
166 // SeededRgswCiphertext::<Vec<Vec<u64>>, _>::empty(ring_size,
167 // d0, rgsw_seed, q); let mut p_rng =
168 // DefaultSecureRng::new_seeded(rgsw_seed);
169 // secret_key_encrypt_rgsw(
170 // &mut seeded_rgsw1.data,
171 // &m1,
172 // &gadget_vector,
173 // &gadget_vector,
174 // sk.values(),
175 // &modq_op,
176 // &nttq_op,
177 // &mut p_rng,
178 // &mut rng,
179 // );
180
181 // // TODO(Jay): Why cant you create RgswCIphertext from
182 // SeededRgswCiphertext? let mut rgsw0 = {
183 // let mut evl_tmp =
184 // RgswCiphertextEvaluationDomain::<_, DefaultSecureRng,
185 // NttBackendU64>::from( &seeded_rgsw0,
186 // );
187 // evl_tmp
188 // .data
189 // .iter_mut()
190 // .for_each(|ri| nttq_op.backward(ri.as_mut()));
191 // evl_tmp.data
192 // };
193 // let rgsw1 = RgswCiphertextEvaluationDomain::<_, DefaultSecureRng,
194 // NttBackendU64>::from( &seeded_rgsw1,
195 // );
196 // let mut scratch_matrix_d_plus_rgsw_by_ring = vec![vec![0u64;
197 // ring_size]; d0 + (d0 * 4)];
198
199 // // RGSW(m0m1) = RGSW(m0)xRGSW(m1)
200 // rgsw_by_rgsw_inplace(
201 // &mut rgsw0,
202 // &rgsw1.data,
203 // &decomposer,
204 // &decomposer,
205 // &mut scratch_matrix_d_plus_rgsw_by_ring,
206 // &nttq_op,
207 // &modq_op,
208 // );
209
210 // // send RGSW(m0m1) to Evaluation domain
211 // let mut rgsw01 = rgsw0;
212 // rgsw01
213 // .iter_mut()
214 // .for_each(|v| nttq_op.forward(v.as_mut_slice()));
215
216 // // RLWE(m2)
217 // let mut m2 = vec![0u64; ring_size as usize];
218 // RandomUniformDist::random_fill(&mut rng, &q, m2.as_mut_slice());
219 // let mut rlwe_seed = [0u8; 32];
220 // rng.fill_bytes(&mut rlwe_seed);
221 // let mut seeded_rlwe =
222 // SeededRlweCiphertext::<Vec<u64>, _>::empty(ring_size,
223 // rlwe_seed, q); let mut p_rng =
224 // DefaultSecureRng::new_seeded(rlwe_seed);
225 // secret_key_encrypt_rlwe(
226 // &m2,
227 // &mut seeded_rlwe.data,
228 // sk.values(),
229 // &modq_op,
230 // &nttq_op,
231 // &mut p_rng,
232 // &mut rng,
233 // );
234
235 // let mut rlwe = RlweCiphertext::<Vec<Vec<u64>>,
236 // DefaultSecureRng>::from(&seeded_rlwe);
237
238 // // RLWE(m0m1m2) = RLWE(m2) x RGSW(m0m1)
239 // let mut scratch_matrix_dplus2_ring = vec![vec![0u64; ring_size];
240 // d0 + 2]; less1_rlwe_by_rgsw(
241 // &mut rlwe,
242 // &rgsw01,
243 // &mut scratch_matrix_dplus2_ring,
244 // &decomposer,
245 // &nttq_op,
246 // &modq_op,
247 // 1,
248 // 2,
249 // );
250
251 // let mul_mod = |v0: &u64, v1: &u64| ((*v0 as u128 * *v1 as u128) %
252 // q as u128) as u64; let m0m1 = negacyclic_mul(&m0, &m1,
253 // mul_mod, q); let m0m1m2 = negacyclic_mul(&m2, &m0m1, mul_mod,
254 // q); let noise = measure_noise(&rlwe.data, &m0m1m2, &nttq_op,
255 // &modq_op, sk.values());
256
257 // println!("Noise: {noise}");
258 // }
259 // }
260}