@tonysamperi/krypto 1.0.0

package/dist/esm/kdf/evpkdf.class.d.ts

@@ -0,0 +1,42 @@
+import { WordArray } from "../lib/word-array.class.js";
+import { Hasher } from "../lib/hasher.class.js";
+import { AbstractKDF } from "./kdf.model.js";
+export interface OptionalEVPKDFConfig {
+    keySize?: number;
+    hasher?: typeof Hasher;
+    iterations?: number;
+}
+export interface EVPKDFConfig extends OptionalEVPKDFConfig {
+    keySize: number;
+    hasher: typeof Hasher;
+    iterations: number;
+}
+export declare class EVPKDF implements AbstractKDF {
+    cfg: EVPKDFConfig;
+    /**
+     * Initializes a newly created key derivation function.
+     *
+     * @param cfg (Optional) The configuration options to use for the derivation.
+     *
+     * @example
+     *
+     *     let kdf = EvpKDF.create();
+     *     let kdf = EvpKDF.create({ keySize: 8 });
+     *     let kdf = EvpKDF.create({ keySize: 8, iterations: 1000 });
+     */
+    constructor(cfg?: OptionalEVPKDFConfig);
+    static execute(password: WordArray | string, salt: WordArray | string, cfg?: OptionalEVPKDFConfig): WordArray;
+    /**
+     * Derives a key from a password.
+     *
+     * @param password The password.
+     * @param salt A salt.
+     *
+     * @return The derived key.
+     *
+     * @example
+     *
+     *     let key = kdf.compute(password, salt);
+     */
+    compute(password: WordArray | string, salt: WordArray | string): WordArray;
+}

package/dist/esm/kdf/evpkdf.class.js

@@ -0,0 +1,59 @@
+import { WordArray } from "../lib/word-array.class.js";
+import { MD5 } from "../algo/md5.class.js";
+class EVPKDF {
+  /**
+   * Initializes a newly created key derivation function.
+   *
+   * @param cfg (Optional) The configuration options to use for the derivation.
+   *
+   * @example
+   *
+   *     let kdf = EvpKDF.create();
+   *     let kdf = EvpKDF.create({ keySize: 8 });
+   *     let kdf = EvpKDF.create({ keySize: 8, iterations: 1000 });
+   */
+  constructor(cfg) {
+    this.cfg = Object.assign({
+      keySize: 128 / 32,
+      hasher: MD5,
+      iterations: 1
+    }, cfg);
+  }
+  static execute(password, salt, cfg) {
+    return new EVPKDF(cfg).compute(password, salt);
+  }
+  /**
+   * Derives a key from a password.
+   *
+   * @param password The password.
+   * @param salt A salt.
+   *
+   * @return The derived key.
+   *
+   * @example
+   *
+   *     let key = kdf.compute(password, salt);
+   */
+  compute(password, salt) {
+    const hasher = new this.cfg.hasher();
+    const derivedKey = new WordArray();
+    let block;
+    while (derivedKey.words.length < this.cfg.keySize) {
+      if (block) {
+        hasher.update(block);
+      }
+      block = hasher.update(password).finalize(salt);
+      hasher.reset();
+      for (let i = 1; i < this.cfg.iterations; i++) {
+        block = hasher.finalize(block);
+        hasher.reset();
+      }
+      derivedKey.concat(block);
+    }
+    derivedKey.sigBytes = this.cfg.keySize * 4;
+    return derivedKey;
+  }
+}
+export {
+  EVPKDF
+};

package/dist/esm/kdf/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./pbkdf2.class.js";
+export * from "./evpkdf.class.js";
+export * from "./kdf.model.js";

package/dist/esm/kdf/index.js

@@ -0,0 +1,3 @@
+export * from "./pbkdf2.class.js";
+export * from "./evpkdf.class.js";
+export * from "./kdf.model.js";

package/dist/esm/kdf/kdf.model.d.ts

@@ -0,0 +1,7 @@
+import { WordArray } from "../lib/word-array.class.js";
+import { CipherParams } from "../lib/cipher-params.class.js";
+export declare abstract class AbstractKDF {
+    static execute: (password: string, keySize: number, ivSize: number, salt?: WordArray | string) => CipherParams;
+    abstract compute?(password: WordArray | string, salt: WordArray | string): WordArray;
+}
+export type KDF = typeof AbstractKDF;

