@tonysamperi/krypto 1.0.0

package/dist/esm/enc/base64.class.js

@@ -0,0 +1,80 @@
+import { WordArray } from "../lib/word-array.class.js";
+class Base64 {
+  /**
+   * Converts a Base64 string to a word array.
+   *
+   * @param base64Str The Base64 string.
+   *
+   * @return The word array.
+   *
+   * @example
+   *
+   *     let wordArray = Base64.parse(base64String);
+   */
+  static parse(base64Str) {
+    let base64StrLength = base64Str.length;
+    if (this._reverseMap === void 0) {
+      this._reverseMap = [];
+      for (let j = 0; j < this._map.length; j++) {
+        this._reverseMap[this._map.charCodeAt(j)] = j;
+      }
+    }
+    const paddingChar = this._map.charAt(64);
+    if (paddingChar) {
+      const paddingIndex = base64Str.indexOf(paddingChar);
+      if (paddingIndex !== -1) {
+        base64StrLength = paddingIndex;
+      }
+    }
+    return this.parseLoop(base64Str, base64StrLength, this._reverseMap);
+  }
+  static parseLoop(base64Str, base64StrLength, reverseMap) {
+    const words = [];
+    let nBytes = 0;
+    for (let i = 0; i < base64StrLength; i++) {
+      if (i % 4) {
+        const bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << i % 4 * 2;
+        const bits2 = reverseMap[base64Str.charCodeAt(i)] >>> 6 - i % 4 * 2;
+        words[nBytes >>> 2] |= (bits1 | bits2) << 24 - nBytes % 4 * 8;
+        nBytes++;
+      }
+    }
+    return new WordArray(words, nBytes);
+  }
+  /**
+   * Converts a word array to a Base64 string.
+   *
+   * @param wordArray The word array.
+   *
+   * @return The Base64 string.
+   *
+   * @example
+   *
+   *     let base64String = Base64.stringify(wordArray);
+   */
+  static stringify(wordArray) {
+    wordArray.clamp();
+    const base64Chars = [];
+    for (let i = 0; i < wordArray.sigBytes; i += 3) {
+      const byte1 = wordArray.words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+      const byte2 = wordArray.words[i + 1 >>> 2] >>> 24 - (i + 1) % 4 * 8 & 255;
+      const byte3 = wordArray.words[i + 2 >>> 2] >>> 24 - (i + 2) % 4 * 8 & 255;
+      const triplet = byte1 << 16 | byte2 << 8 | byte3;
+      for (let j = 0; j < 4 && i + j * 0.75 < wordArray.sigBytes; j++) {
+        base64Chars.push(this._map.charAt(triplet >>> 6 * (3 - j) & 63));
+      }
+    }
+    const paddingChar = this._map.charAt(64);
+    if (paddingChar) {
+      while (base64Chars.length % 4) {
+        base64Chars.push(paddingChar);
+      }
+    }
+    return base64Chars.join("");
+  }
+}
+Base64._map = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+Base64._reverseMap = void 0;
+export {
+  Base64
+};

package/dist/esm/enc/encoder.model.d.ts

@@ -0,0 +1,6 @@
+import { WordArray } from "../lib/word-array.class.js";
+export declare abstract class AbstractEncoder {
+    static parse: (word: string) => WordArray;
+    static stringify: (word: WordArray) => string;
+}
+export type Encoder = typeof AbstractEncoder;

package/dist/esm/enc/encoder.model.js

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

package/dist/esm/enc/hex.class.d.ts

@@ -0,0 +1,27 @@
+import { WordArray } from "../lib/word-array.class.js";
+export declare class Hex {
+    /**
+     * Converts a hex string to a word array.
+     *
+     * @param hexStr The hex string.
+     *
+     * @return The word array.
+     *
+     * @example
+     *
+     *     let wordArray = Hex.parse(hexString);
+     */
+    static parse(hexStr: string): WordArray;
+    /**
+     * Converts a word array to a hex string.
+     *
+     * @param wordArray The word array.
+     *
+     * @return The hex string.
+     *
+     * @example
+     *
+     *     let hexString = Hex.stringify(wordArray);
+     */
+    static stringify(wordArray: WordArray): string;
+}

package/dist/esm/enc/hex.class.js

