Struct seec::circuit::base_circuit::BaseCircuit

pub struct BaseCircuit<Plain = bool, Gate = BooleanGate, Idx = u32, Wire = ()> { /* private fields */ }

Implementations

impl<P, G: Gate<P>, Idx: GateIdx, W: Wire> BaseCircuit<P, G, Idx, W>

pub fn new() -> Self

pub fn new_main() -> Self

pub fn with_capacity(gates: usize, wires: usize) -> Self

pub fn add_gate(&mut self, gate: G) -> GateId<Idx>

pub fn add_sc_input_gate(&mut self, gate: G) -> GateId<Idx>

pub fn get_gate(&self, id: impl Into<GateId<Idx>>) -> G

pub fn parent_gates( &self, id: impl Into<GateId<Idx>> ) -> impl Iterator<Item = GateId<Idx>> + '_

pub fn gate_count(&self) -> usize

pub fn wire_count(&self) -> usize

pub fn save_dot(&self, path: impl AsRef<Path>) -> Result<(), CircuitError>

pub fn as_graph(&self) -> &Graph<G, W, Directed, Idx>

pub fn interactive_iter(&self) -> impl Iterator<Item = (G, GateId<Idx>)> + '_

pub fn iter(&self) -> impl Iterator<Item = (G, GateId<Idx>)> + '_

impl<P, G: Gate<P>, Idx: GateIdx> BaseCircuit<P, G, Idx, ()>

pub fn add_wire(&mut self, from: GateId<Idx>, to: GateId<Idx>)

pub fn add_wired_gate(&mut self, gate: G, from: &[GateId<Idx>]) -> GateId<Idx>

pub fn add_sub_circuit( &mut self, circuit: &Self, inputs: impl IntoIterator<Item = GateId<Idx>> ) -> Vec<GateId<Idx>>

Adds another SubCircuit into self. The gates and wires of circuit are added to self and the inputs gates in self are connected to the BaseCircuit::sub_circuit_input_gates of the provided circuit.

Examples found in repository

crates/seec/examples/aes_cbc.rs (line 458)

fn aes128(
    key: &[Secret<BooleanGmw, usize>],
    chunk: &[Secret<BooleanGmw, usize>],
    use_sc: bool,
) -> Vec<Secret<BooleanGmw, usize>> {
    static AES_CIRC: Lazy<SharedCircuit<bool, BooleanGate, usize>> = Lazy::new(|| {
        let aes_circ_str = include_str!("../test_resources/bristol-circuits/aes_128.bristol");
        BaseCircuit::from_bristol(
            seec::bristol::circuit(aes_circ_str).expect("parsing AES circuit failed"),
            Load::SubCircuit,
        )
        .expect("converting AES circuit failed")
        .into_shared()
    });

    let inp = [chunk, key].concat();

    if use_sc {
        let (output, circ_id) = CircuitBuilder::with_global(|builder| {
            let circ_id = builder.push_circuit(AES_CIRC.clone());
            (builder.connect_sub_circuit(&inp, circ_id), circ_id)
        });
        output.connect_to_main(circ_id)
    } else {
        CircuitBuilder::with_global(|builder| {
            let inp = inp.into_iter().map(|sh| {
                assert_eq!(0, sh.circuit_id());
                sh.gate_id()
            });
            let out = builder
                .get_main_circuit()
                .lock()
                .add_sub_circuit(&AES_CIRC.lock(), inp);
            out.into_iter()
                .map(|gate_id| Secret::from_parts(0, gate_id))
                .collect()
        })
    }
}

impl<P, G, Idx, W> BaseCircuit<P, G, Idx, W>

pub fn is_simd(&self) -> bool

pub fn simd_size(&self) -> Option<NonZeroUsize>

pub fn interactive_count(&self) -> usize

pub fn input_count(&self) -> usize

pub fn input_gates(&self) -> &[GateId<Idx>]

