@tonysamperi/krypto 1.0.0

package/dist/cjs/mode/block-cipher-mode.class.d.cts

@@ -0,0 +1,28 @@
+import { BlockCipher } from "../lib/block-cipher.class.cjs";
+import { BlockCipherModeAlgorithm } from "./block-cipher-mode-algorithm.class.cjs";
+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/cjs/mode/cbc/cbc-decryptor.class.d.cts

@@ -0,0 +1,17 @@
+import { BlockCipherModeAlgorithm } from "../block-cipher-mode-algorithm.class.cjs";
+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/cjs/mode/cbc/cbc-encryptor.class.d.cts

@@ -0,0 +1,17 @@
+import { BlockCipherModeAlgorithm } from "../block-cipher-mode-algorithm.class.cjs";
+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/cjs/mode/cbc/cbc.class.d.cts

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

package/dist/cjs/mode/ctr/ctr-decryptor.class.d.cts

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

package/dist/cjs/mode/ctr/ctr-encryptor.class.d.cts

@@ -0,0 +1,16 @@
+import { BlockCipherModeAlgorithm } from "../block-cipher-mode-algorithm.class.cjs";
+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;
+}

package/dist/cjs/mode/ctr/ctr.class.d.cts

@@ -0,0 +1,10 @@
+import { BlockCipherMode } from "../block-cipher-mode.class.cjs";
+import { CTREncryptor } from "./ctr-encryptor.class.cjs";
+import { CTRDecryptor } from "./ctr-decryptor.class.cjs";
+/**
+ * Counter mode.
+ */
+export declare abstract class CTR extends BlockCipherMode {
+    static Decryptor: typeof CTRDecryptor;
+    static Encryptor: typeof CTREncryptor;
+}

package/dist/cjs/mode/ecb/ecb-decryptor.class.d.cts

