@tonysamperi/krypto 1.0.0

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

@@ -0,0 +1,112 @@
+import { BufferedBlockAlgorithm } from "./buffered-block-algorithm.class.js";
+import { WordArray } from "./word-array.class.js";
+import { BufferedBlockAlgorithmConfig } from "./buffered-block-algorithm-config.interface.js";
+import { CipherHelper } from "./cipher-helper.class.js";
+export declare abstract class Cipher extends BufferedBlockAlgorithm {
+    /**
+     * This cipher's IV size. Default: 4 (128 bits / 32 Bits)
+     */
+    static ivSize: number;
+    /**
+     * This cipher's key size. Default: 4 (128 bits / 32 Bits)
+     */
+    static keySize: number;
+    /**
+     * A constant representing decryption mode.
+     */
+    protected static readonly _DEC_XFORM_MODE = 2;
+    /**
+     * A constant representing encryption mode.
+     */
+    protected static readonly _ENC_XFORM_MODE = 1;
+    /**
+     * The key.
+     */
+    protected _key: WordArray;
+    /**
+     * Either the encryption or decryption transformation mode constant.
+     */
+    protected _xformMode: number;
+    /**
+     * Initializes a newly created cipher.
+     *
+     * @param xformMode Either the encryption or decryption transormation mode constant.
+     * @param key The key.
+     * @param cfg (Optional) The configuration options to use for this operation.
+     *
+     * @example
+     *
+     *     let cipher = AES.create(AES._ENC_XFORM_MODE, keyWordArray, { iv: ivWordArray });
+     */
+    constructor(xformMode: number, key: WordArray, cfg?: BufferedBlockAlgorithmConfig);
+    /**
+     * Creates shortcut functions to a cipher's object interface.
+     *
+     * @param cipher The cipher to create a helper for.
+     *
+     * @return An object with encrypt and decrypt shortcut functions.
+     *
+     * @example
+     *
+     *     const AES = Cipher._createHelper(AESAlgorithm);
+     */
+    static _createHelper(cipher: typeof Cipher): CipherHelper;
+    /**
+     * Creates this cipher in decryption mode.
+     *
+     * @param key The key.
+     * @param cfg (Optional) The configuration options to use for this operation.
+     *
+     * @return A cipher instance.
+     *
+     * @example
+     *
+     *     let cipher = AES.createDecryptor(keyWordArray, { iv: ivWordArray });
+     */
+    static createDecryptor(key: WordArray | string, cfg?: BufferedBlockAlgorithmConfig): Cipher;
+    /**
+     * Creates this cipher in encryption mode.
+     *
+     * @param key The key.
+     * @param cfg (Optional) The configuration options to use for this operation.
+     *
+     * @return A cipher instance.
+     *
+     * @example
+     *
+     *     let cipher = AES.createEncryptor(keyWordArray, { iv: ivWordArray });
+     */
+    static createEncryptor(key: WordArray | string, cfg?: BufferedBlockAlgorithmConfig): Cipher;
+    /**
+     * Finalizes the encryption or decryption process.
+     * Note that the finalize operation is effectively a destructive, read-once operation.
+     *
+     * @param dataUpdate The final data to encrypt or decrypt.
+     *
+     * @return The data after final processing.
+     *
+     * @example
+     *
+     *     var encrypted = cipher.finalize();
+     *     var encrypted = cipher.finalize('data');
+     *     var encrypted = cipher.finalize(wordArray);
+     */
+    finalize(dataUpdate?: WordArray | string): WordArray;
+    /**
+     * Adds data to be encrypted or decrypted.
+     *
+     * @param dataUpdate The data to encrypt or decrypt.
+     *
+     * @return The data after processing.
+     *
+     * @example
+     *
+     *     let encrypted = cipher.process('data');
+     *     let encrypted = cipher.process(wordArray);
+     */
+    process(dataUpdate: WordArray | string): WordArray;
+    /**
+     * Cipher specific finalize function explicitly implemented in the derived class.
+     */
+    protected abstract _doFinalize(): WordArray;
+}

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

