Function test_input

ciphercore-base/src/mpc/mpc_compiler.rs:1335–1428

()

    #[test]
    fn test_input() {
        let seed = b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F";
        let mut prng = PRNG::new(Some(*seed)).unwrap();
        let mut helper =
            |t: Type, input_status: IOStatus, output_parties: Vec<IOStatus>| -> Result<()> {
                let c = simple_context(|g| g.input(t.clone()))?;
                let mpc_mapped_context = compile_to_mpc(
                    c,
                    vec![vec![input_status.clone()]],
                    vec![output_parties.clone()],
                )?;
                let mpc_context = mpc_mapped_context.get_context();
                let mpc_graph = mpc_context.get_main_graph()?;
                let mut inputs = vec![];
                if input_status == IOStatus::Shared {
                    let tuple_t = tuple_type(vec![t.clone(); PARTIES]);
                    inputs.push(prng.get_random_value(tuple_t.clone())?);
                } else {
                    inputs.push(prng.get_random_value(t.clone())?);
                }
                let output = random_evaluate(mpc_graph.clone(), inputs.clone())?;

                let mpc_computation_graph = mpc_context.get_graphs()[0].clone();

                let computation_output_node = mpc_computation_graph.get_output_node()?;
                let computation_output_annotations = computation_output_node.get_annotations()?;
                if input_status != IOStatus::Public {
                    let expected = if input_status == IOStatus::Shared {
                        reveal_private_value(inputs[0].clone(), t.clone())?
                    } else {
                        inputs[0].clone()
                    };
                    // check that output is a sharing of expected
                    if output_parties.is_empty() {
                        let revealed_output = reveal_private_value(output.clone(), t.clone())?;
                        assert!(output.check_type(tuple_type(vec![t.clone(); PARTIES]))?);
                        assert_eq!(revealed_output, expected);
                    } else {
                        // check that output is of the right type
                        assert!(output.check_type(t.clone())?);
                        assert_eq!(output, expected.clone());
                    }
                    assert!(computation_output_annotations.contains(&NodeAnnotation::Private));
                } else {
                    // public input must be shared
                    if output_parties.is_empty() {
                        let revealed_output = reveal_private_value(output.clone(), t.clone())?;
                        assert!(output.check_type(tuple_type(vec![t.clone(); PARTIES]))?);
                        assert_eq!(revealed_output, inputs[0]);
                        // check that the final output is private (since it's shared)
                        let output_annotations = mpc_graph.get_output_node()?.get_annotations()?;
                        assert!(output_annotations.contains(&NodeAnnotation::Private));
                    } else {
                        assert_eq!(output, inputs[0]);
                    }
                    // computation output should be public on public inputs
                    assert!(!computation_output_annotations.contains(&NodeAnnotation::Private));
                }