web-dc-api 0.0.58 → 0.0.60

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

@@ -0,0 +1,66 @@
+'use strict';
+
+var OpenSSLFormatter = require('./formatter/OpenSSLFormatter.js');
+
+/**
+ * A collection of cipher parameters.
+ *
+ * @property {Word32Array} ciphertext The raw ciphertext.
+ * @property {Word32Array} key The key to this ciphertext.
+ * @property {Word32Array} iv The IV used in the ciphering operation.
+ * @property {Word32Array} salt The salt used with a key derivation function.
+ * @property {typeof Cipher} algorithm The cipher algorithm.
+ * @property {BlockCipherMode} mode The block mode used in the ciphering operation.
+ * @property {Pad} padding The padding scheme used in the ciphering operation.
+ * @property {number} blockSize The block size of the cipher.
+ * @property {Formatter} formatter The default formatting strategy to convert this cipher params object to a string.
+ */
+class CipherParams {
+  /**
+   * Initializes a newly created cipher params object.
+   *
+   * @param {Partial<CipherParams>} cp An object with any of the possible cipher parameters.
+   * @example
+   *   var cipherParams = new CipherParams({
+   *       ciphertext: ciphertextWordArray,
+   *       key: keyWordArray,
+   *       iv: ivWordArray,
+   *       salt: saltWordArray,
+   *       algorithm: AES,
+   *       mode: CBC,
+   *       padding: PKCS7,
+   *       blockSize: 4,
+   *       formatter: OpenSSLFormatter
+   *     });
+   */
+  constructor(cp) {
+    this.formatter = OpenSSLFormatter.OpenSSLFormatter;
+    if (cp) {
+      this.cipherText = cp.cipherText;
+      this.key = cp.key;
+      this.iv = cp.iv;
+      this.salt = cp.salt;
+      this.Algorithm = cp.Algorithm;
+      this.mode = cp.mode;
+      this.padding = cp.padding;
+      this.blockSize = cp.blockSize;
+      this.formatter = cp.formatter || OpenSSLFormatter.OpenSSLFormatter;
+    }
+  }
+  /**
+   * Converts this cipher params object to a string.
+   *
+   * @param {Formatter?} formatter (Optional) The formatting strategy to use.
+   * @return {string} The stringified cipher params.
+   * @throws Error If neither the formatter nor the default formatter is set.
+   * @example
+   *   var string = cipherParams + '';
+   *   var string = cipherParams.toString();
+   *   var string = cipherParams.toString(OpenSSLFormatter);
+   */
+  toString(formatter) {
+    return (formatter || this.formatter).stringify(this);
+  }
+}
+
+exports.CipherParams = CipherParams;

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

