lakutata 0.1.1 → 0.1.2-beta.1

package/build/Crypto.d.ts

@@ -0,0 +1,504 @@
+import './ReflectMetadata.js';
+import { PathLike } from 'fs';
+import { IConstructor } from './Lakutata.js';
+import { Cipher, Decipher, KeyObject } from 'crypto';
+import 'events';
+import './RelationMetadataArgs.d-8d416101.js';
+import 'tls';
+import 'net';
+import 'dns';
+import 'stream';
+import 'worker_threads';
+import 'url';
+import 'http';
+import 'https';
+
+/**
+ * 公钥操作方法对象接口
+ */
+interface AsymmetricEncryptionPublic {
+    /**
+     * 加密数据
+     * @param message
+     */
+    encrypt(message: string): string;
+    /**
+     * 验证签名
+     * @param message
+     * @param sign
+     */
+    verify(message: string, sign: string): boolean;
+    /**
+     * 获取公钥
+     */
+    getPublicKey(): string;
+}
+/**
+ * 私钥操作方法对象接口
+ */
+interface AsymmetricEncryptionPrivate {
+    /**
+     * 解密数据
+     * @param encryptedMessage
+     */
+    decrypt(encryptedMessage: string): string;
+    /**
+     * 数据签名
+     * @param message
+     */
+    sign(message: string): string;
+    /**
+     * 获取私钥
+     */
+    getPrivateKey(): string;
+}
+interface AsymmetricEncryptionKeyPair {
+    /**
+     * 公钥字符串
+     */
+    publicKey: string;
+    /**
+     * 私钥字符串
+     */
+    privateKey: string;
+}
+declare abstract class AsymmetricEncryption {
+    protected readonly publicKeyString: string;
+    protected readonly privateKeyString: string;
+    protected readonly privateKey: any;
+    protected readonly publicKey: any;
+    protected options: Record<string, any>;
+    constructor(keyPair?: Partial<AsymmetricEncryptionKeyPair>);
+    /**
+     * 创建私钥对象
+     * @param privateKeyString
+     * @protected
+     */
+    protected abstract createPrivateKey(privateKeyString: string): any;
+    /**
+     * 创建公钥对象
+     * @param publicKeyString
+     * @protected
+     */
+    protected abstract createPublicKey(publicKeyString: string): any;
+    /**
+     * 加密数据，供内部调用
+     * @param message
+     * @protected
+     */
+    protected _encrypt(message: string): string;
+    /**
+     * 加密数据
+     * @param message
+     * @protected
+     */
+    protected abstract encrypt(message: string): string;
+    /**
+     * 解密数据，供内部调用
+     * @param encryptedMessage
+     * @protected
+     */
+    protected _decrypt(encryptedMessage: string): string;
+    /**
+     * 解密数据
+     * @param encryptedMessage
+     * @protected
+     */
+    protected abstract decrypt(encryptedMessage: string): string;
+    /**
+     * 数据签名，供内部调用
+     * @param message
+     * @protected
+     */
+    protected _sign(message: string): string;
+    /**
+     * 数据签名
+     * @param message
+     * @protected
+     */
+    protected abstract sign(message: string): string;
+    /**
+     * 验证签名，供内部调用
+     * @param message
+     * @param sign
+     * @protected
+     */
+    protected _verify(message: string, sign: string): boolean;
+    /**
+     * 验证签名
+     * @param message
+     * @param sign
+     * @protected
+     */
+    protected abstract verify(message: string, sign: string): boolean;
+    /**
+     * 生成密钥对
+     * @param options
+     * @protected
+     */
+    protected abstract generateKeyPair(options?: object): Promise<AsymmetricEncryptionKeyPair>;
+    /**
+     * 获取字符串形式的公钥
+     */
+    getPublicKey(): string;
+    /**
+     * 获取字符串形式的私钥
+     */
+    getPrivateKey(): string;
+    /**
+     * 公钥操作方法对象
+     */
+    get public(): AsymmetricEncryptionPublic;
+    /**
+     * 私钥操作方法对象
+     */
+    get private(): AsymmetricEncryptionPrivate;
+    /**
+     * 生成密钥对
+     * @param options
+     */
+    static generateKeyPair<T extends AsymmetricEncryption>(this: IConstructor<T>, options?: object): Promise<AsymmetricEncryptionKeyPair>;
+    /**
+     * 加载密钥对并返回不对称加密类实例
+     * @param keyPair
+     * @param options
+     */
+    static loadKeyPair<T extends AsymmetricEncryption>(this: IConstructor<T>, keyPair: AsymmetricEncryptionKeyPair, options?: Record<string, any>): Promise<T>;
+    /**
+     * 加载公钥并返回公钥操作方法对象
+     * @param filename
+     * @param options
+     */
+    static loadPublicKey(filename: PathLike, options?: Record<string, any>): Promise<AsymmetricEncryptionPublic>;
+    static loadPublicKey(keyContent: string, options?: Record<string, any>): Promise<AsymmetricEncryptionPublic>;
+    /**
+     * 加载私钥并返回私钥操作方法对象
+     * @param filename
+     * @param options
+     */
+    static loadPrivateKey(filename: PathLike, options?: Record<string, any>): Promise<AsymmetricEncryptionPrivate>;
+    static loadPrivateKey(keyContent: string, options?: Record<string, any>): Promise<AsymmetricEncryptionPrivate>;
+}
+
+interface SymmetricEncryptionValidateKeyLengthResult {
+    isValid: boolean;
+    expectBytes: number;
+    receivedBytes: number;
+}
+interface SymmetricEncryptionValidateIVLengthResult {
+    isValid: boolean;
+    expectBytes: number;
+    receivedBytes: number;
+}
+interface AlgorithmInitializer {
+    blockSize: number;
+    cipherCreator: () => Cipher;
+    decipherCreator: () => Decipher;
+}
+/**
+ * 同步加密抽象类
+ */
+declare abstract class SymmetricEncryption {
+    /**
+     * 加解密算法
+     * @protected
+     */
+    protected algorithm: string;
+    /**
+     * 加密分组大小
+     * @protected
+     */
+    protected blockSize: number;
+    /**
+     * 加解密秘钥
+     * @protected
+     */
+    protected key: Buffer;
+    /**
+     * 加解密向量
+     * @protected
+     */
+    protected iv: Buffer;
+    /**
+     * 是否使用空向量(ECB模式)
+     * 允许则为ECB模式，否则为CBC模式
+     * @protected
+     */
+    protected allowNullIV: boolean;
+    /**
+     * 加解密秘钥长度，以Bytes为单位
+     * @protected
+     */
+    protected abstract readonly keyLength: number;
+    /**
+     * 加解密向量长度，以Bytes为单位
+     * @protected
+     */
+    protected abstract readonly ivLength: number;
+    /**
+     * 加密器
+     * @constructor
+     */
+    get Cipher(): Cipher;
+    /**
+     * 解密器
+     * @constructor
+     */
+    get Decipher(): Decipher;
+    /**
+     * 加密器创建函数
+     * @protected
+     */
+    protected cipherCreator: () => Cipher;
+    /**
+     * 解密器创建函数
+     * @protected
+     */
+    protected decipherCreator: () => Decipher;
+    /**
+     * 初始化加密器
+     * @param algorithm
+     * @param allowNullIV
+     * @param key
+     * @param iv
+     * @protected
+     */
+    protected initCipher(algorithm: string, allowNullIV: boolean, key?: Buffer | string, iv?: Buffer | string): void;
+    /**
+     * 当算法在运行环境原生支持时的初始化函数
+     * @protected
+     */
+    protected algorithmFoundInitializer(): AlgorithmInitializer;
+    /**
+     * 当算法在运行环境原生不支持时的初始化函数
+     * @protected
+     */
+    protected algorithmNotFoundInitializer(): AlgorithmInitializer;
+    /**
+     * 验证key的长度
+     * @param key
+     * @protected
+     */
+    protected validateKeyLength(key: Buffer): SymmetricEncryptionValidateKeyLengthResult;
+    /**
+     * 验证iv向量的长度
+     * @param iv
+     * @protected
+     */
+    protected validateIVLength(iv: Buffer): SymmetricEncryptionValidateIVLengthResult;
+    /**
+     * 加密消息
+     * @param message
+     */
+    encrypt(message: string): string;
+    /**
+     * 异步加密消息
+     * @param message
+     */
+    encryptAsync(message: string): Promise<string>;
+    /**
+     * 解密消息
+     * @param encryptedMessage
+     */
+    decrypt(encryptedMessage: string): string;
+    /**
+     * 异步解密消息
+     * @param encryptedMessage
+     */
+    decryptAsync(encryptedMessage: string): Promise<string>;
+    /**
+     * 获取秘钥，Hex字符串格式
+     */
+    getKey(): string;
+    /**
+     * 获取向量，Hex字符串格式
+     */
+    getIV(): string | null;
+    /**
+     * 生成随机秘钥，Hex字符串格式
+     */
+    static generateKey<T extends SymmetricEncryption>(this: IConstructor<T>): string;
+    /**
+     * 生成随机向量，Hex字符串格式
+     */
+    static generateIV<T extends SymmetricEncryption>(this: IConstructor<T>): string;
+}
+
+declare class AES128 extends SymmetricEncryption {
+    protected readonly ivLength: number;
+    protected readonly keyLength: number;
+    constructor(key: Buffer, iv?: Buffer);
+    constructor(key: string, iv?: string);
+    protected algorithmNotFoundInitializer(): AlgorithmInitializer;
+}
+
+declare class AES192 extends SymmetricEncryption {
+    protected readonly ivLength: number;
+    protected readonly keyLength: number;
+    constructor(key: Buffer, iv?: Buffer);
+    constructor(key: string, iv?: string);
+    protected algorithmNotFoundInitializer(): AlgorithmInitializer;
+}
+
+declare class AES256 extends SymmetricEncryption {
+    protected readonly ivLength: number;
+    protected readonly keyLength: number;
+    constructor(key: Buffer, iv?: Buffer);
+    constructor(key: string, iv?: string);
+    protected algorithmNotFoundInitializer(): AlgorithmInitializer;
+}
+
+declare class DES extends SymmetricEncryption {
+    protected readonly ivLength: number;
+    protected readonly keyLength: number;
+    constructor(key: Buffer, iv?: Buffer);
+    constructor(key: string, iv?: string);
+    protected algorithmNotFoundInitializer(): AlgorithmInitializer;
+}
+
+declare class TripleDES extends SymmetricEncryption {
+    protected readonly ivLength: number;
+    protected readonly keyLength: number;
+    constructor(key: Buffer, iv?: Buffer);
+    constructor(key: string, iv?: string);
+    protected algorithmNotFoundInitializer(): AlgorithmInitializer;
+}
+
+declare class ARIA128 extends SymmetricEncryption {
+    protected readonly ivLength: number;
+    protected readonly keyLength: number;
+    constructor(key: Buffer, iv?: Buffer);
+    constructor(key: string, iv?: string);
+}
+
+declare class ARIA192 extends SymmetricEncryption {
+    protected readonly ivLength: number;
+    protected readonly keyLength: number;
+    constructor(key: Buffer, iv?: Buffer);
+    constructor(key: string, iv?: string);
+}
+
+declare class ARIA256 extends SymmetricEncryption {
+    protected readonly ivLength: number;
+    protected readonly keyLength: number;
+    constructor(key: Buffer, iv?: Buffer);
+    constructor(key: string, iv?: string);
+}
+
+declare class CAMELLIA128 extends SymmetricEncryption {
+    protected readonly ivLength: number;
+    protected readonly keyLength: number;
+    constructor(key: Buffer, iv?: Buffer);
+    constructor(key: string, iv?: string);
+}
+
+declare class CAMELLIA192 extends SymmetricEncryption {
+    protected readonly ivLength: number;
+    protected readonly keyLength: number;
+    constructor(key: Buffer, iv?: Buffer);
+    constructor(key: string, iv?: string);
+}
+
+declare class CAMELLIA256 extends SymmetricEncryption {
+    protected readonly ivLength: number;
+    protected readonly keyLength: number;
+    constructor(key: Buffer, iv?: Buffer);
+    constructor(key: string, iv?: string);
+}
+
+interface RSAKeyPairOptions {
+    /**
+     * 密钥长度，以bit为单位
+     * @default 1024
+     */
+    modulusLength?: number;
+    /**
+     * 公钥指数
+     * @default 0x10001
+     */
+    publicExponent?: number | undefined;
+    publicKeyEncoding?: {
+        /**
+         * @default pkcs1
+         */
+        type?: 'pkcs1' | 'spki';
+        /**
+         * @default pem
+         */
+        format?: 'pem' | 'der';
+    };
+    privateKeyEncoding?: {
+        /**
+         * @default pem
+         */
+        format?: 'pem' | 'der';
+        /**
+         * @default pkcs1
+         */
+        type?: 'pkcs1' | 'pkcs8';
+    };
+}
+interface RSAOptions {
+    /**
+     * 签名或验签时所使用的哈希算法
+     * @default sha256
+     */
+    signatureAlgorithm?: string;
+}
+declare class RSA extends AsymmetricEncryption {
+    protected options: RSAOptions;
+    protected createPrivateKey(privateKeyString: string): KeyObject;
+    protected createPublicKey(publicKeyString: string): KeyObject;
+    protected decrypt(encryptedMessage: string): string;
+    protected encrypt(message: string): string;
+    protected generateKeyPair(options?: RSAKeyPairOptions): Promise<AsymmetricEncryptionKeyPair>;
+    protected sign(message: string): string;
+    protected verify(message: string, sign: string): boolean;
+    static generateKeyPair(options?: RSAKeyPairOptions): Promise<AsymmetricEncryptionKeyPair>;
+    static loadKeyPair<T extends AsymmetricEncryption = RSA>(keyPair: AsymmetricEncryptionKeyPair, options?: RSAOptions): Promise<T>;
+    static loadPublicKey(inp: PathLike | string, options?: RSAOptions): Promise<AsymmetricEncryptionPublic>;
+    static loadPrivateKey(inp: string | PathLike, options?: RSAOptions): Promise<AsymmetricEncryptionPrivate>;
+}
+
+interface SM2KeyPairOptions {
+    /**
+     * 是否将公钥长度进行压缩，从默认公钥的130位压缩至66位
+     * @default false
+     */
+    compressPublicKey?: boolean;
+}
+interface SM2Options {
+    /**
+     * 加密模式
+     * 0 - C1C2C3
+     * 1 - C1C3C2
+     * @default 1
+     */
+    cipherMode?: 0 | 1;
+    /**
+     * 是否在签名或验签当中使用SM3杂凑
+     * @default true
+     */
+    signatureSM3Hash?: boolean;
+    /**
+     * 在签名或验签当中使用的用户标识
+     * @default undefined
+     */
+    signatureUserId?: string;
+}
+declare class SM2 extends AsymmetricEncryption {
+    protected options: SM2Options;
+    protected createPrivateKey(privateKeyString: string): string;
+    protected createPublicKey(publicKeyString: string): string;
+    protected decrypt(encryptedMessage: string): string;
+    protected encrypt(message: string): string;
+    protected generateKeyPair(options?: SM2KeyPairOptions): Promise<AsymmetricEncryptionKeyPair>;
+    protected sign(message: string): string;
+    protected verify(message: string, sign: string): boolean;
+    static generateKeyPair(options?: SM2KeyPairOptions): Promise<AsymmetricEncryptionKeyPair>;
+    static loadKeyPair<T extends AsymmetricEncryption = SM2>(keyPair: AsymmetricEncryptionKeyPair, options?: SM2Options): Promise<T>;
+    static loadPublicKey(inp: PathLike | string, options?: SM2Options): Promise<AsymmetricEncryptionPublic>;
+    static loadPrivateKey(inp: string | PathLike, options?: SM2Options): Promise<AsymmetricEncryptionPrivate>;
+}
+
+export { AES128, AES192, AES256, ARIA128, ARIA192, ARIA256, AsymmetricEncryption, CAMELLIA128, CAMELLIA192, CAMELLIA256, DES, RSA, RSAKeyPairOptions, RSAOptions, SM2, SM2KeyPairOptions, SM2Options, SymmetricEncryption, TripleDES };