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

fusion TFHE to use GFHE underthehood

Browse Source
This commit is contained in:
arnaucube
2025-07-24 14:32:44 +00:00
parent 87da85a035
commit 81306edf05
7 changed files with 54 additions and 173 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
README.md
View File

@@ -19,8 +19,8 @@ and the line `type S = TWLE<K>` to use `CKKS<Q, N>` or `BFV<Q, N, T>`.
```rust
const T: u64 = 128; // msg space (msg modulus)
const K: usize = 16;
type S = TLWE<K>;
type M = Rq<T, 1>; // msg space
type S = TLWE<256>;
let mut rng = rand::thread_rng();
let msg_dist = Uniform::new(0_u64, T);
@@ -28,13 +28,13 @@ let msg_dist = Uniform::new(0_u64, T);
let (sk, pk) = S::new_key(&mut rng)?;
// get two random msgs in Z_t
let m1 = Rq::<T, 1>::rand_u64(&mut rng, msg_dist)?;
let m2 = Rq::<T, 1>::rand_u64(&mut rng, msg_dist)?;
let m3 = Rq::<T, 1>::rand_u64(&mut rng, msg_dist)?;
let m1 = M::rand_u64(&mut rng, msg_dist)?;
let m2 = M::rand_u64(&mut rng, msg_dist)?;
let m3 = M::rand_u64(&mut rng, msg_dist)?;
// encode the msgs into the plaintext space
let p1: Tn<1> = S::encode::<T>(&m1); // plaintext
let p2: Tn<1> = S::encode::<T>(&m2); // plaintext
let p1 = S::encode::<T>(&m1); // plaintext
let p2 = S::encode::<T>(&m2); // plaintext
let c3_const: Tn<1> = Tn(array::from_fn(|i| T64(m3.coeffs()[i].0))); // encode it as constant value
let c1 = S::encrypt(&mut rng, &pk, &p1)?;
@@ -42,8 +42,8 @@ let c2 = S::encrypt(&mut rng, &pk, &p2)?;
// now we can do encrypted operations (notice that we do them using simple
// operations by operator overloading):
let c3 = c1 + c2;
let c4 = c2 * c3_const;
let c_12 = c1 + c2;
let c4 = c_12 * c3_const;
// decrypt & decode
let p4_recovered = c4.decrypt(&sk);

4
arith/src/ring.rs
View File

@@ -3,8 +3,8 @@ use std::fmt::Debug;
use std::iter::Sum;
use std::ops::{Add, AddAssign, Mul, Sub, SubAssign};
/// Represents a ring element. Currently implemented by ring_n.rs#R and
/// ring_nq.rs#Rq. Is not a 'pure algebraic ring', but more a custom trait
/// Represents a ring element. Currently implemented by ring_nq.rs#Rq and
/// ring_torus.rs#Tn. Is not a 'pure algebraic ring', but more a custom trait
/// definition which includes methods like `mod_switch`.
// assumed to be mod (X^N +1)
pub trait Ring:

2
gfhe/src/glev.rs
View File

@@ -73,11 +73,11 @@ mod tests {
// let delta: u64 = Q / T; // floored
let mut rng = rand::thread_rng();
let msg_dist = Uniform::new(0_u64, T);
for _ in 0..200 {
let (sk, pk) = GLWE::<Rq<Q, N>, K>::new_key(&mut rng)?;
let msg_dist = Uniform::new(0_u64, T);
let m = Rq::<T, N>::rand_u64(&mut rng, msg_dist)?;
let m: Rq<Q, N> = m.remodule::<Q>();

18
gfhe/src/glwe.rs
View File

@@ -17,12 +17,12 @@ const ERR_SIGMA: f64 = 3.2;
/// GLWE implemented over the `Ring` trait, so that it can be also instantiated
/// over the Torus polynomials 𝕋_<N,q>[X] = 𝕋_q[X]/ (X^N+1).
#[derive(Clone, Debug)]
pub struct GLWE<R: Ring, const K: usize>(TR<R, K>, R);
pub struct GLWE<R: Ring, const K: usize>(pub TR<R, K>, pub R);
#[derive(Clone, Debug)]
pub struct SecretKey<R: Ring, const K: usize>(TR<R, K>);
pub struct SecretKey<R: Ring, const K: usize>(pub TR<R, K>);
#[derive(Clone, Debug)]
pub struct PublicKey<R: Ring, const K: usize>(R, TR<R, K>);
pub struct PublicKey<R: Ring, const K: usize>(pub R, pub TR<R, K>);
// K GLevs, each KSK_i=l GLWEs
#[derive(Clone, Debug)]
@@ -261,11 +261,11 @@ mod tests {
type S = GLWE<Rq<Q, N>, K>;
let mut rng = rand::thread_rng();
let msg_dist = Uniform::new(0_u64, T);
for _ in 0..200 {
let (sk, pk) = S::new_key(&mut rng)?;
let msg_dist = Uniform::new(0_u64, T);
let m = Rq::<T, N>::rand_u64(&mut rng, msg_dist)?; // msg
// let m: Rq<Q, N> = m.remodule::<Q>();
@@ -306,11 +306,11 @@ mod tests {
type S = GLWE<Tn<4>, K>;
let mut rng = rand::thread_rng();
let msg_dist = Uniform::new(0_f64, T as f64);
for _ in 0..200 {
let (sk, pk) = S::new_key(&mut rng)?;
let msg_dist = Uniform::new(0_f64, T as f64);
let m = Rq::<T, 4>::rand(&mut rng, msg_dist); // msg
let p = t_encode::<T>(&m); // plaintext
@@ -340,11 +340,11 @@ mod tests {
type S = GLWE<Rq<Q, N>, K>;
let mut rng = rand::thread_rng();
let msg_dist = Uniform::new(0_u64, T);
for _ in 0..200 {
let (sk, pk) = S::new_key(&mut rng)?;
let msg_dist = Uniform::new(0_u64, T);
let m1 = Rq::<T, N>::rand_u64(&mut rng, msg_dist)?;
let m2 = Rq::<T, N>::rand_u64(&mut rng, msg_dist)?;
let p1: Rq<Q, N> = S::encode::<T>(&m1); // plaintext
@@ -373,11 +373,11 @@ mod tests {
type S = GLWE<Rq<Q, N>, K>;
let mut rng = rand::thread_rng();
let msg_dist = Uniform::new(0_u64, T);
for _ in 0..200 {
let (sk, pk) = S::new_key(&mut rng)?;
let msg_dist = Uniform::new(0_u64, T);
let m1 = Rq::<T, N>::rand_u64(&mut rng, msg_dist)?;
let m2 = Rq::<T, N>::rand_u64(&mut rng, msg_dist)?;
let p1: Rq<Q, N> = S::encode::<T>(&m1); // plaintext
@@ -405,11 +405,11 @@ mod tests {
type S = GLWE<Rq<Q, N>, K>;
let mut rng = rand::thread_rng();
let msg_dist = Uniform::new(0_u64, T);
for _ in 0..200 {
let (sk, pk) = S::new_key(&mut rng)?;
let msg_dist = Uniform::new(0_u64, T);
let m1 = Rq::<T, N>::rand_u64(&mut rng, msg_dist)?;
let m2 = Rq::<T, N>::rand_u64(&mut rng, msg_dist)?;
let p1: Rq<Q, N> = S::encode::<T>(&m1); // plaintext
@@ -438,11 +438,11 @@ mod tests {
type S = GLWE<Rq<Q, N>, K>;
let mut rng = rand::thread_rng();
let msg_dist = Uniform::new(0_u64, T);
for _ in 0..200 {
let (sk, pk) = S::new_key(&mut rng)?;
let msg_dist = Uniform::new(0_u64, T);
let m = Rq::<T, N>::rand_u64(&mut rng, msg_dist)?;
let p = S::encode::<T>(&m);

89
tfhe/src/lib.rs
View File

@@ -5,94 +5,5 @@
#![allow(clippy::upper_case_acronyms)]
#![allow(dead_code)] // TMP
use anyhow::Result;
use rand::Rng;
use rand_distr::{Normal, Uniform};
use std::array;
use arith::{Ring, Rq, Tn, T64};
use gfhe::{glwe, GLWE};
pub mod tlev;
pub mod tlwe;
#[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>);
impl<const K: usize> TLWE<K> {
pub fn new_key(rng: impl Rng) -> Result<(SecretKey<K>, PublicKey<K>)> {
let (sk, pk) = GLWE::new_key(rng)?;
Ok((SecretKey(sk), PublicKey(pk)))
}
pub fn encode<const P: u64>(m: &Rq<P, 1>) -> Tn<1> {
let delta = u64::MAX / P; // floored
let coeffs = m.coeffs();
Tn(array::from_fn(|i| T64(coeffs[i].0 * delta)))
}
pub fn decode<const P: u64>(p: &Tn<1>) -> 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())
}
pub fn encrypt_s(rng: impl Rng, sk: &SecretKey<K>, p: &Tn<1>) -> Result<Self> {
let glwe = GLWE::encrypt_s(rng, &sk.0, 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)?;
Ok(Self(glwe))
}
pub fn decrypt(&self, sk: &SecretKey<K>) -> Tn<1> {
self.0.decrypt(&sk.0)
}
}
#[cfg(test)]
mod tests {
use anyhow::Result;
use rand::distributions::Uniform;
use super::*;
#[test]
fn test_encrypt_decrypt() -> Result<()> {
const T: u64 = 128; // plaintext modulus
const K: usize = 16;
type S = TLWE<K>;
// let delta: u64 = Q / T; // floored
let mut rng = rand::thread_rng();
for _ in 0..200 {
let (sk, pk) = S::new_key(&mut rng)?;
let msg_dist = Uniform::new(0_f64, T as f64);
let m = Rq::<T, 1>::rand(&mut rng, msg_dist); // msg
// let m: Rq<Q, N> = m.remodule::<Q>();
let p = S::encode::<T>(&m); // plaintext
let c = S::encrypt(&mut rng, &pk, &p)?; // ciphertext
let p_recovered = c.decrypt(&sk);
let m_recovered = S::decode::<T>(&p_recovered);
assert_eq!(m, m_recovered);
// same but using encrypt_s (with sk instead of pk))
let c = S::encrypt_s(&mut rng, &sk, &p)?;
let p_recovered = c.decrypt(&sk);
let m_recovered = S::decode::<T>(&p_recovered);
assert_eq!(m.remodule::<T>(), m_recovered.remodule::<T>());
}
Ok(())
}
}

2
tfhe/src/tlev.rs
View File

@@ -72,11 +72,11 @@ mod tests {
let l: u32 = 16;
let mut rng = rand::thread_rng();
let msg_dist = Uniform::new(0_u64, T);
for _ in 0..200 {
let (sk, pk) = TLWE::<K>::new_key(&mut rng)?;
let msg_dist = Uniform::new(0_u64, T);
let m: Rq<T, 1> = Rq::rand_u64(&mut rng, msg_dist)?;
let p: Tn<1> = S::encode::<T>(&m); // plaintext

94
tfhe/src/tlwe.rs
View File

@@ -8,32 +8,26 @@ use std::iter::Sum;
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 TLWE<const K: usize>(TR<Tn<1>, K>, Tn<1>);
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 SecretKey<const K: usize>(TR<Tn<1>, K>);
#[derive(Clone, Debug)]
pub struct PublicKey<const K: usize>(Tn<1>, TR<Tn<1>, K>);
pub struct TLWE<const K: usize>(pub GLWE<Tn<1>, K>);
impl<const K: usize> TLWE<K> {
pub fn zero() -> Self {
Self(TR::zero(), Tn::zero())
Self(GLWE::<Tn<1>, K>::zero())
}
pub fn new_key(mut rng: impl Rng) -> Result<(SecretKey<K>, PublicKey<K>)> {
let Xi_key = Uniform::new(0_f64, 2_f64);
let Xi_err = Normal::new(0_f64, ERR_SIGMA)?;
let s: TR<Tn<1>, K> = TR::rand(&mut rng, Xi_key);
let a: TR<Tn<1>, K> = TR::rand(&mut rng, Standard);
let e = Tn::rand(&mut rng, Xi_err);
let pk: PublicKey<K> = PublicKey((&a * &s) + e, a);
Ok((SecretKey(s), pk))
pub fn new_key(rng: impl Rng) -> Result<(SecretKey<K>, PublicKey<K>)> {
let (sk, pk) = GLWE::new_key(rng)?;
Ok((SecretKey(sk), PublicKey(pk)))
}
pub fn encode<const P: u64>(m: &Rq<P, 1>) -> Tn<1> {
@@ -47,50 +41,28 @@ impl<const K: usize> TLWE<K> {
}
// encrypts with the given SecretKey (instead of PublicKey)
pub fn encrypt_s(mut rng: impl Rng, sk: &SecretKey<K>, m: &Tn<1>) -> Result<Self> {
let Xi_key = Uniform::new(0_f64, 2_f64);
let Xi_err = Normal::new(0_f64, ERR_SIGMA)?;
let a: TR<Tn<1>, K> = TR::rand(&mut rng, Xi_key);
let e = Tn::rand(&mut rng, Xi_err);
let b: Tn<1> = (&a * &sk.0) + *m + e;
Ok(Self(a, b))
pub fn encrypt_s(rng: impl Rng, sk: &SecretKey<K>, p: &Tn<1>) -> Result<Self> {
let glwe = GLWE::encrypt_s(rng, &sk.0, p)?;
Ok(Self(glwe))
}
pub fn encrypt(mut rng: impl Rng, pk: &PublicKey<K>, m: &Tn<1>) -> Result<Self> {
let Xi_key = Uniform::new(0_f64, 2_f64);
let Xi_err = Normal::new(0_f64, ERR_SIGMA)?;
let u: Tn<1> = Tn::rand(&mut rng, Xi_key);
let e0: Tn<1> = Tn::rand(&mut rng, Xi_err);
let e1 = TR::<Tn<1>, K>::rand(&mut rng, Xi_err);
let b: Tn<1> = pk.0 * u + *m + e0;
let d: TR<Tn<1>, K> = &pk.1 * &u + e1;
Ok(Self(d, b))
pub fn encrypt(rng: impl Rng, pk: &PublicKey<K>, p: &Tn<1>) -> Result<Self> {
let glwe = GLWE::encrypt(rng, &pk.0, p)?;
Ok(Self(glwe))
}
pub fn decrypt(&self, sk: &SecretKey<K>) -> Tn<1> {
let (d, b): (TR<Tn<1>, K>, Tn<1>) = (self.0.clone(), self.1);
b - &d * &sk.0
self.0.decrypt(&sk.0)
}
}
impl<const K: usize> Add<TLWE<K>> for TLWE<K> {
type Output = Self;
fn add(self, other: Self) -> Self {
let a: TR<Tn<1>, K> = self.0 + other.0;
let b: Tn<1> = self.1 + other.1;
Self(a, b)
Self(self.0 + other.0)
}
}
impl<const K: usize> AddAssign for TLWE<K> {
fn add_assign(&mut self, rhs: Self) {
for i in 0..K {
self.0 .0[i] = self.0 .0[i] + rhs.0 .0[i];
}
self.1 = self.1 + rhs.1;
self.0 += rhs.0
}
}
impl<const K: usize> Sum<TLWE<K>> for TLWE<K> {
@@ -109,9 +81,7 @@ impl<const K: usize> Sum<TLWE<K>> for TLWE<K> {
impl<const K: usize> Sub<TLWE<K>> for TLWE<K> {
type Output = Self;
fn sub(self, other: Self) -> Self {
let a: TR<Tn<1>, K> = self.0 - other.0;
let b: Tn<1> = self.1 - other.1;
Self(a, b)
Self(self.0 - other.0)
}
}
@@ -119,27 +89,27 @@ impl<const K: usize> Sub<TLWE<K>> for TLWE<K> {
impl<const K: usize> Add<Tn<1>> for TLWE<K> {
type Output = Self;
fn add(self, plaintext: Tn<1>) -> Self {
let a: TR<Tn<1>, K> = self.0;
let b: Tn<1> = self.1 + plaintext;
Self(a, b)
let a: TR<Tn<1>, K> = self.0 .0;
let b: Tn<1> = self.0 .1 + plaintext;
Self(GLWE(a, b))
}
}
// plaintext substraction
impl<const K: usize> Sub<Tn<1>> for TLWE<K> {
type Output = Self;
fn sub(self, plaintext: Tn<1>) -> Self {
let a: TR<Tn<1>, K> = self.0;
let b: Tn<1> = self.1 - plaintext;
Self(a, b)
let a: TR<Tn<1>, K> = self.0 .0;
let b: Tn<1> = self.0 .1 - plaintext;
Self(GLWE(a, b))
}
}
// plaintext multiplication
impl<const K: usize> Mul<Tn<1>> for TLWE<K> {
type Output = Self;
fn mul(self, plaintext: Tn<1>) -> Self {
let a: TR<Tn<1>, K> = TR(self.0 .0.iter().map(|r_i| *r_i * plaintext).collect());
let b: Tn<1> = self.1 * plaintext;
Self(a, b)
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;
Self(GLWE(a, b))
}
}
@@ -157,11 +127,11 @@ mod tests {
type S = TLWE<K>;
let mut rng = rand::thread_rng();
let msg_dist = Uniform::new(0_u64, T);
for _ in 0..200 {
let (sk, pk) = S::new_key(&mut rng)?;
let msg_dist = Uniform::new(0_u64, T);
let m = Rq::<T, 1>::rand_u64(&mut rng, msg_dist)?;
dbg!(&m);
let p: Tn<1> = S::encode::<T>(&m);
@@ -191,11 +161,11 @@ mod tests {
type S = TLWE<K>;
let mut rng = rand::thread_rng();
let msg_dist = Uniform::new(0_u64, T);
for _ in 0..200 {
let (sk, pk) = S::new_key(&mut rng)?;
let msg_dist = Uniform::new(0_u64, T);
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
@@ -222,11 +192,11 @@ mod tests {
type S = TLWE<K>;
let mut rng = rand::thread_rng();
let msg_dist = Uniform::new(0_u64, T);
for _ in 0..200 {
let (sk, pk) = S::new_key(&mut rng)?;
let msg_dist = Uniform::new(0_u64, T);
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
@@ -252,11 +222,11 @@ mod tests {
type S = TLWE<K>;
let mut rng = rand::thread_rng();
let msg_dist = Uniform::new(0_u64, T);
for _ in 0..200 {
let (sk, pk) = S::new_key(&mut rng)?;
let msg_dist = Uniform::new(0_u64, T);
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);