midway-fatcms 0.0.1-beta.65 → 0.0.1-beta.67

package/dist/libs/utils/AsymmetricCrypto.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsymmetricCrypto = void 0;
+function getCrypto() {
+    if (typeof crypto !== 'undefined' && crypto.subtle) {
+        // 浏览器环境或Node.js 19+的global.crypto
+        return crypto;
+    }
+    else if (typeof global !== 'undefined') {
+        // Node.js环境
+        if (global.crypto && global.crypto.subtle) {
+            // Node.js 19+
+            return global.crypto;
+        }
+        // @ts-ignore
+        else if (global.crypto && global.crypto.webcrypto && global.crypto.webcrypto.subtle) {
+            // Node.js 16+
+            // @ts-ignore
+            return global.crypto.webcrypto;
+        }
+        else {
+            // Node.js 16-18，使用crypto.webcrypto
+            const nodeCrypto = require('crypto');
+            if (nodeCrypto.webcrypto && nodeCrypto.webcrypto.subtle) {
+                return nodeCrypto.webcrypto;
+            }
+            throw new Error('Node.js版本低于16或缺少webcrypto支持');
+        }
+    }
+    throw new Error('当前环境不支持Web Crypto API');
+}
+class AsymmetricCrypto {
+    /**
+     * 生成RSA密钥对并返回字符串格式的公钥和私钥
+     * @param {number} modulusLength - 密钥长度，默认2048
+     * @returns {Promise<{publicKey: string, privateKey: string}>} PEM格式的密钥字符串
+     */
+    static async generateKeyPair(modulusLength = 2048) {
+        const crypto = getCrypto();
+        try {
+            // 生成密钥对
+            const keyPair = await crypto.subtle.generateKey({
+                name: "RSA-OAEP",
+                modulusLength,
+                publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
+                hash: "SHA-256",
+            }, true, // 是否可导出
+            ["encrypt", "decrypt"]);
+            // 导出公钥为PEM格式字符串
+            const publicKeyDer = await crypto.subtle.exportKey("spki", keyPair.publicKey);
+            const publicKeyPem = this.derToPem(publicKeyDer, 'PUBLIC');
+            // 导出私钥为PEM格式字符串
+            const privateKeyDer = await crypto.subtle.exportKey("pkcs8", keyPair.privateKey);
+            const privateKeyPem = this.derToPem(privateKeyDer, 'PRIVATE');
+            return {
+                publicKey: publicKeyPem,
+                privateKey: privateKeyPem
+            };
+        }
+        catch (error) {
+            throw new Error(`生成密钥对失败: ${error.message}`);
+        }
+    }
+    /**
+     * 使用公钥加密字符串
+     * @param {string} publicKeyPem - PEM格式的公钥字符串
+     * @param {string} data - 要加密的字符串数据
+     * @returns {Promise<string>} Base64编码的加密字符串
+     */
+    static async encrypt(publicKeyPem, data) {
+        const crypto = getCrypto();
+        try {
+            // 导入公钥
+            const publicKey = await this.importPublicKey(publicKeyPem);
+            // 转换数据为Uint8Array
+            const encoder = new TextEncoder();
+            const dataBuffer = encoder.encode(data);
+            // 检查数据长度（RSA-OAEP有最大长度限制）
+            const maxLength = this.getMaxEncryptLength(publicKeyPem);
+            if (dataBuffer.length > maxLength) {
+                throw new Error(`数据过长，最大支持${maxLength}字节，当前${dataBuffer.length}字节`);
+            }
+            // 加密数据
+            const encrypted = await crypto.subtle.encrypt({
+                name: "RSA-OAEP"
+            }, publicKey, dataBuffer);
+            // 转换为Base64字符串
+            return this.arrayBufferToBase64(encrypted);
+        }
+        catch (error) {
+            throw new Error(`加密失败: ${error.message}`);
+        }
+    }
+    /**
+     * 使用私钥解密字符串
+     * @param {string} privateKeyPem - PEM格式的私钥字符串
+     * @param {string} encryptedData - Base64编码的加密字符串
+     * @returns {Promise<string>} 解密后的原始字符串
+     */
+    static async decrypt(privateKeyPem, encryptedData) {
+        const crypto = getCrypto();
+        try {
+            // 导入私钥
+            const privateKey = await this.importPrivateKey(privateKeyPem);
+            // 转换Base64字符串为ArrayBuffer
+            const encryptedBuffer = this.base64ToArrayBuffer(encryptedData);
+            // 解密数据
+            const decrypted = await crypto.subtle.decrypt({
+                name: "RSA-OAEP"
+            }, privateKey, encryptedBuffer);
+            // 转换回字符串
+            const decoder = new TextDecoder();
+            return decoder.decode(decrypted);
+        }
+        catch (error) {
+            throw new Error(`解密失败: ${error.message}`);
+        }
+    }
+    /**
+     * 导入PEM格式的公钥字符串为CryptoKey对象
+     * @param {string} publicKeyPem - PEM格式的公钥字符串
+     * @returns {Promise<CryptoKey>}
+     */
+    static async importPublicKey(publicKeyPem) {
+        const crypto = getCrypto();
+        try {
+            // PEM转DER
+            const der = this.pemToDer(publicKeyPem);
+            // 导入密钥
+            return await crypto.subtle.importKey("spki", der, {
+                name: "RSA-OAEP",
+                hash: "SHA-256"
+            }, true, ["encrypt"]);
+        }
+        catch (error) {
+            throw new Error(`导入公钥失败: ${error.message}`);
+        }
+    }
+    /**
+     * 导入PEM格式的私钥字符串为CryptoKey对象
+     * @param {string} privateKeyPem - PEM格式的私钥字符串
+     * @returns {Promise<CryptoKey>}
+     */
+    static async importPrivateKey(privateKeyPem) {
+        const crypto = getCrypto();
+        try {
+            // PEM转DER
+            const der = this.pemToDer(privateKeyPem);
+            // 导入密钥
+            return await crypto.subtle.importKey("pkcs8", der, {
+                name: "RSA-OAEP",
+                hash: "SHA-256"
+            }, true, ["decrypt"]);
+        }
+        catch (error) {
+            throw new Error(`导入私钥失败: ${error.message}`);
+        }
+    }
+    /**
+     * 获取公钥支持的最大加密长度（字节数）
+     * @param {string} publicKeyPem - PEM格式的公钥字符串
+     * @returns {number} 最大加密字节数
+     */
+    static getMaxEncryptLength(publicKeyPem) {
+        // 简单估算最大加密长度
+        // RSA-OAEP最大加密长度 = modulusLength/8 - 2*hashLength/8 - 2
+        // 这里通过PEM字符串长度来估算密钥长度
+        // 提取Base64内容
+        const base64Data = publicKeyPem
+            .replace(/-----BEGIN PUBLIC KEY-----/, '')
+            .replace(/-----END PUBLIC KEY-----/, '')
+            .replace(/\s+/g, '');
+        // Base64解码获取DER长度
+        const derLength = atob(base64Data).length;
+        // 典型长度对应关系：
+        if (derLength <= 294) { // 2048位密钥DER长度约294字节
+            return 190; // 2048位：190字节
+        }
+        else if (derLength <= 422) { // 3072位密钥DER长度约422字节
+            return 318; // 3072位：318字节
+        }
+        else { // 4096位
+            return 446; // 4096位：446字节
+        }
+    }
+    /**
+     * 将DER格式转换为PEM格式字符串
+     * @param {ArrayBuffer} der - DER格式的密钥数据
+     * @param {string} type - 密钥类型 ('PUBLIC' 或 'PRIVATE')
+     * @returns {string} PEM格式的密钥字符串
+     */
+    static derToPem(der, type) {
+        const base64 = this.arrayBufferToBase64(der);
+        // 将Base64字符串分割为64字符一行
+        const wrapped = base64.match(/.{1,64}/g).join('\n');
+        if (type === 'PUBLIC') {
+            return `-----BEGIN PUBLIC KEY-----\n${wrapped}\n-----END PUBLIC KEY-----`;
+        }
+        else {
+            return `-----BEGIN PRIVATE KEY-----\n${wrapped}\n-----END PRIVATE KEY-----`;
+        }
+    }
+    /**
+     * 将PEM格式字符串转换为DER格式
+     * @param {string} pem - PEM格式的密钥字符串
+     * @returns {ArrayBuffer} DER格式的密钥数据
+     */
+    static pemToDer(pem) {
+        // 移除PEM头部、尾部和所有空白字符
+        const base64 = pem
+            .replace(/-----BEGIN (?:PUBLIC|PRIVATE) KEY-----/, '')
+            .replace(/-----END (?:PUBLIC|PRIVATE) KEY-----/, '')
+            .replace(/\s+/g, '');
+        return this.base64ToArrayBuffer(base64);
+    }
+    /**
+     * ArrayBuffer转Base64字符串
+     * @param {ArrayBuffer} buffer
+     * @returns {string}
+     */
+    static arrayBufferToBase64(buffer) {
+        const bytes = new Uint8Array(buffer);
+        let binary = '';
+        for (let i = 0; i < bytes.byteLength; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        return btoa(binary);
+    }
+    /**
+     * Base64字符串转ArrayBuffer
+     * @param {string} base64
+     * @returns {ArrayBuffer}
+     */
+    static base64ToArrayBuffer(base64) {
+        const binaryString = atob(base64);
+        const bytes = new Uint8Array(binaryString.length);
+        for (let i = 0; i < binaryString.length; i++) {
+            bytes[i] = binaryString.charCodeAt(i);
+        }
+        return bytes.buffer;
+    }
+    /**
+     * 验证PEM格式的密钥字符串
+     * @param {string} pem - PEM格式的密钥字符串
+     * @param {'PUBLIC'|'PRIVATE'} expectedType - 期望的密钥类型
+     * @returns {boolean} 是否为有效的PEM格式
+     */
+    static validatePemFormat(pem, expectedType) {
+        if (typeof pem !== 'string')
+            return false;
+        const publicKeyPattern = /^-----BEGIN PUBLIC KEY-----\n([A-Za-z0-9+/=\n]+)\n-----END PUBLIC KEY-----$/;
+        const privateKeyPattern = /^-----BEGIN PRIVATE KEY-----\n([A-Za-z0-9+/=\n]+)\n-----END PRIVATE KEY-----$/;
+        if (expectedType === 'PUBLIC') {
+            return publicKeyPattern.test(pem);
+        }
+        else {
+            return privateKeyPattern.test(pem);
+        }
+    }
+}
+exports.AsymmetricCrypto = AsymmetricCrypto;

package/dist/libs/utils/base64.d.ts

@@ -1,9 +1,9 @@
-declare function toBase64(obj: any): string;
-/**
- * 将经 toBase64 函数序列化的 Base64 字符串还原为 JS 对象
- * @param base64Str - 经 toBase64 处理后的 Base64 字符串
- * @returns 还原后的 JS 对象
- * @throws 当 Base64 格式无效或 JSON 解析失败时抛出含具体原因的错误
- */
-declare function fromBase64(base64Str: string): any;
-export { toBase64, fromBase64 };
+declare function toBase64(obj: any): string;
+/**
+ * 将经 toBase64 函数序列化的 Base64 字符串还原为 JS 对象
+ * @param base64Str - 经 toBase64 处理后的 Base64 字符串
+ * @returns 还原后的 JS 对象
+ * @throws 当 Base64 格式无效或 JSON 解析失败时抛出含具体原因的错误
+ */
+declare function fromBase64(base64Str: string): any;
+export { toBase64, fromBase64 };

package/dist/libs/utils/base64.js

@@ -1,42 +1,42 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fromBase64 = exports.toBase64 = void 0;
-function toBase64(obj) {
-    const jsonString = JSON.stringify(obj);
-    return Buffer.from(jsonString, 'utf8').toString('base64');
-}
-exports.toBase64 = toBase64;
-/**
- * 将经 toBase64 函数序列化的 Base64 字符串还原为 JS 对象
- * @param base64Str - 经 toBase64 处理后的 Base64 字符串
- * @returns 还原后的 JS 对象
- * @throws 当 Base64 格式无效或 JSON 解析失败时抛出含具体原因的错误
- */
-function fromBase64(base64Str) {
-    // 校验输入是否为字符串
-    if (typeof base64Str !== 'string') {
-        throw new Error('input must Base64 string');
-    }
-    try {
-        // 1. 反向步骤1：将 Base64 字符串解码为 UTF-8 格式的 JSON 字符串
-        // 对应原函数的 Buffer.from(jsonString, 'utf8') 反向操作
-        const jsonString = Buffer.from(base64Str, 'base64').toString('utf8');
-        // 2. 反向步骤2：将 JSON 字符串解析为 JS 对象
-        // 对应原函数的 JSON.stringify(obj) 反向操作
-        const restoredObj = JSON.parse(jsonString);
-        return restoredObj;
-    }
-    catch (error) {
-        // 分类处理不同错误类型，提供明确提示
-        if (error instanceof TypeError && error.message.includes('invalid base64')) {
-            throw new Error('还原失败：输入不是有效的 Base64 字符串');
-        }
-        else if (error instanceof SyntaxError && error.message.includes('JSON')) {
-            throw new Error('还原失败：解码后的内容不是有效的 JSON 格式');
-        }
-        else {
-            throw new Error(`还原失败：未知错误 - ${error.message}`);
-        }
-    }
-}
-exports.fromBase64 = fromBase64;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromBase64 = exports.toBase64 = void 0;
+function toBase64(obj) {
+    const jsonString = JSON.stringify(obj);
+    return Buffer.from(jsonString, 'utf8').toString('base64');
+}
+exports.toBase64 = toBase64;
+/**
+ * 将经 toBase64 函数序列化的 Base64 字符串还原为 JS 对象
+ * @param base64Str - 经 toBase64 处理后的 Base64 字符串
+ * @returns 还原后的 JS 对象
+ * @throws 当 Base64 格式无效或 JSON 解析失败时抛出含具体原因的错误
+ */
+function fromBase64(base64Str) {
+    // 校验输入是否为字符串
+    if (typeof base64Str !== 'string') {
+        throw new Error('input must Base64 string');
+    }
+    try {
+        // 1. 反向步骤1：将 Base64 字符串解码为 UTF-8 格式的 JSON 字符串
+        // 对应原函数的 Buffer.from(jsonString, 'utf8') 反向操作
+        const jsonString = Buffer.from(base64Str, 'base64').toString('utf8');
+        // 2. 反向步骤2：将 JSON 字符串解析为 JS 对象
+        // 对应原函数的 JSON.stringify(obj) 反向操作
+        const restoredObj = JSON.parse(jsonString);
+        return restoredObj;
+    }
+    catch (error) {
+        // 分类处理不同错误类型，提供明确提示
+        if (error instanceof TypeError && error.message.includes('invalid base64')) {
+            throw new Error('还原失败：输入不是有效的 Base64 字符串');
+        }
+        else if (error instanceof SyntaxError && error.message.includes('JSON')) {
+            throw new Error('还原失败：解码后的内容不是有效的 JSON 格式');
+        }
+        else {
+            throw new Error(`还原失败：未知错误 - ${error.message}`);
+        }
+    }
+}
+exports.fromBase64 = fromBase64;

package/dist/libs/utils/common-dto.d.ts

@@ -1,18 +1,18 @@
-export interface ICommonResult {
-    success: boolean;
-    data?: any;
-    message?: string;
-    code?: string;
-    debugInfo?: any;
-}
-export declare class CommonResult implements ICommonResult {
-    code: string;
-    data: any;
-    message: string;
-    success: boolean;
-    debugInfo: any;
-    static successNotNull(data?: any): CommonResult;
-    static successRes(data?: any): CommonResult;
-    static successMsg(message: string, data?: any): CommonResult;
-    static errorRes(message: string, errorCode?: string, debugInfo?: any): CommonResult;
-}
+export interface ICommonResult {
+    success: boolean;
+    data?: any;
+    message?: string;
+    code?: string;
+    debugInfo?: any;
+}
+export declare class CommonResult implements ICommonResult {
+    code: string;
+    data: any;
+    message: string;
+    success: boolean;
+    debugInfo: any;
+    static successNotNull(data?: any): CommonResult;
+    static successRes(data?: any): CommonResult;
+    static successMsg(message: string, data?: any): CommonResult;
+    static errorRes(message: string, errorCode?: string, debugInfo?: any): CommonResult;
+}

package/dist/libs/utils/common-dto.js

@@ -1,40 +1,40 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommonResult = void 0;
-class CommonResult {
-    static successNotNull(data) {
-        const res = new CommonResult();
-        if (data) {
-            res.success = true;
-            res.data = data;
-        }
-        else {
-            res.success = false;
-            res.message = '对象找不到';
-        }
-        return res;
-    }
-    static successRes(data) {
-        const res = new CommonResult();
-        res.success = true;
-        res.data = data;
-        return res;
-    }
-    static successMsg(message, data) {
-        const res = new CommonResult();
-        res.success = true;
-        res.message = message;
-        res.data = data;
-        return res;
-    }
-    static errorRes(message, errorCode = '', debugInfo = null) {
-        const res = new CommonResult();
-        res.success = false;
-        res.data = null;
-        res.message = message;
-        res.code = errorCode;
-        res.debugInfo = debugInfo;
-        return res;
-    }
-}
-exports.CommonResult = CommonResult;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonResult = void 0;
+class CommonResult {
+    static successNotNull(data) {
+        const res = new CommonResult();
+        if (data) {
+            res.success = true;
+            res.data = data;
+        }
+        else {
+            res.success = false;
+            res.message = '对象找不到';
+        }
+        return res;
+    }
+    static successRes(data) {
+        const res = new CommonResult();
+        res.success = true;
+        res.data = data;
+        return res;
+    }
+    static successMsg(message, data) {
+        const res = new CommonResult();
+        res.success = true;
+        res.message = message;
+        res.data = data;
+        return res;
+    }
+    static errorRes(message, errorCode = '', debugInfo = null) {
+        const res = new CommonResult();
+        res.success = false;
+        res.data = null;
+        res.message = message;
+        res.code = errorCode;
+        res.debugInfo = debugInfo;
+        return res;
+    }
+}
+exports.CommonResult = CommonResult;

package/dist/libs/utils/crypto-utils.d.ts

@@ -1,3 +1,3 @@
-import { Aes128CBC } from 'aes-128-cbc';
-declare const privateAES: Aes128CBC;
-export { privateAES };
+import { Aes128CBC } from 'aes-128-cbc';
+declare const privateAES: Aes128CBC;
+export { privateAES };

package/dist/libs/utils/crypto-utils.js

@@ -1,46 +1,46 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.privateAES = void 0;
-const crypto = require("crypto");
-const path = require("path");
-const fs = require("fs");
-const md5 = require("md5");
-const aes_128_cbc_1 = require("aes-128-cbc");
-function hashUtf8Hex(data) {
-    const hash = crypto.createHash('sha256');
-    const chunkSize = 1024; // 每次处理 1MB 数据
-    for (let i = 0; i < data.length; i += chunkSize) {
-        const chunk = data.slice(i, i + chunkSize);
-        const inputBuffer = Buffer.from(chunk, 'utf8');
-        hash.update(inputBuffer);
-    }
-    return hash.digest('hex');
-}
-function readSeed1() {
-    // 这个文件肯定存在
-    const t = path.join(__dirname, '../../config/seed/aeskey.txt');
-    return fs.readFileSync(t, 'utf-8');
-}
-function readSeed2() {
-    const filePath = path.join(__dirname, '../../../config/seed/aeskey.txt');
-    if (!fs.existsSync(filePath)) {
-        return null;
-    }
-    return fs.readFileSync(filePath, 'utf-8');
-}
-function createAes128BySeedContent(seedContent) {
-    const hash1 = hashUtf8Hex(seedContent.trim());
-    const key = md5(hash1);
-    const iv = md5(key + hash1);
-    return new aes_128_cbc_1.Aes128CBC(key, iv);
-}
-function createAes128BySeedFile() {
-    const seed2 = readSeed2();
-    if (seed2) {
-        return createAes128BySeedContent(seed2);
-    }
-    const seed1 = readSeed1();
-    return createAes128BySeedContent(seed1);
-}
-const privateAES = createAes128BySeedFile();
-exports.privateAES = privateAES;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.privateAES = void 0;
+const crypto = require("crypto");
+const path = require("path");
+const fs = require("fs");
+const md5 = require("md5");
+const aes_128_cbc_1 = require("aes-128-cbc");
+function hashUtf8Hex(data) {
+    const hash = crypto.createHash('sha256');
+    const chunkSize = 1024; // 每次处理 1MB 数据
+    for (let i = 0; i < data.length; i += chunkSize) {
+        const chunk = data.slice(i, i + chunkSize);
+        const inputBuffer = Buffer.from(chunk, 'utf8');
+        hash.update(inputBuffer);
+    }
+    return hash.digest('hex');
+}
+function readSeed1() {
+    // 这个文件肯定存在
+    const t = path.join(__dirname, '../../config/seed/aeskey.txt');
+    return fs.readFileSync(t, 'utf-8');
+}
+function readSeed2() {
+    const filePath = path.join(__dirname, '../../../config/seed/aeskey.txt');
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+    return fs.readFileSync(filePath, 'utf-8');
+}
+function createAes128BySeedContent(seedContent) {
+    const hash1 = hashUtf8Hex(seedContent.trim());
+    const key = md5(hash1);
+    const iv = md5(key + hash1);
+    return new aes_128_cbc_1.Aes128CBC(key, iv);
+}
+function createAes128BySeedFile() {
+    const seed2 = readSeed2();
+    if (seed2) {
+        return createAes128BySeedContent(seed2);
+    }
+    const seed1 = readSeed1();
+    return createAes128BySeedContent(seed1);
+}
+const privateAES = createAes128BySeedFile();
+exports.privateAES = privateAES;

package/dist/libs/utils/errorToString.d.ts

@@ -1,2 +1,2 @@
-declare function errorToString(error: any): string;
-export { errorToString };
+declare function errorToString(error: any): string;
+export { errorToString };