web-dc-api 0.0.58 → 0.0.60

package/dist/cjs/node_modules/jscrypto/es6/lib/algorithm/cipher/mode/GCM.js

@@ -0,0 +1,304 @@
+'use strict';
+
+var BlockCipherMode = require('./BlockCipherMode.js');
+var Word32Array = require('../../../Word32Array.js');
+var commonLib = require('./commonLib.js');
+
+/**
+ * Galois Counter Mode
+ */
+class GCM extends BlockCipherMode.BlockCipherMode {
+  constructor(props) {
+    super(props);
+    this._H = [];
+    this._J0 = [];
+    this._CB = []; // Counter Block
+    if (props.cipher.blockSize !== 128 / 32) {
+      throw new Error("In GCM block cipher mode, cipher block size must be 128bit");
+    }
+    const {
+      cipher,
+      iv
+    } = props;
+    const H = [0, 0, 0, 0];
+    cipher.encryptBlock(H, 0);
+    this._H = H;
+    // iv should be array of 32bit int
+    this._J0 = GCM.getJ0(H, iv === null || iv === void 0 ? void 0 : iv.words);
+    this._CB = this._J0.slice();
+  }
+  /**
+   * Initialize Initial Counter Block J0.
+   * @param {[number, number, number, number]} H - 128bit(4word) block
+   * @param {number[]} iv - Initializing Vector which must be multiple of 32bit(4byte)
+   */
+  static getJ0(H, iv) {
+    let J0;
+    if (!iv || iv.length === 0) {
+      J0 = [0, 0, 0, 1];
+    } else if (iv.length === 3) {
+      J0 = [iv[0], iv[1], iv[2], 1];
+    } else {
+      const remainderOf4Word = iv.length % 4 > 0 ? 4 - iv.length % 4 : 0;
+      const iv2 = iv.slice();
+      for (let i = 0; i < remainderOf4Word + 2; i++) {
+        iv2.push(0); // append 32bit 0
+      }
+      // This should be upper 32bit of len(iv),
+      // But iv.length > 4294967295(0xffffffff, unsigned 32bit int max) is not supported for now.
+      iv2.push(0);
+      iv2.push(iv.length * 32); // An element of `iv` is 4byte = 32bit.
+      J0 = GCM.GHASH(H, iv2);
+    }
+    return J0;
+  }
+  /**
+   * https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf
+   * 6.2 Incrementing Function
+   * inc(s=32, X) = MSB(len(X)-s, X) || [int(LSB(s, X)+1 mod 2^s]
+   *
+   * @param {number[]} X - [32bit int, 32bit int, 32bit int, 32bit int].
+   * @example
+   *   inc32([0,0,0,0]) = [0,0,0,1]
+   *   inc32([0,0,0,1]) = [0,0,0,2]
+   *   inc32([0,0,0,0xffffffff]) = [0,0,1,0]
+   *   inc32([0,0,0xffffffff,0xffffffff]) = [0,1,0,0]
+   *   inc32([0,0xffffffff,0xffffffff,0xffffffff]) = [0,0,0,0]
+   */
+  static inc32(X) {
+    const A = X.slice();
+    const unsignedX3 = A[3] >>> 0;
+    const carry3 = unsignedX3 + 1 >>> 0 < unsignedX3;
+    A[3] = A[3] + 1 | 0;
+    if (carry3) {
+      const unsignedX2 = A[2] >>> 0;
+      const carry2 = unsignedX2 + 1 >>> 0 < unsignedX2;
+      A[2] = A[2] + 1 | 0;
+      if (carry2) {
+        A[1] = A[1] + 1 | 0;
+      }
+    }
+    return A;
+  }
+  /**
+   * https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf
+   * 6.3 Multiplication Operation on Blocks
+   *
+   * @param {number[]} X - [32bit int, 32bit int, 32bit int, 32bit int], 128bit block.
+   * @param {number[]} Y - [32bit int, 32bit int, 32bit int, 32bit int], 128bit block.
+   * @returns 128bit block
+   */
+  static mul(X, Y) {
+    const R = [0xe1000000, 0, 0, 0];
+    const Z = [0, 0, 0, 0];
+    const V = Y.slice();
+    for (let i = 0; i < 128; i++) {
+      const xIndex = i >>> 5;
+      const xi = X[xIndex] >>> 31 - i % 32 & 1;
+      if (xi > 0) {
+        Z[0] = Z[0] ^ V[0];
+        Z[1] = Z[1] ^ V[1];
+        Z[2] = Z[2] ^ V[2];
+        Z[3] = Z[3] ^ V[3];
+      }
+      const LSBVi = (V[3] & 1) >>> 0;
+      const carry0 = (V[0] & 1) >>> 0;
+      const carry1 = (V[1] & 1) >>> 0;
+      const carry2 = (V[2] & 1) >>> 0;
+      V[0] = V[0] >>> 1;
+      V[1] = V[1] >>> 1 | (carry0 ? 0x80000000 : 0);
+      V[2] = V[2] >>> 1 | (carry1 ? 0x80000000 : 0);
+      V[3] = V[3] >>> 1 | (carry2 ? 0x80000000 : 0);
+      if (LSBVi > 0) {
+        V[0] ^= R[0];
+        V[1] ^= R[1];
+        V[2] ^= R[2];
+        V[3] ^= R[3];
+      }
+    }
+    return Z;
+  }
+  /**
+   * https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf
+   * 6.4 GHASH Function
+   *
+   * @param {number[]} H - The hash sub key block of 128bit.
+   * @param {number[]} X - X.length must be multiple of 4. (multiple of 128bit)
+   * @returns 128bit block
+   */
+  static GHASH(H, X) {
+    if (H.length % 4 !== 0) {
+      throw new Error("Length of 32bit word array 'H' must be multiple of 4(128bit)");
+    } else if (X.length % 4 !== 0) {
+      throw new Error("Length of 32bit word array 'X' must be multiple of 4(128bit)");
+    }
+    const m = X.length;
+    let Y = [0, 0, 0, 0];
+    for (let i = 0; i < m; i += 4) {
+      Y[0] = Y[0] ^ X[i];
+      Y[1] = Y[1] ^ X[i + 1];
+      Y[2] = Y[2] ^ X[i + 2];
+      Y[3] = Y[3] ^ X[i + 3];
+      Y = GCM.mul(Y, H);
+    }
+    return Y;
+  }
+  /**
+   * https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf
+   * 6.5 GCTR Function
+   *
+   * @param {BlockCipher} cipher
+   * @param {number[]} ICB - Initial Code Block. Required to be 128bit(4word).
+   * @param {Word32Array} X - Arbitrary length block
+   */
+  static GCTR(cipher, ICB, X) {
+    if (X.nSigBytes === 0) {
+      return X.clone();
+    }
+    if (ICB.length !== 4) {
+      throw new Error("Initial Counter Block size must be 128bit");
+    }
+    const words = X.words;
+    const n = Math.ceil(X.nSigBytes / 16);
+    const CB = [ICB.slice()];
+    for (let i = 1; i < n; i++) {
+      const CBi = GCM.inc32(CB[i - 1]);
+      CB.push(CBi);
+    }
+    const Y = new Word32Array.Word32Array();
+    for (let i = 0; i < n; i++) {
+      cipher.encryptBlock(CB[i], 0);
+      const remainderOf16Bytes = X.nSigBytes % 16;
+      if (i < n - 1 || /* i === n-1 && */remainderOf16Bytes === 0) {
+        const Yi0 = words[i * 4] ^ CB[i][0];
+        const Yi1 = words[i * 4 + 1] ^ CB[i][1];
+        const Yi2 = words[i * 4 + 2] ^ CB[i][2];
+        const Yi3 = words[i * 4 + 3] ^ CB[i][3];
+        const Yi = new Word32Array.Word32Array([Yi0, Yi1, Yi2, Yi3]);
+        Y.concat(Yi);
+        continue;
+      }
+      // i === n-1
+      const w = [];
+      let nSigBytes = 0;
+      const nMaxAligned = Math.floor(remainderOf16Bytes / 4);
+      for (let k = 0; k < nMaxAligned; k++) {
+        const Ynk = words[i * 4 + k] ^ CB[i][k];
+        w.push(Ynk);
+        nSigBytes += 4;
+      }
+      const remaining0to3Bytes = remainderOf16Bytes % 4;
+      if (remaining0to3Bytes > 0) {
+        const Ynr = words[i * 4 + nMaxAligned] << 32 - 8 * remaining0to3Bytes ^ CB[i][nMaxAligned];
+        w.push(Ynr);
+        nSigBytes += remaining0to3Bytes;
+      }
+      const Yn = new Word32Array.Word32Array(w, nSigBytes);
+      Y.concat(Yn);
+    }
+    Y.nSigBytes = X.nSigBytes;
+    Y.clamp();
+    return Y;
+  }
+  /**
+   * Calculate Message Authentication Code with GCM
+   *
+   * @param {typeof BlockCipher} Cipher - 128 bit block Cipher i.e. AES
+   * @param {Word32Array} key - key
+   * @param {Word32Array} iv - iv should be 12byte length. i.e. `new Word32Array([0x11223344, 0x55667788, 0x99aabbcc], 12);`
+   * @param {Word32Array?} aad - Additional Authenticated Data
+   * @param {Word32Array?} cipherText - encrypted text
+   * @param {number?} tagLength - authTag size in octet length. If omitted, tagLength will be set to 16byte.
+   */
+  static mac(Cipher, key, iv, aad, cipherText, tagLength) {
+    const cipher = new Cipher({
+      key,
+      iv
+    });
+    const H = [0, 0, 0, 0];
+    cipher.encryptBlock(H, 0);
+    const J0 = GCM.getJ0(H, iv.words);
+    const A = (aad === null || aad === void 0 ? void 0 : aad.clone()) || new Word32Array.Word32Array();
+    const lenA = [0, A.nSigBytes * 8];
+    const C = (cipherText === null || cipherText === void 0 ? void 0 : cipherText.clone()) || new Word32Array.Word32Array();
+    const lenC = [0, C.nSigBytes * 8];
+    const lenT = tagLength || 16;
+    // Pad
+    commonLib.padTo128m(A);
+    commonLib.padTo128m(C);
+    const s = A.words.concat(C.words).concat(lenA).concat(lenC);
+    const S = GCM.GHASH(H, s);
+    const MAC = GCM.GCTR(cipher, J0, new Word32Array.Word32Array(S));
+    return commonLib.msb(MAC, lenT);
+  }
+  /**
+   * Creates this mode for encryption.
+   * @param {BlockCipherModeProps} props
+   * @example
+   *   var mode = CTR.createEncryptor(cipher, iv.words);
+   */
+  static createEncryptor(props) {
+    return new GCM.Encryptor(props);
+  }
+  /**
+   * Creates this mode for decryption.
+   * @param {BlockCipherModeProps} props
+   * @example
+   *   var mode = CTR.createDecryptor(cipher, iv.words);
+   */
+  static createDecryptor(props) {
+    return new GCM.Decryptor(props);
+  }
+}
+/**
+ * CTR encryptor.
+ */
+GCM.Encryptor = class Encryptor extends GCM {
+  /**
+   * Processes the data block at offset.
+   *
+   * @param {number[]} words The data words to operate on.
+   * @param {number} offset The offset where the block starts.
+   * @example
+   *   mode.processBlock(data.words, offset);
+   */
+  processBlock(words, offset) {
+    // Shortcuts
+    const cipher = this._cipher;
+    const blockSize = cipher.blockSize;
+    // Encrypt with CTR mode
+    this._CB = GCM.inc32(this._CB);
+    const plainText = new Word32Array.Word32Array(words.slice(offset, offset + blockSize));
+    const C = GCM.GCTR(this._cipher, this._CB, plainText);
+    for (let i = 0; i < blockSize; i++) {
+      words[offset + i] = C.words[i];
+    }
+  }
+};
+/**
+ * CTR decryptor.
+ */
+GCM.Decryptor = class Decryptor extends GCM {
+  /**
+   * Processes the data block at offset.
+   *
+   * @param {number[]} words The data words to operate on.
+   * @param {number} offset The offset where the block starts.
+   * @example
+   *   mode.processBlock(data.words, offset);
+   */
+  processBlock(words, offset) {
+    // Shortcuts
+    const cipher = this._cipher;
+    const blockSize = cipher.blockSize;
+    // Decrypt with CTR mode
+    this._CB = GCM.inc32(this._CB);
+    const C = new Word32Array.Word32Array(words.slice(offset, offset + blockSize));
+    const P = GCM.GCTR(this._cipher, this._CB, C);
+    for (let i = 0; i < blockSize; i++) {
+      words[offset + i] = P.words[i];
+    }
+  }
+};
+
+exports.GCM = GCM;