@@ -0,0 +1,45 @@
+import { WordArray } from "../lib/word-array.class.js";
+class Hex {
+  /**
+   * Converts a hex string to a word array.
+   *
+   * @param hexStr The hex string.
+   *
+   * @return The word array.
+   *
+   * @example
+   *
+   *     let wordArray = Hex.parse(hexString);
+   */
+  static parse(hexStr) {
+    const hexStrLength = hexStr.length;
+    const words = [];
+    for (let i = 0; i < hexStrLength; i += 2) {
+      words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << 24 - i % 8 * 4;
+    }
+    return new WordArray(words, hexStrLength / 2);
+  }
+  /**
+   * Converts a word array to a hex string.
+   *
+   * @param wordArray The word array.
+   *
+   * @return The hex string.
+   *
+   * @example
+   *
+   *     let hexString = Hex.stringify(wordArray);
+   */
+  static stringify(wordArray) {
+    const hexChars = [];
+    for (let i = 0; i < wordArray.sigBytes; i++) {
+      const bite = wordArray.words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+      hexChars.push((bite >>> 4).toString(16));
+      hexChars.push((bite & 15).toString(16));
+    }
+    return hexChars.join("");
+  }
+}
+export {
+  Hex
+};

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

@@ -0,0 +1,6 @@
+export * from "./base64.class.js";
+export * from "./encoder.model.js";
+export * from "./hex.class.js";
+export * from "./latin1.class.js";
+export * from "./utf16.class.js";
+export * from "./utf8.class.js";

package/dist/esm/enc/index.js

@@ -0,0 +1,6 @@
+export * from "./base64.class.js";
+export * from "./encoder.model.js";
+export * from "./hex.class.js";
+export * from "./latin1.class.js";
+export * from "./utf16.class.js";
+export * from "./utf8.class.js";

package/dist/esm/enc/latin1.class.d.ts

@@ -0,0 +1,27 @@
+import { WordArray } from "../lib/word-array.class.js";
+export declare class Latin1 {
+    /**
+     * Converts a Latin1 string to a word array.
+     *
+     * @param latin1Str The Latin1 string.
+     *
+     * @return The word array.
+     *
+     * @example
+     *
+     *     let wordArray = Latin1.parse(latin1String);
+     */
+    static parse(latin1Str: string): WordArray;
+    /**
+     * Converts a word array to a Latin1 string.
+     *
+     * @param wordArray The word array.
+     *
+     * @return The Latin1 string.
+     *
+     * @example
+     *
+     *     let latin1String = Latin1.stringify(wordArray);
+     */
+    static stringify(wordArray: WordArray): string;
+}

package/dist/esm/enc/latin1.class.js

@@ -0,0 +1,44 @@
+import { WordArray } from "../lib/word-array.class.js";
+class Latin1 {
+  /**
+   * Converts a Latin1 string to a word array.
+   *
+   * @param latin1Str The Latin1 string.
+   *
+   * @return The word array.
+   *
+   * @example
+   *
+   *     let wordArray = Latin1.parse(latin1String);
+   */
+  static parse(latin1Str) {
+    const latin1StrLength = latin1Str.length;
+    const words = [];
+    for (let i = 0; i < latin1StrLength; i++) {
+      words[i >>> 2] |= (latin1Str.charCodeAt(i) & 255) << 24 - i % 4 * 8;
+    }
+    return new WordArray(words, latin1StrLength);
+  }
+  /**
+   * Converts a word array to a Latin1 string.
+   *
+   * @param wordArray The word array.
+   *
+   * @return The Latin1 string.
+   *
+   * @example
+   *
+   *     let latin1String = Latin1.stringify(wordArray);
+   */
+  static stringify(wordArray) {
+    const latin1Chars = [];
+    for (let i = 0; i < wordArray.sigBytes; i++) {
+      const bite = wordArray.words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+      latin1Chars.push(String.fromCharCode(bite));
+    }
+    return latin1Chars.join("");
+  }
+}
+export {
+  Latin1
+};

package/dist/esm/enc/utf16.class.d.ts

@@ -0,0 +1,28 @@
+import { WordArray } from "../lib/word-array.class.js";
+import { AbstractEncoder } from "./encoder.model.js";
+export declare class Utf16 implements AbstractEncoder {
+    /**
+     * Converts a UTF-16 BE string to a word array.
+     *
+     * @param utf16Str The UTF-16 BE string.
+     *
+     * @return The word array.
+     *
+     * @example
+     *
+     *     const wordArray = Utf16.parse(utf8String);
+     */
+    static parse(utf16Str: string): WordArray;
+    /**
+     * Converts a word array to a UTF-16 BE string.
+     *
+     * @param wordArray The word array.
+     *
+     * @return The UTF-16 BE string.
+     *
+     * @example
+     *
+     *     const utf16String = Utf16.stringify(wordArray);
+     */
+    static stringify(wordArray: WordArray): string;
+}

package/dist/esm/enc/utf16.class.js

