poulpy/rlwe/src/encryptor.rs
rlwe/src/encryptor.rsRaw
1use crate::ciphertext::{Ciphertext, GadgetCiphertext};
2use crate::decryptor::decrypt_rlwe_thread_safe;
3use crate::elem::Elem;
4use crate::keys::SecretKey;
5use crate::parameters::Parameters;
6use crate::plaintext::Plaintext;
7use base2k::ffi::znx::znx_zero_i64_ref;
8use base2k::sampling::Sampling;
9use base2k::{
10 Module, Scalar, SvpPPol, SvpPPolOps, VecZnx, VecZnxBig, VecZnxDft, VecZnxOps, VmpPMatOps,
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.limbs_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,
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_thread_safe(
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_thread_safe(
73 &self,
74 params: &Parameters,
75 ct: &mut Ciphertext,
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_thread_safe]: [EncryptorSk] has not been initialized with a [SecretKey]"
84 );
85 params.encrypt_rlwe_sk_thread_safe(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_thread_safe(
95 &self,
96 ct: &mut Ciphertext,
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_thread_safe(
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_thread_safe(
122 module: &Module,
123 ct: &mut Elem,
124 pt: Option<&Elem>,
125 sk: &SvpPPol,
126 source_xa: &mut Source,
127 source_xe: &mut Source,
128 sigma: f64,
129 tmp_bytes: &mut [u8],
130) {
131 let limbs: usize = ct.limbs();
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 c1.fill_uniform(log_base2k, limbs, source_xa);
148
149 let bytes_of_vec_znx_dft: usize = module.bytes_of_vec_znx_dft(limbs);
150
151 // Scratch space for DFT values
152 let mut buf_dft: VecZnxDft =
153 VecZnxDft::from_bytes(limbs, &mut tmp_bytes[..bytes_of_vec_znx_dft]);
154
155 // Applies buf_dft <- DFT(s) * DFT(c1)
156 module.svp_apply_dft(&mut buf_dft, sk, c1, limbs);
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, limbs);
163
164 let carry: &mut [u8] = &mut tmp_bytes[bytes_of_vec_znx_dft..];
165
166 // c0 <- -s x c1 + m
167 let c0: &mut VecZnx = ct.at_mut(0);
168
169 if let Some(pt) = pt {
170 module.vec_znx_big_sub_small_a_inplace(&mut buf_big, pt.at(0));
171 module.vec_znx_big_normalize(log_base2k, c0, &buf_big, carry);
172 } else {
173 module.vec_znx_big_normalize(log_base2k, c0, &buf_big, carry);
174 module.vec_znx_negate_inplace(c0);
175 }
176
177 // c0 <- -s x c1 + m + e
178 //c0.add_normal(log_base2k, log_q, source_xe, sigma, (sigma * 6.0).ceil());
179}
180
181pub fn encrypt_grlwe_sk_tmp_bytes(
182 module: &Module,
183 log_base2k: usize,
184 rows: usize,
185 log_q: usize,
186) -> usize {
187 let cols = (log_q + log_base2k - 1) / log_base2k;
188 Elem::bytes_of(module, log_base2k, log_q, 1)
189 + Plaintext::bytes_of(module, log_base2k, log_q)
190 + encrypt_rlwe_sk_tmp_bytes(module, log_base2k, log_q)
191 + module.vmp_prepare_tmp_bytes(rows, cols)
192}
193
194pub fn encrypt_grlwe_sk_thread_safe(
195 module: &Module,
196 ct: &mut GadgetCiphertext,
197 m: &Scalar,
198 sk: &SvpPPol,
199 source_xa: &mut Source,
200 source_xe: &mut Source,
201 sigma: f64,
202 tmp_bytes: &mut [u8],
203) {
204 let rows: usize = ct.rows();
205 let log_q: usize = ct.log_q();
206 let log_base2k: usize = ct.log_base2k();
207
208 let min_tmp_bytes_len = encrypt_grlwe_sk_tmp_bytes(module, log_base2k, rows, log_q);
209
210 assert!(
211 tmp_bytes.len() >= min_tmp_bytes_len,
212 "invalid tmp_bytes: tmp_bytes.len()={} < encrypt_grlwe_sk_tmp_bytes={}",
213 tmp_bytes.len(),
214 min_tmp_bytes_len
215 );
216
217 let mut ptr: usize = 0;
218 let mut tmp_elem: Elem = Elem::from_bytes(module, log_base2k, ct.log_q(), 1, tmp_bytes);
219 let bytes_of_elem: usize = Elem::bytes_of(module, log_base2k, log_q, 1);
220 ptr += bytes_of_elem;
221
222 let mut tmp_pt: Plaintext =
223 Plaintext::from_bytes(module, log_base2k, log_q, &mut tmp_bytes[ptr..]);
224 ptr += Plaintext::bytes_of(module, log_base2k, log_q);
225
226 let (tmp_bytes_encrypt_sk, tmp_bytes_vmp_prepare_row) =
227 tmp_bytes[ptr..].split_at_mut(encrypt_rlwe_sk_tmp_bytes(module, log_base2k, log_q));
228
229 (0..rows).for_each(|row_i| {
230 // Sets the i-th row of the RLWE sample to m (i.e. m * 2^{-log_base2k*i})
231 tmp_pt.0.value[0].at_mut(row_i).copy_from_slice(&m.0);
232
233 // Encrypts RLWE(m * 2^{-log_base2k*i})
234 encrypt_rlwe_sk_thread_safe(
235 module,
236 &mut tmp_elem,
237 Some(&tmp_pt.0),
238 sk,
239 source_xa,
240 source_xe,
241 sigma,
242 tmp_bytes_encrypt_sk,
243 );
244
245 // Zeroes the ith-row of tmp_pt
246 tmp_pt.0.value[0].at_mut(row_i).fill(0);
247
248 let mut res: Elem = Elem::new(module, log_base2k, log_q, 0, tmp_elem.log_scale);
249
250 decrypt_rlwe_thread_safe(module, &mut res, &tmp_elem, sk, tmp_bytes_encrypt_sk);
251
252 println!("row:{}", row_i);
253 res.value[0].print_limbs(res.limbs(), 16);
254 println!();
255
256 // GRLWE[row_i][0] = -as + m * 2^{-i*log_base2k} + e*2^{-log_q}
257 module.vmp_prepare_row(
258 &mut ct.value[0],
259 tmp_elem.at(0),
260 row_i,
261 tmp_bytes_vmp_prepare_row,
262 );
263
264 // GRLWE[row_i][1] = a
265 module.vmp_prepare_row(
266 &mut ct.value[1],
267 tmp_elem.at(1),
268 row_i,
269 tmp_bytes_vmp_prepare_row,
270 );
271 })
272}