package/dist/cjs/node_modules/jscrypto/es6/lib/algorithm/cipher/mode/OFB.js

@@ -0,0 +1,68 @@
+'use strict';
+
+var BlockCipherMode = require('./BlockCipherMode.js');
+
+/**
+ * Output Feedback Block mode
+ */
+class OFB extends BlockCipherMode.BlockCipherMode {
+  constructor(props) {
+    super(props);
+    this._keyStream = [];
+  }
+  /**
+   * Creates this mode for encryption.
+   * @param {BlockCipherModeProps} props
+   * @example
+   *   var mode = OFB.createEncryptor(cipher, iv.words);
+   */
+  static createEncryptor(props) {
+    return new OFB.Encryptor(props);
+  }
+  /**
+   * Creates this mode for decryption.
+   * @param {BlockCipherModeProps} props
+   * @example
+   *   var mode = OFB.createDecryptor(cipher, iv.words);
+   */
+  static createDecryptor(props) {
+    return new OFB.Decryptor(props);
+  }
+}
+/**
+ * OFB encryptor.
+ */
+OFB.Encryptor = class Encryptor extends OFB {
+  /**
+   * Processes the data block at offset.
+   *
+   * @param {number[]} words The data words to operate on.
+   * @param {number} offset The offset where the block starts.
+   * @example
+   *   mode.processBlock(data.words, offset);
+   */
+  processBlock(words, offset) {
+    // Shortcuts
+    const cipher = this._cipher;
+    const blockSize = cipher.blockSize;
+    const iv = this._iv;
+    let keyStream = this._keyStream;
+    // Generate key stream
+    if (iv) {
+      keyStream = this._keyStream = iv.words.slice(0);
+      // Remove IV for subsequent blocks
+      this._iv = undefined;
+    }
+    cipher.encryptBlock(keyStream, 0);
+    // Encrypt
+    for (let i = 0; i < blockSize; i++) {
+      words[offset + i] ^= keyStream[i];
+    }
+  }
+};
+/**
+ * OFB decryptor.
+ */
+OFB.Decryptor = OFB.Encryptor;
+
+exports.OFB = OFB;

