Use browser (subtle) implementation for all env

package.json

@@ -158,6 +158,9 @@
       "**/*.spec.js"
     ]
   },
+  "browser": {
+    "./lib/crypto_subtle.js": "./lib/crypto_subtle_browser.js"
+  },
   "size-limit": [
     {
       "path": "build/esm/index.js",

src/lib/crypto.ts

@@ -1,26 +1,4 @@
-import nodeCrypto from "crypto";
-
-// IE 11
-declare global {
-  interface Window {
-    msCrypto?: Crypto;
-  }
-
-  interface Crypto {
-    webkitSubtle?: SubtleCrypto;
-  }
-}
-
-const crypto =
-  (typeof window !== "undefined" &&
-    (window as Window) &&
-    (window.crypto || window.msCrypto)) ||
-  (nodeCrypto.webcrypto as unknown as Crypto);
-const subtle: SubtleCrypto = crypto.subtle || crypto.webkitSubtle;
-
-if (subtle === undefined) {
-  throw new Error("crypto and/or subtle api unavailable");
-}
+import { crypto, subtle } from "./crypto_subtle";
 
 export { crypto, subtle };
 

src/lib/crypto_subtle.ts

@@ -0,0 +1,15 @@
+import nodeCrypto from "crypto";
+
+// Types do not seem up-to-date
+const crypto: Crypto = nodeCrypto.webcrypto as unknown as Crypto;
+if (crypto === undefined) {
+  throw new Error("node crypto api unavailable");
+}
+
+const subtle: SubtleCrypto = crypto.subtle || crypto.webkitSubtle;
+
+if (subtle === undefined) {
+  throw new Error("node subtle api unavailable");
+}
+
+export { crypto, subtle };

src/lib/crypto_subtle_browser.ts

@@ -0,0 +1,22 @@
+declare global {
+  interface Window {
+    msCrypto?: Crypto;
+  }
+
+  interface Crypto {
+    webkitSubtle?: SubtleCrypto;
+  }
+}
+
+const crypto = window.crypto || window.msCrypto;
+if (crypto === undefined) {
+  throw new Error("browser crypto api unavailable");
+}
+
+const subtle: SubtleCrypto = crypto.subtle || crypto.webkitSubtle;
+
+if (subtle === undefined) {
+  throw new Error("browser subtle api unavailable");
+}
+
+export { crypto, subtle };

src/lib/enr/keypair/secp256k1.ts

@@ -1,8 +1,8 @@
-import crypto from "crypto";
-
 import * as secp256k1 from "secp256k1";
 import { concat } from "uint8arrays/concat";
 
+import { randomBytes } from "../../crypto";
+
 import { AbstractKeypair, IKeypair, IKeypairClass, KeypairType } from "./types";
 
 export function secp256k1PublicKeyToCompressed(
@@ -41,7 +41,7 @@ export const Secp256k1Keypair: IKeypairClass = class Secp256k1Keypair
   }
 
   static async generate(): Promise<Secp256k1Keypair> {
-    const privateKey = await randomBytes(32);
+    const privateKey = randomBytes(32);
     const publicKey = secp256k1.publicKeyCreate(privateKey);
     return new Secp256k1Keypair(privateKey, publicKey);
   }
@@ -69,13 +69,3 @@ export const Secp256k1Keypair: IKeypairClass = class Secp256k1Keypair
     return secp256k1.ecdsaVerify(sig, msg, this.publicKey);
   }
 };
-
-function randomBytes(length: number): Uint8Array {
-  if (typeof window !== "undefined" && window && window.crypto) {
-    const array = new Uint8Array(length);
-    window.crypto.getRandomValues(array);
-    return array;
-  } else {
-    return crypto.randomBytes(length);
-  }
-}

src/lib/enr/v4.ts

@@ -1,16 +1,16 @@
-import crypto from "crypto";
-
 import { keccak256 } from "js-sha3";
 import * as secp256k1 from "secp256k1";
 
+import { randomBytes } from "../crypto";
+
 import { createNodeId } from "./create";
 import { NodeId } from "./types";
 
 export function hash(input: Uint8Array): Uint8Array {
   return new Uint8Array(keccak256.arrayBuffer(input));
 }
 
