Merge pull request #3 from multiparty/cleanup

Cleanup

Author: KinanBab

.eslintignore

@@ -0,0 +1 @@
+**/node_modules/

.eslint.json renamed to .eslintrc

@@ -29,17 +29,15 @@
     "browser": true,
     "jquery": true,
     "node": true,
-    "amd": true,
+    "amd":true,
     "es6": true
   },
 
   "parserOptions":{
-    "ecmaVersion": 6,
-    "ecmaFeatures": {
-      "experimentalObjectRestSpread": true
-    }
+    "ecmaVersion": 6
   },
   "plugins": [
-    "requirejs"
+    "requirejs",
+    "mocha"
   ]
 }

.eslintrc.js

@@ -1,7 +1,9 @@
 # JIGG
+
 JavaScript implementation of garbled gates and 2PC boolean circuit protocols.
 
 ## Requirements and Installation
+
 This library is implemented entirely in JavaScript. Running the server requires [Node.js](https://nodejs.org/en/), [npm](https://www.npmjs.com/) (both installed via `yum install nodejs npm` or `brew install npm` on macOS), [Socket.IO](https://socket.io/), and [libsodium](https://www.npmjs.com/package/libsodium).
 
 Run `npm` to install all JIGG dependencies:
@@ -12,60 +14,58 @@ npm install
 ## Project Layout
 
     ├─ circuits/        Circuit files
-    │  └─ bristol/          Extended functionality for use cases (e.g. negative numbers)
+    │  ├─ macros/       Macro files to assemble circuits using [CASM](https://github.com/wyatt-howe/macro-circuit-assembler)
+    │  └─ bristol/      Bristol format files
     ├─ demo/            Demo for client-server deployment scenario
     ├─ src/             Library modules implementing protocol steps for participants
     │  ├─ comm/         Communications modules (such as for OT)
-    │  ├─ data/         Data structure modules (such as circuits)
+    │  ├─ modules/         Data structure modules (such as circuits)
     │  └─ utils/        Other utility modules (such as cryptographic primitives)
-    └─ test/            Unit tests and end-to-end simulation tests
-       └─ suite/        End-to-end simulation tests
+    └─ test/            End-to-end tests
+
 
+## Running Demo Circuit Applications
 
-## Running Applications
-Start the communications server from server.js with the command below and optionally specify a port number such as:
+Start the communications server from server.js with the command below:
 ```shell
-node server 3000
+node demo/server.js <port number>
 ```
 
 ### As a Browser Party
-Parties can go to `http://localhost:port/` in a web browser supporting JavaScript to begin communications. This is strictly a two-party protocol at the moment.
+
+Parties can go to `http://localhost:<port>/` in a web browser supporting JavaScript to begin communications.
 
 ### As a Node.js Party
+
 Connect a new party in Node.js by running:
 ```shell
-node demo/party.js <circuit> <role> <b16-input>
+node demo/party.js <port> <role> <input> <encoding> <circuitName>
+# <role>: Garbler or Evaluator
+# <input>: string with no whitespaces
+# <encoding>: bits, number, or hex
+# <circuitName>: must include file extension
+#                demo will run bristol circuit found at
+#                'circuits/bristol/<circuitName>'
 ```
+
 For example to join an AES-128 computation as the garbler, run:
 ```shell
-node demo/party.js aes128.txt garbler 00000000000000000000000000000000  # message in base 16
+node demo/party.js 3000 Evaluator 00000000000000000000000000000000 hex aes-128-reverse.txt
 ```
 
-### Demos
-We have a 64-bit equal-to-zero test (`circuits/bristol/zero_equal_64.txt`) in `circuits/bristol` and several other circuits from the same [page](https://homes.esat.kuleuven.be/~nsmart/MPC/). Circuits larger than ~6000 gates seem to hang the JS engine (sometimes only temporarily) and so are now forced to run in sequence to prevent this from occurring.
-
-There is now a SHA-256 demo at `sha256.html` and `client.html`.
-The boolean circuit for SHA has +100,000 gates, and by limiting the number of gates encrypted in parallel, JIGG is able to compute it in under a minute in the browser. Test vectors are found [here](https://homes.esat.kuleuven.be/~nsmart/MPC/sha-256-test.txt) and in the `test/` folder.
+### Server + Garbler/Evaluator
 
-### Circuit Format
-JIGG can evaluate a boolean circuit in either of two formats. It supports circuits represented using JSON according to the [SIGG](https://github.com/multiparty/sigg) standard.
-```javascript
-const circuit = {
-  "wire_count":8, "gate_count":4,
-  "value_in_count":2, "value_in_length":[2,2],
-  "value_out_count":1, "value_out_length":[3],  
-  "wire_in_count":4, "wire_in_index":[1,2,3,4],
-  "wire_out_count":3, "wire_out_index":[5,7,8],
-  "gate": [
-    {"wire_in_index":[1,2], "wire_out_index":[5], "operation":"and"},
-    {"wire_in_index":[3,4], "wire_out_index":[6], "operation":"xor"},
-    {"wire_in_index":[6], "wire_out_index":[7], "operation":"not"},
-    {"wire_in_index":[5,7], "wire_out_index":[8], "operation":"and"}
-  ]
-};
+The server may also run as a garbler or evaluator. You can acheive this by running the server with
+the same arguments as a party:
+```shell
+node demo/server.js <port> <role> <input> <encoding> <circuitName>
 ```
 
-JIGG can also parse a circuit in the standardized '[Bristol](https://homes.esat.kuleuven.be/~nsmart/MPC/) [Format](https://homes.esat.kuleuven.be/~nsmart/MPC/old-circuits.html)' which is supported by several compiled MPC libraries such as [SCALE-MAMBA](https://homes.esat.kuleuven.be/~nsmart/SCALE/).
+## Demo Circuits
+We have a variety of circuits available under `circuits/bristol` mostly from this [page](https://homes.esat.kuleuven.be/~nsmart/MPC/).
+
+### Circuit Format
+JIGG can parse a circuit in the standardized '[Bristol](https://homes.esat.kuleuven.be/~nsmart/MPC/) [Format](https://homes.esat.kuleuven.be/~nsmart/MPC/old-circuits.html)' which is supported by several compiled MPC libraries such as [SCALE-MAMBA](https://homes.esat.kuleuven.be/~nsmart/SCALE/).
 ```ada
 4 8
 2 2 2
@@ -77,64 +77,22 @@ JIGG can also parse a circuit in the standardized '[Bristol](https://homes.esat.
 ```
 
 ### Circuit Assembler
-To create a new circuit, write a macro with existing circuits as its gates and run the [macro-circuit-assembler](https://github.com/wyatt-howe/macro-circuit-assembler/tree/casm) with `npm run casm <path_to_macro> <output_path>`.
-
-<!--For example, `npm run-script casm circuits/macros/and8.casm circuits/and8.txt` assembles the 8-bit AND circuit.-->
-
-## Running Tests
+To create a new circuit, write a macro with existing circuits as its gates and run the [macro-circuit-assembler](https://github.com/wyatt-howe/macro-circuit-assembler/tree/casm) with:
 
-### Generating Precomputed Garbled Gates
-It is possible to generate a collection of precomputed label assignments and garbled gates for each circuit.
 ```shell
-node test/suite/generate.js
+npm run casm -- <path_to_macro> <output_path>
 ```
-These files represent what a dedicated service could precompute and make available on-demand in order to improve the performance of a deployed instance of the protocol. Unit tests make use of these files if they are present.
 
-### Unit Tests
-Unit tests of functional components (single-process without sockets) can be run using [mocha](https://mochajs.org/).
-```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
-```
+For example, this macro assembles an AND circuit over 8 bits using
+existing 4 bit AND circuits:
 
-### 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.
-```shell
-npm test
-```
-You may also run an individual test on a specific circuit file.
-```shell
-node test/suite/simulate.js <circuit-file-path>
 ```
-For example, execute the following to test a computation using the 8-bit conjunction circuit.
-```shell
-node test/suite/simulate.js and8.txt
+npm run casm -- circuits/macros/and-8.casm circuits/and-8.txt
 ```
 
-#### Legacy End-to-end Tests
-All of the built-in test vectors can be verified in `npm run test-old` or `node test/suite/all.js`.  Communcations between the server, garbler and evaluator are automated.  You do not need to already have a server running – tests are run over port 3001.
-
-You may also access the test function directly, by running `test.js`.
-```shell
-node test/suite/test.js <circuit> <testvector>
-```
-For example to test an equal-to-zero computation with the zero vector, write:
-```shell
-node test/suite/test.js compare-eq-zero-64-bit.txt '["00000000","00000000","1"]'
-```
+## Running Tests
 
-Predefined test cases (circuit name, test vector) for the circuits can be configured in `test/suite/defaults.json` or specified inside another file such as `test/sample-tests.txt`.  Test vectors are written as `[input1, input2, output]` as shown above.
+All of the built-in test vectors can be verified in `npm test`. The tests will run a server automatically. These are end-to-end tests.
 
 ## Capabilities
 JIGG is designed for semi-honest parties (in either node or in the browser). We support point-and-permute, free-XOR, free single-input gates, and encryption from a random oracle (fixed-key XChaCha20). The half-AND optimization is compatible but not yet supported. The default label size is 128 bits and relies on JavaScript's Uint8Array class. The [`simple-labels`](https://github.com/wyatt-howe/jigg/tree/simple-labels) branch demonstrates dynamically-sized labels (that are 53 bits in length or less) without using arrays. Some potential improvements are listed in the to-do section.
@@ -144,9 +102,7 @@ JIGG is fully functional as it is now, but there's still more to do (see the lis
 
 ### To Do
 - Half-AND gate optimization
-- Standardize JSON, serialized, and compressed formats for inter-party messages
-- Create a single unified test suite
+- Standardize JSON/serialized/compressed formats for inter-party messages compatible with [SIGG](https://github.com/multiparty/sigg)
 
 ## Information and Collaborators
-
 More information about this project, including collaborators and publications, can be found at [multiparty.org](https://multiparty.org/).

README.md

@@ -27692,4 +27692,4 @@
 2 1 1487 1540 29179 XOR
 2 1 1495 1541 29187 XOR
 2 1 1519 1542 29211 XOR
-2 1 1527 1543 29219 XOR
+2 1 1527 1543 29219 XOR

circuits/bristol/aes-128-expanded-old.txt

@@ -33616,4 +33616,4 @@
 2 1 264 265 33805 XOR
 2 1 266 267 33807 XOR
 2 1 268 269 257 XOR
-2 1 256 257 33749 XOR
+2 1 256 257 33749 XOR