Struct fancy_garbling::Garbler

pub struct Garbler<C, RNG> { /* fields omitted */ }

Streams garbled circuit ciphertexts through a callback. Parallelizable.

Methods

impl<C: AbstractChannel, RNG: CryptoRng + RngCore> Garbler<C, RNG>

pub fn new(channel: C, rng: RNG, reused_deltas: &[Wire]) -> 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) -> Result<(), GarblerError>

Send a wire using the Sender.

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]
) -> Result<(Vec<Wire>, Vec<Wire>), GarblerError>

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

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

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

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

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

Trait Implementations

impl<C: AbstractChannel, RNG: CryptoRng + RngCore> Fancy for Garbler<C, RNG>

type Item = Wire

The underlying wire datatype created by an object implementing Fancy.

type Error = GarblerError

Errors which may be thrown by the users of Fancy.

fn constant(&mut self, x: u16, q: u16) -> Result<Wire, GarblerError>

Create a constant x with modulus q.

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

Add x and y.

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

Subtract x and y.

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

Multiply x times the constant c.

fn mul(&mut self, A: &Wire, B: &Wire) -> Result<Wire, GarblerError>

Multiply x and y.

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

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

fn output(&mut self, X: &Wire) -> Result<(), GarblerError>

Process this wire as output.

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

Sum up a slice of wires.

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

Xor is just addition, with the requirement that x and y are mod 2.

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

Negate by xoring x with 1.

fn and(
    &mut self,
    x: &Self::Item,
    y: &Self::Item
) -> Result<Self::Item, Self::Error>

And is just multiplication, with the requirement that x and y are mod 2.

fn or(
    &mut self,
    x: &Self::Item,
    y: &Self::Item
) -> Result<Self::Item, Self::Error>

Or uses Demorgan's Rule implemented with multiplication and negation.

fn and_many(&mut self, args: &[Self::Item]) -> Result<Self::Item, Self::Error>

Returns 1 if all wires equal 1.

fn or_many(&mut self, args: &[Self::Item]) -> Result<Self::Item, Self::Error>

Returns 1 if any wire equals 1.

fn mod_change(
    &mut self,
    x: &Self::Item,
    to_modulus: u16
) -> Result<Self::Item, Self::Error>

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

fn adder(
    &mut self,
    x: &Self::Item,
    y: &Self::Item,
    carry_in: Option<&Self::Item>
) -> Result<(Self::Item, Self::Item), Self::Error>

Binary adder. Returns the result and the carry.

fn mux(
    &mut self,
    b: &Self::Item,
    x: &Self::Item,
    y: &Self::Item
) -> Result<Self::Item, Self::Error>

If b = 0 returns x else y.

fn mux_constant_bits(
    &mut self,
    x: &Self::Item,
    b1: bool,
    b2: bool
) -> Result<Self::Item, Self::Error>

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

fn outputs(&mut self, xs: &[Self::Item]) -> Result<(), Self::Error>

Output a slice of wires.