midway-fatcms 0.0.1-beta.64 → 0.0.1-beta.66

package/src/controller/gateway/FileController.ts

@@ -8,6 +8,7 @@ import { FileCenterService, PATH_PREFIX, toDownloadPaths, isImageFile } from '@/
 import { checkLogin, checkPermission } from '@/middleware/permission.middleware';
 import { CommonResult } from '@/libs/utils/common-dto';
 import { SystemFuncCode } from '@/models/SystemPerm';
+import { formatHost } from '@/libs/utils/format-url';
 
 function isTrue(obj: any) {
   return obj === true || obj === 'true';
@@ -55,8 +56,7 @@ export class FileController extends BaseApiController {
 
     const { fileKey, filename, storageUrl } = await this.fileCenterService.uploadFileToOSS(files, accessType, referer);
 
-    const origin = this.ctx.request.origin;
-
+    const origin = formatHost(this.ctx.request.origin);
     const downloadUrls = toDownloadPaths(origin, fileKey);
 
     const data = {

package/src/controller/gateway/PublicApiController.ts

@@ -10,6 +10,14 @@ import { parseJsonObject } from '@/libs/utils/functions';
 import { WorkbenchService } from '@/service/WorkbenchService';
 import { SystemRoleCode } from '@/models/SystemPerm';
 import { KeysOfAuthType } from '@/libs/crud-pro/models/keys';
+import { CacheServiceFactory } from '@/service/base/cache/CacheServiceFactory';
+import md5 = require('md5');
+import { CacheLevelEnum, CacheNameEnum } from '@/models/SystemEntities';
+
+
+const DEFAULT_CACHE_LEVEL = CacheLevelEnum.MEMORY;
+const DEFAULT_CACHE_SECOND = 60 * 5;
+
 
 /**
  * 公开的API，无需鉴权，所有人可以直接访问
@@ -25,6 +33,9 @@ export class PublicApiController extends BaseApiController {
   @Inject()
   private workbenchService: WorkbenchService;
 
+  @Inject()
+  private cacheServiceFactory: CacheServiceFactory;
+
   /**
    * 获取所有站点列表
    */
@@ -53,39 +64,51 @@ export class PublicApiController extends BaseApiController {
       return CommonResult.errorRes('param workbenchMenuCode is null');
     }
 
-    const workbenchMenuCodeStr = '' + workbenchMenuCode;
-    const workbenchMenuCodeArray = workbenchMenuCodeStr.split(',');
+    const { publicApiMenuCacheLevel, publicApiMenuCacheSecond } = this.ctx.workbenchInfoTools.getWorkbenchConfig();
+
+    const mapResult = await this.cacheServiceFactory.getJsonObjectCache({
+      cacheLevel: publicApiMenuCacheLevel || DEFAULT_CACHE_LEVEL,
+      cacheKey: "" + workbenchMenuCode,
+      cacheSecond: publicApiMenuCacheSecond || DEFAULT_CACHE_SECOND,
+      cacheName: CacheNameEnum.GetWorkbenchMenu,
+      getter: async () => {
+
+        const workbenchMenuCodeStr = '' + workbenchMenuCode;
+        const workbenchMenuCodeArray = workbenchMenuCodeStr.split(',');
+        const condition = {
+          menu_code: {
+            $in: workbenchMenuCodeArray,
+          },
+        };
 
-    const condition = {
-      menu_code: {
-        $in: workbenchMenuCodeArray,
-      },
-    };
+        const rows = await this.sysDBUtil.getList({ condition }, SystemTables.sys_menus);
 
-    const rows = await this.sysDBUtil.getList({ condition }, SystemTables.sys_menus);
+        const map = {};
+        for (let i = 0; i < rows.length; i++) {
+          const rowElement = rows[i];
+          const menu_code = rowElement.menu_code;
+          const view_auth_config = rowElement.view_auth_config;
+          const view_auth_type = rowElement.view_auth_type;
 
-    const map = {};
-    for (let i = 0; i < rows.length; i++) {
-      const rowElement = rows[i];
-      const menu_code = rowElement.menu_code;
-      const view_auth_config = rowElement.view_auth_config;
-      const view_auth_type = rowElement.view_auth_type;
+          const hasPermission = this.ctx.userSession.isAuthPass(view_auth_type, view_auth_config);
 
-      const hasPermission = this.ctx.userSession.isAuthPass(view_auth_type, view_auth_config);
+          const menu_config_content = rowElement.menu_config_content;
+          delete rowElement.menu_config_content;
+          const menu_list = parseJsonObject(menu_config_content) || [];
+          map[menu_code] = { ...rowElement, menu_list, hasPermission };
+        }
 
-      const menu_config_content = rowElement.menu_config_content;
-      delete rowElement.menu_config_content;
-      const menu_list = parseJsonObject(menu_config_content) || [];
-      map[menu_code] = { ...rowElement, menu_list, hasPermission };
-    }
+        // 特殊的devops菜单
+        map['devops'] = {
+          menu_list: [], // 这个特殊的菜单在前端写死。
+          hasPermission: this.ctx.userSession.isAuthPass(KeysOfAuthType.byRoleCode, [SystemRoleCode.DevOpsWriter, SystemRoleCode.DevOpsViewer, SystemRoleCode.SuperAdmin]),
+        };
 
-    // 特殊的devops菜单
-    map['devops'] = {
-      menu_list: [], // 这个特殊的菜单在前端写死。
-      hasPermission: this.ctx.userSession.isAuthPass(KeysOfAuthType.byRoleCode, [SystemRoleCode.DevOpsWriter, SystemRoleCode.DevOpsViewer, SystemRoleCode.SuperAdmin]),
-    };
+        return map;
+      }
+    })
 
-    return CommonResult.successRes(map);
+    return CommonResult.successRes(mapResult);
   }
 
   /**
@@ -96,14 +119,35 @@ export class PublicApiController extends BaseApiController {
     const body = this.ctx.request.body as any;
     const { workbenchCode, appCode, pathname } = body;
     const resultData: any = {};
-    const getOne = async (condition: any, tablenName: string, key: string) => {
+
+    const getOneImpl = async (condition: any, tableName: string) => {
       const values = Object.values(condition).filter(Boolean);
       // 查询条件不能为空
       if (values.length > 0) {
-        const oneData = await this.sysDBUtil.getOne({ condition }, tablenName);
+        const oneData = await this.sysDBUtil.getOne({ condition }, tableName);
         if (oneData && oneData['app_schema']) {
           oneData['app_schema'] = parseJsonObject(oneData['app_schema']);
         }
+        return oneData;
+      }
+      return null;
+    };
+
+
+    const { publicApiNavPageInfoCacheLevel, publicApiNavPageInfoCacheSecond } = this.ctx.workbenchInfoTools.getWorkbenchConfig();
+
+    const getOne = async (condition: any, tableName: string, key: string) => {
+      const cacheKey = md5(tableName + ':' + JSON.stringify(condition) + ":" + key);
+      const oneData = await this.cacheServiceFactory.getJsonObjectCache({
+        cacheLevel: publicApiNavPageInfoCacheLevel || DEFAULT_CACHE_LEVEL,
+        cacheSecond: publicApiNavPageInfoCacheSecond || DEFAULT_CACHE_SECOND,
+        cacheKey,
+        cacheName: CacheNameEnum.GetNavPageInfo,
+        getter: async () => {
+          return await getOneImpl(condition, tableName);
+        },
+      });
+      if (oneData) {
         resultData[key] = oneData;
       }
     };

package/src/controller/manage/DocLibManageApi.ts

@@ -1,11 +1,11 @@
 import { Controller, Inject, Post } from '@midwayjs/core';
 import { Context } from '@midwayjs/koa';
-import { KeysOfSimpleSQL, KeysOfValidators } from '../../libs/crud-pro/models/keys';
+import { KeysOfSimpleSQL, KeysOfValidators } from '@/libs/crud-pro/models/keys';
 import { BaseApiController } from '../base/BaseApiController';
-import { checkPermission } from '../../middleware/permission.middleware';
-import { SystemFuncCode } from '../../models/SystemPerm';
-import { SystemTables } from '../../models/SystemTables';
-import { CTX_WORKBENCH_CODE } from '../../models/bizmodels';
+import { checkPermission } from '@/middleware/permission.middleware';
+import { SystemFuncCode } from '@/models/SystemPerm';
+import { SystemTables } from '@/models/SystemTables';
+import { CTX_WORKBENCH_CODE } from '@/models/bizmodels';
 
 @Controller('/ns/api/manage/docLib', { middleware: [checkPermission(SystemFuncCode.DocMangeRead)] })
 export class DocLibManageApi extends BaseApiController {

package/src/controller/manage/FileManageApi.ts

@@ -1,11 +1,11 @@
 import { Controller, Inject, Post } from '@midwayjs/core';
 import { Context } from '@midwayjs/koa';
-import { KeysOfSimpleSQL, KeysOfValidators } from '../../libs/crud-pro/models/keys';
+import { KeysOfSimpleSQL, KeysOfValidators } from '@/libs/crud-pro/models/keys';
 import { BaseApiController } from '../base/BaseApiController';
-import { FileCenterService } from '../../service/FileCenterService';
-import { checkPermission } from '../../middleware/permission.middleware';
-import { SystemFuncCode } from '../../models/SystemPerm';
-import { SystemTables } from '../../models/SystemTables';
+import { FileCenterService } from '@/service/FileCenterService';
+import { checkPermission } from '@/middleware/permission.middleware';
+import { SystemFuncCode } from '@/models/SystemPerm';
+import { SystemTables } from '@/models/SystemTables';
 
 @Controller('/ns/api/manage/file', { middleware: [checkPermission(SystemFuncCode.FileMangeRead)] })
 export class FileMangeApi extends BaseApiController {

package/src/controller/manage/MenuManageApi.ts

@@ -1,10 +1,10 @@
 import { Controller, Inject, Post } from '@midwayjs/core';
 import { Context } from '@midwayjs/koa';
-import { KeysOfSimpleSQL, KeysOfValidators } from '../../libs/crud-pro/models/keys';
+import { KeysOfSimpleSQL, KeysOfValidators } from '@/libs/crud-pro/models/keys';
 import { BaseApiController } from '../base/BaseApiController';
-import { checkPermission } from '../../middleware/permission.middleware';
-import { SystemFuncCode } from '../../models/SystemPerm';
-import { SystemTables } from '../../models/SystemTables';
+import { checkPermission } from '@/middleware/permission.middleware';
+import { SystemFuncCode } from '@/models/SystemPerm';
+import { SystemTables } from '@/models/SystemTables';
 
 @Controller('/ns/api/manage/menu', { middleware: [checkPermission(SystemFuncCode.MenuMangeRead)] })
 export class MenuManageApi extends BaseApiController {

package/src/index.ts

@@ -54,7 +54,7 @@ export * from './service/anyapi/AnyApiSandboxService';
 export * from './service/anyapi/AnyApiService';
 export * from './service/base/ApiBaseService';
 export * from './service/base/BaseService';
-export * from './service/base/RedisCacheService';
+export * from './service/base/cache/FatcmsBaseRedisCache';
 export * from './service/crudstd/CrudStdActionService';
 export * from './service/crudstd/CrudStdRelationService';
 export * from './service/crudstd/CrudStdService';

package/src/interface.ts

@@ -3,12 +3,14 @@ import { Transaction } from './libs/crud-pro/models/Transaction';
 import { UserSessionInfo } from './models/userSession';
 import { ContextLogger } from './models/contextLogger';
 import { IWorkbenchEntity } from './models/SystemEntities';
+import { WorkbenchInfoTools } from './models/WorkbenchInfoTools';
 
 declare module '@midwayjs/core' {
   interface Context {
     transaction: Transaction;
     userSession: UserSessionInfo;
     workbenchInfo: IWorkbenchEntity;
+    workbenchInfoTools: WorkbenchInfoTools;
     contextLogger: ContextLogger;
   }
 }

package/src/libs/crud-pro/exceptions.ts

@@ -47,6 +47,8 @@ export enum Exceptions {
   CFG_PARSE_ERROR = 'CFG_PARSE_ERROR',
   CFG_ERROR_POSTGRES_UNIQUE_COLUMNS_NULL = 'CFG_ERROR_POSTGRES_UNIQUE_COLUMNS_NULL',
   CFG_UNIQUE_COLUMN_COUNT_MUST_ONE = 'CFG_UNIQUE_COLUMN_COUNT_MUST_ONE',
+  CFG_ORDER_BY_TYPE_ERROR = 'CFG_ORDER_BY_TYPE_ERROR',
+  CFG_ERROR_POSTGRES_COLUMN_NAME_INVALID = 'CFG_ERROR_POSTGRES_COLUMN_NAME_INVALID',
 
   /**
    * 数据传错

package/src/libs/crud-pro/models/keys.ts

@@ -112,19 +112,19 @@ export const KeysOfConditions = {
   $NOT_NULL: '$notNull', // is not null
   $NULL: '$null', // is null
   $RANGE: '$range', // between 1 and 2
-  $LIKE: '$like', // A% 以A开头 {age:1, name:{"$like":"张"} }
-  $NOT_LIKE: '$notLike', // A% 以A开头 {age:1, name:{"$notLike":"张"} }
+  $LIKE: '$like', //前缀匹配， A% 以A开头 {age:1, name:{"$like":"张"} }
+  $NOT_LIKE: '$notLike', // 前缀匹配 A% 以A开头 {age:1, name:{"$notLike":"张"} }
 
   $LIKE_INCLUDE: '$likeInclude', // %A% 包含A {age:1, name:{"$like":"张"} }
   $NOT_LIKE_INCLUDE: '$notLikeInclude', // %A%  包含A {age:1, name:{"$notLike":"张"} }
 
-  $MATCH: '$match', // 全文索引 {age:1, name:{"$match":"张"} }
-  $MATCH_BOOL: '$matchBool', // 全文索引 {age:1, name:{"$matchBool":"张"} }
+  $MATCH: '$match', // MYSQL 全文索引 {age:1, name:{"$match":"张"} }
+  $MATCH_BOOL: '$matchBool', // MYSQL 全文索引 {age:1, name:{"$matchBool":"张"} }
 
   /**
-   * SELECT * FROM tms_biz.表 WHERE JSON_CONTAINS(`related_user1`, JSON_ARRAY('2512274'), '$');
+   * SELECT * FROM table WHERE JSON_CONTAINS(`related_user1`, JSON_ARRAY('aaaaa'), '$');
    */
-  $JSON_ARRAY_CONTAINS: '$jsonArrayContains', // 全文索引 { related_user1:{"$jsonArrayContains":"2512274"} }
+  $JSON_ARRAY_CONTAINS: '$jsonArrayContains', // 全文索引 { related_user1:{"$jsonArrayContains":"aaaaa"} }
 
   COMPARE_KEYS: new Set<string>([]),
   ALL_KEYS: new Set<string>([]),

package/src/libs/crud-pro/services/CrudProOriginToExecuteSql.ts

@@ -238,8 +238,14 @@ class CrudProOriginToExecuteSql extends CrudProServiceBase {
     if (MixinUtils.isEmpty(orderBys)) {
       return null;
     }
+    const ORDER_BY_TYPE_ARR = ['asc', 'desc'];
+
     const orderByArr = orderBys.map(orderBy => {
-      return toSqlColumnName(orderBy.fieldName, sqlCfgModel) + ' ' + orderBy.orderType;
+      const orderType = (orderBy.orderType || 'asc').toLowerCase();
+      if (!ORDER_BY_TYPE_ARR.includes(orderType)) {
+        throw new CommonException(Exceptions.CFG_ORDER_BY_TYPE_ERROR, 'orderType must be asc or desc : ' + orderType);
+      }
+      return toSqlColumnName(orderBy.fieldName, sqlCfgModel) + ' ' + orderType;
     });
     const sql = 'order by ' + orderByArr.join(',');
     return new SqlSegArg(sql);

package/src/libs/crud-pro/utils/sqlConvert/convertColumnName.ts

@@ -1,7 +1,25 @@
+import { CommonException, Exceptions } from '../../exceptions';
 import { SqlCfgModel } from '../../models/SqlCfgModel';
 import { SqlDbType } from '../../models/keys';
 
+const COLUMN_NAME_REGEX = /^[a-zA-Z0-9_]+$/;
+function isColumnNameValid(str: string): boolean {
+  if (typeof str !== 'string') {
+    return false;
+  }
+  if (str === '') {
+    return false;
+  }
+  return COLUMN_NAME_REGEX.test(str);
+}
+
+
 function toSqlColumnName(columnName: string, sqlCfgModel: SqlCfgModel): string {
+
+  if (!isColumnNameValid(columnName)) {
+    throw new CommonException(Exceptions.CFG_ERROR_POSTGRES_COLUMN_NAME_INVALID, 'column name is invalid : ' + columnName);
+  }
+
   if (sqlCfgModel.sqlDbType === SqlDbType.postgres) {
     return '"' + columnName + '"';
   }

package/src/libs/utils/AsymmetricCrypto.ts

@@ -0,0 +1,310 @@
+
+
+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

@@ -0,0 +1,16 @@
+function formatHost(host: string) {
+ 
+    if (host.endsWith(':80')) {
+      host = host.slice(0, -3);
+    }
+
+    if (host.endsWith(':443')) {
+      host = host.slice(0, -4);
+    }
+
+    return host;
+}
+
+export {
+    formatHost,
+}