@tonysamperi/krypto 1.0.0

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

@@ -0,0 +1,108 @@
+import { WordArray } from "./word-array.class.js";
+import { OpenSSL } from "../format/open-ssl.class.js";
+import { CipherParams } from "./cipher-params.class.js";
+class SerializableCipher {
+  /**
+   * 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, ciphertext, key, optionalCfg) {
+    const cfg = Object.assign({}, this.cfg, optionalCfg);
+    if (!cfg.format) {
+      throw new Error("could not determine format");
+    }
+    ciphertext = this._parse(ciphertext, cfg.format);
+    if (!ciphertext.ciphertext) {
+      throw new Error("could not determine ciphertext");
+    }
+    return cipher.createDecryptor(key, cfg).finalize(ciphertext.ciphertext);
+  }
+  /**
+   * 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, message, key, cfg) {
+    const config = Object.assign({}, this.cfg, cfg);
+    const encryptor = cipher.createEncryptor(key, config);
+    const ciphertext = encryptor.finalize(message);
+    return new CipherParams({
+      ciphertext,
+      key,
+      iv: encryptor.cfg.iv,
+      algorithm: cipher,
+      mode: encryptor.cfg.mode,
+      padding: encryptor.cfg.padding,
+      blockSize: encryptor.cfg.blockSize,
+      formatter: config.format
+    });
+  }
+  /**
+   * 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);
+   */
+  static _parse(ciphertext, format) {
+    if (typeof ciphertext === "string") {
+      return format.parse(ciphertext);
+    } else {
+      return ciphertext;
+    }
+  }
+}
+SerializableCipher.cfg = {
+  blockSize: 4,
+  iv: new WordArray([]),
+  format: OpenSSL
+};
+export {
+  SerializableCipher
+};

package/dist/esm/lib/word-array.class.d.ts

@@ -0,0 +1,75 @@
+export declare class WordArray {
+    sigBytes: number;
+    words: number[];
+    /**
+     * Initializes a newly created word array.
+     *
+     * @param words (Optional) An array of 32-bit words.
+     * @param sigBytes (Optional) The number of significant bytes in the words.
+     *
+     * @example
+     *
+     *     let wordArray = new WordArray();
+     *     let wordArray = new WordArray([0x00010203, 0x04050607]);
+     *     let wordArray = new WordArray([0x00010203, 0x04050607], 6);
+     */
+    constructor(words?: number[], sigBytes?: number);
+    /**
+     * Creates a word array filled with random bytes.
+     *
+     * @param nBytes The number of random bytes to generate.
+     *
+     * @return The random word array.
+     *
+     * @example
+     *
+     *     let wordArray = WordArray.random(16);
+     */
+    static random(nBytes: number): WordArray;
+    /**
+     * Removes insignificant bits.
+     *
+     * @example
+     *
+     *     wordArray.clamp();
+     */
+    clamp(): void;
+    /**
+     * Creates a copy of this word array.
+     *
+     * @return The clone.
+     *
+     * @example
+     *
+     *     let clone = wordArray.clone();
+     */
+    clone(): WordArray;
+    /**
+     * Concatenates a word array to this word array.
+     *
+     * @param wordArray The word array to append.
+     *
+     * @return This word array.
+     *
+     * @example
+     *
+     *     wordArray1.concat(wordArray2);
+     */
+    concat(wordArray: WordArray): WordArray;
+    /**
+     * Converts this word array to a string.
+     *
+     * @param encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex
+     *
+     * @return The stringified word array.
+     *
+     * @example
+     *
+     *     let string = wordArray + '';
+     *     let string = wordArray.toString();
+     *     let string = wordArray.toString(CryptoJS.enc.Utf8);
+     */
+    toString<T extends {
+        stringify: (arg: WordArray) => string;
+    }>(encoder?: T): string;
+}

package/dist/esm/lib/word-array.class.js