@@ -0,0 +1,86 @@
+'use strict';
+
+var SerializableCipher = require('./SerializableCipher.js');
+var OpenSSLKDF = require('./kdf/OpenSSLKDF.js');
+var CipherParams = require('./CipherParams.js');
+var OpenSSLFormatter = require('./formatter/OpenSSLFormatter.js');
+
+const PasswordBasedCipher = {
+  /**
+   * Encrypts a message using a password.
+   *
+   * @param {typeof Cipher} Cipher The cipher algorithm to use.
+   * @param {Word32Array|string} message The message to encrypt.
+   * @param {string} password The password.
+   * @param {Partial<PasswordBasedCipherProps>?} props (Optional) The configuration options to use for this operation.
+   * @return {CipherParams} A cipher params object.
+   * @example
+   *   var params = PasswordBasedCipher.encrypt(AES, message, 'password');
+   *   var params = PasswordBasedCipher.encrypt(AES, message, 'password', { format: OpenSSLFormatter });
+   */
+  encrypt(Cipher, message, password, props) {
+    const cipherProps = props ? Object.assign({}, props) : {};
+    const KDF = props && props.KDF ? props.KDF : OpenSSLKDF.OpenSSLKDF;
+    const kdfProps = {};
+    if (props && props.kdfHasher) {
+      kdfProps.kdfHasher = props.kdfHasher;
+    }
+    if (props && props.kdfIterations) {
+      kdfProps.kdfIterations = props.kdfIterations;
+    }
+    if (props && props.kdfModule) {
+      kdfProps.kdfModule = props.kdfModule;
+    }
+    const derivedParams = KDF.execute(password, Cipher.keySize, Cipher.ivSize, cipherProps.kdfSalt, kdfProps);
+    cipherProps.iv = derivedParams.iv;
+    const cipherParams = SerializableCipher.SerializableCipher.encrypt(Cipher, message, derivedParams.key, cipherProps);
+    return new CipherParams.CipherParams(Object.assign(Object.assign({}, cipherParams), {
+      key: derivedParams.key,
+      iv: derivedParams.iv,
+      salt: derivedParams.salt
+    }));
+  },
+  /**
+   * Decrypts serialized ciphertext using a password.
+   *
+   * @param {typeof Cipher} Cipher The cipher algorithm to use.
+   * @param {CipherParams|string} cipherParams The ciphertext to decrypt.
+   * @param {string} password The password.
+   * @param {Partial<PasswordBasedCipherProps>?} props (Optional) The configuration options to use for this operation.
+   * @return {Word32Array} The plaintext.
+   * @example
+   *   var plaintext = PasswordBasedCipher.decrypt(
+   *     AES,
+   *     formattedCiphertext,
+   *     'password',
+   *     { format: OpenSSLFormatter }
+   *   );
+   *   var plaintext = PasswordBasedCipher.decrypt(
+   *     AES,
+   *     ciphertextParams,
+   *     'password',
+   *     { format: OpenSSLFormatter }
+   *   );
+   */
+  decrypt(Cipher, cipherParams, password, props) {
+    const p = props ? Object.assign({}, props) : {};
+    const KDF = p.KDF ? p.KDF : OpenSSLKDF.OpenSSLKDF;
+    const formatter = p.formatter ? p.formatter : OpenSSLFormatter.OpenSSLFormatter;
+    const cipherParamsObj = SerializableCipher.parseCipherText(cipherParams, formatter);
+    const kdfProps = {};
+    if (props && props.kdfHasher) {
+      kdfProps.kdfHasher = props.kdfHasher;
+    }
+    if (props && props.kdfIterations) {
+      kdfProps.kdfIterations = props.kdfIterations;
+    }
+    if (props && props.kdfModule) {
+      kdfProps.kdfModule = props.kdfModule;
+    }
+    const derivedParams = KDF.execute(password, Cipher.keySize, Cipher.ivSize, cipherParamsObj.salt, kdfProps);
+    p.iv = derivedParams.iv;
+    return SerializableCipher.SerializableCipher.decrypt(Cipher, cipherParamsObj, derivedParams.key, p);
+  }
+};
+
+exports.PasswordBasedCipher = PasswordBasedCipher;

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

@@ -0,0 +1,68 @@
+'use strict';
+
+var OpenSSLFormatter = require('./formatter/OpenSSLFormatter.js');
+var CipherParams = require('./CipherParams.js');
+
+/**
+ * Converts serialized ciphertext to CipherParams,
+ * else assumed CipherParams already and returns ciphertext unchanged.
+ * @param {CipherParams|string} cipherTextParams The ciphertext.
+ * @param {Formatter} formatter The formatting strategy to use to parse serialized ciphertext.
+ * @return {CipherParams} The un-serialized ciphertext.
+ * @example
+ *   var ciphertextParams = SerializableCipher.parse(ciphertextStringOrParams, format);
+ */
+function parseCipherText(cipherTextParams, formatter) {
+  if (typeof cipherTextParams === "string") {
+    return formatter.parse(cipherTextParams);
+  }
+  return cipherTextParams;
+}
+const SerializableCipher = {
+  /**
+   * Encrypts a message.
+   *
+   * @param {typeof Cipher} Cipher The cipher algorithm to use.
+   * @param {Word32Array|string} message The message to encrypt.
+   * @param {Word32Array} key The key.
+   * @param {Partial<SerializableCipherProps>?} props (Optional) The configuration options to use for this operation.
+   * @return {CipherParams} A cipher params object.
+   * @example
+   *   var ciphertextParams = SerializableCipher.encrypt(AES, message, key);
+   *   var ciphertextParams = SerializableCipher.encrypt(AES, message, key, { iv: iv });
+   */
+  encrypt(Cipher, message, key, props) {
+    const encryptor = Cipher.createEncryptor(key, props);
+    const cipherText = encryptor.finalize(message);
+    return new CipherParams.CipherParams({
+      cipherText,
+      key,
+      iv: encryptor.iv,
+      Algorithm: Cipher,
+      mode: encryptor.mode,
+      padding: encryptor.padding,
+      blockSize: encryptor.blockSize,
+      formatter: (props === null || props === void 0 ? void 0 : props.formatter) || OpenSSLFormatter.OpenSSLFormatter
+    });
+  },
+  /**
+   * Decrypts serialized ciphertext.
+   *
+   * @param {typeof Cipher} Cipher The cipher algorithm to use.
+   * @param {CipherParams|string} cipherParams The ciphertext to decrypt.
+   * @param {Word32Array} key The key.
+   * @param {Partial<SerializableCipherProps>} props (Optional) The configuration options to use for this operation.
+   * @return {Word32Array} The plaintext.
+   * @example
+   *     var plaintext = SerializableCipher.decrypt(AES, formattedCiphertext, key, { iv: iv, format: OpenSSLFormatter });
+   *     var plaintext = SerializableCipher.decrypt(AES, ciphertextParams, key, { iv: iv, format: OpenSSLFormatter });
+   */
+  decrypt(Cipher, cipherParams, key, props) {
+    const decryptor = Cipher.createDecryptor(key, props);
+    const cipherParamsObj = parseCipherText(cipherParams, (props === null || props === void 0 ? void 0 : props.formatter) || OpenSSLFormatter.OpenSSLFormatter);
+    return decryptor.finalize(cipherParamsObj.cipherText || "");
+  }
+};
+
+exports.SerializableCipher = SerializableCipher;
+exports.parseCipherText = parseCipherText;

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