pub fn sub_circuit_input_gates(&self) -> &[GateId<Idx>]

pub fn sub_circuit_input_count(&self) -> usize

Examples found in repository

crates/seec/examples/bristol.rs (line 120)

fn compile(compile_args: CompileArgs) -> Result<()> {
    let load = match compile_args.simd {
        Some(_) => Load::SubCircuit,
        None => Load::Circuit,
    };
    let mut bc: BaseCircuit = BaseCircuit::load_bristol(&compile_args.circuit, load)
        .expect("failed to load bristol circuit");

    let mut circ = match compile_args.simd {
        Some(size) => {
            bc.set_simd_size(size);
            let circ_input_size = bc.sub_circuit_input_count();
            let inputs = inputs::<u32>(circ_input_size);
            let bc = bc.into_shared();

            let (output, circ_id) = CircuitBuilder::with_global(|builder| {
                builder.get_main_circuit().lock().set_simd_size(size);
                let circ_id = builder.push_circuit(bc);
                let output = builder.connect_sub_circuit(&inputs, circ_id);
                (output, circ_id)
            });
            let main = output.connect_to_main(circ_id);
            main.iter().for_each(|s| {
                s.output();
            });
            let circ = CircuitBuilder::global_into_circuit();
            ExecutableCircuit::DynLayers(circ)
        }
        None => ExecutableCircuit::DynLayers(bc.into()),
    };
    if !compile_args.dyn_layers {
        circ = circ.precompute_layers();
    }
    let out =
        BufWriter::new(File::create(&compile_args.output).context("failed to create output file")?);
    bincode::serialize_into(out, &circ).context("failed to serialize circuit")?;
    Ok(())
}

pub fn output_count(&self) -> usize

pub fn output_gates(&self) -> &[GateId<Idx>]

pub fn sub_circuit_output_gates(&self) -> &[GateId<Idx>]

pub fn into_shared(self) -> SharedCircuit<P, G, Idx, W>

Examples found in repository

crates/seec/examples/aes_cbc.rs (line 438)

    static AES_CIRC: Lazy<SharedCircuit<bool, BooleanGate, usize>> = Lazy::new(|| {
        let aes_circ_str = include_str!("../test_resources/bristol-circuits/aes_128.bristol");
        BaseCircuit::from_bristol(
            seec::bristol::circuit(aes_circ_str).expect("parsing AES circuit failed"),
            Load::SubCircuit,
        )
        .expect("converting AES circuit failed")
        .into_shared()
    });

crates/seec/examples/bristol.rs (line 122)

fn compile(compile_args: CompileArgs) -> Result<()> {
    let load = match compile_args.simd {
        Some(_) => Load::SubCircuit,
        None => Load::Circuit,
    };
    let mut bc: BaseCircuit = BaseCircuit::load_bristol(&compile_args.circuit, load)
        .expect("failed to load bristol circuit");

    let mut circ = match compile_args.simd {
        Some(size) => {
            bc.set_simd_size(size);
            let circ_input_size = bc.sub_circuit_input_count();
            let inputs = inputs::<u32>(circ_input_size);
            let bc = bc.into_shared();

            let (output, circ_id) = CircuitBuilder::with_global(|builder| {
                builder.get_main_circuit().lock().set_simd_size(size);
                let circ_id = builder.push_circuit(bc);
                let output = builder.connect_sub_circuit(&inputs, circ_id);
                (output, circ_id)
            });
            let main = output.connect_to_main(circ_id);
            main.iter().for_each(|s| {
                s.output();
            });
            let circ = CircuitBuilder::global_into_circuit();
            ExecutableCircuit::DynLayers(circ)
        }
        None => ExecutableCircuit::DynLayers(bc.into()),
    };
    if !compile_args.dyn_layers {
        circ = circ.precompute_layers();
    }
    let out =
        BufWriter::new(File::create(&compile_args.output).context("failed to create output file")?);
    bincode::serialize_into(out, &circ).context("failed to serialize circuit")?;
    Ok(())
}