@@ -0,0 +1,123 @@
+import { Hex } from "../enc/hex.class.js";
+class WordArray {
+  /**
+   * Initializes a newly created word array.
+   *
+   * @param words (Optional) An array of 32-bit words.
+   * @param sigBytes (Optional) The number of significant bytes in the words.
+   *
+   * @example
+   *
+   *     let wordArray = new WordArray();
+   *     let wordArray = new WordArray([0x00010203, 0x04050607]);
+   *     let wordArray = new WordArray([0x00010203, 0x04050607], 6);
+   */
+  constructor(words, sigBytes) {
+    this.words = words || [];
+    if (sigBytes !== void 0) {
+      this.sigBytes = sigBytes;
+    } else {
+      this.sigBytes = this.words.length * 4;
+    }
+  }
+  /**
+   * Creates a word array filled with random bytes.
+   *
+   * @param nBytes The number of random bytes to generate.
+   *
+   * @return The random word array.
+   *
+   * @example
+   *
+   *     let wordArray = WordArray.random(16);
+   */
+  static random(nBytes) {
+    const words = [];
+    const r = function(mw) {
+      let mz = 987654321;
+      const mask = 4294967295;
+      return function() {
+        mz = 36969 * (mz & 65535) + (mz >> 16) & mask;
+        mw = 18e3 * (mw & 65535) + (mw >> 16) & mask;
+        let result = (mz << 16) + mw & mask;
+        result /= 4294967296;
+        result += 0.5;
+        return result * (Math.random() > 0.5 ? 1 : -1);
+      };
+    };
+    for (let i = 0, rcache; i < nBytes; i += 4) {
+      const rnd1 = r((rcache || Math.random()) * 4294967296);
+      rcache = rnd1() * 987654071;
+      words.push(rnd1() * 4294967296 | 0);
+    }
+    return new WordArray(words, nBytes);
+  }
+  /**
+   * Removes insignificant bits.
+   *
+   * @example
+   *
+   *     wordArray.clamp();
+   */
+  clamp() {
+    this.words[this.sigBytes >>> 2] &= 4294967295 << 32 - this.sigBytes % 4 * 8;
+    this.words.length = Math.ceil(this.sigBytes / 4);
+  }
+  /**
+   * Creates a copy of this word array.
+   *
+   * @return The clone.
+   *
+   * @example
+   *
+   *     let clone = wordArray.clone();
+   */
+  clone() {
+    return new WordArray(this.words.slice(0), this.sigBytes);
+  }
+  /**
+   * Concatenates a word array to this word array.
+   *
+   * @param wordArray The word array to append.
+   *
+   * @return This word array.
+   *
+   * @example
+   *
+   *     wordArray1.concat(wordArray2);
+   */
+  concat(wordArray) {
+    this.clamp();
+    if (this.sigBytes % 4) {
+      for (let i = 0; i < wordArray.sigBytes; i++) {
+        const thatByte = wordArray.words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+        this.words[this.sigBytes + i >>> 2] |= thatByte << 24 - (this.sigBytes + i) % 4 * 8;
+      }
+    } else {
+      for (let i = 0; i < wordArray.sigBytes; i += 4) {
+        this.words[this.sigBytes + i >>> 2] = wordArray.words[i >>> 2];
+      }
+    }
+    this.sigBytes += wordArray.sigBytes;
+    return this;
+  }
+  /**
+   * Converts this word array to a string.
+   *
+   * @param encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex
+   *
+   * @return The stringified word array.
+   *
+   * @example
+   *
+   *     let string = wordArray + '';
+   *     let string = wordArray.toString();
+   *     let string = wordArray.toString(CryptoJS.enc.Utf8);
+   */
+  toString(encoder) {
+    return (encoder || Hex).stringify(this);
+  }
+}
+export {
+  WordArray
+};

package/dist/esm/lib/x64-word-array.class.d.ts

@@ -0,0 +1,10 @@
+import { X64Word } from "./x64-word.class.js";
+import { WordArray } from "./word-array.class.js";
+export declare class X64WordArray {
+    sigBytes: number;
+    words: X64Word[];
+    constructor(words?: X64Word[], sigBytes?: number);
+    static create(words?: X64Word[], sigBytes?: number): X64WordArray;
+    clone(): X64WordArray;
+    toX32(): WordArray;
+}

package/dist/esm/lib/x64-word-array.class.js

