map evaluator to use Channel

src/garble.rs

@@ -303,10 +303,8 @@ mod streaming {
     use itertools::Itertools;
     use rand::thread_rng;
     use scuttlebutt::{AesRng, Channel};
-    use std::cell::RefCell;
     use std::io::{BufReader, BufWriter};
     use std::os::unix::net::UnixStream;
-    use std::rc::Rc;
 
     type MyChannel = Channel<BufReader<UnixStream>, BufWriter<UnixStream>>;
 
@@ -319,7 +317,7 @@ mod streaming {
         input_mods: &[u16],
     ) where
         FGB: FnMut(&mut Garbler<MyChannel, AesRng>, &[Wire]) + Send + Sync + Copy + 'static,
-        FEV: FnMut(&mut Evaluator<UnixStream>, &[Wire]) + Send + Sync + Copy + 'static,
+        FEV: FnMut(&mut Evaluator<MyChannel>, &[Wire]) + Send + Sync + Copy + 'static,
         FDU: FnMut(&mut Dummy, &[DummyVal]) + Send + Sync + Copy + 'static,
     {
         let mut rng = AesRng::new();
@@ -346,9 +344,10 @@ mod streaming {
             }
             f_gb(&mut gb, &gb_inp);
         });
-
-        let receiver = Rc::new(RefCell::new(receiver));
-        let mut ev = Evaluator::new(receiver);
+        let reader = BufReader::new(receiver.try_clone().unwrap());
+        let writer = BufWriter::new(receiver);
+        let channel = Channel::new(reader, writer);
+        let mut ev = Evaluator::new(channel);
         let ev_inp = input_mods
             .iter()
             .map(|q| ev.read_wire(*q).unwrap())
@@ -466,10 +465,8 @@ mod complex {
     use itertools::Itertools;
     use rand::thread_rng;
     use scuttlebutt::{AesRng, Channel};
-    use std::cell::RefCell;
     use std::io::{BufReader, BufWriter};
     use std::os::unix::net::UnixStream;
-    use std::rc::Rc;
 
     fn complex_gadget<F: Fancy>(b: &mut F, xs: &[CrtBundle<F::Item>]) {
         let zs = xs
@@ -525,9 +522,10 @@ mod complex {
                 }
                 complex_gadget(&mut garbler, &gb_inp);
             });
-
-            let receiver = Rc::new(RefCell::new(receiver));
-            let mut evaluator = Evaluator::new(receiver);
+            let reader = BufReader::new(receiver.try_clone().unwrap());
+            let writer = BufWriter::new(receiver);
+            let channel = Channel::new(reader, writer);
+            let mut evaluator = Evaluator::new(channel);
 
             // receive encoded wires from the garbler thread
             let mut ev_inp = Vec::with_capacity(N);