package/dist/cjs/node_modules/jscrypto/es6/lib/algorithm/cipher/mode/commonLib.js

@@ -0,0 +1,64 @@
+'use strict';
+
+var Word32Array = require('../../../Word32Array.js');
+
+/**
+ * Pad word array to multiple of 128bit(4byte)
+ * @param {Word32Array} w - Padding target. This w will be modified directly.
+ * @returns {void}
+ */
+function padTo128m(w) {
+  const remainder = w.nSigBytes % 16;
+  if (remainder === 0) {
+    return;
+  }
+  const nPaddingBytes = 16 - remainder;
+  // Pad Ciphertext
+  const pad = [];
+  const maxI = Math.floor(nPaddingBytes / 4);
+  for (let i = 0; i < maxI; i++) {
+    pad.push(0);
+  }
+  if (nPaddingBytes % 4 > 0) {
+    pad.push(0);
+  }
+  w.concat(new Word32Array.Word32Array(pad, nPaddingBytes));
+}
+/**
+ * Extract Most Significant Bit.
+ * @param {Word32Array} w
+ * @param {number} bytes - Number of bytes to extract
+ * @example
+ *   const w = new Word32Array([0x11223344, 0x55667788]);
+ *   msb(w, 2).toString() === "1122"; // true
+ */
+function msb(w, bytes) {
+  return new Word32Array.Word32Array(w.words.slice(), bytes);
+}
+/**
+ * Extract Least Significant Bit.
+ * @param {Word32Array} w
+ * @param {number} bytes - Number of bytes to extract
+ * @example
+ *   const w = new Word32Array([0x11223344, 0x55667788, 0x99aabb00], 11);
+ *   lsb(w, 5).toString() === "778899aabb"; // true
+ */
+function lsb(w, bytes) {
+  const n = w.nSigBytes;
+  const nShift = n - bytes;
+  const lsbWords = [];
+  for (let i = 0; i < bytes; i++) {
+    const j = i >>> 2;
+    const byteIndex = nShift + i;
+    const wordIndex = byteIndex >>> 2;
+    const b = w.words[wordIndex] >>> 24 - byteIndex % 4 * 8 & 0x000000ff;
+    lsbWords[j] = lsbWords[j] | 0 | b << 24 - i % 4 * 8;
+  }
+  const wLsb = new Word32Array.Word32Array(lsbWords, bytes);
+  wLsb.clamp();
+  return wLsb;
+}
+
+exports.lsb = lsb;
+exports.msb = msb;
+exports.padTo128m = padTo128m;