package/dist/esm/kdf/kdf.model.js

@@ -0,0 +1,5 @@
+class AbstractKDF {
+}
+export {
+  AbstractKDF
+};

package/dist/esm/kdf/open-ssl-kdf.class.d.ts

@@ -0,0 +1,21 @@
+import { WordArray } from "../lib/word-array.class.js";
+import { CipherParams } from "../lib/cipher-params.class.js";
+import { AbstractKDF } from "./kdf.model.js";
+export declare class OpenSSLKdf implements AbstractKDF {
+    /**
+     * Derives a key and IV from a password.
+     *
+     * @param password The password to derive from.
+     * @param keySize The size in words of the key to generate.
+     * @param ivSize The size in words of the IV to generate.
+     * @param salt (Optional) A 64-bit salt to use. If omitted, a salt will be generated randomly.
+     *
+     * @return A cipher params object with the key, IV, and salt.
+     *
+     * @example
+     *
+     *     let derivedParams = OpenSSL.execute('Password', 256/32, 128/32);
+     *     let derivedParams = OpenSSL.execute('Password', 256/32, 128/32, 'saltsalt');
+     */
+    static execute(password: string, keySize: number, ivSize: number, salt?: WordArray | string): CipherParams;
+}

package/dist/esm/kdf/open-ssl-kdf.class.js

@@ -0,0 +1,32 @@
+import { WordArray } from "../lib/word-array.class.js";
+import { CipherParams } from "../lib/cipher-params.class.js";
+import { EVPKDF } from "./evpkdf.class.js";
+class OpenSSLKdf {
+  /**
+   * Derives a key and IV from a password.
+   *
+   * @param password The password to derive from.
+   * @param keySize The size in words of the key to generate.
+   * @param ivSize The size in words of the IV to generate.
+   * @param salt (Optional) A 64-bit salt to use. If omitted, a salt will be generated randomly.
+   *
+   * @return A cipher params object with the key, IV, and salt.
+   *
+   * @example
+   *
+   *     let derivedParams = OpenSSL.execute('Password', 256/32, 128/32);
+   *     let derivedParams = OpenSSL.execute('Password', 256/32, 128/32, 'saltsalt');
+   */
+  static execute(password, keySize, ivSize, salt) {
+    if (!salt) {
+      salt = WordArray.random(64 / 8);
+    }
+    const key = new EVPKDF({ keySize: keySize + ivSize }).compute(password, salt);
+    const iv = new WordArray(key.words.slice(keySize), ivSize * 4);
+    key.sigBytes = keySize * 4;
+    return new CipherParams({ key, iv, salt });
+  }
+}
+export {
+  OpenSSLKdf
+};

package/dist/esm/kdf/pbkdf2.class.d.ts

@@ -0,0 +1,18 @@
+import { WordArray } from "../lib/word-array.class.js";
+import { HasherConstructor } from "../lib/hasher-constructor.type.js";
+import { AbstractKDF } from "./kdf.model.js";
+export interface PBKDF2Config {
+    keySize: number;
+    hasher: HasherConstructor;
+    iterations: number;
+}
+export declare class PBKDF2 implements AbstractKDF {
+    cfg: PBKDF2Config;
+    constructor(cfg: Partial<PBKDF2Config>);
+    static execute(password: WordArray | string, salt: WordArray | string, cfg?: {
+        keySize?: number;
+        hasher?: HasherConstructor;
+        iterations?: number;
+    }): WordArray;
+    compute(password: WordArray | string, salt: WordArray | string): WordArray;
+}

package/dist/esm/kdf/pbkdf2.class.js