@@ -0,0 +1,46 @@
+import { WordArray } from "../lib/word-array.class.js";
+class Utf16 {
+  /**
+   * Converts a UTF-16 BE string to a word array.
+   *
+   * @param utf16Str The UTF-16 BE string.
+   *
+   * @return The word array.
+   *
+   * @example
+   *
+   *     const wordArray = Utf16.parse(utf8String);
+   */
+  static parse(utf16Str) {
+    const utf16StrLength = utf16Str.length;
+    const words = [];
+    for (let i = 0; i < utf16StrLength; i++) {
+      words[i >>> 1] |= utf16Str.charCodeAt(i) << 16 - i % 2 * 16;
+    }
+    return new WordArray(words, utf16StrLength * 2);
+  }
+  /**
+   * Converts a word array to a UTF-16 BE string.
+   *
+   * @param wordArray The word array.
+   *
+   * @return The UTF-16 BE string.
+   *
+   * @example
+   *
+   *     const utf16String = Utf16.stringify(wordArray);
+   */
+  static stringify(wordArray) {
+    const words = wordArray.words;
+    const sigBytes = wordArray.sigBytes;
+    const utf16Chars = [];
+    for (let i = 0; i < sigBytes; i += 2) {
+      const codePoint = words[i >>> 2] >>> 16 - i % 4 * 8 & 65535;
+      utf16Chars.push(String.fromCharCode(codePoint));
+    }
+    return utf16Chars.join("");
+  }
+}
+export {
+  Utf16
+};

package/dist/esm/enc/utf8.class.d.ts

@@ -0,0 +1,28 @@
+import { WordArray } from "../lib/word-array.class.js";
+import { AbstractEncoder } from "./encoder.model.js";
+export declare class Utf8 implements AbstractEncoder {
+    /**
+     * Converts a UTF-8 string to a word array.
+     *
+     * @param utf8Str The UTF-8 string.
+     *
+     * @return The word array.
+     *
+     * @example
+     *
+     *     let wordArray = Utf8.parse(utf8String);
+     */
+    static parse(utf8Str: string): WordArray;
+    /**
+     * Converts a word array to a UTF-8 string.
+     *
+     * @param wordArray The word array.
+     *
+     * @return The UTF-8 string.
+     *
+     * @example
+     *
+     *     const utf8String = Utf8.stringify(wordArray);
+     */
+    static stringify(wordArray: WordArray): string;
+}

package/dist/esm/enc/utf8.class.js

@@ -0,0 +1,39 @@
+import { Latin1 } from "./latin1.class.js";
+class Utf8 {
+  /**
+   * Converts a UTF-8 string to a word array.
+   *
+   * @param utf8Str The UTF-8 string.
+   *
+   * @return The word array.
+   *
+   * @example
+   *
+   *     let wordArray = Utf8.parse(utf8String);
+   */
+  static parse(utf8Str) {
+    return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
+  }
+  /**
+   * Converts a word array to a UTF-8 string.
+   *
+   * @param wordArray The word array.
+   *
+   * @return The UTF-8 string.
+   *
+   * @example
+   *
+   *     const utf8String = Utf8.stringify(wordArray);
+   */
+  static stringify(wordArray) {
+    try {
+      return decodeURIComponent(escape(Latin1.stringify(wordArray)));
+    } catch (e) {
+      console.error("Malformed UTF-8 data", e);
+      throw new Error("Malformed UTF-8 data");
+    }
+  }
+}
+export {
+  Utf8
+};

package/dist/esm/format/formatter.interface.d.ts

@@ -0,0 +1,5 @@
+import { CipherParams } from '../lib/cipher-params.class.js';
+export interface Formatter {
+    stringify: (cipherParams: CipherParams) => string;
+    parse: (paramsStr: string) => CipherParams;
+}

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

@@ -0,0 +1,27 @@
+import { CipherParams } from "../lib/cipher-params.class.js";
+export declare class OpenSSL {
+    /**
+     * Converts an OpenSSL-compatible string to a cipher params object.
+     *
+     * @param openSSLStr The OpenSSL-compatible string.
+     *
+     * @return The cipher params object.
+     *
+     * @example
+     *
+     *     let cipherParams = OpenSSLFormatter.parse(openSSLString);
+     */
+    static parse(openSSLStr: string): CipherParams;
+    /**
+     * Converts a cipher params object to an OpenSSL-compatible string.
+     *
+     * @param cipherParams The cipher params object.
+     *
+     * @return The OpenSSL-compatible string.
+     *
+     * @example
+     *
+     *     let openSSLString = OpenSSLFormatter.stringify(cipherParams);
+     */
+    static stringify(cipherParams: CipherParams): string;
+}

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

