Switched to webcrypto

package.json

@@ -54,14 +54,14 @@
     "ws": "~>7.1.0"
   },
   "optionalDependencies": {
-    "text-encoding": "^0.7.0",
+    "@peculiar/webcrypto": "^1.0.19",
-    "node-webcrypto-ossl": "^1.0.47",
+    "emailjs": "^2.2.0",
-    "emailjs": "^2.2.0"
+    "text-encoding": "^0.7.0"
   },
   "devDependencies": {
     "aws-sdk": ">=2.153.0",
     "ip": "^1.1.5",
-    "mocha": "^5.2.0",
+    "mocha": "^6.2.0",
     "panic-manager": "^1.2.0",
     "panic-server": "^1.1.1",
     "uglify-js": ">=2.8.22"

sea.js

@@ -64,6 +64,11 @@
           (_, i) => String.fromCharCode(this[ i + start])
         ).join('')
       }
+
+      function btoa(b) {
+        return new Buffer(b).toString('base64');
+    };
+ 
       if (enc === 'base64') {
         return btoa(this)
       }
@@ -91,6 +96,9 @@
         }
         const input = arguments[0]
         let buf
+        function atob(a) {
+          return new Buffer(a, 'base64').toString('binary');
+      };
         if (typeof input === 'string') {
           const enc = arguments[1] || 'utf8'
           if (enc === 'hex') {
@@ -174,7 +182,7 @@
         random: (len) => Buffer.from(crypto.randomBytes(len))
       });
       //try{
-        const WebCrypto = USE('node-webcrypto-ossl', 1);
+        const { Crypto: WebCrypto } = USE('@peculiar/webcrypto', 1);
         api.ossl = api.subtle = new WebCrypto({directory: 'ossl'}).subtle // ECDH
       //}catch(e){
         //console.log("node-webcrypto-ossl is optionally needed for ECDH, please install if needed.");