@@ -0,0 +1,43 @@
+import { SHA256 } from "../algo/sha256.class.js";
+import { WordArray } from "../lib/word-array.class.js";
+import { HMAC } from "../lib/hmac.class.js";
+class PBKDF2 {
+  constructor(cfg) {
+    this.cfg = Object.assign({ keySize: 128 / 32, hasher: SHA256, iterations: 25e4 }, cfg);
+  }
+  static execute(password, salt, cfg) {
+    return new PBKDF2(cfg).compute(password, salt);
+  }
+  compute(password, salt) {
+    const cfg = this.cfg;
+    const hmac = new HMAC(cfg.hasher, password);
+    const derivedKey = new WordArray();
+    const blockIndex = new WordArray([1]);
+    const derivedKeyWords = derivedKey.words;
+    const blockIndexWords = blockIndex.words;
+    const keySize = cfg.keySize;
+    const iterations = cfg.iterations;
+    while (derivedKeyWords.length < keySize) {
+      const block = hmac.update(salt).finalize(blockIndex);
+      hmac.reset();
+      const blockWords = block.words;
+      const blockWordsLength = blockWords.length;
+      let intermediate = block;
+      for (let i = 1; i < iterations; i++) {
+        intermediate = hmac.finalize(intermediate);
+        hmac.reset();
+        const intermediateWords = intermediate.words;
+        for (let j = 0; j < blockWordsLength; j++) {
+          blockWords[j] ^= intermediateWords[j];
+        }
+      }
+      derivedKey.concat(block);
+      blockIndexWords[0]++;
+    }
+    derivedKey.sigBytes = keySize * 4;
+    return derivedKey;
+  }
+}
+export {
+  PBKDF2
+};

package/dist/esm/lib/block-cipher.class.d.ts

@@ -0,0 +1,13 @@
+import { Cipher } from "./cipher.class.js";
+import { WordArray } from "./word-array.class.js";
+import { BufferedBlockAlgorithmConfig } from "./buffered-block-algorithm-config.interface.js";
+import { BlockCipherModeAlgorithm } from "../mode/block-cipher-mode-algorithm.class.js";
+export declare abstract class BlockCipher extends Cipher {
+    protected _mode: BlockCipherModeAlgorithm;
+    constructor(xformMode: number, key: WordArray, cfg?: BufferedBlockAlgorithmConfig);
+    abstract decryptBlock(M: number[], offset: number): void;
+    abstract encryptBlock(M: number[], offset: number): void;
+    reset(): void;
+    protected _doFinalize(): WordArray;
+    protected _doProcessBlock(words: number[], offset: number): void;
+}

package/dist/esm/lib/block-cipher.class.js

@@ -0,0 +1,55 @@
+import { Cipher } from "./cipher.class.js";
+import { CBC } from "../mode/cbc/cbc.class.js";
+import { PKCS7 } from "../pad/pkcs7.class.js";
+class BlockCipher extends Cipher {
+  constructor(xformMode, key, cfg) {
+    super(xformMode, key, Object.assign({
+      // default: 128 / 32
+      blockSize: 4,
+      mode: CBC,
+      padding: PKCS7
+    }, cfg));
+  }
+  reset() {
+    super.reset();
+    if (this.cfg.mode === void 0) {
+      throw new Error("missing mode in config");
+    }
+    let modeCreator;
+    if (this._xformMode === this.constructor._ENC_XFORM_MODE) {
+      modeCreator = this.cfg.mode.createEncryptor;
+    } else {
+      modeCreator = this.cfg.mode.createDecryptor;
+      this._minBufferSize = 1;
+    }
+    if (this._mode && this._mode.__creator === modeCreator) {
+      this._mode.init(this, this.cfg.iv && this.cfg.iv.words);
+    } else {
+      this._mode = modeCreator.call(this.cfg.mode, this, this.cfg.iv && this.cfg.iv.words);
+      this._mode.__creator = modeCreator;
+    }
+  }
+  _doFinalize() {
+    if (this.cfg.padding === void 0) {
+      throw new Error("missing padding in config");
+    }
+    let finalProcessedBlocks;
+    if (this._xformMode === this.constructor._ENC_XFORM_MODE) {
+      if (this.cfg.blockSize === void 0) {
+        throw new Error("missing blockSize in config");
+      }
+      this.cfg.padding.pad(this._data, this.cfg.blockSize);
+      finalProcessedBlocks = this._process(true);
+    } else {
+      finalProcessedBlocks = this._process(true);
+      this.cfg.padding.unpad(finalProcessedBlocks);
+    }
+    return finalProcessedBlocks;
+  }
+  _doProcessBlock(words, offset) {
+    this._mode.processBlock(words, offset);
+  }
+}
+export {
+  BlockCipher
+};

