Improved performances

Author: mathisbot

Cargo.lock

@@ -21,3 +21,4 @@ custom_rand = ["getrandom/custom"]
 [profile.release]
 codegen-units = 1
 lto = "thin"
+debug = 1

Cargo.toml

@@ -66,10 +66,10 @@ Parameters used for this benchmark were :
 
 | Operation         | Average time     |
 |:-----------------:|:----------------:|
-| Encryption        |      83.2 µs     |
-| Decryption        |      18.1 µs     |
-| Add               |       2.4 ms     |
-| Dec. after add    |       1.4 ms     |
+| Encryption        |     80.5  µs     |
+| Decryption        |     12.9  µs     |
+| Add               |      1.57 ms     |
+| Dec. after add    |      1.03 ms     |
 
 It is still more efficient to decrypt, operate and then re-encrypt the data. This limits the use of the system to applications where security is paramount, and takes precedence over speed.
 

README.md

@@ -28,18 +28,18 @@ unsafe impl ByteConvertible for Vec3 {
     }
 
     fn from_bytes(bytes: &[u8]) -> Self {
-        if bytes.len() != 3 * size_of::<Coordinate>() {
-            panic!(
-                "Invalid size of bytes for conversion: {} instead of {}",
-                bytes.len(),
-                3 * size_of::<Coordinate>()
-            );
-        }
+        assert!(
+            3 * size_of::<Coordinate>() == bytes.len(),
+            "Invalid size of bytes for conversion: expected {} got {}.",
+            3 * size_of::<Coordinate>(),
+            bytes.len(),
+        );
 
         let x = u16::from_le_bytes([bytes[0], bytes[1]]);
         let y = u16::from_le_bytes([bytes[2], bytes[3]]);
         let z = u16::from_le_bytes([bytes[4], bytes[5]]);
-        Vec3 { x, y, z }
+
+        Self { x, y, z }
     }
 }
 