@@ -0,0 +1,112 @@
+import { BufferedBlockAlgorithm } from "./buffered-block-algorithm.class.js";
+import { CipherHelper } from "./cipher-helper.class.js";
+class Cipher extends BufferedBlockAlgorithm {
+  /**
+   * Initializes a newly created cipher.
+   *
+   * @param xformMode Either the encryption or decryption transormation mode constant.
+   * @param key The key.
+   * @param cfg (Optional) The configuration options to use for this operation.
+   *
+   * @example
+   *
+   *     let cipher = AES.create(AES._ENC_XFORM_MODE, keyWordArray, { iv: ivWordArray });
+   */
+  constructor(xformMode, key, cfg) {
+    super(Object.assign({
+      blockSize: 1
+    }, cfg));
+    this._xformMode = xformMode;
+    this._key = key;
+    this.reset();
+  }
+  /**
+   * Creates shortcut functions to a cipher's object interface.
+   *
+   * @param cipher The cipher to create a helper for.
+   *
+   * @return An object with encrypt and decrypt shortcut functions.
+   *
+   * @example
+   *
+   *     const AES = Cipher._createHelper(AESAlgorithm);
+   */
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  static _createHelper(cipher) {
+    return new CipherHelper(cipher);
+  }
+  /**
+   * Creates this cipher in decryption mode.
+   *
+   * @param key The key.
+   * @param cfg (Optional) The configuration options to use for this operation.
+   *
+   * @return A cipher instance.
+   *
+   * @example
+   *
+   *     let cipher = AES.createDecryptor(keyWordArray, { iv: ivWordArray });
+   */
+  static createDecryptor(key, cfg) {
+    const thisClass = this;
+    return new thisClass(this._DEC_XFORM_MODE, key, cfg);
+  }
+  /**
+   * Creates this cipher in encryption mode.
+   *
+   * @param key The key.
+   * @param cfg (Optional) The configuration options to use for this operation.
+   *
+   * @return A cipher instance.
+   *
+   * @example
+   *
+   *     let cipher = AES.createEncryptor(keyWordArray, { iv: ivWordArray });
+   */
+  static createEncryptor(key, cfg) {
+    return new this(this._ENC_XFORM_MODE, key, cfg);
+  }
+  /**
+   * Finalizes the encryption or decryption process.
+   * Note that the finalize operation is effectively a destructive, read-once operation.
+   *
+   * @param dataUpdate The final data to encrypt or decrypt.
+   *
+   * @return The data after final processing.
+   *
+   * @example
+   *
+   *     var encrypted = cipher.finalize();
+   *     var encrypted = cipher.finalize('data');
+   *     var encrypted = cipher.finalize(wordArray);
+   */
+  finalize(dataUpdate) {
+    if (dataUpdate) {
+      this._append(dataUpdate);
+    }
+    return this._doFinalize();
+  }
+  /**
+   * Adds data to be encrypted or decrypted.
+   *
+   * @param dataUpdate The data to encrypt or decrypt.
+   *
+   * @return The data after processing.
+   *
+   * @example
+   *
+   *     let encrypted = cipher.process('data');
+   *     let encrypted = cipher.process(wordArray);
+   */
+  process(dataUpdate) {
+    this._append(dataUpdate);
+    return this._process();
+  }
+}
+Cipher.ivSize = 4;
+Cipher.keySize = 4;
+Cipher._DEC_XFORM_MODE = 2;
+Cipher._ENC_XFORM_MODE = 1;
+export {
+  Cipher
+};

package/dist/esm/lib/hasher-constructor.type.d.ts

@@ -0,0 +1,3 @@
+import { BufferedBlockAlgorithmConfig } from "./buffered-block-algorithm-config.interface.js";
+import { Hasher } from "./hasher.class.js";
+export type HasherConstructor<T extends Hasher = Hasher> = new (cfg?: BufferedBlockAlgorithmConfig) => T;

package/dist/esm/lib/hasher-helper.type.d.ts

@@ -0,0 +1,3 @@
+import { WordArray } from "./word-array.class.js";
+import { BufferedBlockAlgorithmConfig } from "./buffered-block-algorithm-config.interface.js";
+export type HasherHelper = (message: WordArray | string, cfg?: BufferedBlockAlgorithmConfig) => WordArray;