@@ -0,0 +1,57 @@
+import { CipherParams } from "../lib/cipher-params.class.js";
+import { WordArray } from "../lib/word-array.class.js";
+import { Base64 } from "../enc/base64.class.js";
+class OpenSSL {
+  /**
+   * Converts an OpenSSL-compatible string to a cipher params object.
+   *
+   * @param openSSLStr The OpenSSL-compatible string.
+   *
+   * @return The cipher params object.
+   *
+   * @example
+   *
+   *     let cipherParams = OpenSSLFormatter.parse(openSSLString);
+   */
+  static parse(openSSLStr) {
+    const ciphertext = Base64.parse(openSSLStr);
+    let salt;
+    if (ciphertext.words[0] === 1398893684 && ciphertext.words[1] === 1701076831) {
+      salt = new WordArray(ciphertext.words.slice(2, 4));
+      ciphertext.words.splice(0, 4);
+      ciphertext.sigBytes -= 16;
+    }
+    return new CipherParams({ ciphertext, salt });
+  }
+  /**
+   * Converts a cipher params object to an OpenSSL-compatible string.
+   *
+   * @param cipherParams The cipher params object.
+   *
+   * @return The OpenSSL-compatible string.
+   *
+   * @example
+   *
+   *     let openSSLString = OpenSSLFormatter.stringify(cipherParams);
+   */
+  static stringify(cipherParams) {
+    if (!cipherParams.ciphertext) {
+      throw new Error("missing ciphertext in params");
+    }
+    const ciphertext = cipherParams.ciphertext;
+    const salt = cipherParams.salt;
+    let wordArray;
+    if (salt) {
+      if (typeof salt === "string") {
+        throw new Error("salt is expected to be a WordArray");
+      }
+      wordArray = new WordArray([1398893684, 1701076831]).concat(salt).concat(ciphertext);
+    } else {
+      wordArray = ciphertext;
+    }
+    return wordArray.toString(Base64);
+  }
+}
+export {
+  OpenSSL
+};

package/dist/esm/helpers/aes.helper.d.ts

@@ -0,0 +1,2 @@
+import { CipherHelper } from "../lib/cipher-helper.class.js";
+export declare const aesHelper: CipherHelper;

package/dist/esm/helpers/aes.helper.js

@@ -0,0 +1,6 @@
+import { BlockCipher } from "../lib/block-cipher.class.js";
+import { AES } from "../algo/aes.class.js";
+const aesHelper = BlockCipher._createHelper(AES);
+export {
+  aesHelper
+};

package/dist/esm/helpers/des.helper.d.ts

@@ -0,0 +1,2 @@
+import { CipherHelper } from "../lib/cipher-helper.class.js";
+export declare const desHelper: CipherHelper;

package/dist/esm/helpers/des.helper.js

@@ -0,0 +1,6 @@
+import { BlockCipher } from "../lib/block-cipher.class.js";
+import { DES } from "../algo/des.class.js";
+const desHelper = BlockCipher._createHelper(DES);
+export {
+  desHelper
+};

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

@@ -0,0 +1,7 @@
+export { aesHelper } from "./aes.helper.js";
+export { desHelper } from "./des.helper.js";
+export { md5Helper } from "./md5.helper.js";
+export { sha1Helper } from "./sha1.helper.js";
+export { sha256Helper } from "./sha256.helper.js";
+export { sha512Helper } from "./sha512.helper.js";
+export { tripleDesHelper } from "./triple-des.helper.js";

package/dist/esm/helpers/index.js

@@ -0,0 +1,16 @@
+import { aesHelper } from "./aes.helper.js";
+import { desHelper } from "./des.helper.js";
+import { md5Helper } from "./md5.helper.js";
+import { sha1Helper } from "./sha1.helper.js";
+import { sha256Helper } from "./sha256.helper.js";
+import { sha512Helper } from "./sha512.helper.js";
+import { tripleDesHelper } from "./triple-des.helper.js";
+export {
+  aesHelper,
+  desHelper,
+  md5Helper,
+  sha1Helper,
+  sha256Helper,
+  sha512Helper,
+  tripleDesHelper
+};

package/dist/esm/helpers/md5.helper.d.ts

@@ -0,0 +1,2 @@
+import { HasherHelper } from "../lib/hasher-helper.type.js";
+export declare const md5Helper: HasherHelper;

package/dist/esm/helpers/md5.helper.js

@@ -0,0 +1,6 @@
+import { Hasher } from "../lib/hasher.class.js";
+import { MD5 } from "../algo/md5.class.js";
+const md5Helper = Hasher._createHelper(MD5);
+export {
+  md5Helper
+};

