fix: code coverage

Author: mathisbot

.github/workflows/rust.yml

@@ -2,9 +2,9 @@ name: Rust
 
 on:
   push:
-    branches: [ "main" ]
+    branches: ["main"]
   pull_request:
-    branches: [ "main" ]
+    branches: ["main"]
 
 env:
   CARGO_TERM_COLOR: always
@@ -14,48 +14,57 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v3
+      - uses: actions/checkout@v3
 
-    - name: Install Rust
-      uses: actions-rs/toolchain@v1
-      with:
-        toolchain: stable
-        target: x86_64-unknown-linux-gnu
-        profile: minimal
-        components: rustfmt, clippy
-        override: true
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          target: x86_64-unknown-linux-gnu
+          profile: minimal
+          override: true
 
-    - name: Build
-      run: cargo build --lib --verbose
+      - name: Build
+        run: cargo build --lib --verbose
 
-    - name: Run basic tests
-      run: cargo test --verbose
+      - name: Run basic tests
+        run: cargo test --verbose
 
-    - name: Run extensive tests
-      run: cargo test --release --verbose -- --ignored
+      - name: Run a basic example
+        run: cargo run --release --example new_struct
 
-    - name: Run a basic example
-      run: cargo run --release --example new_struct
+  clippy-fmt:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          target: x86_64-unknown-linux-gnu
+          profile: minimal
+          components: rustfmt, clippy
+          override: true
 
-    - name: Run Clippy
-      run: cargo clippy --all-targets --all-features -- -D warnings --no-deps
+      - name: Run clippy
+        run: cargo clippy --verbose --all-targets --all-features -- -D warnings --no-deps
 
-    - name: Check formatting
-      run: cargo fmt -- --check
+      - name: Run fmt
+        run: cargo fmt --verbose --all -- --check
 
   x86_64-unknown-none:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v3
-
-    - name: Install Rust
-      uses: actions-rs/toolchain@v1
-      with:
-        toolchain: stable
-        target: x86_64-unknown-none
-        profile: minimal
-        override: true
-
-    - name: Build
-      run: cargo build --lib --verbose
+      - uses: actions/checkout@v3
+
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          target: x86_64-unknown-none
+          profile: minimal
+          override: true
+
+      - name: Build
+        run: cargo build --lib --verbose --target x86_64-unknown-none

Cargo.lock