pub fn set_simd_size(&mut self, size: NonZeroUsize)

Examples found in repository

crates/seec/examples/bristol.rs (line 119)

fn compile(compile_args: CompileArgs) -> Result<()> {
    let load = match compile_args.simd {
        Some(_) => Load::SubCircuit,
        None => Load::Circuit,
    };
    let mut bc: BaseCircuit = BaseCircuit::load_bristol(&compile_args.circuit, load)
        .expect("failed to load bristol circuit");

    let mut circ = match compile_args.simd {
        Some(size) => {
            bc.set_simd_size(size);
            let circ_input_size = bc.sub_circuit_input_count();
            let inputs = inputs::<u32>(circ_input_size);
            let bc = bc.into_shared();

            let (output, circ_id) = CircuitBuilder::with_global(|builder| {
                builder.get_main_circuit().lock().set_simd_size(size);
                let circ_id = builder.push_circuit(bc);
                let output = builder.connect_sub_circuit(&inputs, circ_id);
                (output, circ_id)
            });
            let main = output.connect_to_main(circ_id);
            main.iter().for_each(|s| {
                s.output();
            });
            let circ = CircuitBuilder::global_into_circuit();
            ExecutableCircuit::DynLayers(circ)
        }
        None => ExecutableCircuit::DynLayers(bc.into()),
    };
    if !compile_args.dyn_layers {
        circ = circ.precompute_layers();
    }
    let out =
        BufWriter::new(File::create(&compile_args.output).context("failed to create output file")?);
    bincode::serialize_into(out, &circ).context("failed to serialize circuit")?;
    Ok(())
}

impl<P, G, Idx: GateIdx> BaseCircuit<P, G, Idx>

where P: Clone, G: Gate<P> + From<BaseGate<P>> + for<'a> From<&'a Gate>,

pub fn from_bristol(bristol: Circuit, load: Load) -> Result<Self, CircuitError>

Examples found in repository

crates/seec/examples/aes_cbc.rs (lines 433-436)

    static AES_CIRC: Lazy<SharedCircuit<bool, BooleanGate, usize>> = Lazy::new(|| {
        let aes_circ_str = include_str!("../test_resources/bristol-circuits/aes_128.bristol");
        BaseCircuit::from_bristol(
            seec::bristol::circuit(aes_circ_str).expect("parsing AES circuit failed"),
            Load::SubCircuit,
        )
        .expect("converting AES circuit failed")
        .into_shared()
    });

pub fn load_bristol( path: impl AsRef<Path>, load: Load ) -> Result<Self, CircuitError>

Examples found in repository

crates/seec/examples/bristol.rs (line 114)

fn compile(compile_args: CompileArgs) -> Result<()> {
    let load = match compile_args.simd {
        Some(_) => Load::SubCircuit,
        None => Load::Circuit,
    };
    let mut bc: BaseCircuit = BaseCircuit::load_bristol(&compile_args.circuit, load)
        .expect("failed to load bristol circuit");

    let mut circ = match compile_args.simd {
        Some(size) => {
            bc.set_simd_size(size);
            let circ_input_size = bc.sub_circuit_input_count();
            let inputs = inputs::<u32>(circ_input_size);
            let bc = bc.into_shared();

            let (output, circ_id) = CircuitBuilder::with_global(|builder| {
                builder.get_main_circuit().lock().set_simd_size(size);
                let circ_id = builder.push_circuit(bc);
                let output = builder.connect_sub_circuit(&inputs, circ_id);
                (output, circ_id)
            });
            let main = output.connect_to_main(circ_id);
            main.iter().for_each(|s| {
                s.output();
            });
            let circ = CircuitBuilder::global_into_circuit();
            ExecutableCircuit::DynLayers(circ)
        }
        None => ExecutableCircuit::DynLayers(bc.into()),
    };
    if !compile_args.dyn_layers {
        circ = circ.precompute_layers();
    }
    let out =
        BufWriter::new(File::create(&compile_args.output).context("failed to create output file")?);
    bincode::serialize_into(out, &circ).context("failed to serialize circuit")?;
    Ok(())
}

