@ray-js/wechat-tycrypto 0.0.1-beta-1

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@ray-js/wechat-tycrypto",
+  "version": "0.0.1-beta-1",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "module": "./index.esm.js",
+  "main": "./index.js",
+  "type": "module",
+  "types": "./src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./index.esm.js",
+      "require": "./index.js"
+    }
+  },
+  "dependencies": {
+    "js-md5": "0.7.3"
+  },
+  "peerDependencies": {}
+}

package/src/index.d.ts

@@ -0,0 +1,6 @@
+export * from './lib/other/errors';
+export * from './lib/aes/gcm';
+export * from './lib/aes/ecb';
+export * from './lib/aes/aes';
+export * from './lib/aes/cbc';
+export * from './lib/aes/ccm';

package/src/lib/aes/aes.asm.d.ts

@@ -0,0 +1,113 @@
+/**
+ * @file {@link http://asmjs.org Asm.js} implementation of the {@link https://en.wikipedia.org/wiki/Advanced_Encryption_Standard Advanced Encryption Standard}.
+ * @author Artem S Vybornov <vybornov@gmail.com>
+ * @license MIT
+ */
+export declare class AES_asm {
+    constructor(foreign: any, heap: ArrayBuffer);
+    /**
+     * AES enciphering mode constants
+     * @enum {number}
+     * @const
+     */
+    static ENC: {
+        ECB: 0;
+        CBC: 2;
+        CFB: 4;
+        OFB: 6;
+        CTR: 7;
+        [key: string]: number;
+    };
+    /**
+     * AES deciphering mode constants
+     * @enum {number}
+     * @const
+     */
+    static DEC: {
+        ECB: 1;
+        CBC: 3;
+        CFB: 5;
+        OFB: 6;
+        CTR: 7;
+        [key: string]: number;
+    };
+    /**
+     * AES MAC mode constants
+     * @enum {number}
+     * @const
+     */
+    static MAC: {
+        CBC: number;
+        GCM: number;
+    };
+    /**
+     * Heap data offset
+     * @type {number}
+     * @const
+     */
+    static HEAP_DATA: number;
+    /**
+     * @param ks - key size, 4/6/8 (for 128/192/256-bit key correspondingly)
+     * @param k0 - key vector components
+     * @param k1 - key vector components
+     * @param k2 - key vector components
+     * @param k3 - key vector components
+     * @param k4 - key vector components
+     * @param k5 - key vector components
+     * @param k6 - key vector components
+     * @param k7 - key vector components
+     */
+    set_key(ks: number, k0: number, k1: number, k2: number, k3: number, k4: number, k5: number, k6: number, k7: number): void;
+    /**
+     * Populate the internal iv of the module
+     */
+    set_iv(i0: number, i1: number, i2: number, i3: number): void;
+    /**
+     * Set counter mask for CTR-family modes
+     */
+    set_mask(m0: number, m1: number, m2: number, m3: number): void;
+    /**
+     * Set nonce for CTR-family modes
+     */
+    set_nonce(n0: number, n1: number, n2: number, n3: number): void;
+    /**
+     * Set counter for CTR-family modes
+     */
+    set_counter(c0: number, c1: number, c2: number, c3: number): void;
+    /**
+     * Perform ciphering operation on the supplied data
+     *
+     * @param mode - block cipher mode (see {@link AES_asm} mode constants)
+     * @param pos - offset of the data being processed
+     * @param len - length of the data being processed
+     * @return Actual amount of data have been processed
+     */
+    cipher(mode: number, pos: number, len: number): number;
+    /**
+     * GCM initialization
+     */
+    gcm_init(): void;
+    /**
+     * Store the internal iv vector into the heap
+     *
+     * @returns The number of bytes have been written into the heap, always 16
+     */
+    get_iv(pos: number): 16 | -1;
+    /**
+     * Calculates MAC of the supplied data
+     *
+     * @param mode - block cipher mode (see {@link AES_asm} mode constants)
+     * @param pos - offset of the data being processed
+     * @param len - length of the data being processed
+     * @return Actual amount of data have been processed
+     */
+    mac(mode: number, pos: number, len: number): number;
+    /**
+     * Store the internal state vector into the heap.
+     *
+     * @param pos - offset where to put the data
+     * @return The number of bytes have been written into the heap, always 16.
+     */
+    get_state(pos: number): 16 | -1;
+}
+export declare type AES_mode = 'ECB' | 'CBC' | 'CFB' | 'OFB' | 'CTR' | 'CCM';

package/src/lib/aes/aes.d.ts

@@ -0,0 +1,15 @@
+import { AES_asm, AES_mode } from './aes.asm';
+export declare class AES {
+    readonly heap: Uint8Array;
+    readonly asm: AES_asm;
+    private readonly mode;
+    padding: boolean;
+    pos: number;
+    len: number;
+    constructor(key: Uint8Array, iv: Uint8Array | undefined, padding: boolean | undefined, mode: AES_mode, heap?: Uint8Array, asm?: AES_asm);
+    AES_Encrypt_process(data: Uint8Array): Uint8Array;
+    AES_Encrypt_finish(): Uint8Array;
+    AES_Decrypt_process(data: Uint8Array): Uint8Array;
+    AES_Decrypt_finish(): Uint8Array;
+}
+export default AES;

package/src/lib/aes/cbc.d.ts

@@ -0,0 +1,9 @@
+import { AES } from './aes';
+export declare class AES_CBC {
+    private aes;
+    static encrypt(data: Uint8Array, key: Uint8Array, padding?: boolean, iv?: Uint8Array): Uint8Array;
+    static decrypt(data: Uint8Array, key: Uint8Array, padding?: boolean, iv?: Uint8Array): Uint8Array;
+    constructor(key: Uint8Array, iv?: Uint8Array, padding?: boolean, aes?: AES);
+    encrypt(data: Uint8Array): Uint8Array;
+    decrypt(data: Uint8Array): Uint8Array;
+}

