private void compareAndSwapAtIndices(int i, int j, ProtocolBuilderBinary builder) { builder.seq(seq -> { return seq.advancedBinary().keyedCompareAndSwap(numbers.get(i), numbers.get(j)); }).seq((seq, res) -> { numbers.set(i, res.get(0)); numbers.set(j, res.get(1)); return null; }); }
@Override public DRes<SReal> innerProductWithPublicPart(List<BigDecimal> a, List<DRes<SReal>> b) { return builder.par(r1 -> { if (a.size() != b.size()) { throw new IllegalArgumentException("Vectors must have same size"); } List<DRes<SReal>> products = new ArrayList<>(a.size()); for (int i = 0; i < a.size(); i++) { products.add(r1.realNumeric().mult(a.get(i), b.get(i))); } return () -> products; }).seq((seq, list) -> { return seq.realAdvanced().sum(list); }); }
@Override public DRes<SReal> innerProduct(List<DRes<SReal>> a, List<DRes<SReal>> b) { return builder.par(par -> { if (a.size() != b.size()) { throw new IllegalArgumentException("Vectors must have same size"); } List<DRes<SReal>> products = new ArrayList<>(a.size()); for (int i = 0; i < a.size(); i++) { products.add(par.realNumeric().mult(a.get(i), b.get(i))); } return () -> products; }).seq((seq, list) -> { return seq.realAdvanced().sum(list); }); }
@Override public DRes<SInt> buildComputation(ProtocolBuilderNumeric builder) { return builder.par(parallel -> { List<DRes<SInt>> result = new ArrayList<>(vectorA.size()); Numeric numericBuilder = parallel.numeric(); for (int i = 0; i < vectorA.size(); i++) { BigInteger nextA = vectorA.get(i); DRes<SInt> nextB = vectorB.get(i); result.add(numericBuilder.mult(nextA, nextB)); } return () -> result; }).seq((seq, list) -> seq.advancedNumeric().sum(list)); } }
@Override public DRes<SInt> buildComputation(ProtocolBuilderNumeric builder) { return builder.seq((seq) -> () -> this.data ).seq((seq, list) -> seq.advancedNumeric().sum(list) ).seq((seq, sum) -> { BigInteger n = BigInteger.valueOf(this.degreesOfFreedom); return seq.advancedNumeric().div(() -> sum, n); }); }
@Override public DRes<SInt> buildComputation(ProtocolBuilderNumeric sequential) { return sequential.par( parallel -> { List<DRes<SInt>> scores = new ArrayList<>(values.size()); for (int i = 0; i < values.size(); i++) { DRes<SInt> value = values.get(i); List<DRes<SInt>> interval = intervals.get(i); List<DRes<SInt>> intervalScore = intervalScores.get(i); scores.add( parallel.seq(new ComputeIntervalScore(interval, value, intervalScore))); } return () -> scores; } ).seq((seq, list) -> seq.advancedNumeric().sum(list)); }
@Override public DRes<SInt> buildComputation(ProtocolBuilderNumeric builder) { return builder .par(parallel -> { List<DRes<SInt>> products = new ArrayList<>(vectorA.size()); Numeric numericBuilder = parallel.numeric(); for (int i = 0; i < vectorA.size(); i++) { DRes<SInt> nextA = vectorA.get(i); DRes<SInt> nextB = vectorB.get(i); products.add(numericBuilder.mult(nextA, nextB)); } return () -> products; }) .seq((seq, list) -> seq.advancedNumeric().sum(list) ); } }
@Override public DRes<List<byte[]>> buildComputation(BuilderT builder) { return builder.par(par -> { List<DRes<List<byte[]>>> broadcastValues = new ArrayList<>(); for (byte[] singleInput : input) { broadcastValues.add(par.append(new InsecureBroadcastProtocol<>(singleInput))); } return () -> broadcastValues; }).seq((seq, lst) -> { List<byte[]> toValidate = lst.stream() .flatMap(broadcast -> broadcast.out().stream()) .collect(Collectors.toList()); seq.append(new BroadcastValidationProtocol<>(toValidate)); return () -> toValidate; }); }
@Override public DRes<byte[]> buildComputation(ProtocolBuilderNumeric builder) { return builder.seq(new Spdz2kCommitmentComputation(serializer, ownSeed, noOfParties, localDrbg)) .seq((seq, seeds) -> { byte[] jointSeed = new byte[ownSeed.length]; for (byte[] seed : seeds) { ByteArrayHelper.xor(jointSeed, seed); } return () -> jointSeed; }); }
@Override public DRes<SInt> buildComputation(ProtocolBuilderNumeric builder) { return builder.par((par) -> { List<DRes<SInt>> terms = new ArrayList<>(data.size()); for (DRes<SInt> value : data) { DRes<SInt> term = par.seq((seq) -> { Numeric numeric = seq.numeric(); DRes<SInt> tmp = numeric.sub(value, mean); return numeric.mult(tmp, tmp); }); terms.add(term); } return () -> terms; }).seq((seq, terms) -> seq.seq(new Mean(terms, data.size() - 1)) ); }
@Override public DRes<SReal> random(int bits) { return builder.seq(seq -> { DRes<RandomAdditiveMask> random = seq.advancedNumeric().additiveMask(bits); return random; }).seq((seq, random) -> { return () -> new SFixed(random.random, bits); }); } }
@Override public DRes<BigInteger> buildComputation(ProtocolBuilderNumeric producer) { return producer.seq(inputApp).seq((seq, inputs) -> { DRes<SInt> sum = null; for (SInt input : inputs) { if (sum == null) { sum = input; } else { sum = seq.numeric().add(sum, input); } } return seq.numeric().open(sum); }); } }
@Override public DRes<SInt> buildComputation(ProtocolBuilderNumeric builder) { return builder.seq((seq) -> seq.advancedNumeric() .additiveMask(bitLength + securityParameter) ).seq((seq, mask) -> { DRes<SInt> mS = seq.numeric().add(input, () -> mask.random); DRes<BigInteger> mO = seq.numeric().open(mS); return () -> new Pair<>(mask.bits.subList(0, bitLength), mO.out()); }).seq((seq, pair) -> new HammingDistance(pair.getFirst(), pair.getSecond()).buildComputation(seq) ); } }
@Override public DRes<List<SInt>> buildComputation(ProtocolBuilderNumeric builder) { return builder .seq((ignored) -> () -> new State(input, maxInputLength)) .whileLoop( (state) -> state.shifts > 0, (seq, state) -> { DRes<RightShiftResult> remainder = seq.advancedNumeric().rightShiftWithRemainder(state.currentInput); return () -> state.createNext(remainder.out()); }) .seq((seq, state) -> () -> state.remainders); }
@Override public DRes<SInt> buildComputation(ProtocolBuilderNumeric builder) { return builder.par(par -> { Numeric numeric = par.numeric(); return Pair.lazy( numeric.mult(d0, n1), numeric.mult(d1, n0) ); }).seq((seq, pair) -> seq.comparison().equals(pair.getFirst(), pair.getSecond()) ); }
@Override public DRes<List<byte[]>> buildComputation(ProtocolBuilderNumeric builder) { HashBasedCommitment ownCommitment = new HashBasedCommitment(); byte[] ownOpening = ownCommitment.commit(localDrbg, value); return builder.seq(new BroadcastComputation<>(commitmentSerializer.serialize(ownCommitment))) .seq((seq, rawCommitments) -> { DRes<List<byte[]>> openingsDRes = seq.append(new InsecureBroadcastProtocol<>(ownOpening)); List<HashBasedCommitment> commitments = commitmentSerializer .deserializeList(rawCommitments); return () -> open(commitments, openingsDRes.out(), noOfParties); }); }
@Override public void test() throws Exception { Application<Boolean, ProtocolBuilderBinary> app = producer -> producer.seq(seq -> { DRes<SBool> in = seq.binary().input(true, 1); DRes<Boolean> open = seq.binary().open(in); return open; }).seq((seq, out) -> { return () -> out; }); boolean output = runApplication(app); if (doAsserts) { Assert.assertEquals(true, output); } } };
@Override public void test() throws Exception { Application<Boolean, ProtocolBuilderBinary> app = producer -> producer.seq(seq -> { DRes<SBool> in = seq.binary().input(true, 2); DRes<Boolean> open = seq.binary().open(in); return open; }).seq((seq, out) -> { return () -> out; }); boolean output = runApplication(app); if (doAsserts) { Assert.assertEquals(true, output); } } };
@Override public void test() throws Exception { Application<Boolean, ProtocolBuilderBinary> app = producer -> producer.seq(seq -> { DRes<SBool> in = seq.binary().randomBit(); DRes<Boolean> open = seq.binary().open(in); return open; }).seq((seq, out) -> { return () -> out; }); boolean output = runApplication(app); if (doAsserts) { Assert.assertEquals(true, output); } } };
@Override public void test() throws Exception { Application<Void, ProtocolBuilderBinary> app = producer -> producer.seq(seq -> { List<DRes<SBool>> toPrint = BooleanHelper.known(new Boolean[] {true, false, false, true}, seq.binary()); return () -> toPrint; }).seq((seq, inputs) -> { seq.debug().openAndPrint("test", inputs); seq.debug().marker("test"); return null; }); runApplication(app); } };