@@ -0,0 +1,25 @@
+import { X64Word } from "./x64-word.class.js";
+import { WordArray } from "./word-array.class.js";
+class X64WordArray {
+  constructor(words = [], sigBytes) {
+    this.words = words;
+    this.sigBytes = sigBytes !== void 0 ? sigBytes : words.length * 8;
+  }
+  static create(words = [], sigBytes) {
+    return new X64WordArray(words, sigBytes);
+  }
+  clone() {
+    const clonedWords = this.words.map((word) => new X64Word(word.high, word.low));
+    return new X64WordArray(clonedWords, this.sigBytes);
+  }
+  toX32() {
+    const x32Words = [];
+    for (const word of this.words) {
+      x32Words.push(word.high, word.low);
+    }
+    return new WordArray(x32Words, this.sigBytes);
+  }
+}
+export {
+  X64WordArray
+};

package/dist/esm/lib/x64-word.class.d.ts

@@ -0,0 +1,14 @@
+export declare class X64Word {
+    high: number;
+    low: number;
+    constructor(high: number, low: number);
+    add(word: X64Word): X64Word;
+    and(word: X64Word): X64Word;
+    not(): X64Word;
+    or(word: X64Word): X64Word;
+    rotL(n: number): X64Word;
+    rotR(n: number): X64Word;
+    shiftL(n: number): X64Word;
+    shiftR(n: number): X64Word;
+    xor(word: X64Word): X64Word;
+}

package/dist/esm/lib/x64-word.class.js

@@ -0,0 +1,47 @@
+class X64Word {
+  constructor(high, low) {
+    this.high = high;
+    this.low = low;
+  }
+  add(word) {
+    const low = this.low + word.low | 0;
+    const carry = low >>> 0 < this.low >>> 0 ? 1 : 0;
+    const high = this.high + word.high + carry | 0;
+    return new X64Word(high, low);
+  }
+  and(word) {
+    return new X64Word(this.high & word.high, this.low & word.low);
+  }
+  not() {
+    return new X64Word(~this.high, ~this.low);
+  }
+  or(word) {
+    return new X64Word(this.high | word.high, this.low | word.low);
+  }
+  rotL(n) {
+    return this.shiftL(n).or(this.shiftR(64 - n));
+  }
+  rotR(n) {
+    return this.shiftR(n).or(this.shiftL(64 - n));
+  }
+  shiftL(n) {
+    if (n < 32) {
+      return new X64Word(this.high << n | this.low >>> 32 - n, this.low << n);
+    } else {
+      return new X64Word(this.low << n - 32, 0);
+    }
+  }
+  shiftR(n) {
+    if (n < 32) {
+      return new X64Word(this.high >>> n, this.low >>> n | this.high << 32 - n);
+    } else {
+      return new X64Word(0, this.high >>> n - 32);
+    }
+  }
+  xor(word) {
+    return new X64Word(this.high ^ word.high, this.low ^ word.low);
+  }
+}
+export {
+  X64Word
+};

package/dist/esm/mode/block-cipher-mode-algorithm.class.d.ts

@@ -0,0 +1,20 @@
+import { BlockCipher } from "../lib/block-cipher.class.js";
+import { BlockCipherMode } from "./block-cipher-mode.class.js";
+export declare abstract class BlockCipherModeAlgorithm {
+    __creator: ((cipher: BlockCipher, iv: number[]) => BlockCipherMode) | undefined;
+    protected _cipher: BlockCipher;
+    protected _iv: number[] | undefined;
+    constructor(cipher: BlockCipher, iv: number[]);
+    abstract processBlock(words: number[], offset: number): void;
+    /**
+     * Initializes a newly created mode.
+     *
+     * @param cipher A block cipher instance.
+     * @param iv The IV words.
+     *
+     * @example
+     *
+     *     var mode = CBC.Encryptor.create(cipher, iv.words);
+     */
+    init(cipher: BlockCipher, iv?: number[]): void;
+}

package/dist/esm/mode/block-cipher-mode-algorithm.class.js

@@ -0,0 +1,22 @@
+class BlockCipherModeAlgorithm {
+  constructor(cipher, iv) {
+    this.init(cipher, iv);
+  }
+  /**
+   * Initializes a newly created mode.
+   *
+   * @param cipher A block cipher instance.
+   * @param iv The IV words.
+   *
+   * @example
+   *
+   *     var mode = CBC.Encryptor.create(cipher, iv.words);
+   */
+  init(cipher, iv) {
+    this._cipher = cipher;
+    this._iv = iv;
+  }
+}
+export {
+  BlockCipherModeAlgorithm
+};

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