@@ -52,15 +52,15 @@ impl HomomorphicOperation2<Vec3> for Vec3Add {
     unsafe fn apply(a: &Ciphered<Vec3>, b: &Ciphered<Vec3>) -> Ciphered<Vec3> {
         // Unwrap the first `Vec3`
         let (ax, a) = a.split_at(Coordinate::BITS as usize);
-        let ax: Ciphered<Coordinate> = Ciphered::new_from_raw(ax.to_vec());
         let (ay, az) = a.split_at(Coordinate::BITS as usize);
+        let ax: Ciphered<Coordinate> = Ciphered::new_from_raw(ax.to_vec());
         let ay: Ciphered<Coordinate> = Ciphered::new_from_raw(ay.to_vec());
         let az: Ciphered<Coordinate> = Ciphered::new_from_raw(az.to_vec());
 
         // Unwrap the second `Vec3`
         let (bx, b) = b.split_at(Coordinate::BITS as usize);
-        let bx: Ciphered<Coordinate> = Ciphered::new_from_raw(bx.to_vec());
         let (by, bz) = b.split_at(Coordinate::BITS as usize);
+        let bx: Ciphered<Coordinate> = Ciphered::new_from_raw(bx.to_vec());
         let by: Ciphered<Coordinate> = Ciphered::new_from_raw(by.to_vec());
         let bz: Ciphered<Coordinate> = Ciphered::new_from_raw(bz.to_vec());
 

examples/new_struct.rs

@@ -3,7 +3,7 @@ use std::time::Instant;
 
 use homomorph::prelude::*;
 
-const NUMBER_OF_TESTS: usize = 10_000;
+const NUMBER_OF_TESTS: usize = 1_000;
 
 fn main() {
     let mut rng = rand::thread_rng();

examples/uint_add.rs

@@ -81,19 +81,19 @@ pub unsafe trait ByteConvertible {
     fn from_bytes(bytes: &[u8]) -> Self;
 }
 
-// All types that implement Copy and Sized can be converted to bytes
+// All types that implement Copy can be converted to bytes
 // by simply reading stack data as bytes
 // TODO: Make it derivable ?
-unsafe impl<T: Copy + Sized> ByteConvertible for T {
+unsafe impl<T: Copy> ByteConvertible for T {
     /// This function is used to convert a type to a byte array
     fn to_bytes(&self) -> Vec<u8> {
         let mut bytes = Vec::with_capacity(size_of::<T>());
 
         // Safety
         // Because of `Vec::with_capacity`, we know that the buffer
         // is big enough to hold the `size_from::<T>()` bytes.
-        // We also know that the source is valid, because T is Sized and Copy,
-        // and we are reading exactly `size_of::<T>()` bytes from it.
+        // We also know that the source is valid, because we are reading
+        // exactly `size_of::<T>()` bytes from `T`.
         unsafe {
             memcpy(
                 core::ptr::from_ref(self).cast::<u8>(),
@@ -225,8 +225,7 @@ impl<T: ByteConvertible> Ciphered<T> {
     #[must_use]
     // See https://github.com/mathisbot/homomorph-rust?tab=readme-ov-file#system
     fn decipher_bit(c_bit: &CipheredBit, sk: &SecretKey) -> bool {
-        let sk = sk.get_polynomial();
-        let remainder = c_bit.0.rem(sk);
+        let remainder = c_bit.0.rem(sk.get_polynomial());
         remainder.evaluate(false)
     }
 
@@ -250,8 +249,8 @@ impl<T: ByteConvertible> Ciphered<T> {
 
         let mut bytes = Vec::with_capacity(self.len() / 8);
 
-        let mut byte = 0u8;
-        let mut bit_count = 0;
+        let mut byte = 0;
+        let mut bit_count: u8 = 0;
 
         for c_bit in self.iter() {
             let bit = u8::from(Self::decipher_bit(c_bit, sk));

src/cipher.rs

@@ -98,12 +98,82 @@ impl_homomorphic_multiplication_int!(i8, i16, i32, isize, i64, i128);
 
 #[cfg(test)]
 mod tests {
-    use crate::impls::numbers::{HomomorphicAddition, HomomorphicMultiplication};
-    use crate::operations::HomomorphicOperation2;
-    use crate::{Ciphered, Context, Parameters};
+    use crate::prelude::*;
+    use homomorph_impls::numbers::{
+        HomomorphicAddition, HomomorphicAndGate, HomomorphicMultiplication, HomomorphicNotGate,
+        HomomorphicOrGate, HomomorphicXorGate,
+    };
 
     use rand::{thread_rng, Rng};
 
+    #[test]
+    fn test_homomorphic_and_gate() {
+        let parameters = Parameters::new(32, 8, 8, 8);
+        let mut context = Context::new(parameters);
+        context.generate_secret_key();
+        context.generate_public_key();
+        let sk = context.get_secret_key().unwrap();
+        let pk = context.get_public_key().unwrap();
+
+        let a = Ciphered::cipher(&0b1010_i8, pk);
+        let b = Ciphered::cipher(&0b1100_i8, pk);
+        let c = unsafe { HomomorphicAndGate::apply(&a, &b) };
+        let d = c.decipher(sk);
+        assert_eq!(0b1000, d);
+    }
+
+    #[test]
+    fn test_homomorphic_or_gate() {
+        let parameters = Parameters::new(32, 8, 8, 8);
+        let mut context = Context::new(parameters);
+        context.generate_secret_key();
+        context.generate_public_key();
+        let sk = context.get_secret_key().unwrap();
+        let pk = context.get_public_key().unwrap();
+
+        let a = Ciphered::cipher(&0b1010_i8, pk);
+        let b = Ciphered::cipher(&0b1100_i8, pk);
+        let c = unsafe { HomomorphicOrGate::apply(&a, &b) };
+        let d = c.decipher(sk);
+        assert_eq!(0b1110, d);
+    }
+
+    #[test]
+    fn test_homomorphic_xor_gate() {
+        let parameters = Parameters::new(16, 8, 8, 8);
+        let mut context = Context::new(parameters);
+        context.generate_secret_key();
+        context.generate_public_key();
+        let sk = context.get_secret_key().unwrap();
+        let pk = context.get_public_key().unwrap();
+
+        let a = Ciphered::cipher(&0b1010_i8, pk);
+        let b = Ciphered::cipher(&0b1100_i8, pk);
+        let c = unsafe { HomomorphicXorGate::apply(&a, &b) };
+        let d = c.decipher(sk);
+        assert_eq!(0b0110, d);
+    }
+
+    #[test]
+    fn test_homomorphic_not_gate() {
+        let parameters = Parameters::new(16, 8, 8, 8);
+        let mut context = Context::new(parameters);
+        context.generate_secret_key();
+        context.generate_public_key();
+        let sk = context.get_secret_key().unwrap();
+        let pk = context.get_public_key().unwrap();
+
+        let mut a = Ciphered::cipher(&0b0000_1010_i8, pk);
+        unsafe { HomomorphicNotGate::apply(&mut a) };
+        let d = a.decipher(sk);
+        assert_eq!(-11, d);
+
+        let mut a = Ciphered::cipher(&0b0000_1100_i8, pk);
+        unsafe { HomomorphicNotGate::apply(&mut a) };
+        let d = a.decipher(sk);
+        assert_eq!(-13, d);
+    }
+
     #[test]
     #[should_panic = "not yet implemented: Homormophic addition for int"]
     fn test_homomorphic_addition() {