Interoperable JavaScript implementation tested against the Java implementation

.eslintignore

@@ -0,0 +1 @@
+node_modules

.eslintrc

@@ -0,0 +1,16 @@
+{
+  "env": {
+    "browser": true,
+    "commonjs": true,
+    "es6": true,
+    "node": true
+  },
+  "extends": ["eslint:recommended"],
+  "parserOptions": {
+    "sourceType": "module",
+    "ecmaVersion": 2018
+  },
+  "rules": {
+    "linebreak-style": ["error", "unix"]
+  }
+}

.gitignore

@@ -7,3 +7,9 @@ release.properties
 dependency-reduced-pom.xml
 buildNumber.properties
 .mvn/timing.properties
+node_modules/
+.classpath
+.idea/
+.project
+.settings
+.vscode/

.prettierignore

@@ -0,0 +1,2 @@
+package-lock.json
+node_modules/

.prettierrc

@@ -0,0 +1,3 @@
+{
+  "singleQuote": true
+}

Dockerfile

@@ -0,0 +1,11 @@
+# Run the stand java build on openjdk
+FROM maven AS build
+COPY . src
+WORKDIR src
+RUN mvn package
+
+# Copy the result to graaljs and test node.js+java in the same vm
+FROM ghcr.io/graalvm/nodejs-community:23.0.2-jvm17-ol9-20231024 AS graal
+COPY --from=build /src /app/src
+WORKDIR src
+RUN npm test && npm run testwithjava && npm run lint

README.md

@@ -1,11 +1,52 @@
 # Shamir's Secret Sharing
 