@@ -554,10 +552,8 @@ mod reuse {
     use itertools::Itertools;
     use rand::random;
     use scuttlebutt::{AbstractChannel, AesRng, Channel};
-    use std::cell::RefCell;
     use std::io::{BufReader, BufWriter};
     use std::os::unix::net::UnixStream;
-    use std::rc::Rc;
 
     #[test]
     fn reuse_wirelabels() {
@@ -600,16 +596,17 @@ mod reuse {
             // output the input wires from the previous garbler
             gb2.outputs(&gb_inps).unwrap();
         });
-
-        let receiver = Rc::new(RefCell::new(receiver));
-        let mut ev1 = Evaluator::new(receiver.clone());
+        let reader = BufReader::new(receiver.try_clone().unwrap());
+        let writer = BufWriter::new(receiver);
+        let channel = Channel::new(reader, writer);
+        let mut ev1 = Evaluator::new(channel.clone());
 
         let xs = mods
             .iter()
             .map(|q| ev1.read_wire(*q).unwrap())
             .collect_vec();
 
-        let mut ev2 = Evaluator::new(receiver);
+        let mut ev2 = Evaluator::new(channel);
         ev2.outputs(&xs).unwrap();
 
         let result = ev2.decode_output().unwrap();

src/garble/evaluator.rs

@@ -2,31 +2,24 @@ use crate::error::{EvaluatorError, FancyError};
 use crate::fancy::{Fancy, HasModulus};
 use crate::util::{output_tweak, tweak, tweak2};
 use crate::wire::Wire;
-use scuttlebutt::Block;
-use std::cell::RefCell;
-use std::fmt::Debug;
-use std::io::Read;
-use std::rc::Rc;
+use scuttlebutt::{AbstractChannel, Block};
 
 /// Streaming evaluator using a callback to receive ciphertexts as needed.
 ///
 /// Evaluates a garbled circuit on the fly, using messages containing ciphertexts and
 /// wires. Parallelizable.
-pub struct Evaluator<R> {
-    reader: Rc<RefCell<R>>,
+pub struct Evaluator<C> {
+    channel: C,
     current_gate: usize,
     pub(crate) output_cts: Vec<Vec<Block>>,
     pub(crate) output_wires: Vec<Wire>,
 }
 
-impl<R: Read + Debug> Evaluator<R> {
+impl<C: AbstractChannel> Evaluator<C> {
     /// Create a new `Evaluator`.
-    ///
-    /// `callback` enables streaming by producing messages during the `Fancy`
-    /// computation, which contain ciphertexts and wire-labels.
-    pub fn new(reader: Rc<RefCell<R>>) -> Self {
+    pub fn new(channel: C) -> Self {
         Evaluator {
-            reader,
+            channel,
             current_gate: 0,
             output_cts: Vec::new(),
             output_wires: Vec::new(),
@@ -69,23 +62,15 @@ impl<R: Read + Debug> Evaluator<R> {
         current
     }
 
-    /// Read a Block from the reader.
-    #[inline]
-    fn read_block(&mut self) -> Result<Block, EvaluatorError> {
-        let mut reader = self.reader.borrow_mut();
-        let b = Block::read(&mut *reader)?;
-        Ok(b)
-    }
-
     /// Read a Wire from the reader.
     #[inline]
     pub fn read_wire(&mut self, modulus: u16) -> Result<Wire, EvaluatorError> {
-        let block = self.read_block()?;
+        let block = self.channel.read_block()?;
         Ok(Wire::from_block(block, modulus))
     }
 }
 
-impl<R: Read + Debug> Fancy for Evaluator<R> {
+impl<C: AbstractChannel> Fancy for Evaluator<C> {
     type Item = Wire;
     type Error = EvaluatorError;
 
@@ -126,9 +111,8 @@ impl<R: Read + Debug> Fancy for Evaluator<R> {
         let ngates = q as usize + qb as usize - 2 + unequal as usize;
         let mut gate = Vec::with_capacity(ngates);
         {
-            let mut reader = self.reader.borrow_mut();
             for _ in 0..ngates {
-                let block = Block::read(&mut *reader)?;
+                let block = self.channel.read_block()?;
                 gate.push(block);
             }
         }
@@ -169,12 +153,9 @@ impl<R: Read + Debug> Fancy for Evaluator<R> {
     fn proj(&mut self, x: &Wire, q: u16, _: Option<Vec<u16>>) -> Result<Wire, EvaluatorError> {
         let ngates = (x.modulus() - 1) as usize;
         let mut gate = Vec::with_capacity(ngates);
-        {
-            let mut reader = self.reader.borrow_mut();
-            for _ in 0..ngates {
-                let block = Block::read(&mut *reader)?;
-                gate.push(block);
-            }
+        for _ in 0..ngates {
+            let block = self.channel.read_block()?;
+            gate.push(block);
         }
         let t = tweak(self.current_gate());
         if x.color() == 0 {
@@ -188,10 +169,9 @@ impl<R: Read + Debug> Fancy for Evaluator<R> {
     #[inline]
     fn output(&mut self, x: &Wire) -> Result<(), EvaluatorError> {
         let noutputs = x.modulus() as usize;
-        let mut reader = self.reader.borrow_mut();
         let mut blocks = Vec::with_capacity(noutputs);
         for _ in 0..noutputs {
-            let block = Block::read(&mut *reader)?;
+            let block = self.channel.read_block()?;
             blocks.push(block);
         }
         self.output_cts.push(blocks);

src/static.rs

@@ -15,7 +15,6 @@ use crate::wire::Wire;
 use itertools::Itertools;
 use scuttlebutt::{AbstractChannel, AesRng, Block, Channel};
 use serde::{Deserialize, Serialize};
-use std::cell::RefCell;
 use std::collections::HashMap;
 use std::convert::TryInto;
 use std::rc::Rc;
@@ -47,7 +46,8 @@ impl GarbledCircuit {
         garbler_inputs: &[Wire],
         evaluator_inputs: &[Wire],
     ) -> Result<Vec<u16>, EvaluatorError> {
-        let mut evaluator = Evaluator::new(Rc::new(RefCell::new(GarbledReader::new(&self.blocks))));
+        let channel = Channel::new(GarbledReader::new(&self.blocks), GarbledWriter::new(None));
+        let mut evaluator = Evaluator::new(channel);
         let outputs = c.eval(&mut evaluator, garbler_inputs, evaluator_inputs)?;
         c.process_outputs(&outputs, &mut evaluator)?;
         evaluator.decode_output()