package/dist/esm/lib/hasher.class.d.ts

@@ -0,0 +1,58 @@
+import { BufferedBlockAlgorithm } from "./buffered-block-algorithm.class.js";
+import { BufferedBlockAlgorithmConfig } from "./buffered-block-algorithm-config.interface.js";
+import { WordArray } from "./word-array.class.js";
+import { HasherConstructor } from "./hasher-constructor.type.js";
+import { HasherHelper } from "./hasher-helper.type.js";
+export declare abstract class Hasher extends BufferedBlockAlgorithm {
+    /**
+     * Initializes a newly created hasher.
+     *
+     * @param cfg (Optional) The configuration options to use for this hash computation.
+     *
+     * @example
+     *
+     *     let hasher = CryptoJS.algo.SHA256.create();
+     */
+    constructor(cfg?: BufferedBlockAlgorithmConfig);
+    /**
+     * Creates a shortcut function to the object interface of a hasher.
+     *
+     * @param hasher The hasher to create a helper for.
+     *
+     * @return The shortcut function.
+     *
+     * @example
+     *
+     *     const SHA256 = Hasher._createHelper(SHA256);
+     */
+    static _createHelper<T extends Hasher = Hasher>(hasher: HasherConstructor<T>): HasherHelper;
+    protected abstract _doFinalize(): WordArray;
+    /**
+     * Finalizes the hash computation.
+     * Note that the finalize operation is effectively a destructive, read-once operation.
+     *
+     * @param messageUpdate (Optional) A final message update.
+     *
+     * @return The hash.
+     *
+     * @example
+     *
+     *     let hash = hasher.finalize();
+     *     let hash = hasher.finalize('message');
+     *     let hash = hasher.finalize(wordArray);
+     */
+    finalize(messageUpdate?: WordArray | string): WordArray;
+    /**
+     * Updates this hasher with a message.
+     *
+     * @param messageUpdate The message to append.
+     *
+     * @return This hasher.
+     *
+     * @example
+     *
+     *     hasher.update('message');
+     *     hasher.update(wordArray);
+     */
+    update(messageUpdate: WordArray | string): Hasher;
+}

package/dist/esm/lib/hasher.class.js

@@ -0,0 +1,77 @@
+import { BufferedBlockAlgorithm } from "./buffered-block-algorithm.class.js";
+class Hasher extends BufferedBlockAlgorithm {
+  /**
+   * Initializes a newly created hasher.
+   *
+   * @param cfg (Optional) The configuration options to use for this hash computation.
+   *
+   * @example
+   *
+   *     let hasher = CryptoJS.algo.SHA256.create();
+   */
+  constructor(cfg) {
+    super(Object.assign({
+      blockSize: 512 / 32
+    }, cfg));
+    this.reset();
+  }
+  /**
+   * Creates a shortcut function to the object interface of a hasher.
+   *
+   * @param hasher The hasher to create a helper for.
+   *
+   * @return The shortcut function.
+   *
+   * @example
+   *
+   *     const SHA256 = Hasher._createHelper(SHA256);
+   */
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  static _createHelper(hasher) {
+    function helper(message, cfg) {
+      const hasherInstance = new hasher(cfg);
+      return hasherInstance.finalize(message);
+    }
+    return helper;
+  }
+  /**
+   * Finalizes the hash computation.
+   * Note that the finalize operation is effectively a destructive, read-once operation.
+   *
+   * @param messageUpdate (Optional) A final message update.
+   *
+   * @return The hash.
+   *
+   * @example
+   *
+   *     let hash = hasher.finalize();
+   *     let hash = hasher.finalize('message');
+   *     let hash = hasher.finalize(wordArray);
+   */
+  finalize(messageUpdate) {
+    if (messageUpdate) {
+      this._append(messageUpdate);
+    }
+    return this._doFinalize();
+  }
+  /**
+   * Updates this hasher with a message.
+   *
+   * @param messageUpdate The message to append.
+   *
+   * @return This hasher.
+   *
+   * @example
+   *
+   *     hasher.update('message');
+   *     hasher.update(wordArray);
+   */
+  update(messageUpdate) {
+    this._append(messageUpdate);
+    this._process();
+    return this;
+  }
+}
+export {
+  Hasher
+};

