Struct seec::secret::Secret

pub struct Secret<P = BooleanGmw, Idx = DefaultIdx> { /* private fields */ }

Implementations

impl<P, Idx: GateIdx> Secret<P, Idx>

pub fn from_parts(circuit_id: CircuitId, output_of: GateId<Idx>) -> Self

Create a Secret from raw parts. This method should not be needed in most cases. The user needs to ensure that the global CircuitBuilder has a circuit and gate with the corresponding id’s.

Examples found in repository

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

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<Idx: GateIdx> Secret<BooleanGmw, Idx>

pub fn from_const(circuit_id: CircuitId, constant: bool) -> Self

Note: Do not use while holding mutable borrow of self.circuit as it will panic!

Examples found in repository

crates/seec/examples/privmail_sc.rs (line 168)

fn or_sc(input: &[Secret]) -> Secret {
    low_depth_reduce(input.to_owned(), ops::BitOr::bitor)
        .unwrap_or_else(|| Secret::from_const(0, false))
}

crates/seec/examples/privmail.rs (line 94)

fn priv_mail_search(
    search_queries: &[SearchQueryKeywords],
    modifier_chain_share: &str,
    mails: &[Mail],
    duplication_factor: usize,
) -> (BitVec<usize>, Vec<GateId>) {
    debug!(%modifier_chain_share);
    let (mut input, modifier_chain_input) = base64_string_to_input(modifier_chain_share, 1);
    let modifier_chain_share_input: Vec<_> = modifier_chain_input.into_iter().flatten().collect();

    // Decode and initialize the search keywords
    let search_keywords: Vec<_> = search_queries
        .iter()
        .map(|search_query| {
            debug!(keyword = %search_query.keyword_truncated);
            let (query_input, shares) = base64_string_to_input(&search_query.keyword_truncated, 1);
            input.extend_from_bitslice(&query_input);
            shares
        })
        .collect();
    assert!(modifier_chain_share_input.len() >= 2 * search_keywords.len() - 1);

    // Decode and initialize the target text
    let target_texts: Vec<_> = mails
        .iter()
        .map(|mail| {
            debug!(target_text = %mail.secret_share_truncated_block);
            let (mail_input, shares) =
                base64_string_to_input(&mail.secret_share_truncated_block, duplication_factor);
            input.extend_from_bitslice(&mail_input);
            shares
        })
        .collect();

    // Search with the keywords over the target texts
    let mut search_results = Vec::with_capacity(target_texts.len());
    for (j, keyword) in search_keywords.iter().enumerate() {
        for (i, target_text) in target_texts.iter().enumerate() {
            let mut search_result_per_mail = Secret::from_const(0, false);
            if keyword.len() <= target_text.len() {
                search_result_per_mail = create_search_circuit(keyword, target_text);
            }
            if j == 0 {
                search_results.push(search_result_per_mail ^ &modifier_chain_share_input[0]);
            } else {
                search_results[i] = create_chaining_circuit(
                    &search_results[i],
                    &search_result_per_mail,
                    &modifier_chain_share_input[2 * j - 1],
                    &modifier_chain_share_input[2 * j],
                );
            }
        }
    }
    let out_ids = search_results
        .into_iter()
        .map(Secret::into_output)
        .collect();
    (input, out_ids)
}

pub fn input(circuit_id: CircuitId) -> Self

pub fn sub_circuit_input(circuit_id: CircuitId, gate: BooleanGate) -> Self

pub fn sub_circuit_output(&self) -> Self

pub fn output(&self) -> GateId<Idx>

Constructs a Gate::Output in the circuit with this secret’s value

Examples found in repository

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

fn aes_cbc_chunk(
    key: &[Secret<BooleanGmw, usize>],
    chunk: &[Secret<BooleanGmw, usize>],
    chaining_state: &mut [Secret<BooleanGmw, usize>],
    use_sc: bool,
) {
    let inp: Vec<_> = chunk
        .iter()
        .zip(chaining_state.iter())
        .map(|(d, c)| d.clone() ^ c)
        .collect();
    let output = aes128(key, &inp, use_sc);
    chaining_state.clone_from_slice(&output);
    for sh in output {
        sh.output();
    }
}

crates/seec/examples/sub_circuits.rs (line 38)

fn main() {
    tracing_subscriber::fmt()
        .with_env_filter(EnvFilter::from_default_env())
        .init();

    let input_shares = inputs(8);

    let and_outputs = input_shares
        .chunks_exact(4)
        .fold(vec![], |mut acc, input_chunk| {
            let output = and_sc(input_chunk);
            acc.push(output);
            acc
        });

    let or_out = or_sc(&and_outputs);

    (or_out ^ false).output();

    let circuit: Circuit<bool, BooleanGate, DefaultIdx> = CircuitBuilder::global_into_circuit();
    let layer_iter = CircuitLayerIter::new(&circuit);
    for layer in layer_iter {
        dbg!(layer);
    }

    // let circuit = circuit.into_base_circuit();
    // eprintln!("into base");
    // circuit.save_dot("sub_circuits.dot").unwrap();
}

crates/seec/examples/simple.rs (line 46)