@@ -0,0 +1,28 @@
+import { BlockCipher } from "../lib/block-cipher.class.js";
+import { BlockCipherModeAlgorithm } from "./block-cipher-mode-algorithm.class.js";
+export declare abstract class BlockCipherMode {
+    static Decryptor: any;
+    static Encryptor: any;
+    /**
+     * Creates this mode for decryption.
+     *
+     * @param cipher A block cipher instance.
+     * @param iv The IV words.
+     *
+     * @example
+     *
+     *     const mode = CBC.createDecryptor(cipher, iv.words);
+     */
+    static createDecryptor(cipher: BlockCipher, iv: number[]): BlockCipherModeAlgorithm;
+    /**
+     * Creates this mode for encryption.
+     *
+     * @param cipher A block cipher instance.
+     * @param iv The IV words.
+     *
+     * @example
+     *
+     *     var mode = CBC.createEncryptor(cipher, iv.words);
+     */
+    static createEncryptor(cipher: BlockCipher, iv: number[]): BlockCipherModeAlgorithm;
+}

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

@@ -0,0 +1,36 @@
+import { BlockCipherModeAlgorithm } from "./block-cipher-mode-algorithm.class.js";
+class BlockCipherMode {
+  /**
+   * Creates this mode for decryption.
+   *
+   * @param cipher A block cipher instance.
+   * @param iv The IV words.
+   *
+   * @example
+   *
+   *     const mode = CBC.createDecryptor(cipher, iv.words);
+   */
+  static createDecryptor(cipher, iv) {
+    const decryptorClass = this.Decryptor;
+    return new decryptorClass(cipher, iv);
+  }
+  /**
+   * Creates this mode for encryption.
+   *
+   * @param cipher A block cipher instance.
+   * @param iv The IV words.
+   *
+   * @example
+   *
+   *     var mode = CBC.createEncryptor(cipher, iv.words);
+   */
+  static createEncryptor(cipher, iv) {
+    const encryptorClass = this.Encryptor;
+    return new encryptorClass(cipher, iv);
+  }
+}
+BlockCipherMode.Decryptor = BlockCipherModeAlgorithm;
+BlockCipherMode.Encryptor = BlockCipherModeAlgorithm;
+export {
+  BlockCipherMode
+};

package/dist/esm/mode/cbc/cbc-decryptor.class.d.ts

@@ -0,0 +1,17 @@
+import { BlockCipherModeAlgorithm } from "../block-cipher-mode-algorithm.class.js";
+export declare class CBCDecryptor extends BlockCipherModeAlgorithm {
+    get prevBlock(): number[];
+    protected _prevBlock: number[] | undefined;
+    /**
+     * Processes the data block at offset.
+     *
+     * @param words The data words to operate on.
+     * @param offset The offset where the block starts.
+     *
+     * @example
+     *
+     *     mode.processBlock(data.words, offset);
+     */
+    processBlock(words: number[], offset: number): void;
+    xorBlock(words: number[], offset: number, blockSize: number): void;
+}

package/dist/esm/mode/cbc/cbc-decryptor.class.js

@@ -0,0 +1,40 @@
+import { BlockCipherModeAlgorithm } from "../block-cipher-mode-algorithm.class.js";
+class CBCDecryptor extends BlockCipherModeAlgorithm {
+  get prevBlock() {
+    return this._prevBlock;
+  }
+  /**
+   * Processes the data block at offset.
+   *
+   * @param words The data words to operate on.
+   * @param offset The offset where the block starts.
+   *
+   * @example
+   *
+   *     mode.processBlock(data.words, offset);
+   */
+  processBlock(words, offset) {
+    if (this._cipher.cfg.blockSize === void 0) {
+      throw new Error("missing blockSize in cipher config");
+    }
+    const thisBlock = words.slice(offset, offset + this._cipher.cfg.blockSize);
+    this._cipher.decryptBlock(words, offset);
+    this.xorBlock(words, offset, this._cipher.cfg.blockSize);
+    this._prevBlock = thisBlock;
+  }
+  xorBlock(words, offset, blockSize) {
+    let block;
+    if (this._iv) {
+      block = this._iv;
+      this._iv = void 0;
+    } else {
+      block = this._prevBlock;
+    }
+    for (let i = 0; i < blockSize; i++) {
+      words[offset + i] ^= block[i];
+    }
+  }
+}
+export {
+  CBCDecryptor
+};

package/dist/esm/mode/cbc/cbc-encryptor.class.d.ts

