|
|
@ -10,47 +10,50 @@ use std::ops::{Add, AddAssign, Mul, Sub}; |
|
|
|
use arith::{Ring, Rq, Tn, T64, TR};
|
|
|
|
use gfhe::{glwe, GLWE};
|
|
|
|
|
|
|
|
const ERR_SIGMA: f64 = 3.2;
|
|
|
|
// #[derive(Clone, Debug)]
|
|
|
|
// pub struct SecretKey<const K: usize>(glwe::SecretKey<T64, K>);
|
|
|
|
pub type SecretKey<const K: usize> = glwe::SecretKey<T64, K>;
|
|
|
|
|
|
|
|
#[derive(Clone, Debug)]
|
|
|
|
pub struct SecretKey<const K: usize>(glwe::SecretKey<Tn<1>, K>);
|
|
|
|
#[derive(Clone, Debug)]
|
|
|
|
pub struct PublicKey<const K: usize>(glwe::PublicKey<Tn<1>, K>);
|
|
|
|
// #[derive(Clone, Debug)]
|
|
|
|
// pub struct PublicKey<const K: usize>(glwe::PublicKey<T64, K>);
|
|
|
|
pub type PublicKey<const K: usize> = glwe::PublicKey<T64, K>;
|
|
|
|
|
|
|
|
#[derive(Clone, Debug)]
|
|
|
|
pub struct TLWE<const K: usize>(pub GLWE<Tn<1>, K>);
|
|
|
|
pub struct TLWE<const K: usize>(pub GLWE<T64, K>);
|
|
|
|
|
|
|
|
impl<const K: usize> TLWE<K> {
|
|
|
|
pub fn zero() -> Self {
|
|
|
|
Self(GLWE::<Tn<1>, K>::zero())
|
|
|
|
Self(GLWE::<T64, K>::zero())
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn new_key(rng: impl Rng) -> Result<(SecretKey<K>, PublicKey<K>)> {
|
|
|
|
let (sk, pk) = GLWE::new_key(rng)?;
|
|
|
|
Ok((SecretKey(sk), PublicKey(pk)))
|
|
|
|
// Ok((SecretKey(sk), PublicKey(pk)))
|
|
|
|
Ok((sk, pk))
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn encode<const P: u64>(m: &Rq<P, 1>) -> Tn<1> {
|
|
|
|
pub fn encode<const P: u64>(m: &Rq<P, 1>) -> T64 {
|
|
|
|
let delta = u64::MAX / P; // floored
|
|
|
|
let coeffs = m.coeffs();
|
|
|
|
Tn(array::from_fn(|i| T64(coeffs[i].0 * delta)))
|
|
|
|
// Tn(array::from_fn(|i| T64(coeffs[i].0 * delta)))
|
|
|
|
T64(coeffs[0].0 * delta)
|
|
|
|
}
|
|
|
|
pub fn decode<const P: u64>(p: &Tn<1>) -> Rq<P, 1> {
|
|
|
|
pub fn decode<const P: u64>(p: &T64) -> Rq<P, 1> {
|
|
|
|
let p = p.mul_div_round(P, u64::MAX);
|
|
|
|
Rq::<P, 1>::from_vec_u64(p.coeffs().iter().map(|c| c.0).collect())
|
|
|
|
}
|
|
|
|
|
|
|
|
// encrypts with the given SecretKey (instead of PublicKey)
|
|
|
|
pub fn encrypt_s(rng: impl Rng, sk: &SecretKey<K>, p: &Tn<1>) -> Result<Self> {
|
|
|
|
let glwe = GLWE::encrypt_s(rng, &sk.0, p)?;
|
|
|
|
pub fn encrypt_s(rng: impl Rng, sk: &SecretKey<K>, p: &T64) -> Result<Self> {
|
|
|
|
let glwe = GLWE::encrypt_s(rng, &sk, p)?;
|
|
|
|
Ok(Self(glwe))
|
|
|
|
}
|
|
|
|
pub fn encrypt(rng: impl Rng, pk: &PublicKey<K>, p: &Tn<1>) -> Result<Self> {
|
|
|
|
let glwe = GLWE::encrypt(rng, &pk.0, p)?;
|
|
|
|
pub fn encrypt(rng: impl Rng, pk: &PublicKey<K>, p: &T64) -> Result<Self> {
|
|
|
|
let glwe = GLWE::encrypt(rng, &pk, p)?;
|
|
|
|
Ok(Self(glwe))
|
|
|
|
}
|
|
|
|
pub fn decrypt(&self, sk: &SecretKey<K>) -> Tn<1> {
|
|
|
|
self.0.decrypt(&sk.0)
|
|
|
|
pub fn decrypt(&self, sk: &SecretKey<K>) -> T64 {
|
|
|
|
self.0.decrypt(&sk)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
@ -86,29 +89,29 @@ impl Sub> for TLWE { |
|
|
|
}
|
|
|
|
|
|
|
|
// plaintext addition
|
|
|
|
impl<const K: usize> Add<Tn<1>> for TLWE<K> {
|
|
|
|
impl<const K: usize> Add<T64> for TLWE<K> {
|
|
|
|
type Output = Self;
|
|
|
|
fn add(self, plaintext: Tn<1>) -> Self {
|
|
|
|
let a: TR<Tn<1>, K> = self.0 .0;
|
|
|
|
let b: Tn<1> = self.0 .1 + plaintext;
|
|
|
|
fn add(self, plaintext: T64) -> Self {
|
|
|
|
let a: TR<T64, K> = self.0 .0;
|
|
|
|
let b: T64 = self.0 .1 + plaintext;
|
|
|
|
Self(GLWE(a, b))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// plaintext substraction
|
|
|
|
impl<const K: usize> Sub<Tn<1>> for TLWE<K> {
|
|
|
|
impl<const K: usize> Sub<T64> for TLWE<K> {
|
|
|
|
type Output = Self;
|
|
|
|
fn sub(self, plaintext: Tn<1>) -> Self {
|
|
|
|
let a: TR<Tn<1>, K> = self.0 .0;
|
|
|
|
let b: Tn<1> = self.0 .1 - plaintext;
|
|
|
|
fn sub(self, plaintext: T64) -> Self {
|
|
|
|
let a: TR<T64, K> = self.0 .0;
|
|
|
|
let b: T64 = self.0 .1 - plaintext;
|
|
|
|
Self(GLWE(a, b))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// plaintext multiplication
|
|
|
|
impl<const K: usize> Mul<Tn<1>> for TLWE<K> {
|
|
|
|
impl<const K: usize> Mul<T64> for TLWE<K> {
|
|
|
|
type Output = Self;
|
|
|
|
fn mul(self, plaintext: Tn<1>) -> Self {
|
|
|
|
let a: TR<Tn<1>, K> = TR(self.0 .0 .0.iter().map(|r_i| *r_i * plaintext).collect());
|
|
|
|
let b: Tn<1> = self.0 .1 * plaintext;
|
|
|
|
fn mul(self, plaintext: T64) -> Self {
|
|
|
|
let a: TR<T64, K> = TR(self.0 .0 .0.iter().map(|r_i| *r_i * plaintext).collect());
|
|
|
|
let b: T64 = self.0 .1 * plaintext;
|
|
|
|
Self(GLWE(a, b))
|
|
|
|
}
|
|
|
|
}
|
|
|
@ -134,7 +137,7 @@ mod tests { |
|
|
|
|
|
|
|
let m = Rq::<T, 1>::rand_u64(&mut rng, msg_dist)?;
|
|
|
|
dbg!(&m);
|
|
|
|
let p: Tn<1> = S::encode::<T>(&m);
|
|
|
|
let p: T64 = S::encode::<T>(&m);
|
|
|
|
dbg!(&p);
|
|
|
|
|
|
|
|
let c = S::encrypt(&mut rng, &pk, &p)?;
|
|
|
@ -168,8 +171,8 @@ mod tests { |
|
|
|
|
|
|
|
let m1 = Rq::<T, 1>::rand_u64(&mut rng, msg_dist)?;
|
|
|
|
let m2 = Rq::<T, 1>::rand_u64(&mut rng, msg_dist)?;
|
|
|
|
let p1: Tn<1> = S::encode::<T>(&m1); // plaintext
|
|
|
|
let p2: Tn<1> = S::encode::<T>(&m2); // plaintext
|
|
|
|
let p1: T64 = S::encode::<T>(&m1); // plaintext
|
|
|
|
let p2: T64 = S::encode::<T>(&m2); // plaintext
|
|
|
|
|
|
|
|
let c1 = S::encrypt(&mut rng, &pk, &p1)?;
|
|
|
|
let c2 = S::encrypt(&mut rng, &pk, &p2)?;
|
|
|
@ -199,8 +202,8 @@ mod tests { |
|
|
|
|
|
|
|
let m1 = Rq::<T, 1>::rand_u64(&mut rng, msg_dist)?;
|
|
|
|
let m2 = Rq::<T, 1>::rand_u64(&mut rng, msg_dist)?;
|
|
|
|
let p1: Tn<1> = S::encode::<T>(&m1); // plaintext
|
|
|
|
let p2: Tn<1> = S::encode::<T>(&m2); // plaintext
|
|
|
|
let p1: T64 = S::encode::<T>(&m1); // plaintext
|
|
|
|
let p2: T64 = S::encode::<T>(&m2); // plaintext
|
|
|
|
|
|
|
|
let c1 = S::encrypt(&mut rng, &pk, &p1)?;
|
|
|
|
|
|
|
@ -209,7 +212,7 @@ mod tests { |
|
|
|
let p3_recovered = c3.decrypt(&sk);
|
|
|
|
let m3_recovered = S::decode::<T>(&p3_recovered);
|
|
|
|
|
|
|
|
assert_eq!((m1 + m2).remodule::<T>(), m3_recovered);
|
|
|
|
assert_eq!(m1 + m2, m3_recovered);
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(())
|
|
|
@ -229,15 +232,16 @@ mod tests { |
|
|
|
|
|
|
|
let m1 = Rq::<T, 1>::rand_u64(&mut rng, msg_dist)?;
|
|
|
|
let m2 = Rq::<T, 1>::rand_u64(&mut rng, msg_dist)?;
|
|
|
|
let p1: Tn<1> = S::encode::<T>(&m1);
|
|
|
|
let p1: T64 = S::encode::<T>(&m1);
|
|
|
|
// don't scale up p2, set it directly from m2
|
|
|
|
let p2: Tn<1> = Tn(array::from_fn(|i| T64(m2.coeffs()[i].0)));
|
|
|
|
// let p2: T64 = Tn(array::from_fn(|i| T64(m2.coeffs()[i].0)));
|
|
|
|
let p2: T64 = T64(m2.coeffs()[0].0);
|
|
|
|
|
|
|
|
let c1 = S::encrypt(&mut rng, &pk, &p1)?;
|
|
|
|
|
|
|
|
let c3 = c1 * p2;
|
|
|
|
|
|
|
|
let p3_recovered: Tn<1> = c3.decrypt(&sk);
|
|
|
|
let p3_recovered: T64 = c3.decrypt(&sk);
|
|
|
|
let m3_recovered = S::decode::<T>(&p3_recovered);
|
|
|
|
assert_eq!((m1.to_r() * m2.to_r()).to_rq::<T>(), m3_recovered);
|
|
|
|
}
|
|
|
|