package/dist/esm/lib/buffered-block-algorithm-config.interface.d.ts

@@ -0,0 +1,13 @@
+import { Formatter } from "../format/formatter.interface.js";
+import { WordArray } from "./word-array.class.js";
+import { KDF } from "../kdf/kdf.model.js";
+import { BlockCipherMode } from "../mode/block-cipher-mode.class.js";
+import { Padding } from "../pad/padding.model.js";
+export interface BufferedBlockAlgorithmConfig {
+    blockSize?: number;
+    iv?: WordArray;
+    format?: Formatter;
+    kdf?: KDF;
+    mode?: typeof BlockCipherMode;
+    padding?: Padding;
+}

package/dist/esm/lib/buffered-block-algorithm.class.d.ts

@@ -0,0 +1,54 @@
+import { WordArray } from "./word-array.class.js";
+import { BufferedBlockAlgorithmConfig } from "./buffered-block-algorithm-config.interface.js";
+export declare abstract class BufferedBlockAlgorithm {
+    cfg: BufferedBlockAlgorithmConfig;
+    protected _data: WordArray;
+    protected _minBufferSize: number;
+    protected _nDataBytes: number;
+    protected abstract _doProcessBlock(wordArray: number[], offset: number): void;
+    constructor(cfg?: BufferedBlockAlgorithmConfig);
+    /**
+     * Creates a copy of this object.
+     *
+     * @return The clone.
+     *
+     * @example
+     *
+     *     let clone = bufferedBlockAlgorithm.clone();
+     */
+    clone(): BufferedBlockAlgorithm;
+    /**
+     * Resets this block algorithm's data buffer to its initial state.
+     *
+     * @example
+     *
+     *     bufferedBlockAlgorithm.reset();
+     */
+    reset(): void;
+    /**
+     * Adds new data to this block algorithm's buffer.
+     *
+     * @param data The data to append. Strings are converted to a WordArray using UTF-8.
+     *
+     * @example
+     *
+     *     bufferedBlockAlgorithm._append('data');
+     *     bufferedBlockAlgorithm._append(wordArray);
+     */
+    protected _append(data: string | WordArray): void;
+    /**
+     * Processes available data blocks.
+     *
+     * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.
+     *
+     * @param doFlush Whether all blocks and partial blocks should be processed.
+     *
+     * @return The processed data.
+     *
+     * @example
+     *
+     *     let processedData = bufferedBlockAlgorithm._process();
+     *     let processedData = bufferedBlockAlgorithm._process(!!'flush');
+     */
+    protected _process(doFlush?: boolean): WordArray;
+}

package/dist/esm/lib/buffered-block-algorithm.class.js

