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 send_wire( &mut self, wire: &Wire, channel: &mut Channel<'_>, ) -> Result<()>

Send a wire over the established channel.

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

Encode a wire, producing the zero wire as well as the encoded value.

pub fn encode_many_wires( &mut self, vals: &[u16], moduli: &[u16], ) -> (Vec<Wire>, Vec<Wire>)

Encode many wires, producing zero wires as well as encoded values.

Panics

Panics if the length of vals and moduli are not equal.

pub fn crt_encode_wire( &mut self, val: u128, modulus: u128, ) -> (CrtBundle<Wire>, CrtBundle<Wire>)

Encode a CrtBundle, producing zero wires as well as encoded values.

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

Encode a BinaryBundle, producing zero wires as well as encoded values.

Trait Implementations

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

type Item = Wire

The underlying wire datatype created by an object implementing Fancy.

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

Create a constant x with modulus q.

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

Process this wire as output. Some Fancy implementers don’t actually return output, but they need to be involved in the process, so they can return None.

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

Output a slice of wires.

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 times the constant c.

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

Multiply x and y.

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.

fn add_many(&mut self, args: &[Self::Item]) -> Self::Item

Sum up a slice of wires.

fn mod_change( &mut self, x: &Self::Item, to_modulus: u16, channel: &mut Channel<'_>, ) -> Result<Self::Item>

Change the modulus of x to to_modulus using a projection gate.

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>

Uses Demorgan’s Rule implemented with an and gate and negation.

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

Binary adder. Returns the result and the carry.

fn and_many( &mut self, args: &[Self::Item], channel: &mut Channel<'_>, ) -> Result<Self::Item>

Returns 1 if all wires equal 1.

fn or_many( &mut self, args: &[Self::Item], channel: &mut Channel<'_>, ) -> Result<Self::Item>

Returns 1 if any wire equals 1.

fn xor_many(&mut self, args: &[Self::Item]) -> Self::Item

XOR many wires together.

fn mux_constant_bits( &mut self, x: &Self::Item, b1: bool, b2: bool, channel: &mut Channel<'_>, ) -> Result<Self::Item>

If x = 0 returns the constant b1 else return b2. Folds constants if possible.

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

If b = 0 returns x else y.

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>

Uses Demorgan’s Rule implemented with an and gate and negation.

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

Binary adder. Returns the result and the carry.

fn and_many( &mut self, args: &[Self::Item], channel: &mut Channel<'_>, ) -> Result<Self::Item>

Returns 1 if all wires equal 1.

fn or_many( &mut self, args: &[Self::Item], channel: &mut Channel<'_>, ) -> Result<Self::Item>

Returns 1 if any wire equals 1.

fn xor_many(&mut self, args: &[Self::Item]) -> Self::Item

XOR many wires together.

fn mux_constant_bits( &mut self, x: &Self::Item, b1: bool, b2: bool, channel: &mut Channel<'_>, ) -> Result<Self::Item>

If x = 0 returns the constant b1 else return b2. Folds constants if possible.

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

If b = 0 returns x else y.

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

type Item = Wire

The type that this Fancy object operates over.

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

Encode many values where the actual input is known.

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

Receive many values where the input is not known.

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

Encode a single value.

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

Receive a single value.

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

Encode a bundle.

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

Receive a bundle.

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

Encode many input bundles.

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

Receive many input bundles.

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

Encode a CRT input bundle.

fn crt_receive( &mut self, modulus: u128, channel: &mut Channel<'_>, ) -> Result<CrtBundle<Self::Item>>

Receive an CRT input bundle.

fn crt_encode_many( &mut self, values: &[u128], modulus: u128, channel: &mut Channel<'_>, ) -> Result<Vec<CrtBundle<Self::Item>>>

Encode many CRT input bundles.

fn crt_receive_many( &mut self, n: usize, modulus: u128, channel: &mut Channel<'_>, ) -> Result<Vec<CrtBundle<Self::Item>>>

Receive many CRT input bundles.

fn bin_encode( &mut self, value: u128, nbits: usize, channel: &mut Channel<'_>, ) -> Result<BinaryBundle<Self::Item>>

Encode a binary input bundle.

fn bin_receive( &mut self, nbits: usize, channel: &mut Channel<'_>, ) -> Result<BinaryBundle<Self::Item>>

Receive an binary input bundle.

fn bin_encode_many( &mut self, values: &[u128], nbits: usize, channel: &mut Channel<'_>, ) -> Result<Vec<BinaryBundle<Self::Item>>>

Encode many binary input bundles.

fn bin_receive_many( &mut self, ninputs: usize, nbits: usize, channel: &mut Channel<'_>, ) -> Result<Vec<BinaryBundle<Self::Item>>>

Receive many binary input bundles.

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

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

Reveal the contents of x to all parties.

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

Reveal a slice of items to all parties.

fn reveal_bundle( &mut self, x: &Bundle<Self::Item>, channel: &mut Channel<'_>, ) -> Result<Vec<u16>>

Reveal a bundle to all parties.

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

Reveal many bundles to all parties.

fn crt_reveal( &mut self, x: &CrtBundle<Self::Item>, channel: &mut Channel<'_>, ) -> Result<u128>

Reveal a CRT bundle to all parties.

fn crt_reveal_many( &mut self, xs: &[CrtBundle<Self::Item>], channel: &mut Channel<'_>, ) -> Result<Vec<u128>>

Reveal many CRT bundles to all parties.

fn bin_reveal( &mut self, x: &BinaryBundle<Self::Item>, channel: &mut Channel<'_>, ) -> Result<u128>

Reveal a binary bundle to all parties.

fn bin_reveal_many( &mut self, xs: &[BinaryBundle<Self::Item>], channel: &mut Channel<'_>, ) -> Result<Vec<u128>>

Reveal many binary bundles to all parties.