1use anyhow::Result;
  2use itertools::zip_eq;
  3use rand::Rng;
  4use rand_distr::{Normal, Uniform};
  5use std::{array, ops};
  6
  7use arith::{Ring, Rq, R, TR};
  8
  9const ERR_SIGMA: f64 = 3.2;
 10
 11pub struct GLWE<const Q: u64, const N: usize, const K: usize>(TR<Rq<Q, N>, K>, Rq<Q, N>);
 12
 13#[derive(Clone, Debug)]
 14pub struct SecretKey<const Q: u64, const N: usize, const K: usize>(TR<Rq<Q, N>, K>);
 15#[derive(Clone, Debug)]
 16pub struct PublicKey<const Q: u64, const N: usize, const K: usize>(Rq<Q, N>, TR<Rq<Q, N>, K>);
 17
 18impl<const Q: u64, const N: usize, const K: usize> GLWE<Q, N, K> {
 19    pub fn new_key(mut rng: impl Rng) -> Result<(SecretKey<Q, N, K>, PublicKey<Q, N, K>)> {
 20        let Xi_key = Uniform::new(0_f64, 2_f64);
 21        let Xi_err = Normal::new(0_f64, ERR_SIGMA)?;
 22
 23        let s: TR<Rq<Q, N>, K> = TR::rand(&mut rng, Xi_key);
 24        let a: TR<Rq<Q, N>, K> = TR::rand(&mut rng, Uniform::new(0_f64, Q as f64));
 25        let e = Rq::<Q, N>::rand(&mut rng, Xi_err);
 26
 27        let pk: PublicKey<Q, N, K> = PublicKey((&a * &s) + e, a);
 28        Ok((SecretKey(s), pk))
 29    }
 30
 31    // TODO delta not as input
 32    pub fn encrypt_s<const T: u64>(
 33        mut rng: impl Rng,
 34        sk: &SecretKey<Q, N, K>,
 35        m: &Rq<T, N>,
 36        delta: u64,
 37    ) -> Result<Self> {
 38        let m: Rq<Q, N> = m.remodule::<Q>();
 39
 40        let Xi_key = Uniform::new(0_f64, 2_f64);
 41        let Xi_err = Normal::new(0_f64, ERR_SIGMA)?;
 42
 43        let a: TR<Rq<Q, N>, K> = TR::rand(&mut rng, Xi_key);
 44        let e = Rq::<Q, N>::rand(&mut rng, Xi_err);
 45
 46        let b: Rq<Q, N> = (&a * &sk.0) + m * delta + e;
 47        Ok(Self(a, b))
 48    }
 49    pub fn encrypt<const T: u64>(
 50        mut rng: impl Rng,
 51        pk: &PublicKey<Q, N, K>,
 52        m: &Rq<T, N>,
 53        delta: u64,
 54    ) -> Result<Self> {
 55        let m: Rq<Q, N> = m.remodule::<Q>();
 56
 57        let Xi_key = Uniform::new(0_f64, 2_f64);
 58        let Xi_err = Normal::new(0_f64, ERR_SIGMA)?;
 59
 60        let u: Rq<Q, N> = Rq::rand(&mut rng, Xi_key);
 61
 62        let e0 = Rq::<Q, N>::rand(&mut rng, Xi_err);
 63        let e1 = TR::<Rq<Q, N>, K>::rand(&mut rng, Xi_err);
 64
 65        let b: Rq<Q, N> = pk.0 * u + m * delta + e0;
 66        let d: TR<Rq<Q, N>, K> = &pk.1 * &u + e1;
 67
 68        Ok(Self(d, b))
 69    }
 70    pub fn decrypt<const T: u64>(&self, sk: &SecretKey<Q, N, K>, delta: u64) -> Rq<T, N> {
 71        let (d, b): (TR<Rq<Q, N>, K>, Rq<Q, N>) = (self.0.clone(), self.1);
 72        let r: Rq<Q, N> = b - &d * &sk.0;
 73        let r_scaled: Vec<f64> = r
 74            .coeffs()
 75            .iter()
 76            .map(|e| (e.0 as f64 / delta as f64).round())
 77            .collect();
 78        let r = Rq::<Q, N>::from_vec_f64(r_scaled);
 79        r.remodule::<T>()
 80    }
 81}
 82
 83#[cfg(test)]
 84mod tests {
 85    use anyhow::Result;
 86    use rand::distributions::Uniform;
 87
 88    use super::*;
 89
 90    #[test]
 91    fn test_encrypt_decrypt() -> Result<()> {
 92        const Q: u64 = 2u64.pow(16) + 1;
 93        const N: usize = 128;
 94        const T: u64 = 32; // plaintext modulus
 95        const K: usize = 16;
 96        type S = GLWE<Q, N, K>;
 97
 98        let delta: u64 = Q / T; // floored
 99        let mut rng = rand::thread_rng();
100
101        for _ in 0..200 {
102            let (sk, pk) = S::new_key(&mut rng)?;
103
104            let msg_dist = Uniform::new(0_u64, T);
105            let m = Rq::<T, N>::rand_u64(&mut rng, msg_dist)?;
106
107            let c = S::encrypt(&mut rng, &pk, &m, delta)?;
108            let m_recovered = c.decrypt(&sk, delta);
109
110            assert_eq!(m, m_recovered);
111        }
112
113        Ok(())
114    }
115}