@Override public DRes<SInt> input(BigInteger value, int inputParty) { return this.delegate.input(value, inputParty); }
@Override public DRes<SInt> buildComputation(ProtocolBuilderNumeric builder) { Numeric numeric = builder.numeric(); DRes<SInt> random = numeric.randomElement(); DRes<SInt> product = numeric.mult(value, random); DRes<BigInteger> open = numeric.open(product); return builder.seq((seq) -> { BigInteger value = open.out(); BigInteger inverse = value.modInverse(seq.getBasicNumericContext().getModulus()); return seq.numeric().mult(inverse, random); }); } }
@Override public DRes<SInt> sign(DRes<SInt> x) { Numeric input = builder.numeric(); // TODO create a compareLeqOrEqZero on comparison builder DRes<SInt> compare = compareLEQ(input.known(BigInteger.ZERO), x); BigInteger oint = BigInteger.valueOf(2); Numeric numericBuilder = builder.numeric(); DRes<SInt> twice = numericBuilder.mult(oint, compare); return numericBuilder.sub(twice, BigInteger.valueOf(1)); }
@Override public DRes<SInt> buildComputation(ProtocolBuilderNumeric builder) { AdvancedNumeric advancedNumericBuilder = builder.advancedNumeric(); DRes<SInt> divisionResult = advancedNumericBuilder.div(dividend, divisor); Numeric numeric = builder.numeric(); return numeric.sub(dividend, numeric.mult(divisor, divisionResult)); } }
? numericIo.input(BigInteger.valueOf(myX), 1) : numericIo.input(null, 1); DRes<SInt> y1 = (myId == 1) ? numericIo.input(BigInteger.valueOf(myY), 1) : numericIo.input(null, 1); DRes<SInt> x2 = (myId == 2) ? numericIo.input(BigInteger.valueOf(myX), 2) : numericIo.input(null, 2); DRes<SInt> y2 = (myId == 2) ? numericIo.input(BigInteger.valueOf(myY), 2) : numericIo.input(null, 2); Pair<DRes<SInt>, DRes<SInt>> input1 = new Pair<>(x1, y1); Pair<DRes<SInt>, DRes<SInt>> input2 = new Pair<>(x2, y2); }).pairInPar((seq, input) -> { Numeric numeric = seq.numeric(); DRes<SInt> differenceX = numeric.sub(input.getFirst().getFirst(), input.getSecond().getFirst()); return numeric.mult(differenceX, differenceX); } , (seq, input) -> { Numeric numeric = seq.numeric(); DRes<SInt> differenceY = numeric.sub(input.getFirst().getSecond(), input.getSecond().getSecond()); return numeric.mult(differenceY, differenceY); }).seq((seq, distances) -> seq.numeric().add(distances.getFirst(), distances.getSecond())) .seq((seq, product) -> seq.numeric().open(product));
@Override public void test() { Application<BigInteger, ProtocolBuilderNumeric> app = producer -> { Numeric numeric = producer.numeric(); DRes<SInt> left = numeric.input(leftValue, 1); DRes<SInt> right = numeric.input(rightValue, 1); DRes<SInt> result = numeric.mult(left, right); return numeric.open(result); }; BigInteger output = runApplication(app); Assert.assertEquals(BigInteger.ZERO, output); } };
@Override public void test() { Application<BigInteger, ProtocolBuilderNumeric> app = producer -> { Numeric numeric = producer.numeric(); DRes<SInt> leftClosed = numeric.input(left, 1); DRes<SInt> rightClosed = numeric.input(right, 1); DRes<SInt> result = numeric.sub(leftClosed, rightClosed); return numeric.open(result); }; BigInteger actual = runApplication(app); Assert.assertEquals(BigInteger.valueOf(6), actual); } };
@Override public void test() { Application<BigInteger, ProtocolBuilderNumeric> app = producer -> { Numeric numeric = producer.numeric(); DRes<SInt> exponent = numeric.known(BigInteger.valueOf(exp)); DRes<SInt> result = producer.advancedNumeric().exp(input, exponent, 5); return numeric.open(result); }; BigInteger result = runApplication(app); Assert.assertEquals(BigInteger.valueOf(input).pow(exp), result); } };
@Override public void test() { Application<BigInteger, ProtocolBuilderNumeric> app = producer -> { Numeric numeric = producer.numeric(); DRes<SInt> left = numeric.input(leftValue, 1); DRes<SInt> right = numeric.input(rightValue, 1); DRes<SInt> result = numeric.add(left, right); return numeric.open(result); }; BigInteger output = runApplication(app); Assert.assertEquals(BigInteger.valueOf(14), output); } };
@Override public void test() { Application<BigInteger, ProtocolBuilderNumeric> app = producer -> { Numeric numeric = producer.numeric(); DRes<SInt> firstClosed = numeric.known(first); DRes<SInt> secondClosed = numeric.known(second); DRes<SInt> add = numeric.add(firstClosed, secondClosed); DRes<SInt> mult = numeric.mult(firstClosed, add); return numeric.open(mult); }; BigInteger output = runApplication(app); Assert.assertEquals(first.add(second).multiply(first), output); } };
@Test public void testRunApplication() { Application<BigInteger, ProtocolBuilderNumeric> app = builder -> { DRes<SInt> a = builder.numeric().known(BigInteger.valueOf(10)); DRes<SInt> b = builder.numeric().known(BigInteger.valueOf(10)); return builder.numeric().open(builder.numeric().add(a, b)); }; DummyArithmeticResourcePool rp = new DummyArithmeticResourcePoolImpl(0, 1, fieldDefinition); BigInteger b = sce.runApplication(app, rp, null); assertThat(b, is(BigInteger.valueOf(20))); }
@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); }); } }
DRes<SInt> mimcKey = builder.numeric().randomElement(); return builder.par(par -> { Matrix<DRes<SInt>> inputRows = shuffled.out(); return seq.numeric().open(cipherText); })); ciphers.add(new TripleWithCipher(groupBy, aggOn, openedCipher)); cipherToShare.put(cipher, key); } else { DRes<SInt> subTotal = seq.numeric().add(groupedByCipher.get(cipher), value); groupedByCipher.put(cipher, subTotal);
@Override public void test() { Application<SInt, ProtocolBuilderNumeric> testApplication = root -> { DRes<SInt> left = root.numeric().known(BigInteger.ZERO); DRes<SInt> right = root.numeric().known(BigInteger.ONE); return root.numeric().mult(left, right); }; // this test verifies that the round synchronization logic works when the threshold for // open values is exceeded runApplication(testApplication); Assert.assertFalse( "There should be no unchecked opened values after the evaluation has finished", conf.getResourcePool().getOpenedValueStore().hasPendingValues()); } };
@Override public DRes<SInt> mult(DRes<SInt> a, DRes<SInt> b) { this.multCount++; return this.delegate.mult(a, b); }
@Override public DRes<BigInteger> open(DRes<SInt> secretShare, int outputParty) { return this.delegate.open(secretShare, outputParty); }
@Override public DRes<SInt> add(DRes<SInt> a, DRes<SInt> b) { addCount++; return this.delegate.add(a, b); }
@Override public DRes<SInt> buildComputation(ProtocolBuilderNumeric builder) { int degree = polynomial.getMaxDegree(); /* * We use Horner's method, p(x) = (( ... ((p_{n-1} x + p_{n-2})x + * p_{n-3}) ... )x + a_1)x + a_0 */ DRes<SInt> tmp = polynomial.getCoefficient(degree - 1); for (int i = degree - 2; i >= 0; i--) { tmp = builder.numeric().mult(tmp, valueX); tmp = builder.numeric().add(tmp, polynomial.getCoefficient(i)); } return tmp; }