Fix unit tests; add CLI options (multiple inputs, specific circuit).

Author: lapets

README.md

@@ -95,6 +95,18 @@ Unit tests of functional components (single-process without sockets) can be run
 ```shell
 mocha test
 ```
+It is possible to restrict the end-to-end unit tests to only test inputs on a specific circuit (note that the `.txt` circuit file extension is omitted).
+```shell
+mocha test --circuit logic-and-4-bit
+```
+The number of distinct inputs on which to run the circuits being tested can be specified.
+```shell
+mocha test --trials 3
+```
+The two options can also be combined.
+```shell
+mocha test --circuit logic-and-8-bit --trials 10
+```
 
 ### End-to-end Tests
 All of the built-in test vectors can be verified in `npm test` or, equivalently, `node test/suite/simulate.js`. Communications between the server, garbler and evaluator are automated. You do not need to already have a server running; tests are run over port 3001.

src/comm/channel.js

@@ -111,7 +111,7 @@ ChannelSimulated.prototype.sendOblivious = function (pair) {
 };
 
 /**
- * Receive the specified value under the specified key.
+ * Receive the bit-specified value from first pair in queue. 
  * @param {number} bit - Bit to determine which value to receive
  * @returns {string} Next available value
  */

src/data/assignment.js

@@ -21,16 +21,16 @@ function Assignment() {
 /**
  * Assign an ordered collection of labels to a wire index.
  * @param {number} index - Index of wire to which to assign labels
- * @param {Object[]} labels - Array of one or two labels
+ * @param {Object[]} labels - Ordered collection of labels
  */
 Assignment.prototype.set = function (index, labels) {
   this.mapping[index] = labels;
 };
 
 /**
  * Get the labels at the specified wire index.
- * @param {number} index - Index of wire for which to return the label
- * @param {Object[]} labels - Array of one or two labels
+ * @param {number} index - Index of wire for which to return labels
+ * @returns {Object[]} Ordered collection of labels
  */
 Assignment.prototype.get = function (index) {
   return this.mapping[index];
@@ -52,7 +52,7 @@ Assignment.prototype.toJSON = function () {
 };
 
 /**
- * Return the data structure instance as a JSON string.
+ * Turn an assignment instance into a JSON string.
  * @returns {string} Data structure as a JSON string
  */
 Assignment.prototype.toJSONString = function () {
@@ -61,6 +61,7 @@ Assignment.prototype.toJSONString = function () {
 
 /**
  * Build a data structure instance from its JSON representation.
+ * @param {string} json - Assignment instance as a JSON object
  * @returns {Object} Instance of the data structure
  */
 Assignment.prototype.fromJSON = function (json) {
@@ -73,6 +74,7 @@ Assignment.prototype.fromJSON = function (json) {
 
 /**
  * Build a data structure instance from its JSON string representation.
+ * @param {string} json - Assignment instance in JSON string form
  * @returns {Object} Instance of the data structure
  */
 Assignment.prototype.fromJSONString = function (s) {
@@ -82,7 +84,7 @@ Assignment.prototype.fromJSONString = function (s) {
 /**
  * Return a subset of the map corresponding to the supplied indices.
  * @param {number[]} indices - Indices of map entries to keep in result
- * @returns {Object} Data structure as a JSON object
+ * @returns {Object} New assignment data structure instance
  */
 Assignment.prototype.copyWithOnlyIndices = function (indices) {
   var assignment = new Assignment();

src/evaluate.js

@@ -19,14 +19,17 @@ const crypto = require('./util/crypto');
  */
 function receiveMessages(channel, circuit, input) {
   const inputPair = (new Array(1 + input.length)).concat(input);
+  
+  // Receive the list of garbled gates.
   var messages = [channel.receiveDirect('gatesGarbled')];
 
   // Receive each of the garbler's input labels.
   for (var i = 0; i < circuit.wire_in_count/2; i++) {
     messages.push(channel.receiveDirect('wire[' + circuit.wire_in_index[i] + ']'));
   }
 
-  // Promises to each of the evaluator's input labels.
+  // Receive each of the evaluator's input labels using the input bits
+  // available to the evaluator.
   for (var i = circuit.wire_in_count/2; i < circuit.wire_in_count; i++) {
     messages.push(channel.receiveOblivious(inputPair[circuit.wire_in_index[i]]));
   }
@@ -71,8 +74,23 @@ function evaluateGate(gate_id, gate, gateGarbled, wireToLabels) {
   }
 }
 
+/**
+ * Evaluate all the gates (stateless version).
+ * @param {Object} circuit - Circuit in which to garble the gates
+ * @param {Object} gatesGarbled - Ordered collection of garbled gates
+ * @param {Object} wireToLabels - Labeled wire data structure
+ * @returns {Object} Mapping from each wire index to two labels
+ */
+function evaluateGates(circuit, gatesGarbled, wireToLabels) {
+  for (var i = 0; i < circuit.gate_count; i++) {
+    this.evaluateGate(i, circuit.gate[i], gatesGarbled.get(i), wireToLabels);
+  }
+  return wireToLabels;
+}
+
 module.exports = {
   receiveMessages: receiveMessages,
   processMessages: processMessages,
   evaluateGate: evaluateGate,
+  evaluateGates: evaluateGates
 };

src/garble.js

@@ -159,9 +159,24 @@ function outputLabelsToBits(circuit, wireToLabels, outputWireToLabels) {
   return output;
 }
 
+/**
+ * Garble all the gates (stateless version).
+ * @param {Object} circuit - Circuit in which to garble the gates
+ * @param {Object} wireToLabels - Mapping from each wire index to two labels
+ * @returns {Object} Ordered collection of garbled gates
+ */
+function garbleGates(circuit, wireToLabels) {
+  var gatesGarbled = new gate.GatesGarbled();
+  for (var i = 0; i < circuit.gate_count; i++) {
+    gatesGarbled.set(i, garbleGate(i, circuit.gate[i], wireToLabels));
+  }
+  return gatesGarbled;
+}
+
 module.exports = {
   generateWireToLabelsMap: generateWireToLabelsMap,
   garbleGate: garbleGate,
+  garbleGates: garbleGates,
   sendInputWireToLabelsMap: sendInputWireToLabelsMap,
   outputLabelsToBits: outputLabelsToBits
 };

test/test.js

@@ -431,6 +431,7 @@ var add32_json = {
  * @returns {number[]} Computed bit vector output
  */
 function protocolPureEndToEnd(circuit, inputs, chan, a, gg) {
+
   // Split inputs into two halves (to be divided
   // between garbler and evaluator agents).
   var bs = [];
@@ -529,61 +530,83 @@ describe('end-to-end', function() {
     'compare-eq-zero-64-bit': function (a) { return a.orBits().not(); }
   }
 
+  // Check for command-line arguments.
+  var trials = 1;
+  var filename_only = "*";
+  if (process.argv.length === 5 || process.argv.length === 7) {
+    for (var i = 3; i <= 5; i += 2)
+      if (process.argv[i] === '--trials')
+        trials = parseInt(process.argv[i+1]);
+    for (var i = 3; i <= 5; i += 2)
+      if (process.argv[i] === '--circuit')
+        filename_only = process.argv[i+1];
+    console.log(filename_only);
+  }
+
   // Test each circuit.
   for (let i = 0; i < filenames.length; i++) {
-    it(filenames[i], async function() {
-      this.timeout(4*60*1000); // Necessary for larger circuits.
-
-      // Create the simulated communications channel.
-      var chan = new channel.ChannelSimulated();
-
-      // Load circuit file and perform end-to-end test.
-      let raw = await fs.readFile('./circuits/bristol/' + filenames[i] + '.txt', 'utf8');
-      let c = circuit.fromBristolFashion(raw);
-
-      var inputs = [];
-      for (var j = 0; j < c.value_in_count; j++) {
-        inputs.push(bits.random(c.value_in_length[j], i+j+1));
-      }
-      let outEval = c.evaluate(inputs);
-
-      // Load precomputed data if it is available.
-      let a = null, gg = null;
-      try {
-        let aString = await fs.readFile('./circuits/gg/' + filenames[i] + '.assignment.json', 'utf8');
-        let ggString = await fs.readFile('./circuits/gg/' + filenames[i] + '.gg.json', 'utf8');
-        a = assignment.Assignment.prototype.fromJSONString(aString);
-        gg = gate.GatesGarbled.prototype.fromJSONString(ggString);
-      } catch (err) {}
-
-      let outEtoE = protocolPureEndToEnd(c, inputs, chan, a, gg);
-
-      // Confirm that the circuit is mathematically correct if a
-      // reference function for the circuit is provided.
-      if (filenames[i] in functions) {
-        let outRef = functions[filenames[i]](...inputs);
-        expect(outEval.toString()).to.eql(outRef.toString());
-      }
-
-      // Do the evaluation and end-to-end protocol output bit vectors match?
-      expect(outEval.toString()).to.eql(outEtoE.toString());
 
-      // Confirm that communicated messages conform to schemas.
-      let gatesGarbledSchemaString = await fs.readFile('./schemas/gates.garbled.schema.json', 'utf8');
-      let gatesGarbledSchema = JSON.parse(gatesGarbledSchemaString);
-      expect(JSON.parse(chan.direct['gatesGarbled'])).to.be.jsonSchema(gatesGarbledSchema);
-
-      let assignmentSchemaString = await fs.readFile('./schemas/assignment.schema.json', 'utf8');
-      let assignmentSchema = JSON.parse(assignmentSchemaString);
-      expect(JSON.parse(chan.direct['outputWireToLabels'])).to.be.jsonSchema(assignmentSchema);
-
-      let labelSchemaString = await fs.readFile('./schemas/label.schema.json', 'utf8');
-      let labelSchema = JSON.parse(labelSchemaString);
-      for (var key in chan.direct) {
-        if (key.startsWith("wire[")) {
-          expect(JSON.parse(chan.direct[key])).to.be.jsonSchema(labelSchema);
-        }
-      }
-    });
-  }
+    // Only test the specified circuit if a user specified one.
+    console.log(filenames[i], filename_only === filenames[i]);
+    if (filename_only === "*" || filename_only === filenames[i]) {
+
+      // Test the circuit on each input.
+      for (let trial = 0; trial < trials; trial++) {
+        it(filenames[i], async function() {
+          this.timeout(4*60*1000); // Necessary for larger circuits.
+
+          // Create the simulated communications channel.
+          var chan = new channel.ChannelSimulated();
+
+          // Load circuit file and perform end-to-end test.
+          let raw = await fs.readFile('./circuits/bristol/' + filenames[i] + '.txt', 'utf8');
+          let c = circuit.fromBristolFashion(raw);
+
+          var inputs = [];
+          for (var j = 0; j < c.value_in_count; j++) {
+            inputs.push(bits.random(c.value_in_length[j], 1+trial+j));
+          }
+          let outEval = c.evaluate(inputs);
+
+          // Load precomputed data if it is available.
+          let a = null, gg = null;
+          try {
+            let aString = await fs.readFile('./circuits/gg/' + filenames[i] + '.assignment.json', 'utf8');
+            let ggString = await fs.readFile('./circuits/gg/' + filenames[i] + '.gg.json', 'utf8');
+            a = assignment.Assignment.prototype.fromJSONString(aString);
+            gg = gate.GatesGarbled.prototype.fromJSONString(ggString);
+          } catch (err) {}
+
+          let outEtoE = protocolPureEndToEnd(c, inputs, chan, a, gg);
+
+          // Confirm that the circuit is mathematically correct if a
+          // reference function for the circuit is provided.
+          if (filenames[i] in functions) {
+            let outRef = functions[filenames[i]](...inputs);
+            expect(outEval.toString()).to.eql(outRef.toString());
+          }
+
+          // Do the evaluation and end-to-end protocol output bit vectors match?
+          expect(outEval.toString()).to.eql(outEtoE.toString());
+
+          // Confirm that communicated messages conform to schemas.
+          let gatesGarbledSchemaString = await fs.readFile('./schemas/gates.garbled.schema.json', 'utf8');
+          let gatesGarbledSchema = JSON.parse(gatesGarbledSchemaString);
+          expect(JSON.parse(chan.direct['gatesGarbled'])).to.be.jsonSchema(gatesGarbledSchema);
+
+          let assignmentSchemaString = await fs.readFile('./schemas/assignment.schema.json', 'utf8');
+          let assignmentSchema = JSON.parse(assignmentSchemaString);
+          expect(JSON.parse(chan.direct['outputWireToLabels'])).to.be.jsonSchema(assignmentSchema);
+
+          let labelSchemaString = await fs.readFile('./schemas/label.schema.json', 'utf8');
+          let labelSchema = JSON.parse(labelSchemaString);
+          for (var key in chan.direct) {
+            if (key.startsWith("wire[")) {
+              expect(JSON.parse(chan.direct[key])).to.be.jsonSchema(labelSchema);
+            }
+          }
+        }); // it()
+      } // for each trial
+    } // if a specified circuit
+  } // for each circuit
 });