package/dist/cjs/node_modules/jscrypto/es6/lib/algorithm/cipher/pad/AnsiX923.js

@@ -0,0 +1,42 @@
+'use strict';
+
+/**
+ * ANSI X.923 padding strategy
+ *
+ * @param {Word32Array} data The data to pad.
+ * @param {number} blockSize The multiple that the data should be padded to.
+ * @example
+ *   AnsiX923.pad(wordArray, 4);
+ */
+function pad(data, blockSize) {
+  // Shortcuts
+  const dataSigBytes = data.nSigBytes;
+  const blockSizeBytes = blockSize * 4;
+  // Count padding bytes
+  const nPaddingBytes = blockSizeBytes - dataSigBytes % blockSizeBytes;
+  // Compute last byte position
+  const lastBytePos = dataSigBytes + nPaddingBytes - 1;
+  // Pad
+  data.clamp();
+  data.words[lastBytePos >>> 2] |= nPaddingBytes << 24 - lastBytePos % 4 * 8;
+  data.nSigBytes += nPaddingBytes;
+}
+/**
+ * Unpads data that had been padded with ANSI X.923 padding strategy
+ *
+ * @param {Word32Array} data The data to unpad.
+ * @example
+ *   AnsiX923.unpad(wordArray);
+ */
+function unpad(data) {
+  // Get number of padding bytes from last byte
+  const nPaddingBytes = data.words[data.nSigBytes - 1 >>> 2] & 0xff;
+  // Remove padding
+  data.nSigBytes -= nPaddingBytes;
+}
+const AnsiX923 = {
+  pad,
+  unpad
+};
+
+exports.AnsiX923 = AnsiX923;