@@ -0,0 +1,17 @@
+import { BlockCipherModeAlgorithm } from "../block-cipher-mode-algorithm.class.js";
+export declare class CBCEncryptor extends BlockCipherModeAlgorithm {
+    get prevBlock(): number[];
+    protected _prevBlock: number[] | undefined;
+    /**
+     * Processes the data block at offset.
+     *
+     * @param words The data words to operate on.
+     * @param offset The offset where the block starts.
+     *
+     * @example
+     *
+     *     mode.processBlock(data.words, offset);
+     */
+    processBlock(words: number[], offset: number): void;
+    xorBlock(words: number[], offset: number, blockSize: number): void;
+}

package/dist/esm/mode/cbc/cbc-encryptor.class.js

@@ -0,0 +1,39 @@
+import { BlockCipherModeAlgorithm } from "../block-cipher-mode-algorithm.class.js";
+class CBCEncryptor extends BlockCipherModeAlgorithm {
+  get prevBlock() {
+    return this._prevBlock;
+  }
+  /**
+   * Processes the data block at offset.
+   *
+   * @param words The data words to operate on.
+   * @param offset The offset where the block starts.
+   *
+   * @example
+   *
+   *     mode.processBlock(data.words, offset);
+   */
+  processBlock(words, offset) {
+    if (this._cipher.cfg.blockSize === void 0) {
+      throw new Error("missing blockSize in cipher config");
+    }
+    this.xorBlock(words, offset, this._cipher.cfg.blockSize);
+    this._cipher.encryptBlock(words, offset);
+    this._prevBlock = words.slice(offset, offset + this._cipher.cfg.blockSize);
+  }
+  xorBlock(words, offset, blockSize) {
+    let block;
+    if (this._iv) {
+      block = this._iv;
+      this._iv = void 0;
+    } else {
+      block = this._prevBlock;
+    }
+    for (let i = 0; i < blockSize; i++) {
+      words[offset + i] ^= block[i];
+    }
+  }
+}
+export {
+  CBCEncryptor
+};

package/dist/esm/mode/cbc/cbc.class.d.ts

@@ -0,0 +1,10 @@
+import { BlockCipherMode } from "../block-cipher-mode.class.js";
+import { CBCEncryptor } from "./cbc-encryptor.class.js";
+import { CBCDecryptor } from "./cbc-decryptor.class.js";
+/**
+ * Cipher Block Chaining mode.
+ */
+export declare abstract class CBC extends BlockCipherMode {
+    static Decryptor: typeof CBCDecryptor;
+    static Encryptor: typeof CBCEncryptor;
+}

package/dist/esm/mode/cbc/cbc.class.js

@@ -0,0 +1,10 @@
+import { BlockCipherMode } from "../block-cipher-mode.class.js";
+import { CBCEncryptor } from "./cbc-encryptor.class.js";
+import { CBCDecryptor } from "./cbc-decryptor.class.js";
+class CBC extends BlockCipherMode {
+}
+CBC.Decryptor = CBCDecryptor;
+CBC.Encryptor = CBCEncryptor;
+export {
+  CBC
+};

package/dist/esm/mode/ctr/ctr-decryptor.class.d.ts

@@ -0,0 +1,3 @@
+import { CTREncryptor } from "./ctr-encryptor.class.js";
+export declare class CTRDecryptor extends CTREncryptor {
+}

package/dist/esm/mode/ctr/ctr-decryptor.class.js

@@ -0,0 +1,6 @@
+import { CTREncryptor } from "./ctr-encryptor.class.js";
+class CTRDecryptor extends CTREncryptor {
+}
+export {
+  CTRDecryptor
+};

package/dist/esm/mode/ctr/ctr-encryptor.class.d.ts

@@ -0,0 +1,16 @@
+import { BlockCipherModeAlgorithm } from "../block-cipher-mode-algorithm.class.js";
+export declare class CTREncryptor extends BlockCipherModeAlgorithm {
+    protected _counter: number[];
+    protected _prevBlock: number[] | undefined;
+    /**
+     * Processes the data block at offset.
+     *
+     * @param words The data words to operate on.
+     * @param offset The offset where the block starts.
+     *
+     * @example
+     *
+     *     mode.processBlock(data.words, offset);
+     */
+    processBlock(words: number[], offset: number): void;
+}