package/dist/esm/lib/hmac.class.d.ts

@@ -0,0 +1,11 @@
+import { HasherConstructor } from "./hasher-constructor.type.js";
+import { WordArray } from "./word-array.class.js";
+export declare class HMAC {
+    private _hasher;
+    private _iKey;
+    private _oKey;
+    constructor(hasher: HasherConstructor, rawKey: WordArray | string);
+    finalize(messageUpdate?: WordArray | string): WordArray;
+    reset(): void;
+    update(messageUpdate: WordArray | string): this;
+}

package/dist/esm/lib/hmac.class.js

@@ -0,0 +1,39 @@
+import { Utf8 } from "../enc/utf8.class.js";
+class HMAC {
+  constructor(hasher, rawKey) {
+    this._hasher = new hasher();
+    let key = typeof rawKey == "string" ? Utf8.parse(rawKey) : rawKey;
+    const hasherBlockSize = this._hasher.cfg.blockSize;
+    const hasherBlockSizeBytes = hasherBlockSize * 4;
+    if (key.sigBytes > hasherBlockSizeBytes) {
+      key = this._hasher.finalize(key);
+    }
+    key.clamp();
+    const oKey = this._oKey = key.clone();
+    const iKey = this._iKey = key.clone();
+    const oKeyWords = oKey.words;
+    const iKeyWords = iKey.words;
+    for (let i = 0; i < hasherBlockSize; i++) {
+      oKeyWords[i] ^= 1549556828;
+      iKeyWords[i] ^= 909522486;
+    }
+    oKey.sigBytes = iKey.sigBytes = hasherBlockSizeBytes;
+    this.reset();
+  }
+  finalize(messageUpdate) {
+    const innerHash = this._hasher.finalize(messageUpdate);
+    this._hasher.reset();
+    return this._hasher.finalize(this._oKey.clone().concat(innerHash));
+  }
+  reset() {
+    this._hasher.reset();
+    this._hasher.update(this._iKey);
+  }
+  update(messageUpdate) {
+    this._hasher.update(messageUpdate);
+    return this;
+  }
+}
+export {
+  HMAC
+};

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

@@ -0,0 +1,8 @@
+export { BlockCipher } from "./block-cipher.class.js";
+export { CipherParams } from "./cipher-params.class.js";
+export { Hasher } from "./hasher.class.js";
+export { PasswordBasedCipher } from "./password-based-cipher.class.js";
+export { SerializableCipher } from "./serializable-cipher.class.js";
+export { WordArray } from "./word-array.class.js";
+export { X64Word } from "./x64-word.class.js";
+export { X64WordArray } from "./x64-word-array.class.js";

package/dist/esm/lib/index.js

@@ -0,0 +1,18 @@
+import { BlockCipher } from "./block-cipher.class.js";
+import { CipherParams } from "./cipher-params.class.js";
+import { Hasher } from "./hasher.class.js";
+import { PasswordBasedCipher } from "./password-based-cipher.class.js";
+import { SerializableCipher } from "./serializable-cipher.class.js";
+import { WordArray } from "./word-array.class.js";
+import { X64Word } from "./x64-word.class.js";
+import { X64WordArray } from "./x64-word-array.class.js";
+export {
+  BlockCipher,
+  CipherParams,
+  Hasher,
+  PasswordBasedCipher,
+  SerializableCipher,
+  WordArray,
+  X64Word,
+  X64WordArray
+};

package/dist/esm/lib/password-based-cipher.class.d.ts