@@ -0,0 +1,15 @@
+'use strict';
+
+var Cipher = require('./Cipher.js');
+
+class StreamCipher extends Cipher.Cipher {
+  constructor(props) {
+    super(props);
+    this._blockSize = 1;
+  }
+  _doFinalize() {
+    return this._process(true);
+  }
+}
+
+exports.StreamCipher = StreamCipher;

package/dist/cjs/node_modules/jscrypto/es6/lib/algorithm/cipher/formatter/OpenSSLFormatter.js

@@ -0,0 +1,59 @@
+'use strict';
+
+var CipherParams = require('../CipherParams.js');
+var Word32Array = require('../../../Word32Array.js');
+var Base64 = require('../../../encoder/Base64.js');
+
+const OpenSSLFormatter = {
+  /**
+   * Converts a cipher params object to an OpenSSL-compatible string.
+   *
+   * @param {CipherParams} cipherParams The cipher params object.
+   * @return {string} The OpenSSL-compatible string.
+   * @example
+   *   var openSSLString = OpenSSLFormatter.stringify(cipherParams);
+   */
+  stringify(cipherParams) {
+    // Shortcuts
+    const cipherText = cipherParams.cipherText;
+    const salt = cipherParams.salt;
+    if (!cipherText) {
+      return "";
+    }
+    // Format
+    if (salt) {
+      const wordArray = new Word32Array.Word32Array([0x53616c74, 0x65645f5f]).concat(salt).concat(cipherText);
+      return wordArray.toString(Base64.Base64);
+    }
+    return cipherText.toString(Base64.Base64);
+  },
+  /**
+   * Converts an OpenSSL-compatible string to a cipher params object.
+   *
+   * @param {string} openSSLStr The OpenSSL-compatible string.
+   * @return {CipherParams} The cipher params object.
+   * @example
+   *   var cipherParams = OpenSSLFormatter.parse(openSSLString);
+   */
+  parse(openSSLStr) {
+    let salt;
+    // Parse base64
+    const cipherText = Base64.Base64.parse(openSSLStr);
+    // Shortcut
+    const ciphertextWords = cipherText.words;
+    // Test for salt
+    if (ciphertextWords[0] === 0x53616c74 && ciphertextWords[1] === 0x65645f5f) {
+      // Extract salt
+      salt = new Word32Array.Word32Array(ciphertextWords.slice(2, 4));
+      // Remove salt from ciphertext
+      ciphertextWords.splice(0, 4);
+      cipherText.nSigBytes -= 16;
+    }
+    return new CipherParams.CipherParams({
+      cipherText,
+      salt
+    });
+  }
+};
+
+exports.OpenSSLFormatter = OpenSSLFormatter;