-export async function createPrivateKey(): Promise<Uint8Array> {
+export function createPrivateKey(): Uint8Array {
   return randomBytes(32);
 }
 
@@ -45,13 +45,13 @@ export class ENRKeyPair {
     public readonly publicKey: Uint8Array
   ) {}
 
-  public static async create(privateKey?: Uint8Array): Promise<ENRKeyPair> {
+  public static create(privateKey?: Uint8Array): ENRKeyPair {
     if (privateKey) {
       if (!secp256k1.privateKeyVerify(privateKey)) {
         throw new Error("Invalid private key");
       }
     }
-    const _privateKey = privateKey || (await createPrivateKey());
+    const _privateKey = privateKey || createPrivateKey();
     const _publicKey = publicKey(_privateKey);
     const _nodeId = nodeId(_publicKey);
 
@@ -66,13 +66,3 @@ export class ENRKeyPair {
     return verify(this.publicKey, msg, sig);
   }
 }
-
-function randomBytes(length: number): Uint8Array {
-  if (typeof window !== "undefined" && window && window.crypto) {
-    const array = new Uint8Array(length);
-    window.crypto.getRandomValues(array);
-    return array;
-  } else {
-    return crypto.randomBytes(length);
-  }
-}

src/lib/waku_message/symmetric/browser.ts → src/lib/waku_message/symmetric.ts

@@ -1,23 +1,11 @@
-import { IvSize } from "./index";
+import { randomBytes, subtle } from "../crypto";
 
-declare global {
-  interface Window {
-    msCrypto?: Crypto;
-  }
-  interface Crypto {
-    webkitSubtle?: SubtleCrypto;
-  }
-}
-
-const crypto = window.crypto || window.msCrypto;
-const subtle: SubtleCrypto = crypto.subtle || crypto.webkitSubtle;
+export const KeySize = 32;
+export const IvSize = 12;
+export const TagSize = 16;
 
 const Algorithm = { name: "AES-GCM", length: 128 };
 
-if (subtle === undefined) {
-  throw new Error("Failed to load Subtle CryptoAPI");
-}
-
 export async function encrypt(
   iv: Buffer | Uint8Array,
   key: Buffer,
@@ -45,7 +33,5 @@ export async function decrypt(
 }
 
 export function generateIv(): Uint8Array {
-  const iv = new Uint8Array(IvSize);
-  crypto.getRandomValues(iv);
-  return iv;
+  return randomBytes(IvSize);
 }

src/lib/waku_message/version_1.ts

@@ -1,13 +1,13 @@
 import { Buffer } from "buffer";
-import * as crypto from "crypto";
 
 import { keccak256 } from "js-sha3";
 import * as secp256k1 from "secp256k1";
 
+import { randomBytes } from "../crypto";
 import { hexToBytes } from "../utils";
 
 import * as ecies from "./ecies";
-import { IvSize, symmetric, SymmetricKeySize } from "./symmetric";
+import * as symmetric from "./symmetric";
 
 const FlagsLength = 1;
 const FlagMask = 3; // 0011
@@ -170,7 +170,7 @@ export async function decryptSymmetric(
   key: Uint8Array | Buffer | string
 ): Promise<Uint8Array> {
   const data = Buffer.from(payload);
-  const ivStart = data.length - IvSize;
+  const ivStart = data.length - symmetric.IvSize;
   const cipher = data.slice(0, ivStart);
   const iv = data.slice(ivStart);
 
@@ -190,7 +190,7 @@ export function generatePrivateKey(): Uint8Array {
  * Generate a new symmetric key to be used for symmetric encryption.
  */
 export function generateSymmetricKey(): Uint8Array {
-  return randomBytes(SymmetricKeySize);
+  return randomBytes(symmetric.KeySize);
 }
 
 /**
@@ -258,13 +258,3 @@ function ecRecoverPubKey(messageHash: string, signature: Buffer): Uint8Array {
     false
   );
 }
-
-function randomBytes(length: number): Uint8Array {
-  if (typeof window !== "undefined" && window && window.crypto) {
-    const array = new Uint8Array(length);
-    window.crypto.getRandomValues(array);
-    return array;
-  } else {
-    return crypto.randomBytes(length);
-  }
-}