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