@@ -0,0 +1,99 @@
+import { WordArray } from "./word-array.class.js";
+import { Utf8 } from "../enc/utf8.class.js";
+class BufferedBlockAlgorithm {
+  constructor(cfg) {
+    this._minBufferSize = 0;
+    this.cfg = Object.assign({
+      blockSize: 1
+    }, cfg);
+    this._data = new WordArray();
+    this._nDataBytes = 0;
+  }
+  /**
+   * Creates a copy of this object.
+   *
+   * @return The clone.
+   *
+   * @example
+   *
+   *     let clone = bufferedBlockAlgorithm.clone();
+   */
+  clone() {
+    const clone = this.constructor();
+    for (const attr in this) {
+      if (Object.prototype.hasOwnProperty.call(this, attr)) {
+        clone[attr] = this[attr];
+      }
+    }
+    clone._data = this._data.clone();
+    return clone;
+  }
+  /**
+   * Resets this block algorithm's data buffer to its initial state.
+   *
+   * @example
+   *
+   *     bufferedBlockAlgorithm.reset();
+   */
+  reset() {
+    this._data = new WordArray();
+    this._nDataBytes = 0;
+  }
+  /**
+   * Adds new data to this block algorithm's buffer.
+   *
+   * @param data The data to append. Strings are converted to a WordArray using UTF-8.
+   *
+   * @example
+   *
+   *     bufferedBlockAlgorithm._append('data');
+   *     bufferedBlockAlgorithm._append(wordArray);
+   */
+  _append(data) {
+    if (typeof data === "string") {
+      data = Utf8.parse(data);
+    }
+    this._data.concat(data);
+    this._nDataBytes += data.sigBytes;
+  }
+  /**
+   * Processes available data blocks.
+   *
+   * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.
+   *
+   * @param doFlush Whether all blocks and partial blocks should be processed.
+   *
+   * @return The processed data.
+   *
+   * @example
+   *
+   *     let processedData = bufferedBlockAlgorithm._process();
+   *     let processedData = bufferedBlockAlgorithm._process(!!'flush');
+   */
+  _process(doFlush) {
+    if (!this.cfg.blockSize) {
+      throw new Error("missing blockSize in config");
+    }
+    const blockSizeBytes = this.cfg.blockSize * 4;
+    let nBlocksReady = this._data.sigBytes / blockSizeBytes;
+    if (doFlush) {
+      nBlocksReady = Math.ceil(nBlocksReady);
+    } else {
+      nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
+    }
+    const nWordsReady = nBlocksReady * this.cfg.blockSize;
+    const nBytesReady = Math.min(nWordsReady * 4, this._data.sigBytes);
+    let processedWords;
+    if (nWordsReady) {
+      for (let offset = 0; offset < nWordsReady; offset += this.cfg.blockSize) {
+        this._doProcessBlock(this._data.words, offset);
+      }
+      processedWords = this._data.words.splice(0, nWordsReady);
+      this._data.sigBytes -= nBytesReady;
+    }
+    return new WordArray(processedWords, nBytesReady);
+  }
+}
+export {
+  BufferedBlockAlgorithm
+};

package/dist/esm/lib/cipher-helper.class.d.ts

@@ -0,0 +1,10 @@
+import { WordArray } from "./word-array.class.js";
+import { BufferedBlockAlgorithmConfig } from "./buffered-block-algorithm-config.interface.js";
+import { CipherParams } from "./cipher-params.class.js";
+import { Cipher } from "./cipher.class.js";
+export declare class CipherHelper {
+    private readonly _cipher;
+    constructor(_cipher: typeof Cipher);
+    decrypt(ciphertext: CipherParams | string, key: WordArray | string, cfg?: BufferedBlockAlgorithmConfig): WordArray;
+    encrypt(message: WordArray | string, key: WordArray | string, cfg?: BufferedBlockAlgorithmConfig): CipherParams;
+}

package/dist/esm/lib/cipher-helper.class.js

@@ -0,0 +1,24 @@
+import { PasswordBasedCipher } from "./password-based-cipher.class.js";
+import { SerializableCipher } from "./serializable-cipher.class.js";
+class CipherHelper {
+  constructor(_cipher) {
+    this._cipher = _cipher;
+  }
+  decrypt(ciphertext, key, cfg) {
+    if (typeof key === "string") {
+      return PasswordBasedCipher.decrypt(this._cipher, ciphertext, key, cfg);
+    } else {
+      return SerializableCipher.decrypt(this._cipher, ciphertext, key, cfg);
+    }
+  }
+  encrypt(message, key, cfg) {
+    if (typeof key === "string") {
+      return PasswordBasedCipher.encrypt(this._cipher, message, key, cfg);
+    } else {
+      return SerializableCipher.encrypt(this._cipher, message, key, cfg);
+    }
+  }
+}
+export {
+  CipherHelper
+};

package/dist/esm/lib/cipher-params.class.d.ts