@@ -0,0 +1,14 @@
+import { BlockCipherModeAlgorithm } from "../block-cipher-mode-algorithm.class.cjs";
+export declare class ECBDecryptor extends BlockCipherModeAlgorithm {
+    /**
+     * 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;
+}

package/dist/cjs/mode/ecb/ecb-encryptor.class.d.cts

@@ -0,0 +1,14 @@
+import { BlockCipherModeAlgorithm } from "../block-cipher-mode-algorithm.class.cjs";
+export declare class ECBEncryptor extends BlockCipherModeAlgorithm {
+    /**
+     * 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;
+}

package/dist/cjs/mode/ecb/ecb.class.d.cts

@@ -0,0 +1,10 @@
+import { BlockCipherMode } from "../block-cipher-mode.class.cjs";
+import { ECBEncryptor } from "./ecb-encryptor.class.cjs";
+import { ECBDecryptor } from "./ecb-decryptor.class.cjs";
+/**
+ * Cipher Block Chaining mode.
+ */
+export declare abstract class ECB extends BlockCipherMode {
+    static Decryptor: typeof ECBDecryptor;
+    static Encryptor: typeof ECBEncryptor;
+}

package/dist/cjs/mode/index.d.cts

@@ -0,0 +1,11 @@
+export { BlockCipherMode } from "./block-cipher-mode.class.cjs";
+export { BlockCipherModeAlgorithm } from "./block-cipher-mode-algorithm.class.cjs";
+export { CBC } from "./cbc/cbc.class.cjs";
+export { CBCDecryptor } from "./cbc/cbc-decryptor.class.cjs";
+export { CBCEncryptor } from "./cbc/cbc-encryptor.class.cjs";
+export { CTR } from "./ctr/ctr.class.cjs";
+export { CTRDecryptor } from "./ctr/ctr-decryptor.class.cjs";
+export { CTREncryptor } from "./ctr/ctr-encryptor.class.cjs";
+export { ECB } from "./ecb/ecb.class.cjs";
+export { ECBDecryptor } from "./ecb/ecb-decryptor.class.cjs";
+export { ECBEncryptor } from "./ecb/ecb-encryptor.class.cjs";

package/dist/cjs/pad/index.d.cts

@@ -0,0 +1,4 @@
+export { NoPadding } from "./no-padding.class.cjs";
+export { Padding } from "./padding.model.cjs";
+export { PKCS7 } from "./pkcs7.class.cjs";
+export { ZeroPadding } from "./zero-padding.class.cjs";

package/dist/cjs/pad/no-padding.class.d.cts

@@ -0,0 +1,25 @@
+import { WordArray } from "../lib/word-array.class.cjs";
+import { AbstractPadding } from "./padding.model.cjs";
+export declare class NoPadding implements AbstractPadding {
+    /**
+     * Doesn't pad the data provided.
+     *
+     * @param _data_ The data to pad.
+     * @param _blockSize_ The multiple that the data should be padded to.
+     *
+     * @example
+     *
+     *     NoPadding.pad(wordArray, 4);
+     */
+    static pad(_data_: WordArray, _blockSize_: number): void;
+    /**
+     * Doesn't un-pad the data provided.
+     *
+     * @param _data_ The data to un-pad.
+     *
+     * @example
+     *
+     *     NoPadding.unpad(wordArray);
+     */
+    static unpad(_data_: WordArray): void;
+}

package/dist/cjs/pad/padding.model.d.cts

@@ -0,0 +1,6 @@
+import { WordArray } from "../lib/word-array.class.cjs";
+export declare abstract class AbstractPadding {
+    static pad: (data: WordArray, blockSize: number) => void;
+    static unpad: (data: WordArray) => void;
+}
+export type Padding = typeof AbstractPadding;

package/dist/cjs/pad/pkcs7.class.d.cts

@@ -0,0 +1,25 @@
+import { WordArray } from "../lib/word-array.class.cjs";
+import { AbstractPadding } from "./padding.model.cjs";
+export declare class PKCS7 implements AbstractPadding {
+    /**
+     * Pads data using the algorithm defined in PKCS #5/7.
+     *
+     * @param data The data to pad.
+     * @param blockSize The multiple that the data should be padded to.
+     *
+     * @example
+     *
+     *     PKCS7.pad(wordArray, 4);
+     */
+    static pad(data: WordArray, blockSize: number): void;
+    /**
+     * Unpads data that had been padded using the algorithm defined in PKCS #5/7.
+     *
+     * @param data The data to unpad.
+     *
+     * @example
+     *
+     *     PKCS7.unpad(wordArray);
+     */
+    static unpad(data: WordArray): void;
+}

package/dist/cjs/pad/zero-padding.class.d.cts

@@ -0,0 +1,25 @@
+import { WordArray } from "../lib/word-array.class.cjs";
+import { AbstractPadding } from "./padding.model.cjs";
+export declare class ZeroPadding implements AbstractPadding {
+    /**
+     * Pads data using Zero padding algo
+     *
+     * @param data The data to pad.
+     * @param blockSize The multiple that the data should be padded to.
+     *
+     * @example
+     *
+     *     ZeroPadding.pad(wordArray, 4);
+     */
+    static pad(data: WordArray, blockSize: number): void;
+    /**
+     * Unpads data using Zero padding algo
+     *
+     * @param data The data to un-pad.
+     *
+     * @example
+     *
+     *     ZeroPadding.unpad(wordArray);
+     */
+    static unpad(data: WordArray): void;
+}

package/dist/esm/algo/aes.class.d.ts

@@ -0,0 +1,16 @@
+import { BlockCipher } from "../lib/block-cipher.class.js";
+import { WordArray } from "../lib/word-array.class.js";
+import { BufferedBlockAlgorithmConfig } from "../lib/buffered-block-algorithm-config.interface.js";
+export declare class AES extends BlockCipher {
+    static keySize: number;
+    protected _invKeySchedule: number[];
+    protected _key: WordArray;
+    protected _keyPriorReset: WordArray;
+    protected _keySchedule: number[];
+    protected _nRounds: number;
+    constructor(xformMode: number, key: WordArray, cfg?: BufferedBlockAlgorithmConfig);
+    decryptBlock(m: number[], offset: number): void;
+    encryptBlock(m: number[], offset: number): void;
+    reset(): void;
+    protected _doCryptBlock(m: number[], offset: number, keySchedule: number[], subMix0: number[], subMix1: number[], subMix2: number[], subMix3: number[], sbox: number[]): void;
+}

package/dist/esm/algo/aes.class.js

@@ -0,0 +1,138 @@
+import { BlockCipher } from "../lib/block-cipher.class.js";
+const SBOX = [];
+const INV_SBOX = [];
+const SUB_MIX_0 = [];
+const SUB_MIX_1 = [];
+const SUB_MIX_2 = [];
+const SUB_MIX_3 = [];
+const INV_SUB_MIX_0 = [];
+const INV_SUB_MIX_1 = [];
+const INV_SUB_MIX_2 = [];
+const INV_SUB_MIX_3 = [];
+(function() {
+  const d = [];
+  for (let i = 0; i < 256; i++) {
+    if (i < 128) {
+      d[i] = i << 1;
+    } else {
+      d[i] = i << 1 ^ 283;
+    }
+  }
+  let x = 0;
+  let xi = 0;
+  for (let i = 0; i < 256; i++) {
+    let sx = xi ^ xi << 1 ^ xi << 2 ^ xi << 3 ^ xi << 4;
+    sx = sx >>> 8 ^ sx & 255 ^ 99;
+    SBOX[x] = sx;
+    INV_SBOX[sx] = x;
+    const x2 = d[x];
+    const x4 = d[x2];
+    const x8 = d[x4];
+    let t = d[sx] * 257 ^ sx * 16843008;
+    SUB_MIX_0[x] = t << 24 | t >>> 8;
+    SUB_MIX_1[x] = t << 16 | t >>> 16;
+    SUB_MIX_2[x] = t << 8 | t >>> 24;
+    SUB_MIX_3[x] = t;
+    t = x8 * 16843009 ^ x4 * 65537 ^ x2 * 257 ^ x * 16843008;
+    INV_SUB_MIX_0[sx] = t << 24 | t >>> 8;
+    INV_SUB_MIX_1[sx] = t << 16 | t >>> 16;
+    INV_SUB_MIX_2[sx] = t << 8 | t >>> 24;
+    INV_SUB_MIX_3[sx] = t;
+    if (!x) {
+      x = xi = 1;
+    } else {
+      x = x2 ^ d[d[d[x8 ^ x2]]];
+      xi ^= d[d[xi]];
+    }
+  }
+})();
+const RCON = [0, 1, 2, 4, 8, 16, 32, 64, 128, 27, 54];
+class AES extends BlockCipher {
+  constructor(xformMode, key, cfg) {
+    super(xformMode, key, cfg);
+    super.reset();
+  }
+  decryptBlock(m, offset) {
+    let t = m[offset + 1];
+    m[offset + 1] = m[offset + 3];
+    m[offset + 3] = t;
+    this._doCryptBlock(m, offset, this._invKeySchedule, INV_SUB_MIX_0, INV_SUB_MIX_1, INV_SUB_MIX_2, INV_SUB_MIX_3, INV_SBOX);
+    t = m[offset + 1];
+    m[offset + 1] = m[offset + 3];
+    m[offset + 3] = t;
+  }
+  encryptBlock(m, offset) {
+    this._doCryptBlock(m, offset, this._keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX);
+  }
+  reset() {
+    super.reset();
+    if (this._nRounds && this._keyPriorReset === this._key) {
+      return;
+    }
+    const key = this._keyPriorReset = this._key;
+    const keyWords = key.words;
+    const keySize = key.sigBytes / 4;
+    const nRounds = this._nRounds = keySize + 6;
+    const ksRows = (nRounds + 1) * 4;
+    const keySchedule = this._keySchedule = [];
+    for (let ksRow = 0; ksRow < ksRows; ksRow++) {
+      if (ksRow < keySize) {
+        keySchedule[ksRow] = keyWords[ksRow];
+      } else {
+        let t = keySchedule[ksRow - 1];
+        if (!(ksRow % keySize)) {
+          t = t << 8 | t >>> 24;
+          t = SBOX[t >>> 24] << 24 | SBOX[t >>> 16 & 255] << 16 | SBOX[t >>> 8 & 255] << 8 | SBOX[t & 255];
+          t ^= RCON[ksRow / keySize | 0] << 24;
+        } else if (keySize > 6 && ksRow % keySize === 4) {
+          t = SBOX[t >>> 24] << 24 | SBOX[t >>> 16 & 255] << 16 | SBOX[t >>> 8 & 255] << 8 | SBOX[t & 255];
+        }
+        keySchedule[ksRow] = keySchedule[ksRow - keySize] ^ t;
+      }
+    }
+    this._invKeySchedule = [];
+    for (let invKsRow = 0; invKsRow < ksRows; invKsRow++) {
+      const ksRow = ksRows - invKsRow;
+      let t;
+      if (invKsRow % 4) {
+        t = keySchedule[ksRow];
+      } else {
+        t = keySchedule[ksRow - 4];
+      }
+      if (invKsRow < 4 || ksRow <= 4) {
+        this._invKeySchedule[invKsRow] = t;
+      } else {
+        this._invKeySchedule[invKsRow] = INV_SUB_MIX_0[SBOX[t >>> 24]] ^ INV_SUB_MIX_1[SBOX[t >>> 16 & 255]] ^ INV_SUB_MIX_2[SBOX[t >>> 8 & 255]] ^ INV_SUB_MIX_3[SBOX[t & 255]];
+      }
+    }
+  }
+  _doCryptBlock(m, offset, keySchedule, subMix0, subMix1, subMix2, subMix3, sbox) {
+    let s0 = m[offset] ^ keySchedule[0];
+    let s1 = m[offset + 1] ^ keySchedule[1];
+    let s2 = m[offset + 2] ^ keySchedule[2];
+    let s3 = m[offset + 3] ^ keySchedule[3];
+    let ksRow = 4;
+    for (let round = 1; round < this._nRounds; round++) {
+      const t0 = subMix0[s0 >>> 24] ^ subMix1[s1 >>> 16 & 255] ^ subMix2[s2 >>> 8 & 255] ^ subMix3[s3 & 255] ^ keySchedule[ksRow++];
+      const t1 = subMix0[s1 >>> 24] ^ subMix1[s2 >>> 16 & 255] ^ subMix2[s3 >>> 8 & 255] ^ subMix3[s0 & 255] ^ keySchedule[ksRow++];
+      const t2 = subMix0[s2 >>> 24] ^ subMix1[s3 >>> 16 & 255] ^ subMix2[s0 >>> 8 & 255] ^ subMix3[s1 & 255] ^ keySchedule[ksRow++];
+      const t3 = subMix0[s3 >>> 24] ^ subMix1[s0 >>> 16 & 255] ^ subMix2[s1 >>> 8 & 255] ^ subMix3[s2 & 255] ^ keySchedule[ksRow++];
+      s0 = t0;
+      s1 = t1;
+      s2 = t2;
+      s3 = t3;
+    }
+    const t0g = (sbox[s0 >>> 24] << 24 | sbox[s1 >>> 16 & 255] << 16 | sbox[s2 >>> 8 & 255] << 8 | sbox[s3 & 255]) ^ keySchedule[ksRow++];
+    const t1g = (sbox[s1 >>> 24] << 24 | sbox[s2 >>> 16 & 255] << 16 | sbox[s3 >>> 8 & 255] << 8 | sbox[s0 & 255]) ^ keySchedule[ksRow++];
+    const t2g = (sbox[s2 >>> 24] << 24 | sbox[s3 >>> 16 & 255] << 16 | sbox[s0 >>> 8 & 255] << 8 | sbox[s1 & 255]) ^ keySchedule[ksRow++];
+    const t3g = (sbox[s3 >>> 24] << 24 | sbox[s0 >>> 16 & 255] << 16 | sbox[s1 >>> 8 & 255] << 8 | sbox[s2 & 255]) ^ keySchedule[ksRow++];
+    m[offset] = t0g;
+    m[offset + 1] = t1g;
+    m[offset + 2] = t2g;
+    m[offset + 3] = t3g;
+  }
+}
+AES.keySize = 256 / 32;
+export {
+  AES
+};

package/dist/esm/algo/des.class.d.ts

@@ -0,0 +1,19 @@
+import { BlockCipher } from "../lib/block-cipher.class.js";
+import { WordArray } from "../lib/word-array.class.js";
+import { BufferedBlockAlgorithmConfig } from "../lib/buffered-block-algorithm-config.interface.js";
+export declare class DES extends BlockCipher {
+    static blockSize: number;
+    static ivSize: number;
+    static keySize: number;
+    protected _invSubKeys: number[][];
+    protected _lBlock: number;
+    protected _rBlock: number;
+    protected _subKeys: number[][];
+    constructor(xformMode: number, key: WordArray, cfg?: BufferedBlockAlgorithmConfig);
+    decryptBlock(m: number[], offset: number): void;
+    encryptBlock(m: number[], offset: number): void;
+    reset(): void;
+    protected _doCryptBlock(m: number[], offset: number, subKeys: number[][]): void;
+    protected _exchangeLR(offset: number, mask: number): void;
+    protected _exchangeRL(offset: number, mask: number): void;
+}