package/dist/cjs/node_modules/jscrypto/es6/lib/algorithm/cipher/pad/ISO10126.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var Word32Array = require('../../../Word32Array.js');
+
+/**
+ * ISO10126 padding strategy
+ *
+ * @param {Word32Array} data The data to pad.
+ * @param {number} blockSize The multiple that the data should be padded to.
+ * @example
+ *   ISO10126.pad(wordArray, 4);
+ */
+function pad(data, blockSize) {
+  // Shortcut
+  const blockSizeBytes = blockSize * 4;
+  // Count padding bytes
+  const nPaddingBytes = blockSizeBytes - data.nSigBytes % blockSizeBytes;
+  // Pad
+  data.concat(Word32Array.Word32Array.random(nPaddingBytes - 1)).concat(new Word32Array.Word32Array([nPaddingBytes << 24], 1));
+}
+/**
+ * Unpads data that had been padded with ISO10126 padding strategy.
+ *
+ * @param {Word32Array} data The data to unpad.
+ * @example
+ *   ISO10126.unpad(wordArray);
+ */
+function unpad(data) {
+  // Get number of padding bytes from last byte
+  const nPaddingBytes = data.words[data.nSigBytes - 1 >>> 2] & 0xff;
+  // Remove padding
+  data.nSigBytes -= nPaddingBytes;
+}
+const ISO10126 = {
+  pad,
+  unpad
+};
+
+exports.ISO10126 = ISO10126;

package/dist/cjs/node_modules/jscrypto/es6/lib/algorithm/cipher/pad/ISO97971.js

@@ -0,0 +1,38 @@
+'use strict';
+
+var Word32Array = require('../../../Word32Array.js');
+var Zero = require('./Zero.js');
+
+/**
+ * ISO/IEC 9797-1 Padding Method 2. padding strategy
+ *
+ * @param {Word32Array} data The data to pad.
+ * @param {number} blockSize The multiple that the data should be padded to.
+ * @example
+ *   ISO97971.pad(wordArray, 4);
+ */
+function pad(data, blockSize) {
+  // Add 0x80 byte
+  data.concat(new Word32Array.Word32Array([0x80000000], 1));
+  // Zero pad the rest
+  Zero.Zero.pad(data, blockSize);
+}
+/**
+ * Unpads data that had been padded with ISO/IEC 9797-1 Padding Method 2 strategy.
+ *
+ * @param {Word32Array} data The data to unpad.
+ * @example
+ *   ISO97971.unpad(wordArray);
+ */
+function unpad(data) {
+  // Remove zero padding
+  Zero.Zero.unpad(data);
+  // Remove one more byte -- the 0x80 byte
+  data.nSigBytes -= 1;
+}
+const ISO97971 = {
+  pad,
+  unpad
+};
+
+exports.ISO97971 = ISO97971;

package/dist/cjs/node_modules/jscrypto/es6/lib/algorithm/cipher/pad/NoPadding.js

