1use anyhow::Result;
  2use itertools::zip_eq;
  3use rand::distributions::Standard;
  4use rand::Rng;
  5use rand_distr::{Normal, Uniform};
  6use std::array;
  7use std::iter::Sum;
  8use std::ops::{Add, AddAssign, Mul, Sub};
  9
 10use arith::{Ring, Rq, Tn, T64, TR};
 11use gfhe::{glwe, GLWE};
 12
 13use crate::tlev::TLev;
 14
 15// #[derive(Clone, Debug)]
 16// pub struct SecretKey<const K: usize>(glwe::SecretKey<T64, K>);
 17pub type SecretKey<const K: usize> = glwe::SecretKey<T64, K>;
 18
 19// #[derive(Clone, Debug)]
 20// pub struct PublicKey<const K: usize>(glwe::PublicKey<T64, K>);
 21pub type PublicKey<const K: usize> = glwe::PublicKey<T64, K>;
 22
 23#[derive(Clone, Debug)]
 24pub struct KSK<const K: usize>(Vec<TLev<K>>);
 25
 26#[derive(Clone, Debug)]
 27pub struct TLWE<const K: usize>(pub GLWE<T64, K>);
 28
 29impl<const K: usize> TLWE<K> {
 30    pub fn zero() -> Self {
 31        Self(GLWE::<T64, K>::zero())
 32    }
 33
 34    pub fn new_key(rng: impl Rng) -> Result<(SecretKey<K>, PublicKey<K>)> {
 35        let (sk, pk) = GLWE::new_key(rng)?;
 36        // Ok((SecretKey(sk), PublicKey(pk)))
 37        Ok((sk, pk))
 38    }
 39
 40    pub fn encode<const P: u64>(m: &Rq<P, 1>) -> T64 {
 41        let delta = u64::MAX / P; // floored
 42        let coeffs = m.coeffs();
 43        // Tn(array::from_fn(|i| T64(coeffs[i].0 * delta)))
 44        T64(coeffs[0].0 * delta)
 45    }
 46    pub fn decode<const P: u64>(p: &T64) -> Rq<P, 1> {
 47        let p = p.mul_div_round(P, u64::MAX);
 48        Rq::<P, 1>::from_vec_u64(p.coeffs().iter().map(|c| c.0).collect())
 49    }
 50
 51    // encrypts with the given SecretKey (instead of PublicKey)
 52    pub fn encrypt_s(rng: impl Rng, sk: &SecretKey<K>, p: &T64) -> Result<Self> {
 53        let glwe = GLWE::encrypt_s(rng, &sk, p)?;
 54        Ok(Self(glwe))
 55    }
 56    pub fn encrypt(rng: impl Rng, pk: &PublicKey<K>, p: &T64) -> Result<Self> {
 57        let glwe = GLWE::encrypt(rng, &pk, p)?;
 58        Ok(Self(glwe))
 59    }
 60    pub fn decrypt(&self, sk: &SecretKey<K>) -> T64 {
 61        self.0.decrypt(&sk)
 62    }
 63
 64    pub fn new_ksk(
 65        mut rng: impl Rng,
 66        beta: u32,
 67        l: u32,
 68        sk: &SecretKey<K>,
 69        new_sk: &SecretKey<K>,
 70    ) -> Result<KSK<K>> {
 71        let r: Vec<TLev<K>> = (0..K)
 72            .into_iter()
 73            .map(|i|
 74                // treat sk_i as the msg being encrypted
 75                TLev::<K>::encrypt_s(&mut rng, beta, l, &new_sk, &sk.0 .0[i]))
 76            .collect::<Result<Vec<_>>>()?;
 77
 78        Ok(KSK(r))
 79    }
 80    pub fn key_switch(&self, beta: u32, l: u32, ksk: &KSK<K>) -> Self {
 81        let (a, b): (TR<T64, K>, T64) = (self.0 .0.clone(), self.0 .1);
 82
 83        let lhs: TLWE<K> = TLWE(GLWE(TR::zero(), b));
 84
 85        // K iterations, ksk.0 contains K times GLev
 86        let rhs: TLWE<K> = zip_eq(a.0, ksk.0.clone())
 87            .map(|(a_i, ksk_i)| ksk_i * a_i.decompose(beta, l)) // dot_product
 88            .sum();
 89
 90        lhs - rhs
 91    }
 92}
 93
 94impl<const K: usize> Add<TLWE<K>> for TLWE<K> {
 95    type Output = Self;
 96    fn add(self, other: Self) -> Self {
 97        Self(self.0 + other.0)
 98    }
 99}
