Struct Garbler 

pub struct Garbler<RNG, Wire> { /* private fields */ }

Streams garbled circuit ciphertexts through a callback.

Implementations

impl<RNG: CryptoRng + RngCore, Wire: WireLabel + DeserializeOwned> Garbler<RNG, Wire>

pub fn load_deltas(&mut self, filename: &str) -> Result<(), Box<dyn Error>>

Load pre-chosen deltas from a file

impl<RNG: CryptoRng + RngCore, Wire: WireLabel> Garbler<RNG, Wire>

pub fn new(rng: RNG, channel: &mut Channel<'_>) -> Result<Self>

Create a new Garbler.

pub fn delta(&mut self, q: u16) -> Wire

Create a delta if it has not been created yet for this modulus, otherwise just return the existing one.

pub fn get_deltas(self) -> HashMap<u16, Wire>

Get the deltas, consuming the Garbler.

This is useful for reusing wires in multiple garbled circuit instances.

pub fn encode_zero(&mut self, modulus: u16) -> Wire

Output a fresh zero wirelabel associated with the provided modulus.

pub fn bin_encode_zero(&mut self, nbits: usize) -> BinaryBundle<Wire>

Output fresh zero wirelabels associated with a BinaryBundle.

Trait Implementations

impl<RNG: RngCore + CryptoRng, Wire: WireLabel> Fancy for Garbler<RNG, Wire>

type Item = Wire

The underlying wire representation of this Fancy object.

fn constant( &mut self, x: u16, q: u16, channel: &mut Channel<'_>, ) -> Result<Wire>

Encode a constant x with modulus q.

impl<RNG: RngCore + CryptoRng, Wire: WireLabel + ArithmeticWire> FancyArithmetic for Garbler<RNG, Wire>

fn add(&mut self, x: &Wire, y: &Wire) -> Wire

Add x and y.

fn sub(&mut self, x: &Wire, y: &Wire) -> Wire

Subtract x and y.

fn cmul(&mut self, x: &Wire, c: u16) -> Wire

Multiply x with the constant c.

fn mul(&mut self, A: &Wire, B: &Wire, channel: &mut Channel<'_>) -> Result<Wire>

Multiply x and y.

impl<RNG: RngCore + CryptoRng> FancyBinary for Garbler<RNG, AllWire>

fn negate(&mut self, x: &Self::Item) -> Self::Item

We can negate by having garbler xor wire with Delta

Since we treat all garbler wires as zero, xoring with delta conceptually negates the value of the wire

fn xor(&mut self, x: &Self::Item, y: &Self::Item) -> Self::Item

Xor is just addition

fn and( &mut self, x: &Self::Item, y: &Self::Item, channel: &mut Channel<'_>, ) -> Result<Self::Item>

Use binary and_gate

fn or( &mut self, x: &Self::Item, y: &Self::Item, channel: &mut Channel<'_>, ) -> Result<Self::Item>

Binary OR.

impl<RNG: RngCore + CryptoRng, W: BinaryWireLabel> FancyBinary for Garbler<RNG, W>

fn negate(&mut self, x: &Self::Item) -> Self::Item

We can negate by having garbler xor wire with Delta

Since we treat all garbler wires as zero, xoring with delta conceptually negates the value of the wire

fn and( &mut self, A: &Self::Item, B: &Self::Item, channel: &mut Channel<'_>, ) -> Result<Self::Item>

Binary AND.

fn xor(&mut self, x: &Self::Item, y: &Self::Item) -> Self::Item

Binary XOR.

fn or( &mut self, x: &Self::Item, y: &Self::Item, channel: &mut Channel<'_>, ) -> Result<Self::Item>

Binary OR.

impl<RNG: RngCore + CryptoRng, Wire: WireLabel> FancyEncode for Garbler<RNG, Wire>

fn encode_many( &mut self, values: &[u16], moduli: &[u16], channel: &mut Channel<'_>, ) -> Result<Vec<Self::Item>>

Encode many wires for known values.

fn receive_many( &mut self, _moduli: &[u16], _: &mut Channel<'_>, ) -> Result<Vec<Self::Item>>

Receive many wires for unknown values.

fn encode( &mut self, value: u16, modulus: u16, channel: &mut Channel<'_>, ) -> Result<Self::Item>

Encode a wire for a known value.

fn receive( &mut self, modulus: u16, channel: &mut Channel<'_>, ) -> Result<Self::Item>

Receive a wire for an unknown value.

impl<RNG: RngCore + CryptoRng, Wire: WireLabel> FancyOutput for Garbler<RNG, Wire>

fn output(&mut self, X: &Wire, channel: &mut Channel<'_>) -> Result<Option<u16>>

Output the value associated with wire x.

fn outputs( &mut self, xs: &[Self::Item], channel: &mut Channel<'_>, ) -> Result<Option<Vec<u16>>>

Output the values associated with a slice of wires.

impl<RNG: RngCore + CryptoRng, Wire: WireLabel + ArithmeticWire> FancyProj for Garbler<RNG, Wire>

fn proj( &mut self, A: &Wire, q_out: u16, tt: Option<Vec<u16>>, channel: &mut Channel<'_>, ) -> Result<Wire>

Project x according to the truth table tt. Resulting wire has modulus q.