fhe-study/gfhe/src/glwe.rs
gfhe/src/glwe.rsRaw
1use anyhow::Result;
2use itertools::zip_eq;
3use rand::Rng;
4use rand_distr::{Normal, Uniform};
5use std::iter::Sum;
6use std::ops::{Add, AddAssign, Mul, Sub};
7
8use arith::{Ring, Rq, Zq, TR};
9
10use crate::glev::GLev;
11
12const ERR_SIGMA: f64 = 3.2;
13
14#[derive(Clone, Debug)]
15pub struct GLWE<const Q: u64, const N: usize, const K: usize>(TR<Rq<Q, N>, K>, Rq<Q, N>);
16
17#[derive(Clone, Debug)]
18pub struct SecretKey<const Q: u64, const N: usize, const K: usize>(TR<Rq<Q, N>, K>);
19#[derive(Clone, Debug)]
20pub struct PublicKey<const Q: u64, const N: usize, const K: usize>(Rq<Q, N>, TR<Rq<Q, N>, K>);
21
22// K GLevs, each KSK_i=l GLWEs
23#[derive(Clone, Debug)]
24pub struct KSK<const Q: u64, const N: usize, const K: usize>(Vec<GLev<Q, N, K>>);
25
26impl<const Q: u64, const N: usize, const K: usize> GLWE<Q, N, K> {
27 pub fn zero() -> Self {
28 Self(TR::zero(), Rq::zero())
29 }
30
31 pub fn new_key(mut rng: impl Rng) -> Result<(SecretKey<Q, N, K>, PublicKey<Q, N, K>)> {
32 let Xi_key = Uniform::new(0_f64, 2_f64);
33 let Xi_err = Normal::new(0_f64, ERR_SIGMA)?;
34
35 let s: TR<Rq<Q, N>, K> = TR::rand(&mut rng, Xi_key);
36 let a: TR<Rq<Q, N>, K> = TR::rand(&mut rng, Uniform::new(0_f64, Q as f64));
37 let e = Rq::<Q, N>::rand(&mut rng, Xi_err);
38
39 let pk: PublicKey<Q, N, K> = PublicKey((&a * &s) + e, a);
40 Ok((SecretKey(s), pk))
41 }
42
43 pub fn new_ksk(
44 mut rng: impl Rng,
45 beta: u32,
46 l: u32,
47 sk: &SecretKey<Q, N, K>,
48 new_sk: &SecretKey<Q, N, K>,
49 ) -> Result<KSK<Q, N, K>> {
50 let r: Vec<GLev<Q, N, K>> = (0..K)
51 .into_iter()
52 .map(|i|
53 // treat sk_i as the msg being encrypted
54 GLev::<Q, N, K>::encrypt_s(&mut rng, beta, l, &new_sk, &sk.0 .0[i]))
55 .collect::<Result<Vec<_>>>()?;
56
57 Ok(KSK(r))
58 }
59 pub fn key_switch(&self, beta: u32, l: u32, ksk: &KSK<Q, N, K>) -> Self {
60 let (a, b): (TR<Rq<Q, N>, K>, Rq<Q, N>) = (self.0.clone(), self.1);
61
62 let lhs: GLWE<Q, N, K> = GLWE(TR::zero(), b);
63
64 // K iterations, ksk.0 contains K times GLev
65 let rhs: GLWE<Q, N, K> = zip_eq(a.0, ksk.0.clone())
66 .map(|(a_i, ksk_i)| Self::dot_prod(a_i.decompose(beta, l), ksk_i))
67 .sum();
68
69 lhs - rhs
70 }
71 // note: a_decomp is of length N
72 fn dot_prod(a_decomp: Vec<Rq<Q, N>>, ksk_i: GLev<Q, N, K>) -> GLWE<Q, N, K> {
73 // l times GLWES
74 let glwes: Vec<GLWE<Q, N, K>> = ksk_i.0;
75
76 // l iterations
77 let r: GLWE<Q, N, K> = zip_eq(a_decomp, glwes)
78 .map(|(a_d_i, glwe_i)| glwe_i * a_d_i)
79 .sum();
80 r
81 }
82
83 // scale up
84 pub fn encode<const T: u64>(m: &Rq<T, N>) -> Rq<Q, N> {
85 let m = m.remodule::<Q>();
86 let delta = Q / T; // floored
87 m * delta
88 }
89 // scale down
90 pub fn decode<const T: u64>(p: &Rq<Q, N>) -> Rq<T, N> {
91 let r = p.mul_div_round(T, Q);
92 r.remodule::<T>()
93 }
94
95 // encrypts with the given SecretKey (instead of PublicKey)
96 pub fn encrypt_s(mut rng: impl Rng, sk: &SecretKey<Q, N, K>, m: &Rq<Q, N>) -> Result<Self> {
97 let Xi_key = Uniform::new(0_f64, 2_f64);
98 let Xi_err = Normal::new(0_f64, ERR_SIGMA)?;
99
100 let a: TR<Rq<Q, N>, K> = TR::rand(&mut rng, Xi_key);
101 let e = Rq::<Q, N>::rand(&mut rng, Xi_err);
102
103 let b: Rq<Q, N> = (&a * &sk.0) + *m + e;
104 Ok(Self(a, b))
105 }
106 pub fn encrypt(mut rng: impl Rng, pk: &PublicKey<Q, N, K>, m: &Rq<Q, N>) -> Result<Self> {
107 let Xi_key = Uniform::new(0_f64, 2_f64);
108 let Xi_err = Normal::new(0_f64, ERR_SIGMA)?;
109
110 let u: Rq<Q, N> = Rq::rand(&mut rng, Xi_key);
111
112 let e0 = Rq::<Q, N>::rand(&mut rng, Xi_err);
113 let e1 = TR::<Rq<Q, N>, K>::rand(&mut rng, Xi_err);
114
115 let b: Rq<Q, N> = pk.0 * u + *m + e0;
116 let d: TR<Rq<Q, N>, K> = &pk.1 * &u + e1;
117
118 Ok(Self(d, b))
119 }
120 pub fn decrypt(&self, sk: &SecretKey<Q, N, K>) -> Rq<Q, N> {
121 let (d, b): (TR<Rq<Q, N>, K>, Rq<Q, N>) = (self.0.clone(), self.1);
122 let r: Rq<Q, N> = b - &d * &sk.0;
123 r
124 }
125
126 pub fn mod_switch<const P: u64>(&self) -> GLWE<P, N, K> {
127 let a: TR<Rq<P, N>, K> = TR(self.0 .0.iter().map(|r| r.mod_switch::<P>()).collect());
128 let b: Rq<P, N> = self.1.mod_switch::<P>();
129 GLWE(a, b)
130 }
131}
132
133impl<const Q: u64, const N: usize, const K: usize> Add<GLWE<Q, N, K>> for GLWE<Q, N, K> {
134 type Output = Self;
135 fn add(self, other: Self) -> Self {
136 let a: TR<Rq<Q, N>, K> = self.0 + other.0;
137 let b: Rq<Q, N> = self.1 + other.1;
138 Self(a, b)
139 }
140}
141
142impl<const Q: u64, const N: usize, const K: usize> Add<Rq<Q, N>> for GLWE<Q, N, K> {
143 type Output = Self;
144 fn add(self, plaintext: Rq<Q, N>) -> Self {
145 let a: TR<Rq<Q, N>, K> = self.0;
146 let b: Rq<Q, N> = self.1 + plaintext;
147 Self(a, b)
148 }
149}
150impl<const Q: u64, const N: usize, const K: usize> AddAssign for GLWE<Q, N, K> {
151 fn add_assign(&mut self, rhs: Self) {
152 for i in 0..K {
153 self.0 .0[i] = self.0 .0[i] + rhs.0 .0[i];
154 }
155 self.1 = self.1 + rhs.1;
156 }
157}
158impl<const Q: u64, const N: usize, const K: usize> Sum<GLWE<Q, N, K>> for GLWE<Q, N, K> {
159 fn sum<I>(iter: I) -> Self
160 where
161 I: Iterator<Item = Self>,
162 {
163 let mut acc = GLWE::<Q, N, K>::zero();
164 for e in iter {
165 acc += e;
166 }
167 acc
168 }
169}
170
171impl<const Q: u64, const N: usize, const K: usize> Sub<GLWE<Q, N, K>> for GLWE<Q, N, K> {
172 type Output = Self;
173 fn sub(self, other: Self) -> Self {
174 let a: TR<Rq<Q, N>, K> = self.0 - other.0;
175 let b: Rq<Q, N> = self.1 - other.1;
176 Self(a, b)
177 }
178}
179
180impl<const Q: u64, const N: usize, const K: usize> Mul<Rq<Q, N>> for GLWE<Q, N, K> {
181 type Output = Self;
182 fn mul(self, plaintext: Rq<Q, N>) -> Self {
183 // first compute the NTT for plaintext, to avoid computing it at each
184 // iteration, speeding up the multiplications
185 let mut plaintext = plaintext.clone();
186 plaintext.compute_evals();
187
188 let a: TR<Rq<Q, N>, K> = TR(self.0 .0.iter().map(|r_i| *r_i * plaintext).collect());
189 let b: Rq<Q, N> = self.1 * plaintext;
190 Self(a, b)
191 }
192}
193
194impl<const Q: u64, const N: usize, const K: usize> Mul<Zq<Q>> for GLWE<Q, N, K> {
195 type Output = Self;
196 fn mul(self, e: Zq<Q>) -> Self {
197 let a: TR<Rq<Q, N>, K> = TR(self.0 .0.iter().map(|r_i| *r_i * e).collect());
198 let b: Rq<Q, N> = self.1 * e;
199 Self(a, b)
200 }
201}
202
203#[cfg(test)]
204mod tests {
205 use anyhow::Result;
206 use rand::distributions::Uniform;
207
208 use super::*;
209
210 #[test]
211 fn test_encrypt_decrypt() -> Result<()> {
212 const Q: u64 = 2u64.pow(16) + 1;
213 const N: usize = 128;
214 const T: u64 = 32; // plaintext modulus
215 const K: usize = 16;
216 type S = GLWE<Q, N, K>;
217
218 let mut rng = rand::thread_rng();
219
220 for _ in 0..200 {
221 let (sk, pk) = S::new_key(&mut rng)?;
222
223 let msg_dist = Uniform::new(0_u64, T);
224 let m = Rq::<T, N>::rand_u64(&mut rng, msg_dist)?;
225 let p = S::encode::<T>(&m); // plaintext
226
227 let c = S::encrypt(&mut rng, &pk, &p)?;
228 let p_recovered = c.decrypt(&sk);
229 let m_recovered = S::decode::<T>(&p_recovered);
230
231 assert_eq!(m.remodule::<T>(), m_recovered.remodule::<T>());
232
233 // same but using encrypt_s (with sk instead of pk))
234 let c = S::encrypt_s(&mut rng, &sk, &p)?;
235 let p_recovered = c.decrypt(&sk);
236 let m_recovered = S::decode::<T>(&p_recovered);
237
238 assert_eq!(m.remodule::<T>(), m_recovered.remodule::<T>());
239 }
240
241 Ok(())
242 }
243
244 #[test]
245 fn test_addition() -> Result<()> {
246 const Q: u64 = 2u64.pow(16) + 1;
247 const N: usize = 128;
248 const T: u64 = 20;
249 const K: usize = 16;
250 type S = GLWE<Q, N, K>;
251
252 let mut rng = rand::thread_rng();
253
254 for _ in 0..200 {
255 let (sk, pk) = S::new_key(&mut rng)?;
256
257 let msg_dist = Uniform::new(0_u64, T);
258 let m1 = Rq::<T, N>::rand_u64(&mut rng, msg_dist)?;
259 let m2 = Rq::<T, N>::rand_u64(&mut rng, msg_dist)?;
260 let p1: Rq<Q, N> = S::encode::<T>(&m1); // plaintext
261 let p2: Rq<Q, N> = S::encode::<T>(&m2); // plaintext
262
263 let c1 = S::encrypt(&mut rng, &pk, &p1)?;
264 let c2 = S::encrypt(&mut rng, &pk, &p2)?;
265
266 let c3 = c1 + c2;
267
268 let p3_recovered = c3.decrypt(&sk);
269 let m3_recovered = S::decode::<T>(&p3_recovered);
270
271 assert_eq!((m1 + m2).remodule::<T>(), m3_recovered.remodule::<T>());
272 }
273
274 Ok(())
275 }
276
277 #[test]
278 fn test_add_plaintext() -> Result<()> {
279 const Q: u64 = 2u64.pow(16) + 1;
280 const N: usize = 128;
281 const T: u64 = 32;
282 const K: usize = 16;
283 type S = GLWE<Q, N, K>;
284
285 let mut rng = rand::thread_rng();
286
287 for _ in 0..200 {
288 let (sk, pk) = S::new_key(&mut rng)?;
289
290 let msg_dist = Uniform::new(0_u64, T);
291 let m1 = Rq::<T, N>::rand_u64(&mut rng, msg_dist)?;
292 let m2 = Rq::<T, N>::rand_u64(&mut rng, msg_dist)?;
293 let p1: Rq<Q, N> = S::encode::<T>(&m1); // plaintext
294 let p2: Rq<Q, N> = S::encode::<T>(&m2); // plaintext
295
296 let c1 = S::encrypt(&mut rng, &pk, &p1)?;
297
298 let c3 = c1 + p2;
299
300 let p3_recovered = c3.decrypt(&sk);
301 let m3_recovered = S::decode::<T>(&p3_recovered);
302
303 assert_eq!((m1 + m2).remodule::<T>(), m3_recovered);
304 }
305
306 Ok(())
307 }
308
309 #[test]
310 fn test_mul_plaintext() -> Result<()> {
311 const Q: u64 = 2u64.pow(16) + 1;
312 const N: usize = 16;
313 const T: u64 = 4;
314 const K: usize = 16;
315 type S = GLWE<Q, N, K>;
316
317 let mut rng = rand::thread_rng();
318
319 for _ in 0..200 {
320 let (sk, pk) = S::new_key(&mut rng)?;
321
322 let msg_dist = Uniform::new(0_u64, T);
323 let m1 = Rq::<T, N>::rand_u64(&mut rng, msg_dist)?;
324 let m2 = Rq::<T, N>::rand_u64(&mut rng, msg_dist)?;
325 let p1: Rq<Q, N> = S::encode::<T>(&m1); // plaintext
326 let p2: Rq<Q, N> = m2.remodule::<Q>();
327
328 let c1 = S::encrypt(&mut rng, &pk, &p1)?;
329
330 let c3 = c1 * p2;
331
332 let p3_recovered: Rq<Q, N> = c3.decrypt(&sk);
333 let m3_recovered = S::decode::<T>(&p3_recovered);
334 assert_eq!((m1.to_r() * m2.to_r()).to_rq::<T>(), m3_recovered);
335 }
336
337 Ok(())
338 }
339
340 #[test]
341 fn test_mod_switch() -> Result<()> {
342 const Q: u64 = 2u64.pow(16) + 1;
343 const P: u64 = 2u64.pow(8) + 1;
344 // note: wip, Q and P chosen so that P/Q is an integer
345 const N: usize = 8;
346 const T: u64 = 8; // plaintext modulus, must be a prime or power of a prime
347 const K: usize = 16;
348 type S = GLWE<Q, N, K>;
349
350 let delta: u64 = Q / T; // floored
351 let mut rng = rand::thread_rng();
352
353 dbg!(P as f64 / Q as f64);
354 dbg!(delta);
355 dbg!(delta as f64 * P as f64 / Q as f64);
356 dbg!(delta as f64 * (P as f64 / Q as f64));
357
358 for _ in 0..200 {
359 let (sk, pk) = S::new_key(&mut rng)?;
360
361 let msg_dist = Uniform::new(0_u64, T);
362 let m = Rq::<T, N>::rand_u64(&mut rng, msg_dist)?;
363 let p = S::encode::<T>(&m); // plaintext
364
365 let c = S::encrypt(&mut rng, &pk, &p)?;
366 // let c = S::encrypt_s(&mut rng, &sk, &m, delta)?;
367
368 let c2 = c.mod_switch::<P>();
369 let sk2: SecretKey<P, N, K> =
370 SecretKey(TR(sk.0 .0.iter().map(|s_i| s_i.remodule::<P>()).collect()));
371 // let delta2: u64 = ((P as f64 * delta as f64) / Q as f64).round() as u64;
372
373 let p_recovered = c2.decrypt(&sk2);
374 let m_recovered = GLWE::<P, N, K>::decode::<T>(&p_recovered);
375
376 assert_eq!(m.remodule::<T>(), m_recovered.remodule::<T>());
377 }
378
379 Ok(())
380 }
381
382 #[test]
383 fn test_key_switch() -> Result<()> {
384 const Q: u64 = 2u64.pow(16) + 1;
385 const N: usize = 128;
386 const T: u64 = 2; // plaintext modulus
387 const K: usize = 16;
388 type S = GLWE<Q, N, K>;
389
390 let beta: u32 = 2;
391 let l: u32 = 16;
392
393 let mut rng = rand::thread_rng();
394
395 let (sk, pk) = S::new_key(&mut rng)?;
396 let (sk2, _) = S::new_key(&mut rng)?;
397 // ksk to switch from sk to sk2
398 let ksk = S::new_ksk(&mut rng, beta, l, &sk, &sk2)?;
399
400 let msg_dist = Uniform::new(0_u64, T);
401 let m = Rq::<T, N>::rand_u64(&mut rng, msg_dist)?;
402 let p: Rq<Q, N> = S::encode::<T>(&m); // plaintext
403
404 let c = S::encrypt_s(&mut rng, &sk, &p)?;
405
406 let c2 = c.key_switch(beta, l, &ksk);
407
408 // decrypt with the 2nd secret key
409 let p_recovered = c2.decrypt(&sk2);
410 let m_recovered = S::decode::<T>(&p_recovered);
411 assert_eq!(m, m_recovered);
412
413 // do the same but now encrypting with pk
414 // let c = S::encrypt(&mut rng, &pk, &p)?;
415 // let c2 = c.key_switch(beta, l, &ksk);
416 // let p_recovered = c2.decrypt(&sk2);
417 // let m_recovered = S::decode::<T>(&p_recovered);
418 // assert_eq!(m, m_recovered);
419
420 Ok(())
421 }
422}