impl ProgArgs {
    fn log(&self) -> Option<&PathBuf> {
        match self {
            ProgArgs::Compile(args) => args.log.as_ref(),
            ProgArgs::Execute(args) => args.log.as_ref(),
        }
    }
}

async fn execute(execute_args: ExecuteArgs) -> Result<()> {
    let circ_name = execute_args
        .circuit
        .file_stem()
        .unwrap()
        .to_string_lossy()
        .to_string();
    let circuit = load_circ(&execute_args).context("failed to load circuit")?;

    let create_party = |id, circ| {
        let mut party = BenchParty::<BooleanGmw, u32>::new(id)
            .explicit_circuit(circ)
            .repeat(execute_args.repeat)
            .insecure_setup(execute_args.insecure_setup)
            .interleave_setup(execute_args.interleave_setup)
            .metadata(circ_name.clone());
        if let Some(domain) = &execute_args.domain {
            party = party.tls_domain(domain.clone());
        }
        match (&execute_args.cert, &execute_args.cert_pk) {
            (Some(cert), Some(pk)) => {
                party = party.tls_config(ServerTlsConfig {
                    private_key_file: pk.clone(),
                    certificate_chain_file: cert.clone(),
                });
            }
            (Some(_), None) | (None, Some(_)) => {
                anyhow::bail!("Must provide both --cert and --cert-pk or neither")
            }
            _ => {}
        }
        if let Some(path) = &execute_args.stored_mts {
            party = party.stored_mts(path);
        }
        if let Some(server) = execute_args.server {
            party = party.server(server)
        }
        Ok(party)
    };

    let results = if let Some(id) = execute_args.id {
        let party = create_party(id, circuit)?;
        party.bench().await.context("Failed to run benchmark")?
    } else {
        let party0 = create_party(0, circuit.clone())?;
        let party1 = create_party(1, circuit)?;
        let bench0 = tokio::spawn(party0.bench());
        let bench1 = tokio::spawn(party1.bench());
        let (res0, _res1) = tokio::try_join!(bench0, bench1).context("Failed to join parties")?;
        res0.context("Failed to run benchmark")?
    };

    // Depending on whether a --stats file is set, create a file writer or stdout
    let mut writer: Box<dyn Write> = match execute_args.stats {
        Some(path) => {
            let file = File::create(path)?;
            Box::new(file)
        }
        None => Box::new(stdout()),
    };
    // serde_json is used to write the statistics in json format. `.csv` is currently not
    // supported.
    serde_json::to_writer_pretty(&mut writer, &results)?;
    writeln!(writer)?;

    Ok(())
}

fn load_circ(args: &ExecuteArgs) -> Result<ExecutableCircuit<bool, BooleanGate, u32>> {
    let res = bincode::deserialize_from(BufReader::new(
        File::open(&args.circuit).context("Failed to open circuit file")?,
    ));
    match res {
        Ok(circ) => Ok(circ),
        Err(_) => {
            // try to load as bristol
            Ok(ExecutableCircuit::DynLayers(
                BaseCircuit::load_bristol(&args.circuit, Load::Circuit)
                    .context("Circuit is neither .seec file or bristol")?
                    .into(),
            )
            .precompute_layers())
        }
    }
}

crates/seec/examples/sha256.rs (line 57)