@@ -0,0 +1,29 @@
+'use strict';
+
+/**
+ * A noop padding strategy
+ *
+ * @param {Word32Array} data The data to pad.
+ * @param {number} blockSize The multiple that the data should be padded to.
+ * @example
+ *   NoPadding.pad(wordArray, 4);
+ */
+function pad(data, blockSize) {
+  // NoPadding
+}
+/**
+ * Unpads data that had been padded with NoPadding strategy.
+ *
+ * @param {Word32Array} data The data to unpad.
+ * @example
+ *   NoPadding.unpad(wordArray);
+ */
+function unpad(data) {
+  // NoPadding
+}
+const NoPadding = {
+  pad,
+  unpad
+};
+
+exports.NoPadding = NoPadding;

package/dist/cjs/node_modules/jscrypto/es6/lib/algorithm/cipher/pad/Pkcs7.js

@@ -0,0 +1,47 @@
+'use strict';
+
+var Word32Array = require('../../../Word32Array.js');
+
+/**
+ * Pads data using the algorithm defined in PKCS #5/7.
+ *
+ * @param {Word32Array} data The data to pad.
+ * @param {number} blockSize The multiple that the data should be padded to.
+ * @example
+ *   Pkcs7.pad(wordArray, 4);
+ */
+function pad(data, blockSize) {
+  // Shortcut
+  const blockSizeBytes = blockSize * 4;
+  // Count padding bytes
+  const nPaddingBytes = blockSizeBytes - data.nSigBytes % blockSizeBytes;
+  // Create padding word
+  const paddingWord = nPaddingBytes << 24 | nPaddingBytes << 16 | nPaddingBytes << 8 | nPaddingBytes;
+  // Create padding
+  const paddingWords = [];
+  for (let i = 0; i < nPaddingBytes; i += 4) {
+    paddingWords.push(paddingWord);
+  }
+  const padding = new Word32Array.Word32Array(paddingWords, nPaddingBytes);
+  // Add padding
+  data.concat(padding);
+}
+/**
+ * Unpads data that had been padded using the algorithm defined in PKCS #5/7.
+ *
+ * @param {Word32Array} data The data to unpad.
+ * @example
+ *   Pkcs7.unpad(wordArray);
+ */
+function unpad(data) {
+  // Get number of padding bytes from last byte
+  const nPaddingBytes = data.words[data.nSigBytes - 1 >>> 2] & 0xff;
+  // Remove padding
+  data.nSigBytes -= nPaddingBytes;
+}
+const Pkcs7 = {
+  pad,
+  unpad
+};
+
+exports.Pkcs7 = Pkcs7;

package/dist/cjs/node_modules/jscrypto/es6/lib/algorithm/cipher/pad/Zero.js

@@ -0,0 +1,41 @@
+'use strict';
+
+/**
+ * Pads data with zero padding strategy.
+ *
+ * @param {Word32Array} data The data to pad.
+ * @param {number} blockSize The multiple that the data should be padded to.
+ * @example
+ *   Zero.pad(wordArray, 4);
+ */
+function pad(data, blockSize) {
+  // Shortcut
+  const blockSizeBytes = blockSize * 4;
+  // Pad
+  data.clamp();
+  data.nSigBytes += blockSizeBytes - (data.nSigBytes % blockSizeBytes || blockSizeBytes);
+}
+/**
+ * Unpads data that had been padded with zero padding strategy.
+ *
+ * @param {Word32Array} data The data to unpad.
+ * @example
+ *   Zero.unpad(wordArray);
+ */
+function unpad(data) {
+  // Shortcut
+  const dataWords = data.words;
+  // Unpad
+  for (let i = data.nSigBytes - 1; i >= 0; i--) {
+    if (dataWords[i >>> 2] >>> 24 - i % 4 * 8 & 0xff) {
+      data.nSigBytes = i + 1;
+      break;
+    }
+  }
+}
+const Zero = {
+  pad,
+  unpad
+};
+
+exports.Zero = Zero;

package/dist/cjs/node_modules/jscrypto/es6/lib/browser.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const ua = typeof navigator !== "undefined" && navigator.userAgent ? navigator.userAgent.toLowerCase() : "";
+const IEVer = (() => {
+  let ver = parseInt((/msie (\d+)/.exec(ua) || [])[1], 10);
+  if (isNaN(ver)) {
+    ver = parseInt((/trident\/.*; rv:(\d+)/.exec(ua) || [])[1], 10);
+    if (isNaN(ver)) {
+      return false;
+    }
+    return ver;
+  }
+  return ver;
+})();
+function isIE(op, ver) {
+  if (IEVer === false) return false;
+  return IEVer < ver;
+}
+
+exports.isIE = isIE;