RNS/CRT

core/src/main/java/dk/alexandra/fresco/framework/builder/BuildStep.java

@@ -8,7 +8,7 @@
 
 /**
  * A single step in the chained list of lambda that creates protocols to evaluate. The root step is
- * defined in the ProbtocolBuilderImpl.
+ * defined in the ProtocolBuilderImpl.
  *
  * @param <InputT> the type of input for this binary step (the previous step's output).
  * @param <BuilderT> the type iof builder, currently either numeric or binary

core/src/main/java/dk/alexandra/fresco/framework/builder/ProtocolBuilderImpl.java

@@ -26,7 +26,7 @@ protected ProtocolBuilderImpl(
     this.factory = factory;
   }
 
-  private void createAndAppend(ProtocolProducer producer) {
+  protected void createAndAppend(ProtocolProducer producer) {
     if (protocols == null) {
       throw new IllegalStateException("Cannot build this twice, it has all ready been constructed");
     }
@@ -93,4 +93,8 @@ public <R> BuildStep<Void, BuilderT, R> par(ComputationParallel<R, BuilderT> f)
     createAndAppend(new LazyProtocolProducerDecorator(() -> builder.createProducer(null, factory)));
     return builder;
   }
+
+  public boolean isParallel() {
+    return parallel;
+  }
 }

core/src/main/java/dk/alexandra/fresco/framework/builder/numeric/ProtocolBuilderNumeric.java

@@ -14,7 +14,7 @@ public class ProtocolBuilderNumeric extends ProtocolBuilderImpl<ProtocolBuilderN
   private BasicNumericContext basicNumericContext;
   private Numeric numeric;
   private PreprocessedValues preprocessedValues;
-  ProtocolBuilderNumeric(BuilderFactoryNumeric factory, boolean parallel) {
+  protected ProtocolBuilderNumeric(BuilderFactoryNumeric factory, boolean parallel) {
     super(factory, parallel);
     this.factory = factory;
     this.basicNumericContext = factory.getBasicNumericContext();

core/src/main/java/dk/alexandra/fresco/framework/network/socket/Connector.java

@@ -2,6 +2,11 @@
 
 import dk.alexandra.fresco.framework.Party;
 import dk.alexandra.fresco.framework.configuration.NetworkConfiguration;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.net.ServerSocketFactory;
+import javax.net.SocketFactory;
 import java.io.IOException;
 import java.net.ConnectException;
 import java.net.ServerSocket;
@@ -10,18 +15,7 @@
 import java.time.Instant;
 import java.util.HashMap;
 import java.util.Map;
-import java.util.concurrent.CompletionService;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorCompletionService;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-import javax.net.ServerSocketFactory;
-import javax.net.SocketFactory;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import java.util.concurrent.*;
 
 public class Connector implements NetworkConnector {
 
@@ -85,11 +79,12 @@ private Map<Integer, Socket> connectNetwork(final NetworkConfiguration conf,
     connectionService.submit(() -> connectServer(conf));
     Duration remainingTime = timeout;
     try {
+      Future<Map<Integer, Socket>> completed;
+
       Instant start = Instant.now();
       for (int i = 0; i < connectionThreads; i++) {
         remainingTime = remainingTime.minus(Duration.between(start, Instant.now()));
-        Future<Map<Integer, Socket>> completed =
-            connectionService.poll(remainingTime.toMillis(), TimeUnit.MILLISECONDS);
+        completed = connectionService.poll(remainingTime.toMillis(), TimeUnit.MILLISECONDS);
         if (completed == null) {
           throw new TimeoutException("Timed out waiting for client connections");
         } else {
@@ -134,7 +129,7 @@ private Map<Integer, Socket> connectClient(final NetworkConfiguration conf)
         } catch (ConnectException e) {
           // A connect exception is expected if the opposing side is not listening for our
           // connection attempt yet. We ignore this and try again.
-          Thread.sleep(1 << ++attempts);
+          Thread.sleep(1L << ++attempts);
         }
       }
     }

core/src/main/java/dk/alexandra/fresco/framework/sce/evaluator/NetworkBatchDecorator.java

@@ -52,10 +52,24 @@ public int getNoOfParties() {
   public void send(int id, byte[] data) {
     ByteArrayOutputStream buffer = this.output
         .computeIfAbsent(id, (i) -> new ByteArrayOutputStream());
-    if (data.length > Byte.MAX_VALUE) {
-      throw new IllegalStateException(
-          "Current implementation only supports small packages, data.length=" + data.length);
-    }
+//    if (data.length > Byte.MAX_VALUE) {
+//      byte[] buf = new byte[Byte.MAX_VALUE];
+//      int offset = 0;
+//      do {
+//        System.arraycopy(data, offset, buf, 0, Byte.MAX_VALUE);
+//        send(id, buf);
+//        offset += Byte.MAX_VALUE;
+//      } while (offset + Byte.MAX_VALUE <= data.length);
+//      if (data.length % Byte.MAX_VALUE != 0) {
+//        // we need to send a last block
+//        int length = data.length - offset;
+//        buf = new byte[length];
+//        System.arraycopy(data, offset, buf, 0, length);
+//        send(id, buf);
+//      }
+//      throw new IllegalStateException(
+//          "Current implementation only supports small packages, data.length=" + data.length);
+//    }
     buffer.write(data.length);
     buffer.write(data, 0, data.length);
   }

core/src/main/java/dk/alexandra/fresco/framework/sce/evaluator/ProtocolCollectionList.java

@@ -6,6 +6,8 @@
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.function.Function;
+import java.util.stream.Collectors;
 
 public class ProtocolCollectionList<ResourcePoolT extends ResourcePool>
     implements ProtocolCollection<ResourcePoolT> {

core/src/main/java/dk/alexandra/fresco/lib/helper/SingleProtocolProducer.java

@@ -48,4 +48,9 @@ public T out() {
     }
     return result;
   }
+
+  public NativeProtocol<T, ?> getProtocol() {
+    return protocol;
+  }
+
 }

demos/sum/src/main/java/dk/alexandra/fresco/demo/InputSumExample.java

@@ -43,7 +43,11 @@ public <ResourcePoolT extends ResourcePool> void runApplication(
 
     network.sendToAll(ByteBuffer.allocate(4).putInt(myArraySize).array());
     List<byte[]> received = network.receiveFromAll();
-    int[] allInputSizes = received.stream().mapToInt(binary -> ByteBuffer.allocate(4).put(binary).rewind().getInt()).toArray();
+    int[] allInputSizes = received.stream().mapToInt(binary -> binary[3]
+                    | binary[2] << 8
+                    | binary[1] << 16
+                    | binary[0] << 24
+            ).toArray();
 
     if (myId == 1) {
       // party input

lib/common/src/main/java/dk/alexandra/fresco/lib/common/compare/RandomAdditiveMask.java

@@ -2,6 +2,7 @@
 
 import dk.alexandra.fresco.framework.DRes;
 import dk.alexandra.fresco.framework.builder.Computation;
+import dk.alexandra.fresco.framework.util.Pair;
 import dk.alexandra.fresco.lib.common.math.AdvancedNumeric;
 import dk.alexandra.fresco.framework.builder.numeric.Numeric;
 import dk.alexandra.fresco.framework.builder.numeric.ProtocolBuilderNumeric;
@@ -14,30 +15,25 @@ public class RandomAdditiveMask implements
     Computation<AdvancedNumeric.RandomAdditiveMask, ProtocolBuilderNumeric> {
 
   private final int noOfBits;
-
-  private List<DRes<SInt>> bits;
-  private DRes<SInt> value;
-
   public RandomAdditiveMask(int noOfBits) {
     this.noOfBits = noOfBits;
   }
 
   @Override
   public DRes<AdvancedNumeric.RandomAdditiveMask> buildComputation(
-      ProtocolBuilderNumeric builder) {
-    Numeric numericBuilder = builder.numeric();
-    bits = new ArrayList<>();
-    for (int i = 0; i < noOfBits; i++) {
-      DRes<SInt> randomBit = numericBuilder.randomBit();
-      bits.add(randomBit);
-    }
-
-    MiscBigIntegerGenerators oIntGenerators = new MiscBigIntegerGenerators(builder.getBasicNumericContext().getModulus());
-    AdvancedNumeric advancedNumeric = AdvancedNumeric.using(builder);
-    List<BigInteger> twoPows = oIntGenerators.getTwoPowersList(noOfBits);
-    value = advancedNumeric.innerProductWithPublicPart(twoPows, bits);
-    return () -> new AdvancedNumeric.RandomAdditiveMask(
-        bits,
-        value.out());
+          ProtocolBuilderNumeric builder) {
+    return builder.par(par -> {
+      Numeric numericBuilder = par.numeric();
+      List<DRes<SInt>> bits = new ArrayList<>();
+      for (int i = 0; i < noOfBits; i++) {
+        DRes<SInt> randomBit = numericBuilder.randomBit();
+        bits.add(randomBit);
+      }
+      return DRes.of(bits);
+    }).par((par, bits) -> {
+      MiscBigIntegerGenerators oIntGenerators = new MiscBigIntegerGenerators(par.getBasicNumericContext().getModulus());
+      List<BigInteger> twoPows = oIntGenerators.getTwoPowersList(noOfBits);
+      return Pair.lazy(bits, AdvancedNumeric.using(par).innerProductWithPublicPart(twoPows, bits));
+    }).par((par, bitsAndValue) -> DRes.of(new AdvancedNumeric.RandomAdditiveMask(bitsAndValue.getFirst(), bitsAndValue.getSecond())));
   }
-}
+}

lib/common/src/main/java/dk/alexandra/fresco/lib/common/math/DefaultAdvancedNumeric.java

@@ -7,6 +7,7 @@
 import dk.alexandra.fresco.framework.value.SInt;
 import dk.alexandra.fresco.lib.common.collections.sort.KeyedCompareAndSwap;
 import dk.alexandra.fresco.lib.common.compare.MiscBigIntegerGenerators;
+import dk.alexandra.fresco.lib.common.compare.RandomAdditiveMask;
 import dk.alexandra.fresco.lib.common.math.integer.conditional.ConditionalSelect;
 import dk.alexandra.fresco.lib.common.math.integer.conditional.SwapIf;
 import dk.alexandra.fresco.lib.common.math.integer.binary.IntegerToBitsLogRounds;
@@ -178,7 +179,7 @@ public DRes<List<Pair<DRes<SInt>, List<DRes<SInt>>>>> keyedCompareAndSwap(
   public DRes<SInt> bitsToInteger(List<DRes<SInt>> bits) {
     MiscBigIntegerGenerators oIntGenerators = new MiscBigIntegerGenerators(
         builder.getBasicNumericContext().getModulus());
-    return builder.seq(seq -> AdvancedNumeric.using(seq)
+    return builder.par(par -> AdvancedNumeric.using(par)
         .innerProductWithPublicPart(oIntGenerators.getTwoPowersList(bits.size()), bits));
   }
 }

lib/common/src/main/java/dk/alexandra/fresco/lib/common/math/integer/binary/Truncate.java

@@ -2,12 +2,16 @@
 
 import dk.alexandra.fresco.framework.DRes;
 import dk.alexandra.fresco.framework.builder.Computation;
+import dk.alexandra.fresco.framework.builder.numeric.Numeric;
 import dk.alexandra.fresco.framework.builder.numeric.ProtocolBuilderNumeric;
 import dk.alexandra.fresco.framework.util.Pair;
 import dk.alexandra.fresco.framework.value.SInt;
+import dk.alexandra.fresco.lib.common.compare.MiscBigIntegerGenerators;
 import dk.alexandra.fresco.lib.common.math.AdvancedNumeric;
 import dk.alexandra.fresco.lib.common.math.AdvancedNumeric.RandomAdditiveMask;
 import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
 
 /**
  * Returns a number which is approximately the input shifted a number of positions to the right. The
@@ -37,20 +41,18 @@ public DRes<SInt> buildComputation(ProtocolBuilderNumeric builder) {
     if (shifts >= maxBitLength) {
       return builder.numeric().known(0);
     }
-
-    return builder.seq(seq -> {
-
+    return builder.par(par -> {
       /*
        * Generate random additive mask of the same length as the input + some extra to avoid
        * leakage.
        */
