Janmajaya Mall
10 months ago
12 changed files with 951 additions and 152 deletions
Unified View
Diff Options
-
+276 -130src/bool/evaluator.rs
-
+2 -2src/bool/mod.rs
-
+5 -5src/bool/parameters.rs
-
+1 -1src/decomposer.rs
-
+12 -0src/lib.rs
-
+2 -0src/main.rs
-
+7 -0src/random.rs
-
+0 -14src/shortint.rs
-
+262 -0src/shortint/mod.rs
-
+362 -0src/shortint/ops.rs
-
+14 -0src/shortint/types.rs
-
+8 -0src/utils.rs
@ -1,2 +1,2 @@ |
|||||
mod evaluator;
|
|
||||
mod parameters;
|
|
||||
|
pub(crate) mod evaluator;
|
||||
|
pub(crate) mod parameters;
|
||||
@ -1,3 +1,5 @@ |
|||||
fn main() {
|
fn main() {
|
||||
|
let mut v = Vec::with_capacity(10);
|
||||
|
v[0] = 1;
|
||||
println!("Hello, world!");
|
println!("Hello, world!");
|
||||
}
|
}
|
||||
@ -1,14 +0,0 @@ |
|||||
use itertools::izip;
|
|
||||
|
|
||||
use crate::Matrix;
|
|
||||
|
|
||||
struct FheUint8<M: Matrix> {
|
|
||||
data: M,
|
|
||||
}
|
|
||||
|
|
||||
fn add<M: Matrix>(a: FheUint8<M>, b: FheUint8<M>) {
|
|
||||
// CALL THE EVALUATOR
|
|
||||
izip!(a.data.iter_rows(), b.data.iter_rows()).for_each(|(a_bit, b_bit)| {
|
|
||||
// A ^ B
|
|
||||
});
|
|
||||
}
|
|
||||
@ -0,0 +1,262 @@ |
|||||
|
use itertools::Itertools;
|
||||
|
|
||||
|
use crate::{
|
||||
|
bool::evaluator::{BoolEvaluator, ClientKey, ServerKeyEvaluationDomain, BOOL_SERVER_KEY},
|
||||
|
utils::{Global, WithLocal},
|
||||
|
Decryptor, Encryptor,
|
||||
|
};
|
||||
|
use ops::{
|
||||
|
arbitrary_bit_adder, arbitrary_bit_division_for_quotient_and_rem, arbitrary_bit_subtractor,
|
||||
|
eight_bit_mul,
|
||||
|
};
|
||||
|
|
||||
|
mod ops;
|
||||
|
mod types;
|
||||
|
|
||||
|
type FheUint8 = types::FheUint8<Vec<u64>>;
|
||||
|
|
||||
|
fn add_mut(a: &mut FheUint8, b: &FheUint8) {
|
||||
|
BoolEvaluator::with_local_mut_mut(&mut |e| {
|
||||
|
let key = ServerKeyEvaluationDomain::global();
|
||||
|
arbitrary_bit_adder(e, a.data_mut(), b.data(), false, key);
|
||||
|
});
|
||||
|
}
|
||||
|
|
||||
|
fn sub(a: &FheUint8, b: &FheUint8) -> FheUint8 {
|
||||
|
BoolEvaluator::with_local_mut(|e| {
|
||||
|
let key = ServerKeyEvaluationDomain::global();
|
||||
|
let (out, _, _) = arbitrary_bit_subtractor(e, a.data(), b.data(), key);
|
||||
|
FheUint8 { data: out }
|
||||
|
})
|
||||
|
}
|
||||
|
|
||||
|
fn mul(a: &FheUint8, b: &FheUint8) -> FheUint8 {
|
||||
|
BoolEvaluator::with_local_mut(|e| {
|
||||
|
let key = ServerKeyEvaluationDomain::global();
|
||||
|
let out = eight_bit_mul(e, a.data(), b.data(), key);
|
||||
|
FheUint8 { data: out }
|
||||
|
})
|
||||
|
}
|
||||
|
|
||||
|
fn div(a: &FheUint8, b: &FheUint8) -> (FheUint8, FheUint8) {
|
||||
|
BoolEvaluator::with_local_mut(|e| {
|
||||
|
let key = ServerKeyEvaluationDomain::global();
|
||||
|
let (quotient, remainder) =
|
||||
|
arbitrary_bit_division_for_quotient_and_rem(e, a.data(), b.data(), key);
|
||||
|
|
||||
|
(FheUint8 { data: quotient }, FheUint8 { data: remainder })
|
||||
|
})
|
||||
|
}
|
||||
|
|
||||
|
impl Encryptor<u8, FheUint8> for ClientKey {
|
||||
|
fn encrypt(&self, m: &u8) -> FheUint8 {
|
||||
|
let cts = (0..8)
|
||||
|
.into_iter()
|
||||
|
.map(|i| {
|
||||
|
let bit = ((m >> i) & 1) == 1;
|
||||
|
Encryptor::<bool, Vec<u64>>::encrypt(self, &bit)
|
||||
|
})
|
||||
|
.collect_vec();
|
||||
|
FheUint8 { data: cts }
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
impl Decryptor<u8, FheUint8> for ClientKey {
|
||||
|
fn decrypt(&self, c: &FheUint8) -> u8 {
|
||||
|
let mut out = 0u8;
|
||||
|
c.data().iter().enumerate().for_each(|(index, bit_c)| {
|
||||
|
let bool = Decryptor::<bool, Vec<u64>>::decrypt(self, bit_c);
|
||||
|
if bool {
|
||||
|
out += 1 << index;
|
||||
|
}
|
||||
|
});
|
||||
|
out
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
mod frontend {
|
||||
|
use super::ops::{
|
||||
|
arbitrary_bit_adder, arbitrary_bit_division_for_quotient_and_rem, arbitrary_bit_subtractor,
|
||||
|
eight_bit_mul,
|
||||
|
};
|
||||
|
use crate::{
|
||||
|
bool::evaluator::{BoolEvaluator, ServerKeyEvaluationDomain},
|
||||
|
utils::{Global, WithLocal},
|
||||
|
};
|
||||
|
|
||||
|
use super::{add_mut, div, mul, FheUint8};
|
||||
|
|
||||
|
mod arithetic {
|
||||
|
use super::*;
|
||||
|
use std::ops::{Add, AddAssign, Div, Mul, Rem, Sub};
|
||||
|
|
||||
|
impl AddAssign<&FheUint8> for FheUint8 {
|
||||
|
fn add_assign(&mut self, rhs: &FheUint8) {
|
||||
|
BoolEvaluator::with_local_mut_mut(&mut |e| {
|
||||
|
let key = ServerKeyEvaluationDomain::global();
|
||||
|
arbitrary_bit_adder(e, self.data_mut(), rhs.data(), false, key);
|
||||
|
});
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
impl Add<&FheUint8> for &FheUint8 {
|
||||
|
type Output = FheUint8;
|
||||
|
fn add(self, rhs: &FheUint8) -> Self::Output {
|
||||
|
let mut a = self.clone();
|
||||
|
a += rhs;
|
||||
|
a
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
impl Sub<&FheUint8> for &FheUint8 {
|
||||
|
type Output = FheUint8;
|
||||
|
fn sub(self, rhs: &FheUint8) -> Self::Output {
|
||||
|
BoolEvaluator::with_local_mut(|e| {
|
||||
|
let key = ServerKeyEvaluationDomain::global();
|
||||
|
let (out, _, _) = arbitrary_bit_subtractor(e, self.data(), self.data(), key);
|
||||
|
FheUint8 { data: out }
|
||||
|
})
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
impl Mul<&FheUint8> for &FheUint8 {
|
||||
|
type Output = FheUint8;
|
||||
|
fn mul(self, rhs: &FheUint8) -> Self::Output {
|
||||
|
BoolEvaluator::with_local_mut(|e| {
|
||||
|
let key = ServerKeyEvaluationDomain::global();
|
||||
|
let out = eight_bit_mul(e, self.data(), rhs.data(), key);
|
||||
|
FheUint8 { data: out }
|
||||
|
})
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
impl Div<&FheUint8> for &FheUint8 {
|
||||
|
type Output = FheUint8;
|
||||
|
fn div(self, rhs: &FheUint8) -> Self::Output {
|
||||
|
BoolEvaluator::with_local_mut(|e| {
|
||||
|
let key = ServerKeyEvaluationDomain::global();
|
||||
|
let (quotient, _) = arbitrary_bit_division_for_quotient_and_rem(
|
||||
|
e,
|
||||
|
self.data(),
|
||||
|
rhs.data(),
|
||||
|
key,
|
||||
|
);
|
||||
|
FheUint8 { data: quotient }
|
||||
|
})
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
impl Rem<&FheUint8> for &FheUint8 {
|
||||
|
type Output = FheUint8;
|
||||
|
fn rem(self, rhs: &FheUint8) -> Self::Output {
|
||||
|
BoolEvaluator::with_local_mut(|e| {
|
||||
|
let key = ServerKeyEvaluationDomain::global();
|
||||
|
let (_, remainder) = arbitrary_bit_division_for_quotient_and_rem(
|
||||
|
e,
|
||||
|
self.data(),
|
||||
|
rhs.data(),
|
||||
|
key,
|
||||
|
);
|
||||
|
FheUint8 { data: remainder }
|
||||
|
})
|
||||
|
}
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
mod booleans {}
|
||||
|
}
|
||||
|
|
||||
|
#[cfg(test)]
|
||||
|
mod tests {
|
||||
|
use num_traits::Euclid;
|
||||
|
|
||||
|
use crate::{
|
||||
|
bool::{
|
||||
|
evaluator::{gen_keys, set_parameter_set, BoolEvaluator},
|
||||
|
parameters::SP_BOOL_PARAMS,
|
||||
|
},
|
||||
|
shortint::{add_mut, div, mul, sub, types::FheUint8},
|
||||
|
Decryptor, Encryptor,
|
||||
|
};
|
||||
|
|
||||
|
#[test]
|
||||
|
fn qwerty() {
|
||||
|
set_parameter_set(&SP_BOOL_PARAMS);
|
||||
|
|
||||
|
let (ck, sk) = gen_keys();
|
||||
|
sk.set_server_key();
|
||||
|
|
||||
|
for i in 1..=255 {
|
||||
|
for j in 0..=255 {
|
||||
|
let m0 = i;
|
||||
|
let m1 = j;
|
||||
|
let c0 = ck.encrypt(&m0);
|
||||
|
let c1 = ck.encrypt(&m1);
|
||||
|
|
||||
|
assert!(ck.decrypt(&c0) == m0);
|
||||
|
assert!(ck.decrypt(&c1) == m1);
|
||||
|
|
||||
|
// Add
|
||||
|
// let mut c_m0_plus_m1 = FheUint8 {
|
||||
|
// data: c0.data().to_vec(),
|
||||
|
// };
|
||||
|
// add_mut(&mut c_m0_plus_m1, &c1);
|
||||
|
// let m0_plus_m1 = ck.decrypt(&c_m0_plus_m1);
|
||||
|
// assert_eq!(
|
||||
|
// m0_plus_m1,
|
||||
|
// m0.wrapping_add(m1),
|
||||
|
// "Expected {} but got {m0_plus_m1} for {i}+{j}",
|
||||
|
// m0.wrapping_add(m1)
|
||||
|
// );
|
||||
|
|
||||
|
// Sub
|
||||
|
// let c_sub = sub(&c0, &c1);
|
||||
|
// let m0_sub_m1 = ck.decrypt(&c_sub);
|
||||
|
// dbg!(m0, m1, m0_sub_m1);
|
||||
|
// assert_eq!(
|
||||
|
// m0_sub_m1,
|
||||
|
// m0.wrapping_sub(m1),
|
||||
|
// "Expected {} but got {m0_sub_m1} for {i}-{j}",
|
||||
|
// m0.wrapping_sub(m1)
|
||||
|
// );
|
||||
|
|
||||
|
// Mul
|
||||
|
// let c_m0m1 = mul(&c0, &c1);
|
||||
|
// let m0m1 = ck.decrypt(&c_m0m1);
|
||||
|
// assert_eq!(
|
||||
|
// m0m1,
|
||||
|
// m0.wrapping_mul(m1),
|
||||
|
// "Expected {} but got {m0m1} for {i}x{j}",
|
||||
|
// m0.wrapping_mul(m1)
|
||||
|
// );
|
||||
|
|
||||
|
// Div
|
||||
|
// let (c_quotient, c_rem) = div(&c0, &c1);
|
||||
|
// let m_quotient = ck.decrypt(&c_quotient);
|
||||
|
// let m_remainder = ck.decrypt(&c_rem);
|
||||
|
// if j != 0 {
|
||||
|
// let (q, r) = i.div_rem_euclid(&j);
|
||||
|
// assert_eq!(
|
||||
|
// m_quotient, q,
|
||||
|
// "Expected {} but got {m_quotient} for {i}/{j}",
|
||||
|
// q
|
||||
|
// );
|
||||
|
// assert_eq!(
|
||||
|
// m_remainder, r,
|
||||
|
// "Expected {} but got {m_quotient} for {i}%{j}",
|
||||
|
// r
|
||||
|
// );
|
||||
|
// } else {
|
||||
|
// assert_eq!(
|
||||
|
// m_quotient, 255,
|
||||
|
// "Expected 255 but got {m_quotient}. Case div by zero"
|
||||
|
// );
|
||||
|
// assert_eq!(
|
||||
|
// m_remainder, i,
|
||||
|
// "Expected {i} but got {m_quotient}. Case div by zero"
|
||||
|
// )
|
||||
|
// }
|
||||
|
}
|
||||
|
}
|
||||
|
}
|
||||
|
}
|
||||
@ -0,0 +1,362 @@ |
|||||
|
use std::mem::MaybeUninit;
|
||||
|
|
||||
|
use itertools::{izip, Itertools};
|
||||
|
use num_traits::PrimInt;
|
||||
|
|
||||
|
use crate::{
|
||||
|
backend::ModularOpsU64,
|
||||
|
bool::{
|
||||
|
evaluator::{BoolEvaluator, BooleanGates, ClientKey, ServerKeyEvaluationDomain},
|
||||
|
parameters::CiphertextModulus,
|
||||
|
},
|
||||
|
ntt::NttBackendU64,
|
||||
|
random::DefaultSecureRng,
|
||||
|
Decryptor,
|
||||
|
};
|
||||
|
|
||||
|
pub(super) fn half_adder<E: BooleanGates>(
|
||||
|
evaluator: &mut E,
|
||||
|
a: &mut E::Ciphertext,
|
||||
|
b: &E::Ciphertext,
|
||||
|
key: &E::Key,
|
||||
|
) -> E::Ciphertext {
|
||||
|
let carry = evaluator.and(a, b, key);
|
||||
|
evaluator.xor_inplace(a, b, key);
|
||||
|
carry
|
||||
|
}
|
||||
|
|
||||
|
pub(super) fn full_adder_plain_carry_in<E: BooleanGates>(
|
||||
|
evaluator: &mut E,
|
||||
|
a: &mut E::Ciphertext,
|
||||
|
b: &E::Ciphertext,
|
||||
|
carry_in: bool,
|
||||
|
key: &E::Key,
|
||||
|
) -> E::Ciphertext {
|
||||
|
let mut a_and_b = evaluator.and(a, b, key);
|
||||
|
evaluator.xor_inplace(a, b, key); //a = a ^ b
|
||||
|
if carry_in {
|
||||
|
// a_and_b = A & B | ((A^B) & C_in={True})
|
||||
|
evaluator.or_inplace(&mut a_and_b, &a, key);
|
||||
|
} else {
|
||||
|
// a_and_b = A & B | ((A^B) & C_in={False})
|
||||
|
// a_and_b = A & B
|
||||
|
// noop
|
||||
|
}
|
||||
|
|
||||
|
// In xor if a input is 0, output equals the firt variable. If input is 1 then
|
||||
|
// output equals !(first variable)
|
||||
|
if carry_in {
|
||||
|
// (A^B)^1 = !(A^B)
|
||||
|
evaluator.not_inplace(a);
|
||||
|
} else {
|
||||
|
// (A^B)^0
|
||||
|
// no-op
|
||||
|
}
|
||||
|
a_and_b
|
||||
|
}
|
||||
|
|
||||
|
pub(super) fn full_adder<E: BooleanGates>(
|
||||
|
evaluator: &mut E,
|
||||
|
a: &mut E::Ciphertext,
|
||||
|
b: &E::Ciphertext,
|
||||
|
carry_in: &E::Ciphertext,
|
||||
|
key: &E::Key,
|
||||
|
) -> E::Ciphertext {
|
||||
|
let mut a_and_b = evaluator.and(a, b, key);
|
||||
|
evaluator.xor_inplace(a, b, key); //a = a ^ b
|
||||
|
let a_xor_b_and_c = evaluator.and(&a, carry_in, key);
|
||||
|
evaluator.or_inplace(&mut a_and_b, &a_xor_b_and_c, key); // a_and_b = A & B | ((A^B) & C_in)
|
||||
|
evaluator.xor_inplace(a, &carry_in, key);
|
||||
|
a_and_b
|
||||
|
}
|
||||
|
|
||||
|
pub(super) fn arbitrary_bit_adder<E: BooleanGates>(
|
||||
|
evaluator: &mut E,
|
||||
|
a: &mut [E::Ciphertext],
|
||||
|
b: &[E::Ciphertext],
|
||||
|
carry_in: bool,
|
||||
|
key: &E::Key,
|
||||
|
) -> (E::Ciphertext, E::Ciphertext)
|
||||
|
where
|
||||
|
E::Ciphertext: Clone,
|
||||
|
{
|
||||
|
assert!(a.len() == b.len());
|
||||
|
let n = a.len();
|
||||
|
|
||||
|
let mut carry = if !carry_in {
|
||||
|
half_adder(evaluator, &mut a[0], &b[0], key)
|
||||
|
} else {
|
||||
|
full_adder_plain_carry_in(evaluator, &mut a[0], &b[0], true, key)
|
||||
|
};
|
||||
|
|
||||
|
izip!(a.iter_mut(), b.iter())
|
||||
|
.skip(1)
|
||||
|
.take(n - 3)
|
||||
|
.for_each(|(a_bit, b_bit)| {
|
||||
|
carry = full_adder(evaluator, a_bit, b_bit, &carry, key);
|
||||
|
});
|
||||
|
|
||||
|
let carry_last_last = full_adder(evaluator, &mut a[n - 2], &b[n - 2], &carry, key);
|
||||
|
let carry_last = full_adder(evaluator, &mut a[n - 1], &b[n - 1], &carry_last_last, key);
|
||||
|
|
||||
|
(carry_last, carry_last_last)
|
||||
|
}
|
||||
|
|
||||
|
pub(super) fn arbitrary_bit_subtractor<E: BooleanGates>(
|
||||
|
evaluator: &mut E,
|
||||
|
a: &[E::Ciphertext],
|
||||
|
b: &[E::Ciphertext],
|
||||
|
key: &E::Key,
|
||||
|
) -> (Vec<E::Ciphertext>, E::Ciphertext, E::Ciphertext)
|
||||
|
where
|
||||
|
E::Ciphertext: Clone,
|
||||
|
{
|
||||
|
let mut neg_b: Vec<E::Ciphertext> = b.iter().map(|v| evaluator.not(v)).collect();
|
||||
|
let (carry_last, carry_last_last) = arbitrary_bit_adder(evaluator, &mut neg_b, &a, true, key);
|
||||
|
return (neg_b, carry_last, carry_last_last);
|
||||
|
}
|
||||
|
|
||||
|
pub(super) fn bit_mux<E: BooleanGates>(
|
||||
|
evaluator: &mut E,
|
||||
|
selector: E::Ciphertext,
|
||||
|
if_true: &E::Ciphertext,
|
||||
|
if_false: &E::Ciphertext,
|
||||
|
key: &E::Key,
|
||||
|
) -> E::Ciphertext {
|
||||
|
// (s&a) | ((1-s)^b)
|
||||
|
let not_selector = evaluator.not(&selector);
|
||||
|
|
||||
|
let s_and_a = evaluator.and(&selector, if_true, key);
|
||||
|
let s_and_b = evaluator.and(¬_selector, if_false, key);
|
||||
|
evaluator.or(&s_and_a, &s_and_b, key)
|
||||
|
}
|
||||
|
|
||||
|
pub(super) fn arbitrary_bit_mux<E: BooleanGates>(
|
||||
|
evaluator: &mut E,
|
||||
|
selector: &E::Ciphertext,
|
||||
|
if_true: &[E::Ciphertext],
|
||||
|
if_false: &[E::Ciphertext],
|
||||
|
key: &E::Key,
|
||||
|
) -> Vec<E::Ciphertext> {
|
||||
|
// (s&a) | ((1-s)^b)
|
||||
|
let not_selector = evaluator.not(&selector);
|
||||
|
|
||||
|
izip!(if_true.iter(), if_false.iter())
|
||||
|
.map(|(a, b)| {
|
||||
|
let s_and_a = evaluator.and(&selector, a, key);
|
||||
|
let s_and_b = evaluator.and(¬_selector, b, key);
|
||||
|
evaluator.or(&s_and_a, &s_and_b, key)
|
||||
|
})
|
||||
|
.collect()
|
||||
|
}
|
||||
|
|
||||
|
pub(super) fn eight_bit_mul<E: BooleanGates>(
|
||||
|
evaluator: &mut E,
|
||||
|
a: &[E::Ciphertext],
|
||||
|
b: &[E::Ciphertext],
|
||||
|
key: &E::Key,
|
||||
|
) -> Vec<E::Ciphertext> {
|
||||
|
assert!(a.len() == 8);
|
||||
|
assert!(b.len() == 8);
|
||||
|
let mut carries = Vec::with_capacity(7);
|
||||
|
let mut out = Vec::with_capacity(8);
|
||||
|
|
||||
|
for i in (0..8) {
|
||||
|
if i == 0 {
|
||||
|
let s = evaluator.and(&a[0], &b[0], key);
|
||||
|
out.push(s);
|
||||
|
} else if i == 1 {
|
||||
|
let mut tmp0 = evaluator.and(&a[1], &b[0], key);
|
||||
|
let tmp1 = evaluator.and(&a[0], &b[1], key);
|
||||
|
let carry = half_adder(evaluator, &mut tmp0, &tmp1, key);
|
||||
|
carries.push(carry);
|
||||
|
out.push(tmp0);
|
||||
|
} else {
|
||||
|
let mut sum = {
|
||||
|
let mut sum = evaluator.and(&a[i], &b[0], key);
|
||||
|
let tmp = evaluator.and(&a[i - 1], &b[1], key);
|
||||
|
carries[0] = full_adder(evaluator, &mut sum, &tmp, &carries[0], key);
|
||||
|
sum
|
||||
|
};
|
||||
|
|
||||
|
for j in 2..i {
|
||||
|
let tmp = evaluator.and(&a[i - j], &b[j], key);
|
||||
|
carries[j - 1] = full_adder(evaluator, &mut sum, &tmp, &carries[j - 1], key);
|
||||
|
}
|
||||
|
|
||||
|
let tmp = evaluator.and(&a[0], &b[i], key);
|
||||
|
let carry = half_adder(evaluator, &mut sum, &tmp, key);
|
||||
|
carries.push(carry);
|
||||
|
|
||||
|
out.push(sum)
|
||||
|
}
|
||||
|
debug_assert!(carries.len() <= 7);
|
||||
|
}
|
||||
|
|
||||
|
out
|
||||
|
}
|
||||
|
|
||||
|
pub(super) fn arbitrary_bit_division_for_quotient_and_rem<E: BooleanGates>(
|
||||
|
evaluator: &mut E,
|
||||
|
a: &[E::Ciphertext],
|
||||
|
b: &[E::Ciphertext],
|
||||
|
key: &E::Key,
|
||||
|
) -> (Vec<E::Ciphertext>, Vec<E::Ciphertext>)
|
||||
|
where
|
||||
|
E::Ciphertext: Clone,
|
||||
|
{
|
||||
|
let n = a.len();
|
||||
|
let neg_b = b.iter().map(|v| evaluator.not(v)).collect_vec();
|
||||
|
|
||||
|
// Both remainder and quotient are initially stored in Big-endian in contract to
|
||||
|
// the usual little endian we use. This is more friendly to vec pushes in
|
||||
|
// division. After computing remainder and quotient, we simply reverse the
|
||||
|
// vectors.
|
||||
|
let mut remainder = vec![];
|
||||
|
let mut quotient = vec![];
|
||||
|
for i in 0..n {
|
||||
|
// left shift
|
||||
|
remainder.push(a[n - 1 - i].clone());
|
||||
|
|
||||
|
let mut subtract = remainder.clone();
|
||||
|
|
||||
|
// subtraction
|
||||
|
// At i^th iteration remainder is only filled with i bits and the rest of the
|
||||
|
// bits are zero. For example, at i = 1
|
||||
|
// 0 0 0 0 0 0 X X => remainder
|
||||
|
// - Y Y Y Y Y Y Y Y => divisor .
|
||||
|
// --------------- .
|
||||
|
// Z Z Z Z Z Z Z Z => result
|
||||
|
// For the next iteration we only care about result if divisor is <= remainder
|
||||
|
// (which implies result <= remainder). Otherwise we care about remainder
|
||||
|
// (recall re-storing division). Hence we optimise subtraction and
|
||||
|
// ignore full adders for places where remainder bits are known to be false
|
||||
|
// bits. We instead use `ANDs` to compute the carry overs, since the
|
||||
|
// last carry over indicates whether the value has overflown (i.e. divisor <=
|
||||
|
// remainder). Last carry out is `true` if value has not overflown, otherwise
|
||||
|
// false.
|
||||
|
let mut carry =
|
||||
|
full_adder_plain_carry_in(evaluator, &mut subtract[i], &neg_b[0], true, key);
|
||||
|
for j in 1..i + 1 {
|
||||
|
carry = full_adder(evaluator, &mut subtract[i - j], &neg_b[j], &carry, key);
|
||||
|
}
|
||||
|
for j in i + 1..n {
|
||||
|
// All I care about are the carries
|
||||
|
evaluator.and_inplace(&mut carry, &neg_b[j], key);
|
||||
|
}
|
||||
|
|
||||
|
let not_carry = evaluator.not(&carry);
|
||||
|
// Choose `remainder` if subtraction has overflown (i.e. carry = false).
|
||||
|
// Otherwise choose `subtractor`.
|
||||
|
//
|
||||
|
// mux k^a | !(k)^b, where k is the selector.
|
||||
|
izip!(remainder.iter_mut(), subtract.iter_mut()).for_each(|(r, s)| {
|
||||
|
// choose `s` when carry is true, otherwise choose r
|
||||
|
evaluator.and_inplace(s, &carry, key);
|
||||
|
evaluator.and_inplace(r, ¬_carry, key);
|
||||
|
evaluator.or_inplace(r, s, key);
|
||||
|
});
|
||||
|
|
||||
|
// Set i^th MSB of quotient to 1 if carry = true, otherwise set it to 0.
|
||||
|
// X&1 | X&0 => X&1 => X
|
||||
|
quotient.push(carry);
|
||||
|
}
|
||||
|
|
||||
|
remainder.reverse();
|
||||
|
quotient.reverse();
|
||||
|
|
||||
|
(quotient, remainder)
|
||||
|
}
|
||||
|
|
||||
|
fn is_zero<E: BooleanGates>(evaluator: &mut E, a: &[E::Ciphertext], key: &E::Key) -> E::Ciphertext {
|
||||
|
let mut a = a.iter().map(|v| evaluator.not(v)).collect_vec();
|
||||
|
let (out, rest_a) = a.split_at_mut(1);
|
||||
|
rest_a.iter().for_each(|c| {
|
||||
|
evaluator.and_inplace(&mut out[0], c, key);
|
||||
|
});
|
||||
|
return a.remove(0);
|
||||
|
}
|
||||
|
|
||||
|
fn arbitrary_bit_equality<E: BooleanGates>(
|
||||
|
evaluator: &mut E,
|
||||
|
a: &[E::Ciphertext],
|
||||
|
b: &[E::Ciphertext],
|
||||
|
key: &E::Key,
|
||||
|
) -> E::Ciphertext {
|
||||
|
assert!(a.len() == b.len());
|
||||
|
let mut out = evaluator.and(&a[0], &b[0], key);
|
||||
|
izip!(a.iter(), b.iter()).skip(1).for_each(|(abit, bbit)| {
|
||||
|
let e = evaluator.xnor(abit, bbit, key);
|
||||
|
evaluator.and(&mut out, &e, key);
|
||||
|
});
|
||||
|
return out;
|
||||
|
}
|
||||
|
|
||||
|
/// Comaprator handle computes comparator result 2ns MSB onwards. It is
|
||||
|
/// separated because comparator subroutine for signed and unsgind integers
|
||||
|
/// differs only for 1st MSB and is common second MSB onwards
|
||||
|
fn _comparator_handler_from_second_msb<E: BooleanGates>(
|
||||
|
evaluator: &mut E,
|
||||
|
a: &[E::Ciphertext],
|
||||
|
b: &[E::Ciphertext],
|
||||
|
mut comp: E::Ciphertext,
|
||||
|
mut casc: E::Ciphertext,
|
||||
|
key: &E::Key,
|
||||
|
) -> E::Ciphertext {
|
||||
|
let n = a.len();
|
||||
|
|
||||
|
// handle MSB - 1
|
||||
|
let mut tmp = evaluator.not(&b[n - 2]);
|
||||
|
evaluator.and(&mut tmp, &a[n - 2], key);
|
||||
|
evaluator.and(&mut tmp, &casc, key);
|
||||
|
evaluator.or(&mut comp, &tmp, key);
|
||||
|
|
||||
|
for i in 2..n {
|
||||
|
// calculate cascading bit
|
||||
|
let tmp_casc = evaluator.xnor(&a[n - 2 - i], &b[n - 2 - i], key);
|
||||
|
evaluator.and(&mut casc, &tmp_casc, key);
|
||||
|
|
||||
|
// calculate computate bit
|
||||
|
let mut tmp = evaluator.not(&b[n - 1 - i]);
|
||||
|
evaluator.and(&mut tmp, &a[n - 1 - i], key);
|
||||
|
evaluator.and(&mut tmp, &casc, key);
|
||||
|
evaluator.or(&mut comp, &tmp, key);
|
||||
|
}
|
||||
|
|
||||
|
return comp;
|
||||
|
}
|
||||
|
|
||||
|
/// Signed integer comparison is same as unsigned integer with MSB flipped.
|
||||
|
fn arbitrary_signed_bit_comparator<E: BooleanGates>(
|
||||
|
evaluator: &mut E,
|
||||
|
a: &[E::Ciphertext],
|
||||
|
b: &[E::Ciphertext],
|
||||
|
key: &E::Key,
|
||||
|
) -> E::Ciphertext {
|
||||
|
assert!(a.len() == b.len());
|
||||
|
let n = a.len();
|
||||
|
|
||||
|
// handle MSB
|
||||
|
let mut comp = evaluator.not(&a[n - 1]);
|
||||
|
evaluator.and(&mut comp, &b[n - 1], key); // comp
|
||||
|
let casc = evaluator.xnor(&a[n - 1], &b[n - 1], key); // casc
|
||||
|
|
||||
|
return _comparator_handler_from_second_msb(evaluator, a, b, comp, casc, key);
|
||||
|
}
|
||||
|
|
||||
|
fn arbitrary_bit_comparator<E: BooleanGates>(
|
||||
|
evaluator: &mut E,
|
||||
|
a: &[E::Ciphertext],
|
||||
|
b: &[E::Ciphertext],
|
||||
|
key: &E::Key,
|
||||
|
) -> E::Ciphertext {
|
||||
|
assert!(a.len() == b.len());
|
||||
|
let n = a.len();
|
||||
|
|
||||
|
// handle MSB
|
||||
|
let mut comp = evaluator.not(&b[n - 1]);
|
||||
|
evaluator.and(&mut comp, &a[n - 1], key);
|
||||
|
let casc = evaluator.xnor(&a[n - 1], &b[n - 1], key);
|
||||
|
|
||||
|
return _comparator_handler_from_second_msb(evaluator, a, b, comp, casc, key);
|
||||
|
}
|
||||
@ -0,0 +1,14 @@ |
|||||
|
#[derive(Clone)]
|
||||
|
pub(super) struct FheUint8<C> {
|
||||
|
pub(super) data: Vec<C>,
|
||||
|
}
|
||||
|
|
||||
|
impl<C> FheUint8<C> {
|
||||
|
pub(super) fn data(&self) -> &[C] {
|
||||
|
&self.data
|
||||
|
}
|
||||
|
|
||||
|
pub(super) fn data_mut(&mut self) -> &mut [C] {
|
||||
|
&mut self.data
|
||||
|
}
|
||||
|
}
|
||||