@@ -0,0 +1,54 @@
+import { WordArray } from "./word-array.class.js";
+import { Cipher } from "./cipher.class.js";
+import { BufferedBlockAlgorithmConfig } from "./buffered-block-algorithm-config.interface.js";
+import { CipherParams } from "./cipher-params.class.js";
+import { Formatter } from "../format/formatter.interface.js";
+export declare class PasswordBasedCipher {
+    static cfg: BufferedBlockAlgorithmConfig;
+    /**
+     * Decrypts serialized ciphertext using a password.
+     *
+     * @param cipher The cipher algorithm to use.
+     * @param ciphertext The ciphertext to decrypt.
+     * @param password The password.
+     * @param cfg (Optional) The configuration options to use for this operation.
+     *
+     * @return The plaintext.
+     *
+     * @example
+     *
+     *     var plaintext = PasswordBasedCipher.decrypt(AES, formattedCiphertext, 'password', { format: OpenSSL });
+     *     var plaintext = PasswordBasedCipher.decrypt(AES, ciphertextParams, 'password', { format: OpenSSL });
+     */
+    static decrypt(cipher: typeof Cipher, ciphertext: CipherParams | string, password: string, cfg?: BufferedBlockAlgorithmConfig): WordArray;
+    /**
+     * Encrypts a message using a password.
+     *
+     * @param cipher The cipher algorithm to use.
+     * @param message The message to encrypt.
+     * @param password The password.
+     * @param cfg (Optional) The configuration options to use for this operation.
+     *
+     * @return A cipher params object.
+     *
+     * @example
+     *
+     *     var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(AES, message, 'password');
+     *     var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(AES, message, 'password', { format: OpenSSL });
+     */
+    static encrypt(cipher: typeof Cipher, message: WordArray | string, password: string, cfg?: BufferedBlockAlgorithmConfig): CipherParams;
+    /**
+     * Converts serialized ciphertext to CipherParams,
+     * else assumed CipherParams already and returns ciphertext unchanged.
+     *
+     * @param ciphertext The ciphertext.
+     * @param format The formatting strategy to use to parse serialized ciphertext.
+     *
+     * @return The unserialized ciphertext.
+     *
+     * @example
+     *
+     *     var ciphertextParams = CryptoJS.lib.SerializableCipher._parse(ciphertextStringOrParams, format);
+     */
+    protected static _parse(ciphertext: CipherParams | string, format: Formatter): CipherParams;
+}

package/dist/esm/lib/password-based-cipher.class.js

@@ -0,0 +1,92 @@
+import { SerializableCipher } from "./serializable-cipher.class.js";
+import { WordArray } from "./word-array.class.js";
+import { OpenSSL } from "../format/open-ssl.class.js";
+import { OpenSSLKdf } from "../kdf/open-ssl-kdf.class.js";
+class PasswordBasedCipher {
+  /**
+   * Decrypts serialized ciphertext using a password.
+   *
+   * @param cipher The cipher algorithm to use.
+   * @param ciphertext The ciphertext to decrypt.
+   * @param password The password.
+   * @param cfg (Optional) The configuration options to use for this operation.
+   *
+   * @return The plaintext.
+   *
+   * @example
+   *
+   *     var plaintext = PasswordBasedCipher.decrypt(AES, formattedCiphertext, 'password', { format: OpenSSL });
+   *     var plaintext = PasswordBasedCipher.decrypt(AES, ciphertextParams, 'password', { format: OpenSSL });
+   */
+  static decrypt(cipher, ciphertext, password, cfg) {
+    const config = Object.assign({}, this.cfg, cfg);
+    if (config.format === void 0) {
+      throw new Error("missing format in config");
+    }
+    ciphertext = this._parse(ciphertext, config.format);
+    if (config.kdf === void 0) {
+      throw new Error("the key derivation function must be set");
+    }
+    const derivedParams = config.kdf.execute(password, cipher.keySize, cipher.ivSize, ciphertext.salt);
+    if (derivedParams.iv !== void 0) {
+      config.iv = derivedParams.iv;
+    }
+    return SerializableCipher.decrypt.call(this, cipher, ciphertext, derivedParams.key, config);
+  }
+  /**
+   * Encrypts a message using a password.
+   *
+   * @param cipher The cipher algorithm to use.
+   * @param message The message to encrypt.
+   * @param password The password.
+   * @param cfg (Optional) The configuration options to use for this operation.
+   *
+   * @return A cipher params object.
+   *
+   * @example
+   *
+   *     var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(AES, message, 'password');
+   *     var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(AES, message, 'password', { format: OpenSSL });
+   */
+  static encrypt(cipher, message, password, cfg) {
+    const config = Object.assign({}, this.cfg, cfg);
+    if (config.kdf === void 0) {
+      throw new Error("missing kdf in config");
+    }
+    const derivedParams = config.kdf.execute(password, cipher.keySize, cipher.ivSize);
+    if (derivedParams.iv !== void 0) {
+      config.iv = derivedParams.iv;
+    }
+    const ciphertext = SerializableCipher.encrypt.call(this, cipher, message, derivedParams.key, config);
+    return ciphertext.extend(derivedParams);
+  }
+  /**
+   * Converts serialized ciphertext to CipherParams,
+   * else assumed CipherParams already and returns ciphertext unchanged.
+   *
+   * @param ciphertext The ciphertext.
+   * @param format The formatting strategy to use to parse serialized ciphertext.
+   *
+   * @return The unserialized ciphertext.
+   *
+   * @example
+   *
+   *     var ciphertextParams = CryptoJS.lib.SerializableCipher._parse(ciphertextStringOrParams, format);
+   */
+  static _parse(ciphertext, format) {
+    if (typeof ciphertext === "string") {
+      return format.parse(ciphertext);
+    } else {
+      return ciphertext;
+    }
+  }
+}
+PasswordBasedCipher.cfg = {
+  blockSize: 4,
+  iv: new WordArray([]),
+  format: OpenSSL,
+  kdf: OpenSSLKdf
+};
+export {
+  PasswordBasedCipher
+};

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