-      return AdvancedNumeric.using(seq)
-          .additiveMask(maxBitLength + builder.getBasicNumericContext().getStatisticalSecurityParam());
+      return AdvancedNumeric.using(par)
+              .additiveMask(maxBitLength + builder.getBasicNumericContext().getStatisticalSecurityParam());
 
-    }).seq((seq, randomAdditiveMask) -> {
+    }).par((par, randomAdditiveMask) -> {
 
-      DRes<SInt> result = seq.numeric().add(input, randomAdditiveMask.value);
-      DRes<BigInteger> open = seq.numeric().open(result);
+      DRes<SInt> result = par.numeric().add(input, randomAdditiveMask.value);
+      DRes<BigInteger> open = par.numeric().open(result);
       return Pair.lazy(open, randomAdditiveMask);
 
     }).seq((seq, maskedInput) -> {
@@ -62,10 +64,10 @@ public DRes<SInt> buildComputation(ProtocolBuilderNumeric builder) {
        * rBottom = r (mod 2^shifts).
        */
       final DRes<SInt> rBottom = AdvancedNumeric.using(seq)
-          .bitsToInteger(mask.bits.subList(0, shifts));
+              .bitsToInteger(mask.bits.subList(0, shifts));
 
       BigInteger inverse =
-          BigInteger.ONE.shiftLeft(shifts).modInverse(seq.getBasicNumericContext().getModulus());
+              BigInteger.ONE.shiftLeft(shifts).modInverse(seq.getBasicNumericContext().getModulus());
       DRes<SInt> rTop = seq.numeric().sub(mask.value, rBottom);
 
       /*

lib/common/src/main/java/dk/alexandra/fresco/lib/common/math/integer/linalg/InnerProductOpen.java

@@ -36,6 +36,6 @@ public DRes<SInt> buildComputation(ProtocolBuilderNumeric builder) {
         result.add(numericBuilder.mult(nextA, nextB));
       }
       return () -> result;
-    }).seq((seq, list) -> AdvancedNumeric.using(seq).sum(list));
+    }).par((par, list) -> AdvancedNumeric.using(par).sum(list));
   }
 }

lib/fixed/src/main/java/dk/alexandra/fresco/lib/fixed/DefaultAdvancedFixedNumeric.java

@@ -31,9 +31,9 @@ public DefaultAdvancedFixedNumeric(ProtocolBuilderNumeric builder) {
 
   @Override
   public DRes<SFixed> random() {
-    return builder.seq(seq -> {
+    return builder.par(par -> {
       DRes<RandomAdditiveMask> random =
-          AdvancedNumeric.using(seq).additiveMask(seq.getBasicNumericContext().getDefaultFixedPointPrecision());
+          AdvancedNumeric.using(par).additiveMask(par.getBasicNumericContext().getDefaultFixedPointPrecision());
       return random;
     }).seq((seq, random) -> {
       return () -> new SFixed(random.value);

suite/crt/src/main/java/dk/alexandra/fresco/suite/crt/CRTAdd.java

@@ -0,0 +1,57 @@
+package dk.alexandra.fresco.suite.crt;
+
+import dk.alexandra.fresco.framework.DRes;
+import dk.alexandra.fresco.framework.builder.numeric.NumericResourcePool;
+import dk.alexandra.fresco.framework.network.Network;
+import dk.alexandra.fresco.framework.value.SInt;
+import dk.alexandra.fresco.suite.crt.datatypes.CRTSInt;
+import dk.alexandra.fresco.suite.crt.datatypes.resource.CRTResourcePool;
+import dk.alexandra.fresco.suite.crt.protocols.framework.CRTNativeProtocol;
+import dk.alexandra.fresco.suite.spdz.SpdzResourcePool;
+import dk.alexandra.fresco.suite.spdz.gates.SpdzAddProtocol;
+import dk.alexandra.fresco.suite.spdz.gates.SpdzMultProtocol;
+
+public class CRTAdd extends CRTNativeProtocol<SInt, NumericResourcePool, NumericResourcePool> {
+
+    private final DRes<SInt> a;
+    private final DRes<SInt> b;
+    private CRTSInt out;
+    private EvaluationStatus status = EvaluationStatus.HAS_MORE_ROUNDS;
+    private SpdzAddProtocol spdzAddProtocolLeft;
+    private SpdzAddProtocol spdzAddProtocolRight;
+
+    public CRTAdd(DRes<SInt> a, DRes<SInt> b) {
+        this.a = a;
+        this.b = b;
+    }
+
+    @Override
+    public CRTSInt out() {
+        return out;
+    }
+
+    @Override
+    public EvaluationStatus evaluate(int round, CRTResourcePool CRTResourcePool,
+                                     Network network) {
+        if (round == 0) {
+            CRTSInt aOut = (CRTSInt) a.out();
+            DRes<SInt> aLeft = aOut.getLeft();
+            DRes<SInt> aRight = aOut.getRight();
+
+            CRTSInt bOut = (CRTSInt) b.out();
+            DRes<SInt> bLeft = bOut.getLeft();
+            DRes<SInt> bRight = bOut.getRight();
+
+            spdzAddProtocolLeft = new SpdzAddProtocol(aLeft, bLeft);
+            spdzAddProtocolRight = new SpdzAddProtocol(aRight, bRight);
+        }
+        spdzAddProtocolLeft.evaluate(round, (SpdzResourcePool) CRTResourcePool.getSubResourcePools().getFirst(), network);
+        status = spdzAddProtocolRight.evaluate(round, (SpdzResourcePool) CRTResourcePool.getSubResourcePools().getSecond(), network);
+        if (status == EvaluationStatus.IS_DONE) {
+            this.out = new CRTSInt(spdzAddProtocolLeft.out(), spdzAddProtocolRight.out());
+            return EvaluationStatus.IS_DONE;
+        } else {
+            return EvaluationStatus.HAS_MORE_ROUNDS;
+        }
+    }
+}