100impl<const K: usize> AddAssign for TLWE<K> {
101    fn add_assign(&mut self, rhs: Self) {
102        self.0 += rhs.0
103    }
104}
105impl<const K: usize> Sum<TLWE<K>> for TLWE<K> {
106    fn sum<I>(iter: I) -> Self
107    where
108        I: Iterator<Item = Self>,
109    {
110        let mut acc = TLWE::<K>::zero();
111        for e in iter {
112            acc += e;
113        }
114        acc
115    }
116}
117
118impl<const K: usize> Sub<TLWE<K>> for TLWE<K> {
119    type Output = Self;
120    fn sub(self, other: Self) -> Self {
121        Self(self.0 - other.0)
122    }
123}
124
125// plaintext addition
126impl<const K: usize> Add<T64> for TLWE<K> {
127    type Output = Self;
128    fn add(self, plaintext: T64) -> Self {
129        let a: TR<T64, K> = self.0 .0;
130        let b: T64 = self.0 .1 + plaintext;
131        Self(GLWE(a, b))
132    }
133}
134// plaintext substraction
135impl<const K: usize> Sub<T64> for TLWE<K> {
136    type Output = Self;
137    fn sub(self, plaintext: T64) -> Self {
138        let a: TR<T64, K> = self.0 .0;
139        let b: T64 = self.0 .1 - plaintext;
140        Self(GLWE(a, b))
141    }
142}
143// plaintext multiplication
144impl<const K: usize> Mul<T64> for TLWE<K> {
145    type Output = Self;
146    fn mul(self, plaintext: T64) -> Self {
147        let a: TR<T64, K> = TR(self.0 .0 .0.iter().map(|r_i| *r_i * plaintext).collect());
148        let b: T64 = self.0 .1 * plaintext;
149        Self(GLWE(a, b))
150    }
151}
152
153#[cfg(test)]
154mod tests {
155    use anyhow::Result;
156    use rand::distributions::Uniform;
157
158    use super::*;
159
160    #[test]
161    fn test_encrypt_decrypt() -> Result<()> {
162        const T: u64 = 128; // msg space (msg modulus)
163        const K: usize = 16;
164        type S = TLWE<K>;
165
166        let mut rng = rand::thread_rng();
167        let msg_dist = Uniform::new(0_u64, T);
168
169        for _ in 0..200 {
170            let (sk, pk) = S::new_key(&mut rng)?;
171
172            let m = Rq::<T, 1>::rand_u64(&mut rng, msg_dist)?;
173            dbg!(&m);
174            let p: T64 = S::encode::<T>(&m);
175            dbg!(&p);
176
177            let c = S::encrypt(&mut rng, &pk, &p)?;
178            let p_recovered = c.decrypt(&sk);
179            let m_recovered = S::decode::<T>(&p_recovered);
180
181            assert_eq!(m, m_recovered);
182
183            // same but using encrypt_s (with sk instead of pk))
184            let c = S::encrypt_s(&mut rng, &sk, &p)?;
185            let p_recovered = c.decrypt(&sk);
186            let m_recovered = S::decode::<T>(&p_recovered);
187
188            assert_eq!(m, m_recovered);
189        }
190
191        Ok(())
192    }
193
194    #[test]
195    fn test_addition() -> Result<()> {
196        const T: u64 = 128;
197        const K: usize = 16;
198        type S = TLWE<K>;
199
200        let mut rng = rand::thread_rng();
201        let msg_dist = Uniform::new(0_u64, T);
202
203        for _ in 0..200 {
204            let (sk, pk) = S::new_key(&mut rng)?;
205
206            let m1 = Rq::<T, 1>::rand_u64(&mut rng, msg_dist)?;
207            let m2 = Rq::<T, 1>::rand_u64(&mut rng, msg_dist)?;
208            let p1: T64 = S::encode::<T>(&m1); // plaintext
209            let p2: T64 = S::encode::<T>(&m2); // plaintext
210
211            let c1 = S::encrypt(&mut rng, &pk, &p1)?;
212            let c2 = S::encrypt(&mut rng, &pk, &p2)?;
213
214            let c3 = c1 + c2;
215
216            let p3_recovered = c3.decrypt(&sk);
217            let m3_recovered = S::decode::<T>(&p3_recovered);
218
219            assert_eq!((m1 + m2).remodule::<T>(), m3_recovered.remodule::<T>());
220        }
221
222        Ok(())
223    }
224
225    #[test]
226    fn test_add_plaintext() -> Result<()> {
227        const T: u64 = 128;
228        const K: usize = 16;
229        type S = TLWE<K>;
230
231        let mut rng = rand::thread_rng();
232        let msg_dist = Uniform::new(0_u64, T);
233
234        for _ in 0..200 {
235            let (sk, pk) = S::new_key(&mut rng)?;
236
237            let m1 = Rq::<T, 1>::rand_u64(&mut rng, msg_dist)?;
238            let m2 = Rq::<T, 1>::rand_u64(&mut rng, msg_dist)?;
239            let p1: T64 = S::encode::<T>(&m1); // plaintext
240            let p2: T64 = S::encode::<T>(&m2); // plaintext
241
242            let c1 = S::encrypt(&mut rng, &pk, &p1)?;
243
244            let c3 = c1 + p2;
245
246            let p3_recovered = c3.decrypt(&sk);
247            let m3_recovered = S::decode::<T>(&p3_recovered);
248
249            assert_eq!(m1 + m2, m3_recovered);
250        }
251
252        Ok(())
253    }
254
255    #[test]
256    fn test_mul_plaintext() -> Result<()> {
257        const T: u64 = 128;
258        const K: usize = 16;
259        type S = TLWE<K>;
260
261        let mut rng = rand::thread_rng();
262        let msg_dist = Uniform::new(0_u64, T);
263
264        for _ in 0..200 {
265            let (sk, pk) = S::new_key(&mut rng)?;
266
267            let m1 = Rq::<T, 1>::rand_u64(&mut rng, msg_dist)?;
268            let m2 = Rq::<T, 1>::rand_u64(&mut rng, msg_dist)?;
269            let p1: T64 = S::encode::<T>(&m1);
270            // don't scale up p2, set it directly from m2
271            // let p2: T64 = Tn(array::from_fn(|i| T64(m2.coeffs()[i].0)));
272            let p2: T64 = T64(m2.coeffs()[0].0);
273
274            let c1 = S::encrypt(&mut rng, &pk, &p1)?;
275
276            let c3 = c1 * p2;
277
278            let p3_recovered: T64 = c3.decrypt(&sk);
279            let m3_recovered = S::decode::<T>(&p3_recovered);
280            assert_eq!((m1.to_r() * m2.to_r()).to_rq::<T>(), m3_recovered);
281        }
282
283        Ok(())
284    }
285
286    #[test]
287    fn test_key_switch() -> Result<()> {
288        const T: u64 = 128; // plaintext modulus
289        const K: usize = 16;
290        type S = TLWE<K>;
291
292        let beta: u32 = 2;
293        let l: u32 = 64;
294
295        let mut rng = rand::thread_rng();
296
297        let (sk, pk) = S::new_key(&mut rng)?;
298        let (sk2, _) = S::new_key(&mut rng)?;
299        // ksk to switch from sk to sk2
300        let ksk = S::new_ksk(&mut rng, beta, l, &sk, &sk2)?;
301
302        let msg_dist = Uniform::new(0_u64, T);
303        let m = Rq::<T, 1>::rand_u64(&mut rng, msg_dist)?;
304        let p = S::encode::<T>(&m); // plaintext
305                                    //
306        let c = S::encrypt_s(&mut rng, &sk, &p)?;
307
308        let c2 = c.key_switch(beta, l, &ksk);
309
310        // decrypt with the 2nd secret key
311        let p_recovered = c2.decrypt(&sk2);
312        let m_recovered = S::decode::<T>(&p_recovered);
313        assert_eq!(m.remodule::<T>(), m_recovered.remodule::<T>());
314
315        // do the same but now encrypting with pk
316        let c = S::encrypt(&mut rng, &pk, &p)?;
317        let c2 = c.key_switch(beta, l, &ksk);
318        let p_recovered = c2.decrypt(&sk2);
319        let m_recovered = S::decode::<T>(&p_recovered);
320        assert_eq!(m, m_recovered);
321
322        Ok(())
323    }
324}