midway-fatcms 0.0.3 → 0.0.4

package/src/libs/utils/AsymmetricCrypto.ts

@@ -1,307 +1,307 @@
-function getCrypto(): Crypto {
-  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: number = 2048): Promise<{ publicKey: string, privateKey: string }> {
-    const crypto = getCrypto();
-    try {
-      // 生成密钥对
-      const keyPair = await crypto.subtle.generateKey(
-        {
-          name: "RSA-OAEP",
-          modulusLength,
-          publicExponent: new Uint8Array([0x01, 0x00, 0x01]), // 65537
-          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: string, data: string): Promise<string> {
-    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: string, encryptedData: string): Promise<string> {
-    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: string): Promise<CryptoKey> {
-    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: string): Promise<CryptoKey> {
-    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: string): number {
-
-    // 简单估算最大加密长度
-    // 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: ArrayBuffer, type: 'PUBLIC' | 'PRIVATE'): string {
-
-    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: string): ArrayBuffer {
-    // 移除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: ArrayBuffer): string {
-    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: string): ArrayBuffer {
-    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: string, expectedType: 'PUBLIC' | 'PRIVATE'): boolean {
-    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);
-    }
-  }
-}
-
-
-export {
-  AsymmetricCrypto
-}
+function getCrypto(): Crypto {
+  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: number = 2048): Promise<{ publicKey: string, privateKey: string }> {
+    const crypto = getCrypto();
+    try {
+      // 生成密钥对
+      const keyPair = await crypto.subtle.generateKey(
+        {
+          name: "RSA-OAEP",
+          modulusLength,
+          publicExponent: new Uint8Array([0x01, 0x00, 0x01]), // 65537
+          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: string, data: string): Promise<string> {
+    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: string, encryptedData: string): Promise<string> {
+    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: string): Promise<CryptoKey> {
+    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: string): Promise<CryptoKey> {
+    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: string): number {
+
+    // 简单估算最大加密长度
+    // 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: ArrayBuffer, type: 'PUBLIC' | 'PRIVATE'): string {
+
+    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: string): ArrayBuffer {
+    // 移除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: ArrayBuffer): string {
+    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: string): ArrayBuffer {
+    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: string, expectedType: 'PUBLIC' | 'PRIVATE'): boolean {
+    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);
+    }
+  }
+}
+
+
+export {
+  AsymmetricCrypto
+}

package/src/libs/utils/format-url.ts

@@ -1,30 +1,30 @@
-/**
- * 格式化主机名，移除默认端口号
- * 
- * HTTP默认端口80，HTTPS默认端口443在URL中通常被省略
- * 此函数用于标准化主机名，去除这些默认端口
- * 
- * @param host 主机名（可能包含端口号），如 'example.com:80'
- * @returns 格式化后的主机名，如 'example.com'
- * 
- * @example
- * formatHost('example.com:80')    // 'example.com'
- * formatHost('example.com:443')   // 'example.com'
- * formatHost('example.com:8080')  // 'example.com:8080' (保留非默认端口)
- * formatHost('example.com')       // 'example.com'
- */
-function formatHost(host: string): string {
-  // 移除HTTP默认端口
-  if (host.endsWith(':80')) {
-    return host.slice(0, -3);
-  }
-
-  // 移除HTTPS默认端口
-  if (host.endsWith(':443')) {
-    return host.slice(0, -4);
-  }
-
-  return host;
-}
-
+/**
+ * 格式化主机名，移除默认端口号
+ * 
+ * HTTP默认端口80，HTTPS默认端口443在URL中通常被省略
+ * 此函数用于标准化主机名，去除这些默认端口
+ * 
+ * @param host 主机名（可能包含端口号），如 'example.com:80'
+ * @returns 格式化后的主机名，如 'example.com'
+ * 
+ * @example
+ * formatHost('example.com:80')    // 'example.com'
+ * formatHost('example.com:443')   // 'example.com'
+ * formatHost('example.com:8080')  // 'example.com:8080' (保留非默认端口)
+ * formatHost('example.com')       // 'example.com'
+ */
+function formatHost(host: string): string {
+  // 移除HTTP默认端口
+  if (host.endsWith(':80')) {
+    return host.slice(0, -3);
+  }
+
+  // 移除HTTPS默认端口
+  if (host.endsWith(':443')) {
+    return host.slice(0, -4);
+  }
+
+  return host;
+}
+
 export { formatHost };