-[![CircleCI](https://circleci.com/gh/codahale/shamir.svg?style=svg)](https://circleci.com/gh/codahale/shamir)
+A implementation of [Shamir's Secret Sharing
+algorithm](http://en.wikipedia.org/wiki/Shamir's_Secret_Sharing) over GF(256) in both Java and JavaScript. The Java code is from 
+the archive Codahale's [shamir](https://github.com/codahale/shamir) implementation. The 
+Javascript version is original and is crossed checked against the Java version. 
 
-A Java implementation of [Shamir's Secret Sharing
-algorithm](http://en.wikipedia.org/wiki/Shamir's_Secret_Sharing) over GF(256).
+You can use docker build both codebases and run cross-checks between them using:
 
-## Add to your project
+`docker build . `
+
+*Note: module name for Java 9+ is `com.codahale.shamir`.*
+
+## Add to your JavaScript project
+
+```sh
+npm i shamir
+```
+
+## Use the thing in JavaScript
+
+```javascript
+const { split, join } = require('shamir');
+const { randomBytes } = require('crypto');
+
+const PARTS = 5;
+const QUORUM = 3;
+
+function doIt() {
+    const secret = 'hello there';
+    // you can use any polyfill to covert between strings and Uint8Array
+    const utf8Encoder = new TextEncoder();
+    const utf8Decoder = new TextDecoder();
+    const secretBytes = utf8Encoder.encode(secret);
+    // parts is a map of part numbers to Uint8Array
+    const parts = split(randomBytes, PARTS, QUORUM, secretBytes);
+    // we only need QUORUM of the parts to recover the secret
+    delete parts['2'];
+    delete parts['3'];
+    // recovered is an Unit8Array
+    const recovered = join(parts);
+    // prints 'hello there'
+    console.log(utf8Decoder.decode(recovered));
+}
+```
+
+## [Optional] Add to your Java project
+
+The Java version is available as the orginal Codahale distribution:
 
 ```xml
 <dependency>
@@ -15,9 +56,7 @@ algorithm](http://en.wikipedia.org/wiki/Shamir's_Secret_Sharing) over GF(256).
 </dependency>
 ```
 
-*Note: module name for Java 9+ is `com.codahale.shamir`.*
-
-## Use the thing
+## Use the thing in Java
 
 ```java
 import com.codahale.shamir.Scheme;
@@ -94,7 +133,7 @@ performing the same operation over `GF(Q)` takes several seconds, even using per
 Treating the secret as a single `y` coordinate over `GF(Q)` is even slower, and requires a modulus
 larger than the secret.
 
-## Performance
+## Java Performance
 
 It's fast. Plenty fast.
 
@@ -108,7 +147,25 @@ Benchmarks.split    4          1024  avgt  200   396.708 ±  1.520  us/op
 
 **N.B.:** `split` is quadratic with respect to the number of shares being combined.
 
-## Tiered sharing
+## JavaScript Performance
+
+For a 1KiB secret split with a `n=4,k=3` scheme running on NodeJS v10.16.0:
+
+```
+Benchmark         (n)  (secretSize)  Cnt   Score   Units
+Benchmarks.join     4          1024  200   2.08    ms/op
+Benchmarks.split    4          1024  200   2.78    ms/op
+```
+
+Split is dominated by the calls to `Crypto.randomBytes` to get random polynomials to encode each byte of the secet. Using a more realistic 128 bit secret with `n=4,k=3` scheme running on NodeJS v10.16.0:
+
+```
+Benchmark         (n)  (secretSize)  Cnt   Score   Units
+Benchmarks.join     5            16  200   0.083    ms/op
+Benchmarks.split    5            16  200   0.081    ms/op
+```
+
+## Tiered Sharing Java
 
 Some usages of secret sharing involve levels of access: e.g. recovering a secret requires two admin
 shares and three user shares. As @ba1ciu discovered, these can be implemented by building a tree of
@@ -120,7 +177,7 @@ class BuildTree {
     final byte[] secret = "this is a secret".getBytes(StandardCharsets.UTF_8);
 
     // tier 1 of the tree
-    final Scheme adminScheme = new Scheme(new SecureRandom(), 5, 2);
+    final Scheme adminScheme = new Scheme(new SecureRandom(), 3, 2);
     final Map<Integer, byte[]> admins = adminScheme.split(secret);
 
     // tier 2 of the tree
@@ -147,8 +204,50 @@ By discarding the third admin share and the first two sets of user shares, we ha
 which can be used to recover the original secret as long as either two admins or one admin and three
 users agree.
 
+## Tiered Sharing JavaScript
+
+Sharing a secret requiring either two admins or one admin and three users to recover:
+
+```javascript
+  const secret = new Unit8Array([1, 2, 3]);
+
+  const adminParts = 3;
+  const adminQuorum = 2;
+  const adminSplits = split(randomBytes, adminParts, adminQuorum, secret);
+
+  const userParts = 4;
+  const userQuorum = 3;
+  const usersSplits = split(randomBytes, userParts, userQuorum, adminSplits['3'] );
+
+  // throw away third share that is split into 4 user parts
+  delete adminSplits['3'];
+
+  console.log('Admin Shares:');
+  console.log(`1 = ${adminSplits['1']}`);
+  console.log(`2 = ${adminSplits['2']}`);
+
+  console.log('User Shares:');
+  console.log(`1 = ${usersSplits['1']}`);
+  console.log(`2 = ${usersSplits['2']}`);
+  console.log(`3 = ${usersSplits['3']}`);
+  console.log(`4 = ${usersSplits['4']}`);
+
+  // throw away an admin share and one user share
+  delete adminSplits['2'];
+  delete usersSplits['1'];
+
+  // reconstruct the deleted third admin share from the three user shares 
+  const joinedUserShares = join(usersSplits);
+  // use the first admin share and the recovered third share 
+  const recoverdSecret = join({ '1': adminSplits['1'], '3': joinedUserShares } );
+```
+
+There is a unit test for this in `src/test/js/TieredSharing.js`. 
+
 ## License
 
 Copyright © 2017 Coda Hale
 
+Copyright © 2019 Simon Massey
+
 Distributed under the Apache License 2.0.