fn build_circuit() {
    // The `inputs` method is a convenience method to create n input gates for the circuit.
    // It returns a Vec<Secret>. In the following, we use try_into() to convert it into
    // an array to destructure it
    let [a, b, c, d]: [_; 4] = inputs::<DefaultIdx>(4).try_into().unwrap();
    // a,b,c,d are `Secret`s representing the output share of a gate. They support
    // the standard std::ops traits like BitAnd and BitXor (and their Assign variants) which
    // are used to implicitly build the circuit.

    // Creates a new Xor gate with the input of a and b. The output is a new Secret
    // representing the output of the new gate.
    let xor = a ^ b;
    // To use a Secret multiple times (connect to gate represented by it to multiple
    // different ones), simply use a reference to it (only possibile on the rhs).
    let and = c & &d;
    // we can still use d but not c
    let mut tmp = and ^ d;
    // BitAnd and BitXor are also supported, as is Not. See the Secret documentation for
    // all operations.
    tmp &= !xor;
    // `output()` consumes the Secret and creates a new Output gate with its output.
    // It returns the gate_id of the Output gate (this is usually not needed).
    let _out_gate_id = tmp.output();
}

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

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 into_output(self) -> GateId<Idx>

pub fn connect_to_main_circuit(self) -> Self

pub fn gate_id(&self) -> GateId<Idx>

Examples found in repository

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

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()
        })
    }
}

pub fn circuit_id(&self) -> CircuitId

Examples found in repository

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

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()
        })
    }
}

Trait Implementations

impl<Idx: GateIdx, Rhs: Borrow<Self>> BitAnd<Rhs> for Secret<BooleanGmw, Idx>

type Output = Secret<BooleanGmw, Idx>

The resulting type after applying the & operator.

fn bitand(self, rhs: Rhs) -> Self::Output

Performs the & operation.

impl<Idx: GateIdx> BitAnd<bool> for Secret<BooleanGmw, Idx>

type Output = Secret<BooleanGmw, Idx>

The resulting type after applying the & operator.

fn bitand(self, rhs: bool) -> Self::Output

Performs the & operation.

impl<Idx: GateIdx, Rhs: Borrow<Self>> BitAndAssign<Rhs> for Secret<BooleanGmw, Idx>

fn bitand_assign(&mut self, rhs: Rhs)

Performs the &= operation.

impl<Idx: GateIdx> BitAndAssign<bool> for Secret<BooleanGmw, Idx>

fn bitand_assign(&mut self, rhs: bool)

Performs the &= operation.

impl<Idx: GateIdx, Rhs: Borrow<Self>> BitOr<Rhs> for Secret<BooleanGmw, Idx>

type Output = Secret<BooleanGmw, Idx>

The resulting type after applying the | operator.

fn bitor(self, rhs: Rhs) -> Self::Output

Performs the | operation.

impl<Idx: GateIdx> BitOr<bool> for Secret<BooleanGmw, Idx>

type Output = Secret<BooleanGmw, Idx>

The resulting type after applying the | operator.

fn bitor(self, rhs: bool) -> Self::Output

Performs the | operation.

impl<Idx: GateIdx, Rhs: Borrow<Self>> BitOrAssign<Rhs> for Secret<BooleanGmw, Idx>

fn bitor_assign(&mut self, rhs: Rhs)

Performs the |= operation.

impl<Idx: GateIdx> BitOrAssign<bool> for Secret<BooleanGmw, Idx>

fn bitor_assign(&mut self, rhs: bool)

Performs the |= operation.

impl<Idx: GateIdx, Rhs: Borrow<Self>> BitXor<Rhs> for Secret<BooleanGmw, Idx>

type Output = Secret<BooleanGmw, Idx>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Rhs) -> Self::Output

Performs the ^ operation.

impl<Idx: GateIdx> BitXor<bool> for Secret<BooleanGmw, Idx>

type Output = Secret<BooleanGmw, Idx>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: bool) -> Self::Output

Performs the ^ operation.

impl<Idx: GateIdx, Rhs: Borrow<Self>> BitXorAssign<Rhs> for Secret<BooleanGmw, Idx>

fn bitxor_assign(&mut self, rhs: Rhs)

Performs the ^= operation.

impl<Idx: GateIdx> BitXorAssign<bool> for Secret<BooleanGmw, Idx>

fn bitxor_assign(&mut self, rhs: bool)

Performs the ^= operation.

impl<P, Idx: Clone> Clone for Secret<P, Idx>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P, Idx: GateIdx> Debug for Secret<P, Idx>

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

Formats the value using the given formatter.

impl<P: Protocol, Idx: GateIdx> From<Secret<P, Idx>> for SubCircuitGate<Idx>

fn from(share: Secret<P, Idx>) -> Self

Converts to this type from the input type.

impl<P, Idx: Hash> Hash for Secret<P, Idx>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a, Idx: GateIdx> Not for &'a Secret<BooleanGmw, Idx>

type Output = Secret<BooleanGmw, Idx>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<Idx: GateIdx> Not for Secret<BooleanGmw, Idx>

type Output = Secret<BooleanGmw, Idx>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<P, Idx: Ord> Ord for Secret<P, Idx>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<P, Idx: PartialEq> PartialEq for Secret<P, Idx>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<P, Idx: PartialOrd> PartialOrd for Secret<P, Idx>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Idx: GateIdx> SubCircuitOutput for Secret<BooleanGmw, Idx>

fn create_output_gates(self) -> Self

fn connect_to_main(self, circuit_id: CircuitId) -> Self

fn connect_simd_to_main( self, _circuit_id: CircuitId, _simd_size: usize ) -> Vec<Self>

impl<P, Idx: Eq> Eq for Secret<P, Idx>