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