@@ -13,7 +13,6 @@ getrandom = { version = "0.2.15", default-features = false, features = ["rdrand"
 zeroize = { version = "1.8.1", default-features = false, features = ["alloc","zeroize_derive"] }
 
 [dev-dependencies]
-mimalloc = { version = "0.1.43", features = ["secure"] }
 rand = "0.8.5"
 
 [features]

Cargo.toml

@@ -83,6 +83,18 @@ impl HomomorphicOperation2<Vec3> for Vec3Add {
     }
 }
 
+struct Vec3Sub;
+
+impl HomomorphicOperation<0, u8> for Vec3Sub {
+    unsafe fn apply(args: [&Ciphered<u8>; 0]) -> Ciphered<u8> {
+        panic!(
+            "This function should never be called {}, {:?}",
+            size_of::<[&Ciphered<u8>; 0]>(),
+            args
+        );
+    }
+}
+
 fn main() {
     let params = Parameters::new(64, 32, 1, 32);
     let mut context = Context::new(params);
@@ -92,16 +104,12 @@ fn main() {
     let pk = context.get_public_key().unwrap();
 
     let a = Ciphered::cipher(&Vec3 { x: 1, y: 2, z: 3 }, pk);
-    let b = Ciphered::cipher(&Vec3 { x: 9, y: 8, z: 7 }, pk);
+    let b = Ciphered::cipher(&Vec3 { x: 4, y: 5, z: 6 }, pk);
     let c = unsafe { Vec3Add::apply(&a, &b) };
     let d = Ciphered::decipher(&c, sk);
 
-    assert_eq!(
-        Vec3 {
-            x: 10,
-            y: 10,
-            z: 10
-        },
-        d
-    );
+    let s = unsafe { Vec3Sub::apply([]) };
+    let _ds = Ciphered::decipher(&s, sk);
+
+    assert_eq!(Vec3 { x: 5, y: 7, z: 9 }, d);
 }

examples/new_struct.rs

@@ -3,9 +3,6 @@ use std::time::Instant;
 
 use homomorph::prelude::*;
 
-#[global_allocator]
-static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
-
 const NUMBER_OF_TESTS: usize = 1_000;
 
 fn main() {

examples/uint_add.rs

@@ -83,6 +83,7 @@ pub unsafe trait ByteConvertible {
 
 // All types that implement Copy and Sized can be converted to bytes
 // by simply reading stack data as bytes
+// TODO: Make it derivable ?
 unsafe impl<T: Copy + Sized> ByteConvertible for T {
     fn to_bytes(&self) -> Vec<u8> {
         let mut bytes = Vec::with_capacity(size_of::<T>());
@@ -109,7 +110,7 @@ unsafe impl<T: Copy + Sized> ByteConvertible for T {
     /// This can happen with overflows when adding two unsigned integers for example.
     fn from_bytes(bytes: &[u8]) -> Self {
         assert!(
-            bytes.len() >= size_of::<T>(),
+            bytes.len() == size_of::<T>(),
             "Invalid size of bytes for conversion: {} instead of {}",
             bytes.len(),
             size_of::<T>()
@@ -175,8 +176,7 @@ impl<T: ByteConvertible> Ciphered<T> {
         let tau = pk.len();
         let random_part = Self::part(tau);
 
-        let mut sum =
-            unsafe { Polynomial::new_unchecked(vec![crate::polynomial::Coefficient::from(x)], 0) };
+        let mut sum = Polynomial::new_from_bool(x);
         for i in 0..tau {
             let random = random_part[i / 8] & (1 << (i % 8));
             if random != 0 {
@@ -234,7 +234,7 @@ impl<T: ByteConvertible> Ciphered<T> {
                 chunk
                     .iter()
                     .enumerate()
-                    .fold(0u8, |byte, (i, &bit)| byte | ((u8::from(bit)) << i))
+                    .fold(0, |byte, (i, &bit)| byte | ((u8::from(bit)) << i))
             })
             .collect::<Vec<_>>();
 
@@ -265,6 +265,32 @@ mod tests {
         b: usize,
     }
 
+    #[test]
+    fn test_byteconvertible() {
+        let data = 0b1000_1010_u8;
+        let bytes = data.to_bytes();
+        let decrypted = u8::from_bytes(&bytes);
+        assert_eq!(data, decrypted);
+
+        let data = MyStruct { a: 42, b: 69 };
+        let bytes = data.to_bytes();
+        let decrypted = MyStruct::from_bytes(&bytes);
+        assert_eq!(data, decrypted);
+
+        let data = MyStruct { a: 42, b: 69 };
+        let mut bytes = data.to_bytes();
+        bytes[0] ^= 1;
+        let decrypted = MyStruct::from_bytes(&bytes);
+        assert_ne!(data, decrypted);
+    }
+
+    #[test]
+    #[should_panic = "Invalid size of bytes for conversion: 2 instead of 1"]
+    fn test_byteconvertible_panic() {
+        let bytes = [0u8; 2];
+        let _ = u8::from_bytes(&bytes);
+    }
+
     #[test]
     fn test_cipher() {
         let parameters = Parameters::new(64, 32, 8, 32);
@@ -284,14 +310,24 @@ mod tests {
         let decrypted = ciphered.decipher(sk);
         assert_eq!(data, decrypted);
 
-        let data = "Hello, World!";
+        let data = MyStruct { a: 42, b: 69 };
         let ciphered = Ciphered::cipher(&data, pk);
         let decrypted = ciphered.decipher(sk);
         assert_eq!(data, decrypted);
+    }
 
-        let data = MyStruct { a: 42, b: 69 };
+    #[test]
+    fn test_deref() {
+        let parameters = Parameters::new(64, 32, 8, 32);
+        let mut context = Context::new(parameters);
+        context.generate_secret_key();
+        context.generate_public_key();
+        let pk = context.get_public_key().unwrap();
+
+        let data = 0b1000_1010_u8;
         let ciphered = Ciphered::cipher(&data, pk);
-        let decrypted = ciphered.decipher(sk);
-        assert_eq!(data, decrypted);
+
+        // Assert it is possible to work with bits
+        let _iter = ciphered.iter();
     }
 }

src/cipher.rs

@@ -24,6 +24,7 @@ use alloc::vec::Vec;
 /// `delta` is strictly less than `d`.
 ///
 /// For more information, visit <https://github.com/mathisbot/homomorph-rust?tab=readme-ov-file#system>.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub struct Parameters {
     d: u16,
     dp: u16,
@@ -110,7 +111,7 @@ impl SecretKey {
         let mut coeffs: Vec<_> =
             Vec::with_capacity(bytes.len() / size_of::<crate::polynomial::Coefficient>());
         for chunk in bytes.chunks(size_of::<crate::polynomial::Coefficient>()) {
-            let mut array = [0u8; size_of::<crate::polynomial::Coefficient>()];
+            let mut array = [0; size_of::<crate::polynomial::Coefficient>()];
             array[..chunk.len()].copy_from_slice(chunk);
             coeffs.push(crate::polynomial::Coefficient::from_le_bytes(array));
         }
@@ -200,7 +201,7 @@ impl PublicKey {
             let mut coeffs: Vec<_> =
                 Vec::with_capacity(bytes.len() / size_of::<crate::polynomial::Coefficient>());
             for chunk in bytes.chunks(size_of::<crate::polynomial::Coefficient>()) {
-                let mut array = [0u8; size_of::<crate::polynomial::Coefficient>()];
+                let mut array = [0; size_of::<crate::polynomial::Coefficient>()];
                 array[..chunk.len()].copy_from_slice(chunk);
                 coeffs.push(crate::polynomial::Coefficient::from_le_bytes(array));
             }
@@ -266,6 +267,7 @@ impl PublicKey {
 }
 
 /// The cipher context.
+#[derive(Clone, Debug)]
 pub struct Context {
     secret_key: Option<SecretKey>,
     public_key: Option<PublicKey>,
@@ -449,7 +451,7 @@ mod tests {
         let bytes = sk.get_bytes();
         let sk2 = SecretKey::new(&bytes);
 
-        assert_eq!(sk.s, sk2.s);
+        assert_eq!(sk, sk2);
     }
 
     #[test]
@@ -460,7 +462,7 @@ mod tests {
         let bytes = pk.get_bytes();
         let pk2 = PublicKey::new(&bytes);
 
-        assert_eq!(pk.list, pk2.list);
+        assert_eq!(pk, pk2);
     }
 
     #[test]
@@ -480,4 +482,12 @@ mod tests {
         assert_eq!(sk, sk2);
         assert_eq!(pk, pk2);
     }
+
+    #[test]
+    #[should_panic = "Secret key not generated yet"]
+    fn test_context_panic() {
+        let params = Parameters::new(64, 32, 8, 32);
+        let mut context = Context::new(params);
+        context.generate_public_key();
+    }
 }