arnaucube/fhe-study
1
1
Fork 0
mirror of https://github.com/arnaucube/fhe-study.git synced 2026-01-24 04:33:52 +01:00
Code Issues Packages Projects Releases Wiki Activity

add TGSW encryption & decryption

Browse Source
This commit is contained in:
arnaucube
2025-07-27 19:41:15 +00:00
parent 4f89caef1e
commit f053e9a904
4 changed files with 137 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
tfhe/src/tlwe.rs
View File

@@ -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 PublicKey<const K: usize>(glwe::PublicKey<T64, K>);
pub type PublicKey<const K: usize> = glwe::PublicKey<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 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<const K: usize> Sub<TLWE<K>> for TLWE<K> {
}
// 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);
}