package/dist/cjs/node_modules/jscrypto/es6/lib/algorithm/cipher/kdf/OpenSSLKDF.js

@@ -0,0 +1,46 @@
+'use strict';
+
+var Word32Array = require('../../../Word32Array.js');
+var CipherParams = require('../CipherParams.js');
+var PBKDF2 = require('./module/PBKDF2.js');
+
+/**
+ * Derives a key and IV from a password.
+ *
+ * @param {string} password The password to derive from.
+ * @param {number} keySize The size in words of the key to generate.
+ * @param {number} ivSize The size in words of the IV to generate.
+ * @param {Word32Array?} salt (Optional) A 64-bit salt to use. If omitted, a salt will be generated randomly.
+ * @return {CipherParams} A cipher params object with the key, IV, and salt.
+ * @example
+ *   var derivedParams = OpenSSLKDF.execute('Password', 256/32, 128/32);
+ *   var derivedParams = OpenSSLKDF.execute('Password', 256/32, 128/32, 'saltsalt');
+ */
+const OpenSSLKDF = {
+  execute(password, keySize, ivSize, salt, props) {
+    // Generate random salt
+    if (!salt) {
+      salt = Word32Array.Word32Array.random(64 / 8);
+    }
+    const KDFModule = props && props.kdfModule || PBKDF2.PBKDF2;
+    const kdfProps = props ? {
+      Hasher: props.kdfHasher,
+      iterations: props.kdfIterations
+    } : {};
+    // Derive key and IV
+    const key = KDFModule.getKey(password, salt, Object.assign(Object.assign({}, kdfProps), {
+      keySize: keySize + ivSize
+    }));
+    // Separate key and IV
+    const iv = new Word32Array.Word32Array(key.words.slice(keySize), ivSize * 4);
+    key.nSigBytes = keySize * 4;
+    // Return params
+    return new CipherParams.CipherParams({
+      key,
+      iv,
+      salt
+    });
+  }
+};
+
+exports.OpenSSLKDF = OpenSSLKDF;

package/dist/cjs/node_modules/jscrypto/es6/lib/algorithm/cipher/kdf/module/EvpKDF.js

@@ -0,0 +1,83 @@
+'use strict';
+
+var MD5 = require('../../../../../MD5.js');
+var Word32Array = require('../../../../Word32Array.js');
+var type = require('../type.js');
+
+/**
+ * This key derivation function is meant to conform with EVP_BytesToKey.
+ * https://www.openssl.org/docs/man1.1.1/man3/EVP_BytesToKey.html
+ *
+ * @property {number} keySize The key size in words to generate. Default: 4 (128 bits)
+ * @property {Hasher} hasher The hash algorithm to use. Default: MD5
+ * @property {number} iterations The number of iterations to perform. Default: 1
+ */
+class EvpKDF extends type.BaseKDFModule {
+  constructor(props) {
+    super(props);
+    this._keySize = 128 / 32;
+    this._Hasher = MD5.MD5;
+    this._iterations = 1;
+    if (props) {
+      this._keySize = typeof props.keySize !== "undefined" ? props.keySize : this._keySize;
+      this._Hasher = typeof props.Hasher !== "undefined" ? props.Hasher : this._Hasher;
+      this._iterations = typeof props.iterations !== "undefined" ? props.iterations : this._iterations;
+    }
+  }
+  /**
+   * Derives a key from a password.
+   *
+   * @param {Word32Array|string} password The password.
+   * @param {Word32Array|string} salt A salt.
+   * @return {Word32Array} The derived key.
+   * @example
+   *   var kdf = new EvpKDF();
+   *   var key = kdf.compute(password, salt);
+   */
+  compute(password, salt) {
+    let block;
+    // Init hasher
+    const hasher = new this._Hasher();
+    // Initial values
+    const derivedKey = new Word32Array.Word32Array();
+    // Shortcuts
+    const derivedKeyWords = derivedKey.words;
+    const keySize = this._keySize;
+    const iterations = this._iterations;
+    // Generate key
+    while (derivedKeyWords.length < keySize) {
+      if (block) {
+        hasher.update(block);
+      }
+      block = hasher.update(password).finalize(salt);
+      hasher.reset();
+      // Iterations
+      for (let i = 1; i < iterations; i++) {
+        block = hasher.finalize(block);
+        hasher.reset();
+      }
+      derivedKey.concat(block);
+    }
+    derivedKey.nSigBytes = keySize * 4;
+    return derivedKey;
+  }
+  /**
+   * Derives a key from a password.
+   *
+   * @param {Word32Array|string} password The password.
+   * @param {Word32Array|string} salt A salt.
+   * @param {Partial<EvpKDFProps>?} props (Optional) The configuration options to use for this computation.
+   * @return {Word32Array} The derived key.
+   * @static
+   * @example
+   *
+   *     var key = EvpKDF.getKey(password, salt);
+   *     var key = EvpKDF.getKey(password, salt, { keySize: 8 });
+   *     var key = EvpKDF.getKey(password, salt, { keySize: 8, iterations: 1000 });
+   */
+  static getKey(password, salt, props) {
+    return new EvpKDF(props).compute(password, salt);
+  }
+}
+
+exports.EvpKDF = EvpKDF;

