chore(doc): New example + fixes

Author: mathisbot

.github/workflows/rust.yml

@@ -25,9 +25,6 @@ jobs:
         components: rustfmt, clippy
         override: true
 
-    - name: Run Clippy
-      run: cargo clippy --all-targets --all-features -- -D warnings
-
     - name: Build
       run: cargo build --lib --verbose
 
@@ -37,6 +34,12 @@ jobs:
     - name: Run extensive tests
       run: cargo test --release --verbose -- --ignored
 
+    - name: Run a basic example
+      run: cargo run --release --example new_struct
+
+    - name: Run Clippy
+      run: cargo clippy --all-targets --all-features --no-deps -- -D warnings
+
     - name: Check formatting
       run: cargo fmt -- --check
 

Cargo.toml

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

examples/new_struct.rs

@@ -0,0 +1,107 @@
+//! This example runs perfectly on bare metal
+//! (assuming there's an `alloc` crate)
+#![no_std]
+
+extern crate alloc;
+use alloc::vec::Vec;
+
+use homomorph::prelude::*;
+
+type Coordinate = u16;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+struct Vec3 {
+    x: Coordinate,
+    y: Coordinate,
+    z: Coordinate,
+}
+
+// If you don't want to implement `ByteConvertible` for your struct,
+// use repr(C) and derive Copy
+unsafe impl ByteConvertible for Vec3 {
+    fn to_bytes(&self) -> Vec<u8> {
+        let mut bytes = Vec::with_capacity(3 * size_of::<Coordinate>());
+        bytes.extend_from_slice(&self.x.to_le_bytes());
+        bytes.extend_from_slice(&self.y.to_le_bytes());
+        bytes.extend_from_slice(&self.z.to_le_bytes());
+        bytes
+    }
+
+    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>()
+            );
+        }
+
+        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 }
+    }
+}
+
+struct Vec3Add;
+
+impl HomomorphicOperation2<Vec3> for Vec3Add {
+    /// ## Safety
+    ///
+    /// `d/delta` on cipher must have been at least `21*sizeof::<Coordinates>()`.
+    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 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 by: Ciphered<Coordinate> = Ciphered::new_from_raw(by.to_vec());
+        let bz: Ciphered<Coordinate> = Ciphered::new_from_raw(bz.to_vec());
+
+        // Perform already implemented homomorphic addition over `Coordinate` (`uint` is already implemented)
+        let x = homomorph_impls::numbers::HomomorphicAddition::apply(&ax, &bx);
+        let y = homomorph_impls::numbers::HomomorphicAddition::apply(&ay, &by);
+        let z = homomorph_impls::numbers::HomomorphicAddition::apply(&az, &bz);
+
+        assert_eq!(x.len(), Coordinate::BITS as usize);
+        assert_eq!(y.len(), Coordinate::BITS as usize);
+        assert_eq!(z.len(), Coordinate::BITS as usize);
+
+        // Merge the results
+        let mut res = Vec::with_capacity(8 * size_of::<Vec3>());
+        res.extend_from_slice(x.as_slice());
+        res.extend_from_slice(y.as_slice());
+        res.extend_from_slice(z.as_slice());
+
+        Ciphered::new_from_raw(res)
+    }
+}
+
+fn main() {
+    let params = Parameters::new(64, 32, 1, 32);
+    let mut context = Context::new(params);
+    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(&Vec3 { x: 1, y: 2, z: 3 }, pk);
+    let b = Ciphered::cipher(&Vec3 { x: 9, y: 8, z: 7 }, pk);
+    let c = unsafe { Vec3Add::apply(&a, &b) };
+    let d = Ciphered::decipher(&c, sk);
+
+    assert_eq!(
+        Vec3 {
+            x: 10,
+            y: 10,
+            z: 10
+        },
+        d
+    );
+}

src/cipher.rs

@@ -266,6 +266,7 @@ mod tests {
         assert_eq!(data, decrypted);
 
         #[derive(Copy, Clone, Debug, PartialEq)]
+        #[repr(C)]
         struct MyStruct {
             a: usize,
             b: usize,

src/impls/numbers/uint.rs

@@ -77,15 +77,15 @@ fn homomorph_add_internal(a: &[CipheredBit], b: &[CipheredBit]) -> Vec<CipheredB
         // c <- (p1+p2)*c + p1*p2 + p1*p2*(p1+p2)*c
         // c <- c*(p1+p2)*(1+p1*p2) + p1*p2
         let p1_p2 = p1.and(p2);
-        carry = p1
-            .xor(p2)
-            .and(&carry)
-            .and(&CipheredBit::one().xor(&p1_p2))
-            .xor(&p1_p2);
+        if i + 1 < longest {
+            carry = carry
+                .and(&p1.xor(p2))
+                .and(&CipheredBit::one().xor(&p1_p2))
+                .xor(&p1_p2);
+        }
 
         result.push(s);
     }
-    result.push(carry);
 
     result
 }