@@ -304,7 +312,7 @@
 
     //SEA.pair = async (data, proof, cb) => { try {
     SEA.pair = SEA.pair || (async (cb, opt) => { try {
-
+      console.log('SHIM', shim)
       var ecdhSubtle = shim.ossl || shim.subtle;
       // First: ECDSA keys for signing/verifying...
       var sa = await shim.subtle.generateKey(S.ecdsa.pair, true, [ 'sign', 'verify' ])

sea/array.js

@@ -1,24 +1,29 @@
-
 // This is Array extended to have .toString(['utf8'|'hex'|'base64'])
 function SeaArray() {}
-    Object.assign(SeaArray, { from: Array.from })
+Object.assign(SeaArray, { from: Array.from });
-    SeaArray.prototype = Object.create(Array.prototype)
+SeaArray.prototype = Object.create(Array.prototype);
-    SeaArray.prototype.toString = function(enc, start, end) { enc = enc || 'utf8'; start = start || 0;
+SeaArray.prototype.toString = function(enc, start, end) {
-      const length = this.length
+  enc = enc || "utf8";
-      if (enc === 'hex') {
+  start = start || 0;
-        const buf = new Uint8Array(this)
+  const length = this.length;
-        return [ ...Array(((end && (end + 1)) || length) - start).keys()]
+  if (enc === "hex") {
-        .map((i) => buf[ i + start ].toString(16).padStart(2, '0')).join('')
+    const buf = new Uint8Array(this);
+    return [...Array(((end && end + 1) || length) - start).keys()]
+      .map(i => buf[i + start].toString(16).padStart(2, "0"))
+      .join("");
   }
-      if (enc === 'utf8') {
+  if (enc === "utf8") {
-        return Array.from(
+    return Array.from({ length: (end || length) - start }, (_, i) =>
-          { length: (end || length) - start },
+      String.fromCharCode(this[i + start])
-          (_, i) => String.fromCharCode(this[ i + start])
+    ).join("");
-        ).join('')
   }
-      if (enc === 'base64') {
-        return btoa(this)
-      }
-    }
-    module.exports = SeaArray;
 
+  function btoa(b) {
+    return new Buffer(b).toString("base64");
+  }
+
+  if (enc === "base64") {
+    return btoa(this);
+  }
+};
+module.exports = SeaArray;

sea/buffer.js

@@ -1,78 +1,95 @@
-
 // This is Buffer implementation used in SEA. Functionality is mostly
 // compatible with NodeJS 'safe-buffer' and is used for encoding conversions
 // between binary and 'hex' | 'utf8' | 'base64'
 // See documentation and validation for safe implementation in:
 // https://github.com/feross/safe-buffer#update
-    var SeaArray = require('./array');
+var SeaArray = require("./array");
 function SafeBuffer(...props) {
-      console.warn('new SafeBuffer() is depreciated, please use SafeBuffer.from()')
+  console.warn("new SafeBuffer() is depreciated, please use SafeBuffer.from()");
-      return SafeBuffer.from(...props)
+  return SafeBuffer.from(...props);
 }
-    SafeBuffer.prototype = Object.create(Array.prototype)
+SafeBuffer.prototype = Object.create(Array.prototype);
 Object.assign(SafeBuffer, {
   // (data, enc) where typeof data === 'string' then enc === 'utf8'|'hex'|'base64'
   from() {
     if (!Object.keys(arguments).length) {
-          throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
+      throw new TypeError(
+        "First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object."
+      );
     }
-        const input = arguments[0]
+    const input = arguments[0];
-        let buf
+    let buf;
-        if (typeof input === 'string') {
+    function atob(a) {
-          const enc = arguments[1] || 'utf8'
+      return new Buffer(a, "base64").toString("binary");
-          if (enc === 'hex') {
+    }
-            const bytes = input.match(/([\da-fA-F]{2})/g)
+    if (typeof input === "string") {
-            .map((byte) => parseInt(byte, 16))
+      const enc = arguments[1] || "utf8";
+      if (enc === "hex") {
+        const bytes = input
+          .match(/([\da-fA-F]{2})/g)
+          .map(byte => parseInt(byte, 16));
         if (!bytes || !bytes.length) {
-              throw new TypeError('Invalid first argument for type \'hex\'.')
+          throw new TypeError("Invalid first argument for type 'hex'.");
         }
-            buf = SeaArray.from(bytes)
+        buf = SeaArray.from(bytes);
-          } else if (enc === 'utf8') {
+      } else if (enc === "utf8") {
-            const length = input.length
+        const length = input.length;
-            const words = new Uint16Array(length)
+        const words = new Uint16Array(length);
-            Array.from({ length: length }, (_, i) => words[i] = input.charCodeAt(i))
+        Array.from(
-            buf = SeaArray.from(words)
+          { length: length },
-          } else if (enc === 'base64') {
+          (_, i) => (words[i] = input.charCodeAt(i))
-            const dec = atob(input)
+        );
-            const length = dec.length
+        buf = SeaArray.from(words);
-            const bytes = new Uint8Array(length)
+      } else if (enc === "base64") {
-            Array.from({ length: length }, (_, i) => bytes[i] = dec.charCodeAt(i))
+        const dec = atob(input);
-            buf = SeaArray.from(bytes)
+        const length = dec.length;
-          } else if (enc === 'binary') {
+        const bytes = new Uint8Array(length);
-            buf = SeaArray.from(input)
+        Array.from(
+          { length: length },
+          (_, i) => (bytes[i] = dec.charCodeAt(i))
+        );
+        buf = SeaArray.from(bytes);
+      } else if (enc === "binary") {
+        buf = SeaArray.from(input);
       } else {
-            console.info('SafeBuffer.from unknown encoding: '+enc)
+        console.info("SafeBuffer.from unknown encoding: " + enc);
       }
-          return buf
+      return buf;
     }
-        const byteLength = input.byteLength // what is going on here? FOR MARTTI
+    const byteLength = input.byteLength; // what is going on here? FOR MARTTI
-        const length = input.byteLength ? input.byteLength : input.length
+    const length = input.byteLength ? input.byteLength : input.length;
     if (length) {
-          let buf
+      let buf;
       if (input instanceof ArrayBuffer) {
-            buf = new Uint8Array(input)
+        buf = new Uint8Array(input);
       }
-          return SeaArray.from(buf || input)
+      return SeaArray.from(buf || input);
     }
   },
   // This is 'safe-buffer.alloc' sans encoding support
   alloc(length, fill = 0 /*, enc*/) {
-        return SeaArray.from(new Uint8Array(Array.from({ length: length }, () => fill)))
+    return SeaArray.from(
+      new Uint8Array(Array.from({ length: length }, () => fill))
+    );
   },
   // This is normal UNSAFE 'buffer.alloc' or 'new Buffer(length)' - don't use!
   allocUnsafe(length) {
-        return SeaArray.from(new Uint8Array(Array.from({ length : length })))
+    return SeaArray.from(new Uint8Array(Array.from({ length: length })));
   },
   // This puts together array of array like members
-      concat(arr) { // octet array
+  concat(arr) {
+    // octet array
     if (!Array.isArray(arr)) {
-          throw new TypeError('First argument must be Array containing ArrayBuffer or Uint8Array instances.')
+      throw new TypeError(
+        "First argument must be Array containing ArrayBuffer or Uint8Array instances."
+      );
     }
-        return SeaArray.from(arr.reduce((ret, item) => ret.concat(Array.from(item)), []))
+    return SeaArray.from(
+      arr.reduce((ret, item) => ret.concat(Array.from(item)), [])
+    );
   }
-    })
+});
-    SafeBuffer.prototype.from = SafeBuffer.from
+SafeBuffer.prototype.from = SafeBuffer.from;
-    SafeBuffer.prototype.toString = SeaArray.prototype.toString
+SafeBuffer.prototype.toString = SeaArray.prototype.toString;
 
 module.exports = SafeBuffer;
-  

sea/shim.js

@@ -1,7 +1,6 @@
-
+const SEA = require("./root");
-    const SEA = require('./root')
+const Buffer = require("./buffer");
-    const Buffer = require('./buffer')
+const api = { Buffer: Buffer };
-    const api = {Buffer: Buffer}
 var o = {};
 
 if (SEA.window) {
@@ -9,28 +8,32 @@
   api.subtle = (api.crypto || o).subtle || (api.crypto || o).webkitSubtle;
   api.TextEncoder = window.TextEncoder;
   api.TextDecoder = window.TextDecoder;
-      api.random = (len) => Buffer.from(api.crypto.getRandomValues(new Uint8Array(Buffer.alloc(len))))
+  api.random = len =>
+    Buffer.from(api.crypto.getRandomValues(new Uint8Array(Buffer.alloc(len))));
 }
-    if(!api.crypto){try{
+if (!api.crypto) {
-      var crypto = require('crypto', 1);
+  try {
-      const { TextEncoder, TextDecoder } = require('text-encoding', 1)
+    var crypto = require("crypto", 1);
+    const { TextEncoder, TextDecoder } = require("text-encoding", 1);
     Object.assign(api, {
       crypto,
       //subtle,
       TextEncoder,
       TextDecoder,
-        random: (len) => Buffer.from(crypto.randomBytes(len))
+      random: len => Buffer.from(crypto.randomBytes(len))
     });
     //try{
-        const WebCrypto = require('node-webcrypto-ossl', 1);
+    const { Crypto: WebCrypto } = require("@peculiar/webcrypto", 1);
-        api.ossl = api.subtle = new WebCrypto({directory: 'ossl'}).subtle // ECDH
+    api.ossl = api.subtle = new WebCrypto({ directory: "ossl" }).subtle; // ECDH
     //}catch(e){
     //console.log("node-webcrypto-ossl is optionally needed for ECDH, please install if needed.");
     //}
   } catch (e) {
-      console.log("node-webcrypto-ossl and text-encoding may not be included by default, please add it to your package.json!");
+    console.log(
+      "node-webcrypto-ossl and text-encoding may not be included by default, please add it to your package.json!"
+    );
     OSSL_WEBCRYPTO_OR_TEXT_ENCODING_NOT_INSTALLED;
-    }}
+  }
-
+}
-    module.exports = api
 
+module.exports = api;

test/sea/sea.js

@@ -1,5 +1,8 @@
 var root;
 var Gun;
+function atob(a) {
+  return new Buffer(a, 'base64').toString('binary');
+};
 (function(){
   var env;
   if(typeof global !== 'undefined'){ env = global }