package/dist/cjs/node_modules/jscrypto/es6/lib/algorithm/cipher/kdf/module/PBKDF2.js

@@ -0,0 +1,91 @@
+'use strict';
+
+var SHA256 = require('../../../../../SHA256.js');
+var Hmac = require('../../../../../Hmac.js');
+var Word32Array = require('../../../../Word32Array.js');
+var type = require('../type.js');
+
+/**
+ * Password-Based Key Derivation Function 2 algorithm.
+ *
+ * @property {number} keySize The key size in words to generate. Default: 4 (128 bits)
+ * @property {Hasher} hasher The hash algorithm to use. Default: SHA1
+ * @property {number} iterations The number of iterations to perform. Default: 1
+ */
+class PBKDF2 extends type.BaseKDFModule {
+  constructor(props) {
+    super(props);
+    this._keySize = 128 / 32;
+    this._Hasher = SHA256.SHA256;
+    this._iterations = 10000;
+    if (props) {
+      this._keySize = typeof props.keySize !== "undefined" ? props.keySize : this._keySize;
+      this._Hasher = typeof props.Hasher !== "undefined" ? props.Hasher : this._Hasher;
+      this._iterations = typeof props.iterations !== "undefined" ? props.iterations : this._iterations;
+    }
+  }
+  /**
+   * Derives a key from a password.
+   *
+   * @param {Word32Array|string} password The password.
+   * @param {Word32Array|string} salt A salt.
+   * @return {Word32Array} The derived key.
+   * @example
+   *   var kdf = new PBKDF2();
+   *   var key = kdf.compute(password, salt);
+   */
+  compute(password, salt) {
+    // Init HMAC
+    const hmac = new Hmac.Hmac(new this._Hasher(), password);
+    // Initial values
+    const derivedKey = new Word32Array.Word32Array();
+    const blockIndex = new Word32Array.Word32Array([0x00000001]);
+    // Shortcuts
+    const derivedKeyWords = derivedKey.words;
+    const blockIndexWords = blockIndex.words;
+    const keySize = this._keySize;
+    const iterations = this._iterations;
+    // Generate key
+    while (derivedKeyWords.length < keySize) {
+      const block = hmac.update(salt).finalize(blockIndex);
+      hmac.reset();
+      // Shortcuts
+      const blockWords = block.words;
+      const blockWordsLength = blockWords.length;
+      // Iterations
+      let intermediate = block;
+      for (let i = 1; i < iterations; i++) {
+        intermediate = hmac.finalize(intermediate);
+        hmac.reset();
+        // Shortcut
+        const intermediateWords = intermediate.words;
+        // XOR intermediate with block
+        for (let j = 0; j < blockWordsLength; j++) {
+          blockWords[j] ^= intermediateWords[j];
+        }
+      }
+      derivedKey.concat(block);
+      blockIndexWords[0]++;
+    }
+    derivedKey.nSigBytes = keySize * 4;
+    return derivedKey;
+  }
+  /**
+   * Derives a key from a password.
+   *
+   * @param {Word32Array|string} password The password.
+   * @param {Word32Array|string} salt A salt.
+   * @param {Partial<PBKDF2Props>?} props (Optional) The configuration options to use for this computation.
+   * @return {Word32Array} The derived key.
+   * @static
+   * @example
+   *     var key = PBKDF2.getKey(password, salt);
+   *     var key = PBKDF2.getKey(password, salt, { keySize: 8 });
+   *     var key = PBKDF2.getKey(password, salt, { keySize: 8, iterations: 1000 });
+   */
+  static getKey(password, salt, props) {
+    return new PBKDF2(props).compute(password, salt);
+  }
+}
+
+exports.PBKDF2 = PBKDF2;