async fn main() -> Result<()> {
    let _guard = init_tracing()?;
    let args = Args::parse();
    let circuit: ExecutableCircuit<bool, BooleanGate, u32> = ExecutableCircuit::DynLayers(
        BaseCircuit::load_bristol(args.circuit, Load::Circuit)?.into(),
    );

    let (mut sender, bytes_written, mut receiver, bytes_read) = match args.id {
        0 => seec_channel::tcp::listen(args.server).await?,
        1 => seec_channel::tcp::connect(args.server).await?,
        illegal => anyhow::bail!("Illegal party id {illegal}. Must be 0 or 1."),
    };

    // Initialize the communication statistics tracker with the counters for the main channel
    let mut comm_stats = Statistics::new(bytes_written, bytes_read).without_unaccounted(true);

    let (mut sender, mut receiver) =
        sub_channels_for!(&mut sender, &mut receiver, 8, Message<BooleanGmw>).await?;

    let mut executor: Executor<BooleanGmw, _> = if let Some(addr) = args.mt_provider {
        let (mt_sender, bytes_written, mt_receiver, bytes_read) =
            seec_channel::tcp::connect(addr).await?;
        // Set the counters for the helper channel
        comm_stats.set_helper(bytes_written, bytes_read);
        let mt_provider = TrustedMTProviderClient::new("unique-id".into(), mt_sender, mt_receiver);
        // As the MTs are generated when the Executor is created, we record the communication
        // with the `record_helper` method and a custom category
        comm_stats
            .record_helper(
                Phase::Custom("Helper-Mts".into()),
                Executor::new(&circuit, args.id, mt_provider),
            )
            .await?
    } else {
        let mt_provider = InsecureMTProvider::default();
        comm_stats
            .record(
                Phase::FunctionDependentSetup,
                Executor::new(&circuit, args.id, mt_provider),
            )
            .await?
    };
    let input = BitVec::repeat(false, 768);
    let _out = comm_stats
        .record(
            Phase::Online,
            executor.execute(Input::Scalar(input), &mut sender, &mut receiver),
        )
        .await?;

    // Depending on whether a --stats file is set, create a file writer or stdout
    let mut writer: Box<dyn Write> = match args.stats {
        Some(path) => {
            let file = File::create(path)?;
            Box::new(file)
        }
        None => Box::new(stdout()),
    };
    // serde_json is used to write the statistics in json format. `.csv` is currently not
    // supported.
    let mut res = comm_stats.into_run_result();
    res.add_metadata("circuit", "sha256.rs");
    serde_json::to_writer_pretty(&mut writer, &res)?;
    writeln!(writer)?;

    Ok(())
}

Trait Implementations

impl<P: Clone, G: Clone, Idx: GateIdx, W: Clone> Clone for BaseCircuit<P, G, Idx, W>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<P, G, Idx, W> Debug for BaseCircuit<P, G, Idx, W>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<P, G: Gate<P>, Idx: GateIdx> Default for BaseCircuit<P, G, Idx>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, Plain, Gate, Idx, Wire> Deserialize<'de> for BaseCircuit<Plain, Gate, Idx, Wire>

where Gate: Serialize + DeserializeOwned, Idx: GateIdx + Serialize + DeserializeOwned, Wire: Serialize + DeserializeOwned,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<P, G, Idx: GateIdx + Default, W> From<BaseCircuit<P, G, Idx, W>> for Circuit<P, G, Idx, W>

fn from(bc: BaseCircuit<P, G, Idx, W>) -> Self

Converts to this type from the input type.

impl<P, G: Gate<P>, Idx: GateIdx, W: Wire> LayerIterable for BaseCircuit<P, G, Idx, W>

type Layer = CircuitLayer<G, Idx>

type LayerIter<'this> = BaseLayerIter<'this, P, G, Idx, W> where Self: 'this

fn layer_iter(&self) -> Self::LayerIter<'_>

impl<Plain, Gate, Idx, Wire> Serialize for BaseCircuit<Plain, Gate, Idx, Wire>

where Gate: Serialize + DeserializeOwned, Idx: GateIdx + Serialize + DeserializeOwned, Wire: Serialize + DeserializeOwned,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.