@@ -0,0 +1,73 @@
+import { WordArray } from "./word-array.class.js";
+import { Cipher } from "./cipher.class.js";
+import { BufferedBlockAlgorithmConfig } from "./buffered-block-algorithm-config.interface.js";
+import { CipherParams } from "./cipher-params.class.js";
+import { Formatter } from "../format/formatter.interface.js";
+export declare class SerializableCipher {
+    static cfg: BufferedBlockAlgorithmConfig;
+    /**
+     * Decrypts serialized ciphertext.
+     *
+     * @param cipher The cipher algorithm to use.
+     * @param ciphertext The ciphertext to decrypt.
+     * @param key The key.
+     * @param optionalCfg The configuration options to use for this operation.
+     *
+     * @return The plaintext.
+     *
+     * @example
+     *
+     *     let plaintext = SerializableCipher.decrypt(
+     *         AESAlgorithm,
+     *         formattedCiphertext,
+     *         key, {
+     *             iv: iv,
+     *             format: CryptoJS.format.OpenSSL
+     *         }
+     *     );
+     *
+     *     let plaintext = SerializableCipher.decrypt(
+     *         AESAlgorithm,
+     *         ciphertextParams,
+     *         key, {
+     *             iv: iv,
+     *             format: CryptoJS.format.OpenSSL
+     *         }
+     *     );
+     */
+    static decrypt(cipher: typeof Cipher, ciphertext: CipherParams | string, key: WordArray | string, optionalCfg?: BufferedBlockAlgorithmConfig): WordArray;
+    /**
+     * Encrypts a message.
+     *
+     * @param cipher The cipher algorithm to use.
+     * @param message The message to encrypt.
+     * @param key The key.
+     * @param cfg (Optional) The configuration options to use for this operation.
+     *
+     * @return A cipher params object.
+     *
+     * @example
+     *
+     *     let ciphertextParams = SerializableCipher.encrypt(CryptoJS.algo.AES, message, key);
+     *     let ciphertextParams = SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv });
+     *     let ciphertextParams = SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, {
+     *       iv: iv,
+     *       format: CryptoJS.format.OpenSSL
+     *     });
+     */
+    static encrypt(cipher: typeof Cipher, message: WordArray | string, key: WordArray | string, cfg?: BufferedBlockAlgorithmConfig): CipherParams;
+    /**
+     * Converts serialized ciphertext to CipherParams,
+     * else assumed CipherParams already and returns ciphertext unchanged.
+     *
+     * @param ciphertext The ciphertext.
+     * @param format The formatting strategy to use to parse serialized ciphertext.
+     *
+     * @return The deserialized ciphertext.
+     *
+     * @example
+     *
+     *     var ciphertextParams = CryptoJS.lib.SerializableCipher._parse(ciphertextStringOrParams, format);
+     */
+    protected static _parse(ciphertext: CipherParams | string, format: Formatter): CipherParams;
+}