package/dist/cjs/node_modules/jscrypto/es6/lib/algorithm/cipher/kdf/type.js

@@ -0,0 +1,15 @@
+'use strict';
+
+class BaseKDFModule {
+  constructor(props) {
+    this._props = props;
+  }
+  compute(password, salt) {
+    throw new Error("Not implemented");
+  }
+  static getKey(password, salt, props) {
+    throw new Error("Not implemented");
+  }
+}
+
+exports.BaseKDFModule = BaseKDFModule;

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

@@ -0,0 +1,41 @@
+'use strict';
+
+/**
+ * Abstract base block cipher mode template.
+ * @abstract
+ */
+class BlockCipherMode {
+  constructor(props) {
+    this._props = props;
+    this._cipher = props.cipher;
+    this._iv = props.iv;
+  }
+  /**
+   * @abstract
+   */
+  processBlock(words, offset) {
+    return;
+  }
+  /**
+   * Creates this mode for encryption.
+   * @param {BlockCipherModeProps} props
+   * @abstract
+   * @example
+   *   var mode = CBC.createEncryptor(cipher, iv.words);
+   */
+  static createEncryptor(props) {
+    throw new Error("Not implemented yet");
+  }
+  /**
+   * Creates this mode for decryption.
+   * @param {BlockCipherModeProps} props
+   * @abstract
+   * @example
+   *   var mode = CBC.createDecryptor(cipher, iv.words);
+   */
+  static createDecryptor(props) {
+    throw new Error("Not implemented yet");
+  }
+}
+
+exports.BlockCipherMode = BlockCipherMode;

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

@@ -0,0 +1,95 @@
+'use strict';
+
+var BlockCipherMode = require('./BlockCipherMode.js');
+
+class CBC extends BlockCipherMode.BlockCipherMode {
+  constructor(props) {
+    super(props);
+    this._prevBlock = [];
+  }
+  xorBlock(words, offset, blockSize) {
+    let block;
+    // Shortcut
+    const iv = this._iv;
+    // Choose mixing block
+    if (iv) {
+      block = iv.words;
+      // Remove IV for subsequent blocks
+      this._iv = undefined;
+    } else {
+      block = this._prevBlock;
+    }
+    // XOR blocks
+    for (let i = 0; i < blockSize; i++) {
+      words[offset + i] ^= block[i];
+    }
+  }
+  /**
+   * Creates this mode for encryption.
+   * @param {BlockCipherModeProps} props
+   * @example
+   *   var mode = CBC.createEncryptor(cipher, iv.words);
+   */
+  static createEncryptor(props) {
+    return new CBC.Encryptor(props);
+  }
+  /**
+   * Creates this mode for decryption.
+   * @param {BlockCipherModeProps} props
+   * @example
+   *   var mode = CBC.createDecryptor(cipher, iv.words);
+   */
+  static createDecryptor(props) {
+    return new CBC.Decryptor(props);
+  }
+}
+/**
+ * CBC encryptor.
+ */
+CBC.Encryptor = class Encryptor extends CBC {
+  /**
+   * 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;
+    // XOR and encrypt
+    this.xorBlock(words, offset, blockSize);
+    cipher.encryptBlock(words, offset);
+    // Remember this block to use with next block
+    this._prevBlock = words.slice(offset, offset + blockSize);
+  }
+};
+/**
+ * CBC decryptor.
+ */
+CBC.Decryptor = class Decryptor extends CBC {
+  /**
+   * 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;
+    // Remember this block to use with next block
+    const thisBlock = words.slice(offset, offset + blockSize);
+    // Decrypt and XOR
+    cipher.decryptBlock(words, offset);
+    this.xorBlock(words, offset, blockSize);
+    // This block becomes the previous block
+    this._prevBlock = thisBlock;
+  }
+};
+
+exports.CBC = CBC;