private static void RunSecureComputationParty(int startPort, int numberOfParties, int localPartyId, BitArray localInput, BitArray expectedOutput)
        {
            using (IMultiPartyNetworkSession session = TestNetworkSession.EstablishMultiParty(localPartyId, numberOfParties))
            {
                using (CryptoContext cryptoContext = CryptoContext.CreateDefault())
                {
                    IObliviousTransfer obliviousTransfer = new NaorPinkasObliviousTransfer(
                        new SecurityParameters(47, 23, 4, 1, 1),
                        cryptoContext
                        );

                    IMultiplicativeSharing multiplicativeSharing = new ObliviousTransferMultiplicativeSharing(
                        obliviousTransfer,
                        cryptoContext
                        );

                    GMWSecureComputation computation = new GMWSecureComputation(session, multiplicativeSharing, cryptoContext);

                    SetIntersectionCircuitRecorder circuitRecorder = new SetIntersectionCircuitRecorder(numberOfParties, localInput.Length);
                    CircuitBuilder circuitBuilder = new CircuitBuilder();
                    circuitRecorder.Record(circuitBuilder);

                    ForwardCircuit circuit = new ForwardCircuit(circuitBuilder.CreateCircuit());
                    BitArray       output  = computation.EvaluateAsync(circuit, circuitRecorder.InputMapping, circuitRecorder.OutputMapping, localInput).Result;

                    CollectionAssert.AreEqual(
                        expectedOutput,
                        output,
                        "Incorrect output {0} (should be {1}).",
                        output.ToBinaryString(),
                        expectedOutput.ToBinaryString()
                        );
                }
            }
        }
Beispiel #2
0
        public void TestCircuitEvaluation()
        {
            BitArray[] inputs =
            {
                BitArray.FromBinaryString("0111010011"),
                BitArray.FromBinaryString("1101100010"),
                BitArray.FromBinaryString("0111110011")
            };

            Bit[] sequentialInput = inputs.SelectMany(bits => bits).ToArray();

            CircuitBuilder builder = new CircuitBuilder();
            SetIntersectionCircuitRecorder setIntersectionCircuitRecorder =
                new SetIntersectionCircuitRecorder(inputs.Length, inputs[0].Length);

            setIntersectionCircuitRecorder.Record(builder);

            Circuit        circuit        = builder.CreateCircuit();
            ForwardCircuit forwardCircuit = new ForwardCircuit(circuit);

            ICircuitEvaluator <Bit> evaluator = new LocalCircuitEvaluator();
            ReportingBatchCircuitEvaluator <Bit> batchCircuitEvaluator =
                new ReportingBatchCircuitEvaluator <Bit>(new BatchCircuitEvaluator <Bit>(evaluator));

            BitArray lazyEvaluationOutput     = new BitArray(circuit.Evaluate(evaluator, sequentialInput));
            BitArray forwardEvaluationOutput  = new BitArray(forwardCircuit.Evaluate(batchCircuitEvaluator, sequentialInput));
            BitArray expectedEvaluationOutput = BitArray.FromBinaryString("01010000101100");

            EnumerableAssert.AreEqual(
                expectedEvaluationOutput,
                lazyEvaluationOutput
                );

            EnumerableAssert.AreEqual(
                expectedEvaluationOutput,
                forwardEvaluationOutput
                );

            int[] actualBatchSizes   = batchCircuitEvaluator.BatchSizes;
            int[] expectedBatchSizes = { 10, 10, 9, 9, 8 };

            EnumerableAssert.AreEqual(
                expectedBatchSizes,
                actualBatchSizes
                );
        }
Beispiel #3
0
        private static void PerformSecureComputation(IMultiPartyNetworkSession session, BitArray expectedOutput)
        {
            BitArray localInput = Inputs[session.LocalParty.Id];

            using CryptoContext cryptoContext = CryptoContext.CreateDefault();

            IObliviousTransfer obliviousTransfer = new NaorPinkasObliviousTransfer(
                new SecurityParameters(47, 23, 4, 1, 1),
                cryptoContext
                );

            IMultiplicativeSharing multiplicativeSharing = new ObliviousTransferMultiplicativeSharing(
                obliviousTransfer,
                cryptoContext
                );

            SecretSharingSecureComputation computation = new SecretSharingSecureComputation(
                session,
                multiplicativeSharing,
                cryptoContext
                );

            SetIntersectionCircuitRecorder circuitRecorder = new SetIntersectionCircuitRecorder(
                session.NumberOfParties,
                localInput.Length
                );

            CircuitBuilder circuitBuilder = new CircuitBuilder();

            circuitRecorder.Record(circuitBuilder);

            ForwardCircuit circuit      = new ForwardCircuit(circuitBuilder.CreateCircuit());
            BitArray       actualOutput = computation
                                          .EvaluateAsync(circuit, circuitRecorder.InputMapping, circuitRecorder.OutputMapping, localInput)
                                          .Result;

            EnumerableAssert.AreEqual(
                expectedOutput,
                actualOutput
                );
        }