@@ -0,0 +1,53 @@
+import { WordArray } from "./word-array.class.js";
+import { Cipher } from "./cipher.class.js";
+import { BlockCipherMode } from "../mode/block-cipher-mode.class.js";
+import { Padding } from "../pad/padding.model.js";
+import { Formatter } from "../format/formatter.interface.js";
+export declare class CipherParams {
+    algorithm?: typeof Cipher;
+    blockSize?: number;
+    ciphertext?: WordArray;
+    formatter?: Formatter;
+    iv?: WordArray;
+    key?: WordArray | string;
+    mode?: typeof BlockCipherMode;
+    padding?: Padding;
+    salt?: WordArray | string;
+    /**
+     * Initializes a newly created cipher params object.
+     *
+     * @param cipherParams An object with any of the possible cipher parameters.
+     *
+     * @example
+     *
+     *     let cipherParams = CipherParams.create({
+     *         ciphertext: ciphertextWordArray,
+     *         key: keyWordArray,
+     *         iv: ivWordArray,
+     *         salt: saltWordArray,
+     *         algorithm: AES,
+     *         mode: CBC,
+     *         padding: PKCS7,
+     *         blockSize: 4,
+     *         formatter: OpenSSLFormatter
+     *     });
+     */
+    constructor(cipherParams: Omit<CipherParams, "extend" | "toString">);
+    extend(additionalParams: CipherParams): CipherParams;
+    /**
+     * Converts this cipher params object to a string.
+     *
+     * @param formatter (Optional) The formatting strategy to use.
+     *
+     * @return The stringified cipher params.
+     *
+     * @throws Error If neither the formatter nor the default formatter is set.
+     *
+     * @example
+     *
+     *     let string = cipherParams + '';
+     *     let string = cipherParams.toString();
+     *     let string = cipherParams.toString(CryptoJS.format.OpenSSL);
+     */
+    toString(formatter?: Formatter): string;
+}

package/dist/esm/lib/cipher-params.class.js

@@ -0,0 +1,89 @@
+class CipherParams {
+  /**
+   * Initializes a newly created cipher params object.
+   *
+   * @param cipherParams An object with any of the possible cipher parameters.
+   *
+   * @example
+   *
+   *     let cipherParams = CipherParams.create({
+   *         ciphertext: ciphertextWordArray,
+   *         key: keyWordArray,
+   *         iv: ivWordArray,
+   *         salt: saltWordArray,
+   *         algorithm: AES,
+   *         mode: CBC,
+   *         padding: PKCS7,
+   *         blockSize: 4,
+   *         formatter: OpenSSLFormatter
+   *     });
+   */
+  constructor(cipherParams) {
+    this.ciphertext = cipherParams.ciphertext;
+    this.key = cipherParams.key;
+    this.iv = cipherParams.iv;
+    this.salt = cipherParams.salt;
+    this.algorithm = cipherParams.algorithm;
+    this.mode = cipherParams.mode;
+    this.padding = cipherParams.padding;
+    this.blockSize = cipherParams.blockSize;
+    this.formatter = cipherParams.formatter;
+  }
+  extend(additionalParams) {
+    if (additionalParams.ciphertext !== void 0) {
+      this.ciphertext = additionalParams.ciphertext;
+    }
+    if (additionalParams.key !== void 0) {
+      this.key = additionalParams.key;
+    }
+    if (additionalParams.iv !== void 0) {
+      this.iv = additionalParams.iv;
+    }
+    if (additionalParams.salt !== void 0) {
+      this.salt = additionalParams.salt;
+    }
+    if (additionalParams.algorithm !== void 0) {
+      this.algorithm = additionalParams.algorithm;
+    }
+    if (additionalParams.mode !== void 0) {
+      this.mode = additionalParams.mode;
+    }
+    if (additionalParams.padding !== void 0) {
+      this.padding = additionalParams.padding;
+    }
+    if (additionalParams.blockSize !== void 0) {
+      this.blockSize = additionalParams.blockSize;
+    }
+    if (additionalParams.formatter !== void 0) {
+      this.formatter = additionalParams.formatter;
+    }
+    return this;
+  }
+  /**
+   * Converts this cipher params object to a string.
+   *
+   * @param formatter (Optional) The formatting strategy to use.
+   *
+   * @return The stringified cipher params.
+   *
+   * @throws Error If neither the formatter nor the default formatter is set.
+   *
+   * @example
+   *
+   *     let string = cipherParams + '';
+   *     let string = cipherParams.toString();
+   *     let string = cipherParams.toString(CryptoJS.format.OpenSSL);
+   */
+  toString(formatter) {
+    if (formatter) {
+      return formatter.stringify(this);
+    } else if (this.formatter) {
+      return this.formatter.stringify(this);
+    } else {
+      throw new Error("cipher needs a formatter to be able to convert the result into a string");
+    }
+  }
+}
+export {
+  CipherParams
+};