package/src/lib/aes/ccm.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Counter with CBC-MAC (CCM)
+ *
+ * Due to JS limitations (52 bits of Number precision) maximum encrypted message length
+ * is limited to ~4 PiB ( 2^52 - 16 ) per `nonce`-`key` pair.
+ * That also limits `lengthSize` parameter maximum value to 7 (not 8 as described in RFC3610).
+ *
+ * Additional authenticated data `adata` maximum length is chosen to be no more than 65279 bytes ( 2^16 - 2^8 ),
+ * which is considered enough for the most of use-cases.
+ *
+ * And one more important thing: in case of progressive ciphering of a data stream (in other
+ * words when data can't be held in-memory at a whole and are ciphered chunk-by-chunk)
+ * you have to know the `dataLength` in advance and pass that value to the cipher options.
+ */
+import { AES } from './aes';
+export declare class AES_CCM {
+    private readonly tagSize;
+    private readonly lengthSize;
+    private nonce;
+    private readonly adata;
+    private counter;
+    private dataLength;
+    private aes;
+    static encrypt(clear: Uint8Array, key: Uint8Array, nonce: Uint8Array, adata: Uint8Array | undefined, tagsize?: number): Uint8Array;
+    static decrypt(cipher: Uint8Array, key: Uint8Array, nonce: Uint8Array, adata: Uint8Array | undefined, tagsize?: number): Uint8Array;
+    constructor(key: Uint8Array, nonce: Uint8Array, adata: Uint8Array | undefined, tagSize: number | undefined, dataLength: number, aes?: AES);
+    encrypt(data: Uint8Array): Uint8Array;
+    decrypt(data: Uint8Array): Uint8Array;
+    AES_CCM_calculate_iv(): void;
+    _cbc_mac_process(data: Uint8Array): void;
+    AES_CCM_Encrypt_process(data: Uint8Array): Uint8Array;
+    AES_CCM_Encrypt_finish(): Uint8Array;
+    AES_CCM_Decrypt_process(data: Uint8Array): Uint8Array;
+    AES_CCM_Decrypt_finish(): Uint8Array;
+    private AES_CTR_set_options;
+}

package/src/lib/aes/ecb.d.ts

@@ -0,0 +1,10 @@
+import { AES } from './aes';
+export declare class AES_ECB {
+    private aes;
+    static encrypt(data: Uint8Array, key: Uint8Array, padding?: boolean): Uint8Array;
+    static decrypt(data: Uint8Array, key: Uint8Array, padding?: boolean): Uint8Array;
+    constructor(key: Uint8Array, padding?: boolean, aes?: AES);
+    encrypt(data: Uint8Array): Uint8Array;
+    decrypt(data: Uint8Array): Uint8Array;
+}
+export default AES_ECB;

package/src/lib/aes/exports.d.ts

@@ -0,0 +1,3 @@
+import { AES_asm } from './aes.asm';
+export declare const _AES_heap_instance: Uint8Array;
+export declare const _AES_asm_instance: AES_asm;

package/src/lib/aes/gcm.d.ts

@@ -0,0 +1,21 @@
+import { AES } from './aes';
+export declare class AES_GCM {
+    private readonly tagSize;
+    private readonly adata;
+    private readonly gamma0;
+    private aes;
+    private counter;
+    static encrypt(cleartext: Uint8Array, key: Uint8Array, nonce: Uint8Array, adata?: Uint8Array, tagsize?: number): Uint8Array;
+    static decrypt(ciphertext: Uint8Array, key: Uint8Array, nonce: Uint8Array, adata?: Uint8Array, tagsize?: number): Uint8Array;
+    constructor(key: Uint8Array, nonce: Uint8Array, adata?: Uint8Array, tagSize?: number, aes?: AES);
+    encrypt(data: Uint8Array): Uint8Array;
+    decrypt(data: Uint8Array): Uint8Array;
+    AES_GCM_Encrypt_process(data: Uint8Array): Uint8Array;
+    AES_GCM_Encrypt_finish(): Uint8Array;
+    AES_GCM_Decrypt_process(data: Uint8Array): Uint8Array;
+    AES_GCM_Decrypt_finish(): Uint8Array;
+    private AES_GCM_decrypt;
+    private AES_GCM_encrypt;
+    _gcm_mac_process(data: Uint8Array): void;
+}
+export default AES_GCM;

package/src/lib/other/errors.d.ts

@@ -0,0 +1,9 @@
+export declare class IllegalStateError extends Error {
+    constructor(...args: any[]);
+}
+export declare class IllegalArgumentError extends Error {
+    constructor(...args: any[]);
+}
+export declare class SecurityError extends Error {
+    constructor(...args: any[]);
+}

package/src/lib/other/utils.d.ts

@@ -0,0 +1,9 @@
+export declare function pow2_ceil(a: number): number;
+export declare function is_number(a: number): boolean;
+export declare function is_string(a: string): boolean;
+export declare function is_buffer(a: ArrayBuffer): boolean;
+export declare function is_bytes(a: Uint8Array): boolean;
+export declare function is_typed_array(a: any): boolean;
+export declare function _heap_init(heap?: Uint8Array, heapSize?: number): Uint8Array;
+export declare function _heap_write(heap: Uint8Array, hpos: number, data: Uint8Array, dpos: number, dlen: number): number;
+export declare function joinBytes(...arg: Uint8Array[]): Uint8Array;