src/lib.rs

@@ -184,48 +184,39 @@
 //! use core::ptr::copy_nonoverlapping as memcpy;
 //!
 //! struct MyStruct {
-//!     a: usize,
-//!     b: usize,
+//!     a: u32,
+//!     b: u32,
 //! }
 //!
 //! // Fortunately, `MyStruct` is `Sized`!
 //! unsafe impl ByteConvertible for MyStruct {
 //!     fn to_bytes(&self) -> Vec<u8> {
 //!         let mut bytes = Vec::with_capacity(size_of::<MyStruct>());
-//!         unsafe {
-//!             memcpy(
-//!                 self as *const MyStruct as *const u8,
-//!                 bytes.as_mut_ptr(),
-//!                 size_of::<MyStruct>(),
-//!             );
-//!             bytes.set_len(size_of::<MyStruct>());
-//!         }
+//!         bytes.extend_from_slice(&self.a.to_le_bytes());
+//!         bytes.extend_from_slice(&self.b.to_le_bytes());
 //!         bytes
 //!     }
 //!
 //!     fn from_bytes(bytes: &[u8]) -> Self {
-//!         if bytes.len() < size_of::<MyStruct>() {
+//!         if bytes.len() != size_of::<MyStruct>() {
 //!             panic!(
 //!                 "Invalid size of bytes for conversion: {} instead of {}",
 //!                 bytes.len(),
 //!                 size_of::<MyStruct>()
 //!             );
 //!         }
 //!
-//!         let mut data = core::mem::MaybeUninit::uninit();
-//!         unsafe {
-//!             memcpy(
-//!                 bytes.as_ptr(),
-//!                 data.as_mut_ptr() as *mut u8,
-//!                 size_of::<MyStruct>(),
-//!             );
-//!             data.assume_init()
-//!         }
+//!         let (a_bytes, b_bytes) = bytes.split_at(size_of::<u32>());
+//!
+//!         let a = u32::from_le_bytes([a_bytes[0], a_bytes[1], a_bytes[2], a_bytes[3]]);
+//!         let b = u32::from_le_bytes([b_bytes[0], b_bytes[1], b_bytes[2], b_bytes[3]]);
+//!         MyStruct { a, b }
 //!     }
 //! }
 //! ```
 //!
-//! If we then want to implement an homomorphic addition for `usize`, we will have to define a struct `HomomorphicAddition`
+//! If we then want to implement an homomorphic addition for our struct,
+//! we will have to define a struct `HomomorphicAddition`
 //! that implements the trait `HomomorphicOperation2<usize>`.
 //!
 //! The key to implement such operations is to mimic the behavior of the operation on unciphered bits.
@@ -238,7 +229,8 @@
 //! ```rust
 //! use homomorph::prelude::*;
 //!
-//! // Here, we derive Copy so that the system can cipher the struct
+//! // Here, we derive Copy so that `ByteConvertible` is automatically implemented
+//! #[repr(C)]
 //! #[derive(Copy, Clone)]
 //! struct MyStruct {
 //!     a: usize,
@@ -269,6 +261,8 @@
 //! You simply have to compute the boolean degree of the operation you want to implement.
 //! This can also be done by trial and error.
 //!
+//! For a more precise example, you can take a look at the examples in `./examples/`.
+//!
 //! ## Source
 //!
 //! The source code is available on [GitHub](<https://github.com/mathisbot/homomorph-rust>).

src/operations.rs

@@ -42,6 +42,7 @@ use crate::{ByteConvertible, Ciphered};
 /// ```rust
 /// use homomorph::prelude::*;
 ///
+/// #[repr(C)]
 /// #[derive(Copy, Clone)]
 /// struct MyStruct {
 ///     a: usize,
@@ -90,6 +91,7 @@ pub trait HomomorphicOperation1<T: ByteConvertible> {
 /// ```rust
 /// use homomorph::prelude::*;
 ///
+/// #[repr(C)]
 /// #[derive(Copy, Clone)]
 /// struct MyStruct {
 ///     a: usize,
@@ -147,6 +149,7 @@ pub trait HomomorphicOperation2<T: ByteConvertible> {
 /// use homomorph::prelude::*;
 /// use core::ops::Deref;
 ///
+/// #[repr(C)]
 /// #[derive(Copy, Clone)]
 /// struct MyStruct {
 ///     a: usize,