package/dist/esm/helpers/sha1.helper.d.ts

@@ -0,0 +1,2 @@
+import { HasherHelper } from "../lib/hasher-helper.type.js";
+export declare const sha1Helper: HasherHelper;

package/dist/esm/helpers/sha1.helper.js

@@ -0,0 +1,6 @@
+import { Hasher } from "../lib/hasher.class.js";
+import { SHA1 } from "../algo/sha1.class.js";
+const sha1Helper = Hasher._createHelper(SHA1);
+export {
+  sha1Helper
+};

package/dist/esm/helpers/sha256.helper.d.ts

@@ -0,0 +1,2 @@
+import { HasherHelper } from "../lib/hasher-helper.type.js";
+export declare const sha256Helper: HasherHelper;

package/dist/esm/helpers/sha256.helper.js

@@ -0,0 +1,6 @@
+import { Hasher } from "../lib/hasher.class.js";
+import { SHA256 } from "../algo/sha256.class.js";
+const sha256Helper = Hasher._createHelper(SHA256);
+export {
+  sha256Helper
+};

package/dist/esm/helpers/sha512.helper.d.ts

@@ -0,0 +1,2 @@
+import { HasherHelper } from "../lib/hasher-helper.type.js";
+export declare const sha512Helper: HasherHelper;

package/dist/esm/helpers/sha512.helper.js

@@ -0,0 +1,6 @@
+import { Hasher } from "../lib/hasher.class.js";
+import { SHA512 } from "../algo/sha512.class.js";
+const sha512Helper = Hasher._createHelper(SHA512);
+export {
+  sha512Helper
+};

package/dist/esm/helpers/triple-des.helper.d.ts

@@ -0,0 +1,2 @@
+import { CipherHelper } from "../lib/cipher-helper.class.js";
+export declare const tripleDesHelper: CipherHelper;

package/dist/esm/helpers/triple-des.helper.js

@@ -0,0 +1,6 @@
+import { BlockCipher } from "../lib/block-cipher.class.js";
+import { TripleDES } from "../algo/triple-des.class.js";
+const tripleDesHelper = BlockCipher._createHelper(TripleDES);
+export {
+  tripleDesHelper
+};

package/dist/esm/index.d.ts

@@ -0,0 +1,7 @@
+export { BlockCipher, CipherParams, Hasher, PasswordBasedCipher, SerializableCipher, WordArray, X64Word, X64WordArray } from "./lib/index.js";
+export { AES, DES, MD5, SHA1, SHA256, SHA512, TripleDES } from "./algo/index.js";
+export { Base64, Encoder, Hex, Latin1, Utf16, Utf8 } from "./enc/index.js";
+export { EVPKDF, PBKDF2 } from "./kdf/index.js";
+export { aesHelper, desHelper, md5Helper, sha1Helper, sha256Helper, sha512Helper, tripleDesHelper } from "./helpers/index.js";
+export { CBC, CTR, ECB } from "./mode/index.js";
+export { NoPadding, PKCS7 } from "./pad/index.js";

package/dist/esm/index.js

@@ -0,0 +1,43 @@
+import { BlockCipher, CipherParams, Hasher, PasswordBasedCipher, SerializableCipher, WordArray, X64Word, X64WordArray } from "./lib/index.js";
+import { AES, DES, MD5, SHA1, SHA256, SHA512, TripleDES } from "./algo/index.js";
+import { Base64, Hex, Latin1, Utf16, Utf8 } from "./enc/index.js";
+import { EVPKDF, PBKDF2 } from "./kdf/index.js";
+import { aesHelper, desHelper, md5Helper, sha1Helper, sha256Helper, sha512Helper, tripleDesHelper } from "./helpers/index.js";
+import { CBC, CTR, ECB } from "./mode/index.js";
+import { NoPadding, PKCS7 } from "./pad/index.js";
+export {
+  AES,
+  Base64,
+  BlockCipher,
+  CBC,
+  CTR,
+  CipherParams,
+  DES,
+  ECB,
+  EVPKDF,
+  Hasher,
+  Hex,
+  Latin1,
+  MD5,
+  NoPadding,
+  PBKDF2,
+  PKCS7,
+  PasswordBasedCipher,
+  SHA1,
+  SHA256,
+  SHA512,
+  SerializableCipher,
+  TripleDES,
+  Utf16,
+  Utf8,
+  WordArray,
+  X64Word,
+  X64WordArray,
+  aesHelper,
+  desHelper,
+  md5Helper,
+  sha1Helper,
+  sha256Helper,
+  sha512Helper,
+  tripleDesHelper
+};