poulpy/rlwe/src/encryptor.rs
rlwe/src/encryptor.rsRaw
1use crate::ciphertext::Ciphertext;
2use crate::elem::{Elem, ElemCommon, ElemVecZnx};
3use crate::keys::SecretKey;
4use crate::parameters::Parameters;
5use crate::plaintext::Plaintext;
6use base2k::sampling::Sampling;
7use base2k::{
8 Module, Scalar, SvpPPol, SvpPPolOps, VecZnx, VecZnxBig, VecZnxBigOps, VecZnxDft, VecZnxDftOps,
9 VecZnxOps, VmpPMat, VmpPMatOps,
10};
11
12use sampling::source::{Source, new_seed};
13
14pub struct EncryptorSk {
15 sk: SvpPPol,
16 source_xa: Source,
17 source_xe: Source,
18 initialized: bool,
19 tmp_bytes: Vec<u8>,
20}
21
22impl EncryptorSk {
23 pub fn new(params: &Parameters, sk: Option<&SecretKey>) -> Self {
24 let mut sk_svp_ppol: SvpPPol = params.module().new_svp_ppol();
25 let mut initialized: bool = false;
26 if let Some(sk) = sk {
27 sk.prepare(params.module(), &mut sk_svp_ppol);
28 initialized = true;
29 }
30 Self {
31 sk: sk_svp_ppol,
32 initialized,
33 source_xa: Source::new(new_seed()),
34 source_xe: Source::new(new_seed()),
35 tmp_bytes: vec![0u8; params.encrypt_rlwe_sk_tmp_bytes(params.cols_qp())],
36 }
37 }
38
39 pub fn set_sk(&mut self, module: &Module, sk: &SecretKey) {
40 sk.prepare(module, &mut self.sk);
41 self.initialized = true;
42 }
43
44 pub fn seed_source_xa(&mut self, seed: [u8; 32]) {
45 self.source_xa = Source::new(seed)
46 }
47
48 pub fn seed_source_xe(&mut self, seed: [u8; 32]) {
49 self.source_xe = Source::new(seed)
50 }
51
52 pub fn encrypt_rlwe_sk(
53 &mut self,
54 params: &Parameters,
55 ct: &mut Ciphertext<VecZnx>,
56 pt: Option<&Plaintext>,
57 ) {
58 assert!(
59 self.initialized == true,
60 "invalid call to [EncryptorSk.encrypt_rlwe_sk]: [EncryptorSk] has not been initialized with a [SecretKey]"
61 );
62 params.encrypt_rlwe_sk(
63 ct,
64 pt,
65 &self.sk,
66 &mut self.source_xa,
67 &mut self.source_xe,
68 &mut self.tmp_bytes,
69 );
70 }
71
72 pub fn encrypt_rlwe_sk_core(
73 &self,
74 params: &Parameters,
75 ct: &mut Ciphertext<VecZnx>,
76 pt: Option<&Plaintext>,
77 source_xa: &mut Source,
78 source_xe: &mut Source,
79 tmp_bytes: &mut [u8],
80 ) {
81 assert!(
82 self.initialized == true,
83 "invalid call to [EncryptorSk.encrypt_rlwe_sk]: [EncryptorSk] has not been initialized with a [SecretKey]"
84 );
85 params.encrypt_rlwe_sk(ct, pt, &self.sk, source_xa, source_xe, tmp_bytes);
86 }
87}
88
89impl Parameters {
90 pub fn encrypt_rlwe_sk_tmp_bytes(&self, log_q: usize) -> usize {
91 encrypt_rlwe_sk_tmp_bytes(self.module(), self.log_base2k(), log_q)
92 }
93
94 pub fn encrypt_rlwe_sk(
95 &self,
96 ct: &mut Ciphertext<VecZnx>,
97 pt: Option<&Plaintext>,
98 sk: &SvpPPol,
99 source_xa: &mut Source,
100 source_xe: &mut Source,
101 tmp_bytes: &mut [u8],
102 ) {
103 encrypt_rlwe_sk(
104 self.module(),
105 &mut ct.0,
106 pt.map(|pt| &pt.0),
107 sk,
108 source_xa,
109 source_xe,
110 self.xe(),
111 tmp_bytes,
112 )
113 }
114}
115
116pub fn encrypt_rlwe_sk_tmp_bytes(module: &Module, log_base2k: usize, log_q: usize) -> usize {
117 module.bytes_of_vec_znx_dft((log_q + log_base2k - 1) / log_base2k)
118 + module.vec_znx_big_normalize_tmp_bytes()
119}
120
121pub fn encrypt_rlwe_sk(
122 module: &Module,
123 ct: &mut Elem<VecZnx>,
124 pt: Option<&Elem<VecZnx>>,
125 sk: &SvpPPol,
126 source_xa: &mut Source,
127 source_xe: &mut Source,
128 sigma: f64,
129 tmp_bytes: &mut [u8],
130) {
131 let cols: usize = ct.cols();
132 let log_base2k: usize = ct.log_base2k();
133 let log_q: usize = ct.log_q();
134
135 assert!(
136 tmp_bytes.len() >= encrypt_rlwe_sk_tmp_bytes(module, log_base2k, log_q),
137 "invalid tmp_bytes: tmp_bytes={} < encrypt_rlwe_sk_tmp_bytes={}",
138 tmp_bytes.len(),
139 encrypt_rlwe_sk_tmp_bytes(module, log_base2k, log_q)
140 );
141
142 let log_q: usize = ct.log_q();
143 let log_base2k: usize = ct.log_base2k();
144 let c1: &mut VecZnx = ct.at_mut(1);
145
146 // c1 <- Z_{2^prec}[X]/(X^{N}+1)
147 module.fill_uniform(log_base2k, c1, cols, source_xa);
148
149 let (tmp_bytes_vec_znx_dft, tmp_bytes_normalize) =
150 tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(cols));
151
152 // Scratch space for DFT values
153 let mut buf_dft: VecZnxDft = VecZnxDft::from_bytes_borrow(module, cols, tmp_bytes_vec_znx_dft);
154
155 // Applies buf_dft <- DFT(s) * DFT(c1)
156 module.svp_apply_dft(&mut buf_dft, sk, c1);
157
158 // Alias scratch space
159 let mut buf_big: VecZnxBig = buf_dft.as_vec_znx_big();
160
161 // buf_big = s x c1
162 module.vec_znx_idft_tmp_a(&mut buf_big, &mut buf_dft);
163
164 // c0 <- -s x c1 + m
165 let c0: &mut VecZnx = ct.at_mut(0);
166
167 if let Some(pt) = pt {
168 module.vec_znx_big_sub_small_a_inplace(&mut buf_big, pt.at(0));
169 module.vec_znx_big_normalize(log_base2k, c0, &buf_big, tmp_bytes_normalize);
170 } else {
171 module.vec_znx_big_normalize(log_base2k, c0, &buf_big, tmp_bytes_normalize);
172 module.vec_znx_negate_inplace(c0);
173 }
174
175 // c0 <- -s x c1 + m + e
176 module.add_normal(
177 log_base2k,
178 c0,
179 log_q,
180 source_xe,
181 sigma,
182 (sigma * 6.0).ceil(),
183 );
184}
185
186impl Parameters {
187 pub fn encrypt_grlwe_sk_tmp_bytes(&self, rows: usize, log_q: usize) -> usize {
188 encrypt_grlwe_sk_tmp_bytes(self.module(), self.log_base2k(), rows, log_q)
189 }
190}
191
192pub fn encrypt_grlwe_sk_tmp_bytes(
193 module: &Module,
194 log_base2k: usize,
195 rows: usize,
196 log_q: usize,
197) -> usize {
198 let cols = (log_q + log_base2k - 1) / log_base2k;
199 Elem::<VecZnx>::bytes_of(module, log_base2k, log_q, 2)
200 + Plaintext::bytes_of(module, log_base2k, log_q)
201 + encrypt_rlwe_sk_tmp_bytes(module, log_base2k, log_q)
202 + module.vmp_prepare_tmp_bytes(rows, cols)
203}
204
205pub fn encrypt_grlwe_sk(
206 module: &Module,
207 ct: &mut Ciphertext<VmpPMat>,
208 m: &Scalar,
209 sk: &SvpPPol,
210 source_xa: &mut Source,
211 source_xe: &mut Source,
212 sigma: f64,
213 tmp_bytes: &mut [u8],
214) {
215 let rows: usize = ct.rows();
216 let log_q: usize = ct.log_q();
217 //let cols: usize = (log_q + ct.log_base2k() - 1) / ct.log_base2k();
218 let log_base2k: usize = ct.log_base2k();
219
220 let min_tmp_bytes_len = encrypt_grlwe_sk_tmp_bytes(module, log_base2k, rows, log_q);
221
222 assert!(
223 tmp_bytes.len() >= min_tmp_bytes_len,
224 "invalid tmp_bytes: tmp_bytes.len()={} < encrypt_grlwe_sk_tmp_bytes={}",
225 tmp_bytes.len(),
226 min_tmp_bytes_len
227 );
228
229 let bytes_of_elem: usize = Elem::<VecZnx>::bytes_of(module, log_base2k, log_q, 2);
230 let bytes_of_pt: usize = Plaintext::bytes_of(module, log_base2k, log_q);
231 let bytes_of_enc_sk: usize = encrypt_rlwe_sk_tmp_bytes(module, log_base2k, log_q);
232
233 let (tmp_bytes_pt, tmp_bytes) = tmp_bytes.split_at_mut(bytes_of_pt);
234 let (tmp_bytes_enc_sk, tmp_bytes) = tmp_bytes.split_at_mut(bytes_of_enc_sk);
235 let (tmp_bytes_elem, tmp_bytes_vmp_prepare_row) = tmp_bytes.split_at_mut(bytes_of_elem);
236
237 let mut tmp_elem: Elem<VecZnx> =
238 Elem::<VecZnx>::from_bytes_borrow(module, log_base2k, ct.log_q(), 2, tmp_bytes_elem);
239 let mut tmp_pt: Plaintext =
240 Plaintext::from_bytes_borrow(module, log_base2k, log_q, tmp_bytes_pt);
241
242 (0..rows).for_each(|row_i| {
243 // Sets the i-th row of the RLWE sample to m (i.e. m * 2^{-log_base2k*i})
244 tmp_pt.at_mut(0).at_mut(row_i).copy_from_slice(&m.raw());
245
246 // Encrypts RLWE(m * 2^{-log_base2k*i})
247 encrypt_rlwe_sk(
248 module,
249 &mut tmp_elem,
250 Some(&tmp_pt.0),
251 sk,
252 source_xa,
253 source_xe,
254 sigma,
255 tmp_bytes_enc_sk,
256 );
257
258 //tmp_pt.at(0).print(tmp_pt.cols(), 16);
259 //println!();
260
261 // Zeroes the ith-row of tmp_pt
262 tmp_pt.at_mut(0).at_mut(row_i).fill(0);
263
264 //println!("row:{}/{}", row_i, rows);
265 //tmp_elem.at(0).print(tmp_elem.cols(), tmp_elem.n());
266 //tmp_elem.at(1).print(tmp_elem.cols(), tmp_elem.n());
267 //println!();
268 //println!(">>>");
269
270 // GRLWE[row_i][0||1] = [-as + m * 2^{-i*log_base2k} + e*2^{-log_q} || a]
271 module.vmp_prepare_row(
272 &mut ct.at_mut(0),
273 tmp_elem.at(0).raw(),
274 row_i,
275 tmp_bytes_vmp_prepare_row,
276 );
277 module.vmp_prepare_row(
278 &mut ct.at_mut(1),
279 tmp_elem.at(1).raw(),
280 row_i,
281 tmp_bytes_vmp_prepare_row,
282 );
283 });
284 //println!("DONE");
285}