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

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,
+}

package/src/libs/utils/render-utils.ts

@@ -4,6 +4,7 @@ import { Context } from '@midwayjs/koa';
 import { parseJsonObject } from './functions';
 import { getExtLocalLoaderPort } from './fatcms-request';
 import { TypeUtils } from '../crud-pro/utils/TypeUtils';
+import { ISessionInfo } from '@/models/userSession';
 
 // const demo = {"schema":[
 //   {"title":"资源配置","name":"fileList","type":"array","properties":{"fileUrl":{"label":"文件URL","component":"Input","xProps":{"hasClear":true},"width":500}}}],
@@ -20,7 +21,7 @@ interface IRenderUtilsProps {
   ctx: Context;
   package_assets: any;
   workbenchInfo: any;
-  userInfo?: any;
+  userInfo?: ISessionInfo;
   appInfo?: any;
   fatcmscsrftoken: string;
 }
@@ -63,22 +64,53 @@ function parseCookie(cookieStr: string): any {
   return cookies;
 }
 
+
+function isMobileUserAgent(userAgent = '') {
+  // 空值处理
+  if (!userAgent) return false;
+
+  // 转为小写统一匹配
+  const ua = userAgent.toLowerCase();
+
+  // 【核心】移动端关键词（覆盖主流系统）
+  const mobileKeywords = /android|iphone|ipod|ios|mobile|blackberry|iemobile|opera mini|windows phone|harmonyos/i;
+  // 【排除项】平板/PC关键词（避免误判）
+  const excludeKeywords = /ipad|tablet|playbook|kindle|pc|windows nt|macintosh|linux x86_64/i;
+
+  // 判断规则：包含移动端关键词 + 不包含排除项关键词
+  const isMatchMobile = mobileKeywords.test(ua);
+  const isExclude = excludeKeywords.test(ua);
+
+  return isMatchMobile && !isExclude;
+}
+
 class RenderUtils {
-  private readonly ctx: Context;
-  private readonly fileList: IFileElement[];
-  private readonly workbenchInfo: any;
-  private readonly userInfo: any;
-  private readonly appInfo: any;
-  private readonly fatcmscsrftoken: string;
+  public readonly ctx: Context;
+  public readonly fileList: IFileElement[];
+  public readonly workbenchInfo: any;
+  public readonly userInfo: ISessionInfo;
+  public readonly appInfo: any;
+  public readonly cookieInfo: any;
+  public readonly fatcmscsrftoken: string;
+  public readonly isMobileUserAgent: boolean;
+  public readonly isMobileByQuery: boolean;
 
   constructor(props: IRenderUtilsProps) {
     this.ctx = props.ctx;
+    const query = props.ctx?.query || {};
+    const headers = props.ctx?.headers || {};
     this.workbenchInfo = props.workbenchInfo || {};
-    this.userInfo = props.userInfo || {};
+    this.userInfo = props.userInfo || ({} as ISessionInfo);
     this.appInfo = props.appInfo || {};
     this.fatcmscsrftoken = props.fatcmscsrftoken;
+    this.cookieInfo = parseCookie(headers?.cookie);
+    this.isMobileUserAgent = isMobileUserAgent(headers['user-agent'] || '');
+    this.isMobileByQuery = `${query['__is_mobile_request__']}` === 'true'
+
     const packageAssets = parseJsonObject(props.package_assets) || {};
     const fileList = _.get(packageAssets, 'data.fileList');
+
+
     if (Array.isArray(fileList)) {
       this.fileList = fileList.filter(f => {
         return f && f.fileUrl && typeof f.fileUrl === 'string' && f.fileUrl.length > 5; // 至少五个字符。
@@ -88,11 +120,11 @@ class RenderUtils {
       const time = moment().format('YYYY-MM-DD HH:mm:ss.SSS');
       console.info(
         time +
-          ' 解析fileList为空==>' +
-          JSON.stringify({
-            workbench_code: this.workbenchInfo?.workbench_code,
-            app_code: this.appInfo?.app_code,
-          })
+        ' 解析fileList为空==>' +
+        JSON.stringify({
+          workbench_code: this.workbenchInfo?.workbench_code,
+          app_code: this.appInfo?.app_code,
+        })
       );
     }
   }
@@ -102,7 +134,9 @@ class RenderUtils {
   }
 
   renderUserInfo() {
-    return `<script>window.__user_info = ${JSON.stringify(this.userInfo)}  </script>`;
+    const userInfoClone = { ...this.userInfo };
+    delete userInfoClone.privateKey;
+    return `<script>window.__user_info = ${JSON.stringify(userInfoClone)}  </script>`;
   }
 
   renderWorkbenchInfo() {
@@ -115,9 +149,13 @@ class RenderUtils {
     return `<script>window.__app_info = ${JSON.stringify(infoPick)}</script>`;
   }
 
+
+
+
+
   renderCookieInfo(keys: string) {
     try {
-      const cookies = parseCookie(this.ctx.headers?.cookie);
+      const cookies = this.cookieInfo;
       const cookieObj = {};
       if (typeof keys === 'string') {
         const keyArr = keys.split(',');
@@ -132,6 +170,9 @@ class RenderUtils {
     }
   }
 
+
+
+
   renderJsAssets() {
     const fileList = this.fileList.filter(s => {
       return s.fileType === 'js' || s.fileUrl.endsWith('.js');

package/src/middleware/global.middleware.ts

@@ -10,6 +10,7 @@ import { isEnableDebug, isEnableSuperAdmin } from '@/libs/utils/fatcms-request';
 import { ContextLogger } from '@/models/contextLogger';
 import { Stream } from 'node:stream';
 import { VisitStatService } from '@/service/VisitStatService';
+import { WorkbenchInfoTools } from '@/models/WorkbenchInfoTools';
 
 function isFunction(fun: any): boolean {
   return typeof fun === 'function';
@@ -256,6 +257,13 @@ export class GlobalMiddleware implements IMiddleware<Context, NextFunction> {
 
         ctx.userSession = new UserSessionInfo(sessionInfo, isSuperAdmin);
         ctx.workbenchInfo = await workbenchService.getCurrentHostWorkbenchInfo();
+        ctx.workbenchInfoTools = new WorkbenchInfoTools(ctx.workbenchInfo);
+
+        // 校验是否支持该路径
+        const isSupportTheNodePath = workbenchService.isSupportTheNodePathByWorkbenchInfo(ctx.workbenchInfo, ctx.path);
+        if (!isSupportTheNodePath) {
+          return CommonResult.errorRes('非法访问！此站点不支持该路径！', 'NOT_SUPPORT_PATH');
+        }
 
         // 数据埋点
         await trackRequest(ctx);

package/src/models/SystemEntities.ts

@@ -121,3 +121,46 @@ export interface IWorkbenchEntity {
   workbench_type: number;
   package_assets?: string;
 }
+
+export enum CacheLevelEnum {
+  NONE = 'NONE', // 不缓存
+  CONTEXT = 'CONTEXT', // 请求上下文缓存
+  MEMORY = 'MEMORY', // 内存缓存
+  REDIS = 'REDIS', // Redis缓存
+  DISK = 'DISK', // 磁盘缓存
+}
+
+export enum CacheNameEnum {
+  CurdMixByDict = 'CurdMixByDict',
+  CurdMixByLinkToCustom = 'CurdMixByLinkToCustom',
+  CurdMixBySysConfig = 'CurdMixBySysConfig',
+  CurdMixByWorkbench = 'CurdMixByWorkbench',
+  GetParsedCrudStdAppInfo = 'GetParsedCrudStdAppInfo',
+  GetWorkbenchMenu = 'GetWorkbenchMenu',
+  GetNavPageInfo = 'GetNavPageInfo',
+  GetEnumInfoByCode = 'GetEnumInfoByCode',
+  UserSessionBySessionId = 'UserSessionBySessionId',
+  UserSessionByAsyncTaskId = 'UserSessionByAsyncTaskId',
+}
+
+
+export interface IWorkbenchConfig {
+  nodeApiWhiteEnable?: boolean; // 接口白名单开关
+  nodeApiWhiteList?: string[]; // 接口白名单，完整匹配
+  nodeApiWhitePrefix?: string[]; // 接口白名单，根据前缀匹配
+
+  crudStdAppInfoCacheLevel?: CacheLevelEnum; // 零代码CRUD接口白名单开关. 默认： MEMORY
+  crudStdAppInfoCacheSecond?: number; // 零代码CRUD接口白名单缓存时间，单位：秒。 默认 5分钟
+
+  publicApiNavPageInfoCacheLevel?: CacheLevelEnum; // 公开API导航页缓存级别. 默认： MEMORY
+  publicApiNavPageInfoCacheSecond?: number; // 公开API导航页缓存时间，单位：秒。 默认 5分钟
+
+  publicApiMenuCacheLevel?: CacheLevelEnum; // 公开API菜单缓存级别. 默认： MEMORY
+  publicApiMenuCacheSecond?: number; // 公开API菜单缓存时间，单位：秒。 默认 5分钟 
+
+  queryEnumInfoCacheLevel?: CacheLevelEnum; // 查询枚举缓存级别. 默认： MEMORY
+  queryEnumInfoCacheSecond?: number; // 查询枚举缓存时间，单位：秒。 默认 5分钟
+
+  curdMixByCommonCacheLevel?: CacheLevelEnum; // CrudMixService 缓存级别. 默认： MEMORY
+  curdMixByCommonCacheSecond?: number; // CrudMixService 缓存时间，单位：秒。 默认 5分钟
+}

package/src/models/WorkbenchInfoTools.ts

@@ -0,0 +1,18 @@
+import { parseJsonObject } from "@/libs/utils/functions";
+import { IWorkbenchConfig, IWorkbenchEntity } from "./SystemEntities";
+
+
+export class WorkbenchInfoTools {
+    private parsedConfigContent: IWorkbenchConfig = null;
+    constructor(private readonly workbenchInfo: IWorkbenchEntity) {
+    }
+
+    public getWorkbenchConfig(): IWorkbenchConfig {
+        if (this.parsedConfigContent) {
+            return this.parsedConfigContent;
+        }
+        const configObj: IWorkbenchConfig = parseJsonObject(this.workbenchInfo?.config_content);
+        this.parsedConfigContent = configObj || {};
+        return this.parsedConfigContent;    
+    }
+}

package/src/models/bizmodels.ts

@@ -125,3 +125,15 @@ export interface IStdCrudExportInputParams {
   primaryKey: any; // 公共
   pageSize: number; // 公共
 }
+
+export interface ICacheServiceBase {
+  getJsonObject(key: string): Promise<any>;
+  setJsonObject(key: string, obj: any, cacheSecond?: number): Promise<any>;
+  removeItem(key: string): Promise<any>;
+}
+
+
+export interface IfatcmsCacheConfig {
+    diskCacheDir: string;
+    keyPrefix: string;
+}

package/src/models/contextLogger.ts

@@ -54,17 +54,25 @@ class ContextLogger implements ILoggerContext {
   private readonly ctx: Context;
   private readonly app: koa.Application;
   private readonly logList: any = [];
+  private currentTime: number;
 
   constructor(ctx: Context) {
     this.app = ctx.app;
     this.ctx = ctx;
     this.logList = [];
+    this.currentTime = Date.now();
   }
 
   getLogList() {
     return this.logList;
   }
 
+  private getDiffTime(): number {
+    const diffTime = Date.now() - this.currentTime;
+    this.currentTime = Date.now();
+    return diffTime;
+  }
+
   debug(msg: any, ...args: any[]): void {
     this.getLogger().debug(msg, ...args);
     this.appendLogList('debug', msg, ...args);
@@ -97,7 +105,8 @@ class ContextLogger implements ILoggerContext {
     }
     const time = moment().format('YYYY-MM-DD HH:mm:ss.SSS');
     const caller = getCallerInfo();
-    this.logList.push({ level, msg, args, caller, time });
+    const diffTime = this.getDiffTime();
+    this.logList.push({ level, msg, args, caller, time, diffTime });
   }
 
   private getLogger(): ILogger {

package/src/models/userSession.ts

@@ -24,6 +24,8 @@ interface ISessionInfo {
   accountId: string;
   workbenchCode: string;
   accountType: string;
+  publicKey: string; // 公钥
+  privateKey: string; // 私钥
   bizExt?: any;
 }
 
@@ -57,6 +59,8 @@ function createEmptySessionInfo(superAdmin: boolean): ISessionInfo {
     accountId: '',
     workbenchCode: '',
     accountType: '',
+    publicKey: '',
+    privateKey: '',
   };
 }
 

package/src/schedule/anonymousContext.ts

@@ -14,6 +14,8 @@ const anonymousUserInfo: ISessionInfo = {
   accountId: '',
   workbenchCode: '',
   accountType: SYS_ACCOUNT_TYPE,
+  publicKey: '',
+  privateKey: '',
 };
 
 const anonymousWorkbenchInfo: IWorkbenchEntity = {

package/src/service/AuthService.ts

@@ -12,6 +12,7 @@ import { CommonResult } from '@/libs/utils/common-dto';
 import { isEnableSuperAdmin } from '@/libs/utils/fatcms-request';
 import { CommonException } from '@/libs/crud-pro/exceptions';
 import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
+import { AsymmetricCrypto } from '@/libs/utils/AsymmetricCrypto';
 
 @Provide()
 export class AuthService {
@@ -100,6 +101,10 @@ export class AuthService {
       functionCodes = await this.queryFunctionCodeList(roleCodes);
     }
 
+
+    const { publicKey, privateKey } = await AsymmetricCrypto.generateKeyPair();
+
+
     const sessionInfo: ISessionInfo = {
       nickName: consumerUserInfo.nickName,
       avatar: consumerUserInfo.avatar,
@@ -110,6 +115,8 @@ export class AuthService {
       accountId: consumerUserInfo.accountId,
       workbenchCode: consumerUserInfo.workbenchCode,
       accountType: consumerUserInfo.accountType,
+      publicKey,
+      privateKey,
     };
 
     await this.userSessionService.saveUserSession(sessionInfo);
@@ -142,6 +149,8 @@ export class AuthService {
     const roleCodes = await this.queryUserRoleCodeList(accountId);
     const functionCodes = await this.queryFunctionCodeList(roleCodes);
 
+    const { publicKey, privateKey } = await AsymmetricCrypto.generateKeyPair();
+
     const sessionInfo: ISessionInfo = {
       nickName: userAccount.nick_name,
       avatar: userAccount.avatar,
@@ -153,6 +162,8 @@ export class AuthService {
       workbenchCode,
       accountType: SYS_ACCOUNT_TYPE,
       bizExt: {},
+      publicKey,
+      privateKey,
     };
 
     if (bizExt && typeof bizExt === 'object') {