Added functionality COT

src/e2f/prover.rs

@@ -1,6 +1,7 @@
 //! The prover implementation
 
-use crate::func::ole::{Ole, Role};
+use crate::func::ole::Ole;
+use crate::func::Role;
 use mpz_share_conversion_core::fields::{p256::P256, Field, UniformRand};
 use rand::thread_rng;
 

src/e2f/verifier.rs

@@ -1,6 +1,7 @@
 //! The verifier implementation
 
-use crate::func::ole::{Ole, Role};
+use crate::func::ole::Ole;
+use crate::func::Role;
 use mpz_share_conversion_core::fields::{p256::P256, Field, UniformRand};
 use rand::thread_rng;
 

src/func/cot.rs

@@ -0,0 +1,140 @@
+//! This module implements the COT functionality (page 5) from <https://eprint.iacr.org/2015/546> without errors.
+
+use mpz_share_conversion_core::fields::UniformRand;
+
+use super::Role;
+use crate::f2::F2;
+
+#[derive(Debug, Default)]
+pub struct Cot {
+    kappa: usize,
+    l: usize,
+    delta: Vec<F2>,
+    t: Vec<Vec<F2>>,
+    q: Vec<Vec<F2>>,
+}
+
+impl Cot {
+    pub fn new(kappa: usize, l: usize) -> Self {
+        Self {
+            kappa,
+            l,
+            ..Default::default()
+        }
+    }
+
+    pub fn initialize_input_delta(&mut self, delta: Vec<F2>) {
+        assert_eq!(delta.len(), self.kappa);
+
+        self.delta = delta;
+    }
+
+    pub fn extend_input_x(&mut self, x: Vec<Vec<F2>>) {
+        assert!(self.t.is_empty());
+        assert!(self.q.is_empty());
+        assert_eq!(x.len(), self.l);
+
+        for vec in x.iter() {
+            assert_eq!(vec.len(), self.kappa);
+        }
+
+        let mut rng = rand::thread_rng();
+
+        for _ in 0..self.l {
+            let inner = (0..self.kappa)
+                .map(|_| F2::rand(&mut rng))
+                .collect::<Vec<F2>>();
+            self.t.push(inner);
+        }
+
+        for (ti, xi) in self.t.iter().zip(x.iter()) {
+            let xi_times_delta = self
+                .delta
+                .iter()
+                .zip(xi.iter())
+                .map(|(&deltai, &xi)| deltai * xi)
+                .collect::<Vec<F2>>();
+
+            self.q.push(
+                ti.iter()
+                    .zip(xi_times_delta.iter())
+                    .map(|(&tk, &xtdk)| tk + xtdk)
+                    .collect::<Vec<F2>>(),
+            );
+        }
+    }
+
+    pub fn output(&mut self, role: Role) -> Vec<Vec<F2>> {
+        let out = if role == Role::Sender {
+            std::mem::take(&mut self.q)
+        } else {
+            std::mem::take(&mut self.t)
+        };
+
+        std::mem::take(self);
+        out
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_cot() {
+        let mut cot = Cot::new(5, 3);
+        let delta = vec![
+            F2::new(true),
+            F2::new(false),
+            F2::new(true),
+            F2::new(false),
+            F2::new(true),
+        ];
+
+        let x = vec![
+            vec![
+                F2::new(true),
+                F2::new(false),
+                F2::new(true),
+                F2::new(false),
+                F2::new(true),
+            ],
+            vec![
+                F2::new(false),
+                F2::new(true),
+                F2::new(false),
+                F2::new(true),
+                F2::new(true),
+            ],
+            vec![
+                F2::new(false),
+                F2::new(true),
+                F2::new(true),
+                F2::new(false),
+                F2::new(false),
+            ],
+        ];
+
+        cot.initialize_input_delta(delta.clone());
+        cot.extend_input_x(x.clone());
+
+        let q = cot.output(Role::Sender);
+        let t = cot.output(Role::Receiver);
+
+        for ((qi, ti), xi) in q.iter().zip(t.iter()).zip(x.iter()) {
+            let qi_minus_ti = qi
+                .iter()
+                .zip(ti.iter())
+                .map(|(&qij, &tij)| qij + -tij)
+                .collect::<Vec<F2>>();
+
+            let xi_times_delta = xi
+                .iter()
+                .zip(delta.iter())
+                .map(|(&xij, &deltai)| xij * deltai)
+                .collect::<Vec<F2>>();
+
+            assert_eq!(qi_minus_ti, xi_times_delta);
+        }
+    }
+}

src/func/cote.rs

@@ -1,7 +0,0 @@
-//! This module implements the COTE functionality (page 5) from <https://eprint.iacr.org/2015/546>
-
-#[derive(Debug)]
-pub struct Cote {
-    kappa: usize,
-    l: usize,
-}

src/func/mod.rs

@@ -1,4 +1,10 @@
 //! This module implements some functionalities.
 
-pub mod cote;
+pub mod cot;
 pub mod ole;
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum Role {
+    Sender,
+    Receiver,
+}

src/func/ole.rs

@@ -1,5 +1,6 @@
 //! This module implements an OLE functionality.
 
+use super::Role;
 use mpz_share_conversion_core::Field;
 use rand::thread_rng;
 
@@ -59,13 +60,6 @@ impl<T: Field> Ole<T> {
         output
     }
 }
-
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum Role {
-    Sender,
-    Receiver,
-}
-
 #[cfg(test)]
 mod tests {
     use mpz_share_conversion_core::fields::{p256::P256, UniformRand};

src/ghash/prover.rs

@@ -1,5 +1,6 @@
 use super::pascal_tri;
-use crate::func::ole::{Ole, Role};
+use crate::func::ole::Ole;
+use crate::func::Role;
 use mpz_share_conversion_core::{
     fields::{compute_product_repeated, gf2_128::Gf2_128, UniformRand},
     Field,

src/ghash/verifier.rs

@@ -1,5 +1,6 @@
 use super::pascal_tri;
-use crate::func::ole::{Ole, Role};
+use crate::func::ole::Ole;
+use crate::func::Role;
 use mpz_share_conversion_core::{
     fields::{compute_product_repeated, gf2_128::Gf2_128, UniformRand},
     Field,

src/lib.rs

@@ -3,5 +3,5 @@
 
 pub mod e2f;
 mod f2;
-mod func;
+pub mod func;
 pub mod ghash;