方案二 · 会话密钥改造：前后端实施手册

目标：让前端产物中不再存在任何可用密钥，并让”拿到公开信息即可伪造加密请求”这条路失效。 涉及仓库：ruoyi-office-vben（PC）、dy-ui-admin-uniapp（小程序）、宇擎后端 前置：本文档代码可直接整文件替换。落地顺序见第 6 节，不要跳步。

0. 改动清单总览

前端 · PC 端 ruoyi-office-vben

前端 · 小程序端 dy-ui-admin-uniapp

后端

1. 协议契约（前后端必须逐条对齐）

1.1 请求头

1.2 过滤器触发规则（重要）

if (有 X-Session-Key) {
    // 协商分支：RSA 私钥解出 K，存入 request attribute，供业务层绑定
    // 若同时有 X-Api-Encrypt: true，则用 K 解 body
} else if (有 X-Api-Encrypt: true) {
    // 已协商分支：按 X-Session-Id 查 Redis 取 K
    // 查不到 → 直接拒绝，不回退固定密钥
    // 查到 → 校验归属（owner），再解 body
}

1.3 加密参数（保持不变，避免动后端密码学实现）

2. 前端 · PC 端改造

2.1 F1 apps/web-antd/.env（入库，全部非敏感）

# 应用标题
VITE_APP_TITLE=信息化综合管理平台
# 应用命名空间
VITE_APP_NAMESPACE=yudao-vben-antd
# 是否开启模拟数据
VITE_NITRO_MOCK=false
# 租户开关
VITE_APP_TENANT_ENABLE=true
# 验证码开关
VITE_APP_CAPTCHA_ENABLE=false
# 文档地址开关
VITE_APP_DOCALERT_ENABLE=true
# 百度统计 / GA
VITE_APP_BAIDU_CODE=ede2dc454379d7def7b4363ff72f8824
VITE_APP_GA_ID=
# API 加解密——只保留开关与协议参数，密钥一律不在此文件
VITE_APP_API_ENCRYPT_ENABLE=true
VITE_APP_API_ENCRYPT_HEADER=X-Api-Encrypt
VITE_APP_API_ENCRYPT_ALGORITHM=AES
# 后端 RSA 公钥（公钥可公开，允许入库）
VITE_APP_RSA_PUBLIC_KEY=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC...替换为真实公钥

从原文件删除：VITE_APP_STORE_SECURE_KEY、VITE_APP_API_ENCRYPT_REQUEST_KEY、 VITE_APP_API_ENCRYPT_RESPONSE_KEY、VITE_BAIDU_MAP_KEY、VITE_AMAP_KEY、VITE_GOVIEW_URL。

2.2 F2 apps/web-antd/.env.local（不入库，根 .gitignore 已忽略）

# 本地开发专用，禁止提交
VITE_APP_STORE_SECURE_KEY=<本地随机值>
VITE_BAIDU_MAP_KEY=<你的 ak>
VITE_AMAP_KEY=<你的 key>
VITE_GOVIEW_URL='http://127.0.0.1:3000'

2.3 F3 apps/web-antd/.env.example（入库）

# 复制为 .env.local 后填写真实值；本文件禁止填任何真值
VITE_APP_STORE_SECURE_KEY=      # 本地随机值 / CI 凭据 web-antd-store-secure-key
VITE_BAIDU_MAP_KEY=             # 百度地图控制台（须配域名白名单）
VITE_AMAP_KEY=                  # 高德控制台（须配域名白名单）

2.4 F4 packages/types/global.d.ts

export interface VbenAdminProAppConfigRaw {
  VITE_GLOB_API_URL: string;
  VITE_GLOB_AUTH_DINGDING_CLIENT_ID: string;
  VITE_GLOB_AUTH_DINGDING_CORP_ID: string;
  // API 加解密——只保留开关与协议参数
  VITE_APP_API_ENCRYPT_ENABLE: string;
  VITE_APP_API_ENCRYPT_HEADER: string;
  VITE_APP_API_ENCRYPT_ALGORITHM: string;
  // 后端 RSA 公钥（用于包裹会话密钥）
  VITE_APP_RSA_PUBLIC_KEY: string;
}

删除 VITE_APP_API_ENCRYPT_REQUEST_KEY / VITE_APP_API_ENCRYPT_RESPONSE_KEY 两行。

2.5 F5 packages/@core/base/shared/src/utils/encrypt.ts（整文件替换）

import CryptoJS from 'crypto-js';
import { JSEncrypt } from 'jsencrypt';
/**
 * API 加解密工具（方案二：会话密钥）
 *
 * 与旧实现的区别：
 * - 不再从环境变量读取固定 AES 密钥；
 * - 每次会话生成一把随机对称密钥 K，仅存内存，退出登录即销毁；
 * - K 用后端 RSA 公钥包裹后通过 X-Session-Key 上送，完成协商；
 * - 对称算法 / 填充 / 报文编码保持不变，复用后端既有实现。
 */
/** AES 合法密钥长度（字节），对应 AES-128 / AES-192 / AES-256 */
const AES_KEY_BYTES = [16, 24, 32];
/** 会话密钥字符数 = UTF-8 字节数，必须落在 ASCII 区间 */
const SESSION_KEY_LENGTH = 32;
/**
 * 会话密钥字符集：**只允许 ASCII**。
 * 若混入非 ASCII 字符（含中文），CryptoJS.enc.Utf8.parse 后字节数会膨胀，
 * key.length 与 sigBytes 不再相等，AES 会直接抛 Invalid key size。
 */
const SESSION_KEY_ALPHABET =
  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
/**
 * 校验并返回 AES 密钥
 * @param key 原始密钥字符串
 * @param scene 场景名（加密 / 解密），用于错误提示
 */
function assertAesKey(key: string, scene: string): CryptoJS.lib.WordArray {
  if (!key) {
    throw new Error(`AES ${scene}密钥不能为空`);
  }
  const keyUtf8 = CryptoJS.enc.Utf8.parse(key);
  if (!AES_KEY_BYTES.includes(keyUtf8.sigBytes)) {
    throw new Error(
      `AES ${scene}密钥长度必须为 16/24/32 字节，当前 ${keyUtf8.sigBytes} 字节（字符数 ${key.length}）`,
    );
  }
  return keyUtf8;
}
/** 取随机字节：优先 Web Crypto，回落到 crypto-js 随机源（小程序 / 老环境） */
function randomBytes(len: number): Uint8Array {
  const g = globalThis as any;
  if (g.crypto?.getRandomValues) {
    const arr = new Uint8Array(len);
    g.crypto.getRandomValues(arr);
    return arr;
  }
  const words = CryptoJS.lib.WordArray.random(len);
  const out = new Uint8Array(len);
  for (let i = 0; i < len; i++) {
    out[i] = (words.words[i >>> 2] as number) >>> (24 - (i % 4) * 8) & 0xff;
  }
  return out;
}
/**
 * 生成会话对称密钥（32 个 ASCII 字符 ≈ 190 bit 熵）
 * 用拒绝采样消除取模偏置。
 */
export function generateSessionKey(length = SESSION_KEY_LENGTH): string {
  const n = SESSION_KEY_ALPHABET.length; // 62
  const limit = Math.floor(256 / n) * n; // 248：>= limit 的字节丢弃
  let out = '';
  while (out.length < length) {
    const bytes = randomBytes(length);
    for (let i = 0; i < bytes.length && out.length < length; i++) {
      const b = bytes[i] as number;
      if (b < limit) {
        out += SESSION_KEY_ALPHABET[b % n];
      }
    }
  }
  return out;
}
/** 生成会话标识 */
export function generateSessionId(): string {
  const g = globalThis as any;
  if (g.crypto?.randomUUID) {
    return g.crypto.randomUUID();
  }
  return `${Date.now().toString(36)}-${generateSessionKey(16)}`;
}
/** 用后端 RSA 公钥包裹会话密钥 */
export function wrapSessionKey(rawKey: string, publicKeyPem: string): string {
  if (!publicKeyPem) {
    throw new Error('VITE_APP_RSA_PUBLIC_KEY 未配置，无法协商会话密钥');
  }
  const wrapped = RSA.encrypt(rawKey, publicKeyPem);
  if (wrapped === false) {
    throw new Error('会话密钥包裹失败：RSA 公钥无效');
  }
  return wrapped;
}
/**
 * 判断响应头是否声明了「响应体已加密」
 * 必须用 headers.get(name)：AxiosHeaders 下标访问大小写敏感，取不到值。
 */
export function isEncryptFlaggedHeader(
  headers: any,
  headerName: string,
): boolean {
  if (!headers || !headerName) {
    return false;
  }
  const raw =
    typeof headers.get === 'function'
      ? headers.get(headerName)
      : (headers[headerName] ?? headers[headerName.toLowerCase()]);
  return String(raw) === 'true';
}
/** 判断请求体是否为「不可 JSON 加密」的原始类型 */
export function isNonJsonBody(data: any): boolean {
  if (!data || typeof data !== 'object') {
    return false;
  }
  if (typeof FormData !== 'undefined' && data instanceof FormData) {
    return true;
  }
  if (typeof Blob !== 'undefined' && data instanceof Blob) {
    return true;
  }
  if (
    typeof ArrayBuffer !== 'undefined' &&
    (data instanceof ArrayBuffer || ArrayBuffer.isView(data))
  ) {
    return true;
  }
  return (
    typeof URLSearchParams !== 'undefined' && data instanceof URLSearchParams
  );
}
/** 删除请求头（兼容 AxiosHeaders 与普通对象） */
export function removeHeader(headers: any, name: string): void {
  if (!headers) {
    return;
  }
  if (typeof headers.delete === 'function') {
    headers.delete(name);
  } else {
    delete headers[name];
  }
}
/** AES 工具类 */
export const AES = {
  encrypt(data: string, key: string): string {
    try {
      const keyUtf8 = assertAesKey(key, '加密');
      return CryptoJS.AES.encrypt(data, keyUtf8, {
        mode: CryptoJS.mode.ECB,
        padding: CryptoJS.pad.Pkcs7,
      }).toString();
    } catch (error) {
      console.error('AES 加密失败:', error);
      throw error;
    }
  },
  decrypt(encryptedData: string, key: string): string {
    const keyUtf8 = assertAesKey(key, '解密');
    if (!encryptedData) {
      throw new Error('AES 解密数据不能为空');
    }
    try {
      const result = CryptoJS.AES.decrypt(encryptedData, keyUtf8, {
        mode: CryptoJS.mode.ECB,
        padding: CryptoJS.pad.Pkcs7,
      }).toString(CryptoJS.enc.Utf8);
      if (!result) {
        throw new Error('解密结果为空');
      }
      return result;
    } catch (error) {
      console.error('AES 解密失败:', error);
      throw new Error(
        `AES 解密失败，可能是密钥配置错误或数据损坏：${(error as Error).message}`,
      );
    }
  },
};
/** RSA 工具类（jsencrypt 仅支持 PKCS1v1.5，与后端保持一致） */
export const RSA = {
  encrypt(data: string, publicKey: string): false | string {
    try {
      if (!publicKey) {
        throw new Error('RSA 公钥不能为空');
      }
      const encryptor = new JSEncrypt();
      encryptor.setPublicKey(publicKey);
      const result = encryptor.encrypt(data);
      if (result === false) {
        throw new Error('RSA 加密失败，可能是公钥格式错误或数据过长');
      }
      return result;
    } catch (error) {
      console.error('RSA 加密失败:', error);
      throw error;
    }
  },
  decrypt(encryptedData: string, privateKey: string): false | string {
    try {
      if (!privateKey) {
        throw new Error('RSA 私钥不能为空');
      }
      if (!encryptedData) {
        throw new Error('RSA 解密数据不能为空');
      }
      const encryptor = new JSEncrypt();
      encryptor.setPrivateKey(privateKey);
      const result = encryptor.decrypt(encryptedData);
      if (result === false) {
        throw new Error('RSA 解密失败，可能是私钥错误或数据损坏');
      }
      return result;
    } catch (error) {
      console.error('RSA 解密失败:', error);
      throw error;
    }
  },
};
/** API 加解密配置（不再包含固定密钥） */
export interface ApiEncryptConfig {
  algorithm: 'AES' | 'RSA';
  enable: boolean;
  header: string;
}
/**
 * API 加解密主类（会话密钥版）
 */
export class ApiEncrypt {
  private config: ApiEncryptConfig;
  /** 会话标识，所有加密请求都要带 */
  private sessionId = '';
  /** 会话对称密钥，仅存内存 */
  private sessionKey = '';
  /** 协商用 RSA 密文，只在密钥交换请求上带一次，带完即清 */
  private pendingWrappedKey = '';
  constructor(config: ApiEncryptConfig) {
    this.config = config;
  }
  // ---------- 会话生命周期 ----------
  setSession(sessionId: string, key: string): void {
    this.sessionId = sessionId;
    this.sessionKey = key;
  }
  clearSession(): void {
    this.sessionId = '';
    this.sessionKey = '';
    this.pendingWrappedKey = '';
  }
  getSessionId(): string {
    return this.sessionId;
  }
  hasSession(): boolean {
    return Boolean(this.sessionId && this.sessionKey);
  }
  setPendingWrappedKey(wrapped: string): void {
    this.pendingWrappedKey = wrapped;
  }
  /** 取出待发送的 RSA 密文（取一次即清空） */
  takePendingWrappedKey(): string {
    const v = this.pendingWrappedKey;
    this.pendingWrappedKey = '';
    return v;
  }
  /**
   * 加解密是否已就绪
   *
   * 关键改动：必须「已协商出会话密钥」才算启用。
   * 否则会发出「明文 body + X-Api-Encrypt: true」，后端按声明解密必然失败。
   */
  isEnabled(): boolean {
    return this.config.enable && Boolean(this.sessionKey);
  }
  getEncryptHeader(): string {
    return this.config.header;
  }
  /** 加密请求数据 */
  encryptRequest(data: any): any {
    if (!this.isEnabled()) {
      return data;
    }
    try {
      const jsonData = typeof data === 'string' ? data : JSON.stringify(data);
      if (this.config.algorithm.toUpperCase() === 'AES') {
        return AES.encrypt(jsonData, this.sessionKey);
      }
      if (this.config.algorithm.toUpperCase() === 'RSA') {
        const result = RSA.encrypt(jsonData, this.sessionKey);
        if (result === false) {
          throw new Error('RSA 加密失败');
        }
        return result;
      }
      throw new Error(`不支持的加密算法: ${this.config.algorithm}`);
    } catch (error) {
      console.error('请求数据加密失败:', error);
      throw error;
    }
  }
  /** 解密响应数据 */
  decryptResponse(encryptedData: string): any {
    if (!this.config.enable) {
      return encryptedData;
    }
    try {
      if (!this.sessionKey) {
        throw new Error('会话密钥缺失，无法解密响应');
      }
      let decryptedData: false | string = '';
      if (this.config.algorithm.toUpperCase() === 'AES') {
        decryptedData = AES.decrypt(encryptedData, this.sessionKey);
      } else if (this.config.algorithm.toUpperCase() === 'RSA') {
        decryptedData = RSA.decrypt(encryptedData, this.sessionKey);
        if (decryptedData === false) {
          throw new Error('RSA 解密失败');
        }
      } else {
        throw new Error(`不支持的解密算法: ${this.config.algorithm}`);
      }
      if (!decryptedData) {
        throw new Error('解密结果为空');
      }
      try {
        return JSON.parse(decryptedData);
      } catch {
        return decryptedData;
      }
    } catch (error) {
      console.error('响应数据解密失败:', error);
      throw error;
    }
  }
}
/**
 * 创建基于环境变量的 API 加解密实例
 * 注意：不再从 env 读取任何密钥。
 */
export function createApiEncrypt(env: Record<string, any>): ApiEncrypt {
  return new ApiEncrypt({
    algorithm: env.VITE_APP_API_ENCRYPT_ALGORITHM || 'AES',
    enable: env.VITE_APP_API_ENCRYPT_ENABLE === 'true',
    header: env.VITE_APP_API_ENCRYPT_HEADER || 'X-Api-Encrypt',
  });
}

2.6 F6 apps/web-antd/src/api/request.ts（整文件替换）

/**
 * 该文件可自行根据业务逻辑进行调整
 */
import type { RequestClientOptions } from '@vben/request';
import { isTenantEnable, useAppConfig } from '@vben/hooks';
import { preferences } from '@vben/preferences';
import {
  authenticateResponseInterceptor,
  defaultResponseInterceptor,
  errorMessageResponseInterceptor,
  RequestClient,
} from '@vben/request';
import { useAccessStore } from '@vben/stores';
import {
  createApiEncrypt,
  generateSessionId,
  generateSessionKey,
  isEncryptFlaggedHeader,
  isNonJsonBody,
  removeHeader,
  wrapSessionKey,
} from '@vben/utils';
import { message } from 'ant-design-vue';
import { useAuthStore } from '#/store';
import { refreshTokenApi } from './core';
const { apiURL } = useAppConfig(import.meta.env, import.meta.env.PROD);
const tenantEnable = isTenantEnable();
/** 会话密钥实例：供 auth.ts / store 复用 */
export const apiEncrypt = createApiEncrypt(import.meta.env);
/** 防止并发重复协商 */
let renewing: null | Promise<void> = null;
function formatToken(token: null | string) {
  return token ? `Bearer ${token}` : null;
}
/**
 * 生成新的会话密钥，并把 RSA 密文暂存待发
 * 不发起任何请求 —— 密文会由「下一个加密请求」带出去（登录请求或协商请求）。
 */
export function prepareSession(): void {
  const sessionId = generateSessionId();
  const rawKey = generateSessionKey();
  apiEncrypt.setSession(sessionId, rawKey);
  apiEncrypt.setPendingWrappedKey(
    wrapSessionKey(rawKey, import.meta.env.VITE_APP_RSA_PUBLIC_KEY),
  );
}
/**
 * 已登录场景下（页面刷新后内存丢失）把新会话密钥注册到后端
 * 幂等：同一时刻只会发起一次
 */
export function ensureSessionReady(): Promise<void> {
  const accessStore = useAccessStore();
  if (!accessStore.accessToken) {
    return Promise.resolve();
  }
  if (apiEncrypt.hasSession()) {
    return Promise.resolve();
  }
  if (!renewing) {
    renewing = (async () => {
      prepareSession();
      const wrapped = apiEncrypt.takePendingWrappedKey();
      await baseRequestClient.post('/system/auth/session-key', null, {
        headers: {
          Authorization: formatToken(accessStore.accessToken as string),
          'X-Session-Id': apiEncrypt.getSessionId(),
          'X-Session-Key': wrapped,
        },
      });
    })()
      .catch((error) => {
        // 协商失败时清空，避免用一把后端不认识的密钥继续发加密请求
        apiEncrypt.clearSession();
        throw error;
      })
      .finally(() => {
        renewing = null;
      });
  }
  return renewing;
}
function createRequestClient(baseURL: string, options?: RequestClientOptions) {
  const client = new RequestClient({
    ...options,
    baseURL,
  });
  /** 重新认证逻辑 */
  async function doReAuthenticate() {
    console.warn('Access token or refresh token is invalid or expired. ');
    const accessStore = useAccessStore();
    const authStore = useAuthStore();
    accessStore.setAccessToken(null);
    if (
      preferences.app.loginExpiredMode === 'modal' &&
      accessStore.isAccessChecked
    ) {
      accessStore.setLoginExpired(true);
    } else {
      await authStore.logout();
    }
  }
  /** 刷新 token 逻辑 */
  async function doRefreshToken() {
    const accessStore = useAccessStore();
    const refreshToken = accessStore.refreshToken as string;
    if (!refreshToken) {
      throw new Error('Refresh token is null!');
    }
    const resp = await refreshTokenApi(refreshToken);
    const newToken = resp?.data?.data?.accessToken;
    // add by dy：这里一定要抛出 resp.data，从而触发刷新令牌失败！！！
    if (!newToken) {
      throw resp.data;
    }
    accessStore.setAccessToken(newToken);
    return newToken;
  }
  // 请求头处理
  client.addRequestInterceptor({
    fulfilled: async (config) => {
      const accessStore = useAccessStore();
      config.headers.Authorization = formatToken(accessStore.accessToken);
      config.headers['Accept-Language'] = preferences.app.locale;
      // 添加租户编号
      config.headers['tenant-id'] = tenantEnable
        ? accessStore.tenantId
        : undefined;
      // 只有登录时，才设置 visit-tenant-id 访问租户
      config.headers['visit-tenant-id'] = tenantEnable
        ? accessStore.visitTenantId
        : undefined;
      // 是否 API 加密
      if ((config.headers || {}).isEncrypt) {
        try {
          // 兜底：会话缺失（页面刷新）时先协商，避免发不出加密请求
          if (!apiEncrypt.hasSession()) {
            await ensureSessionReady();
          }
          const sessionId = apiEncrypt.getSessionId();
          if (sessionId) {
            config.headers['X-Session-Id'] = sessionId;
          }
          // 协商密文只在需要时带一次
          const wrapped = apiEncrypt.takePendingWrappedKey();
          if (wrapped) {
            config.headers['X-Session-Key'] = wrapped;
          }
          // 仅当「会话密钥就绪」且「请求体可加密」时才加密并声明加密头
          if (
            apiEncrypt.isEnabled() &&
            config.data &&
            !isNonJsonBody(config.data)
          ) {
            config.data = apiEncrypt.encryptRequest(config.data);
            config.headers[apiEncrypt.getEncryptHeader()] = 'true';
          }
        } catch (error) {
          console.error('请求数据加密失败:', error);
          throw error;
        } finally {
          // 剥离业务侧私有标记头
          removeHeader(config.headers, 'isEncrypt');
        }
      }
      return config;
    },
  });
  // API 解密响应拦截器
  client.addResponseInterceptor({
    fulfilled: (response) => {
      if (
        isEncryptFlaggedHeader(
          response.headers,
          apiEncrypt.getEncryptHeader(),
        ) &&
        typeof response.data === 'string'
      ) {
        try {
          response.data = apiEncrypt.decryptResponse(response.data);
        } catch (error) {
          console.error('响应数据解密失败:', error);
          throw new Error(`响应数据解密失败: ${(error as Error).message}`);
        }
      }
      return response;
    },
    rejected: (error) => {
      // 错误响应（4xx/5xx）也可能被后端加密
      const response = error?.response;
      if (
        response &&
        isEncryptFlaggedHeader(
          response.headers,
          apiEncrypt.getEncryptHeader(),
        ) &&
        typeof response.data === 'string'
      ) {
        try {
          response.data = apiEncrypt.decryptResponse(response.data);
        } catch (decryptError) {
          console.error('错误响应数据解密失败:', decryptError);
        }
      }
      // 会话密钥失效：清空本地会话，下次请求自动重新协商
      const msg = response?.data?.msg ?? response?.data?.message ?? '';
      if (typeof msg === 'string' && msg.includes('会话密钥')) {
        apiEncrypt.clearSession();
      }
      return Promise.reject(error);
    },
  });
  // 处理返回的响应数据格式
  client.addResponseInterceptor(
    defaultResponseInterceptor({
      codeField: 'code',
      dataField: 'data',
      // add by dy: 兼容宇擎后端部分接口实际返回 code=200
      successCode: (code: any) => code === 0 || code === 200,
    }),
  );
  // token 过期的处理
  client.addResponseInterceptor(
    authenticateResponseInterceptor({
      client,
      doReAuthenticate,
      doRefreshToken,
      enableRefreshToken: preferences.app.enableRefreshToken,
      formatToken,
    }),
  );
  // 通用错误处理
  client.addResponseInterceptor(
    errorMessageResponseInterceptor((msg: string, error) => {
      const responseData = error?.response?.data ?? {};
      const errorMessage =
        responseData?.error ?? responseData?.message ?? responseData.msg ?? '';
      // add by dy：避免 401 “账号未登录” 重复提示
      if (error?.data?.code === 401) {
        return;
      }
      message.error(errorMessage || msg);
    }),
  );
  return client;
}
export const requestClient = createRequestClient(apiURL, {
  responseReturn: 'data',
  timeout: 60_000,
});
export const baseRequestClient = new RequestClient({ baseURL: apiURL });
baseRequestClient.addRequestInterceptor({
  fulfilled: (config) => {
    const accessStore = useAccessStore();
    config.headers['tenant-id'] = tenantEnable
      ? accessStore.tenantId
      : undefined;
    config.headers['visit-tenant-id'] = tenantEnable
      ? accessStore.visitTenantId
      : undefined;
    return config;
  },
});

⚠️ ensureSessionReady 内部引用了下方 baseRequestClient。ES 模块下函数体在调用时才求值， 只要不在模块顶层直接调用 ensureSessionReady() 就不会有 TDZ 问题。 若你的 lint 规则报 no-use-before-define，把 baseRequestClient 的声明上移到函数定义之前即可。

2.7 F7 apps/web-antd/src/api/core/auth.ts

import { apiEncrypt, ensureSessionReady, prepareSession, requestClient } from '#/api/request';
/** 登录 */
export async function loginApi(data: AuthApi.LoginParams) {
  // 登录前生成会话密钥；RSA 密文会由本次登录请求的 X-Session-Key 带出去
  prepareSession();
  return requestClient.post<AuthApi.LoginResult>('/system/auth/login', data, {
    headers: {
      isEncrypt: true,
    },
  });
}
/** 退出登录后清理本地会话密钥（由 store/logout 调用） */
export function clearEncryptSession() {
  apiEncrypt.clearSession();
}
export { ensureSessionReady };

其余函数（refreshTokenApi、logoutApi、…）保持原样，不需要 isEncrypt。

2.8 F8 apps/web-antd/src/store/auth.ts — logout 清理

// 在 logout() 的 finally 之后、resetAllStores() 之前插入
import { apiEncrypt } from '#/api/request';
async function logout(redirect: boolean = true) {
  try {
    const accessToken = accessStore.accessToken as string;
    if (accessToken) {
      await logoutApi(accessToken);
    }
  } catch {
    // 不做任何处理
  }
  // ★ 新增：销毁本地会话密钥
  apiEncrypt.clearSession();
  resetAllStores();
  // ...其余保持原样
}

2.9 F9 apps/web-antd/src/bootstrap.ts — 页面刷新后重新协商

在 await initStores(app, { namespace }); 之后插入：

  // 配置 pinia-store
  await initStores(app, { namespace });
  // ★ 新增：若已有登录态（页面刷新），重新协商会话密钥
  //   失败不阻塞启动：登录页/后续请求会再触发
  void import('#/api/request').then(({ ensureSessionReady }) =>
    ensureSessionReady().catch(() => undefined),
  );

2.10 F10 其余 4 个 app

web-ele / web-naive / web-tdesign / web-antdv-next 各自都有独立的 src/api/request.ts、src/api/core/auth.ts、src/store/auth.ts、src/bootstrap.ts， 需要做完全相同的四处改动（F6–F9）。packages/@core/base/shared 是共享包，改一次即可。

这是”多客户端同步”成本的主要来源。如果短时间无法全改完，可先在 web-antd 单点灰度 —— 后端双轨期旧 app 仍能用固定密钥（见第 6 节阶段 1）。

2.11 F11 apps/web-antd/Jenkinsfile

environment {
  // ...原有配置保持不变...
  VITE_APP_RSA_PUBLIC_KEY = credentials('web-antd-rsa-public-key')
  VITE_APP_STORE_SECURE_KEY = credentials('web-antd-store-secure-key')
  VITE_BAIDU_MAP_KEY = credentials('web-antd-baidu-map-ak')
  VITE_AMAP_KEY = credentials('web-antd-amap-key')
}

构建后追加产物扫描（放在 stage('5. 构建应用') 之后）：

stage('5.1 产物密钥扫描') {
  steps {
    sh '''
      if grep -rqE "(VITE_APP_API_ENCRYPT_(REQUEST|RESPONSE)_KEY|BEGIN (RSA )?PRIVATE KEY)" apps/web-antd/dist/ ; then
        echo "检测到密钥被内联进前端产物，已阻断发布"; exit 1
      fi
      echo "产物密钥扫描通过"
    '''
  }
}

3. 前端 · 小程序端改造 dy-ui-admin-uniapp

3.1 M1 env/.env

- VITE_APP_API_ENCRYPT_REQUEST_KEY = ysh8E58Kf5g4CxnrjZB6gTxx73Vt9kCt
- VITE_APP_API_ENCRYPT_RESPONSE_KEY = mk4T42hh98YHDGS47YdVfWD75Hk2bwZr
+ VITE_APP_RSA_PUBLIC_KEY = MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC...替换为真实公钥
  VITE_APP_API_ENCRYPT_ENABLE = true
  VITE_APP_API_ENCRYPT_HEADER = X-Api-Encrypt
  VITE_APP_API_ENCRYPT_ALGORITHM = AES

3.2 M2 src/utils/encrypt.ts（整文件替换）

小程序端没有 Web Crypto，随机源用 CryptoJS.lib.WordArray.random。 同时该文件原先是静态类风格，本方案保留该风格以免改动面扩大。

import CryptoJS from 'crypto-js'
import { JSEncrypt } from 'jsencrypt'
/**
 * API 加解密工具（方案二：会话密钥）
 * 小程序端无 Web Crypto，随机源使用 crypto-js。
 * 会话密钥只存内存，退出登录即销毁。
 */
const API_ENCRYPT_ENABLE = import.meta.env.VITE_APP_API_ENCRYPT_ENABLE === 'true'
const API_ENCRYPT_HEADER = import.meta.env.VITE_APP_API_ENCRYPT_HEADER || 'X-Api-Encrypt'
const API_ENCRYPT_ALGORITHM = import.meta.env.VITE_APP_API_ENCRYPT_ALGORITHM || 'AES'
const RSA_PUBLIC_KEY = import.meta.env.VITE_APP_RSA_PUBLIC_KEY || ''
/** 会话密钥字符集：只允许 ASCII，保证字符数 === UTF-8 字节数 */
const SESSION_KEY_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
// ---------- 会话状态（模块级，仅存内存） ----------
let currentSessionId = ''
let currentSessionKey = ''
let pendingWrappedKey = ''
/** AES 加密工具类 */
export class AES {
  static encrypt(data: string, key: string): string {
    if (!key) throw new Error('AES 加密密钥不能为空')
    if (![16, 24, 32].includes(key.length)) {
      throw new Error(`AES 加密密钥长度必须为 16/24/32 位，当前长度: ${key.length}`)
    }
    const keyUtf8 = CryptoJS.enc.Utf8.parse(key)
    return CryptoJS.AES.encrypt(data, keyUtf8, {
      mode: CryptoJS.mode.ECB,
      padding: CryptoJS.pad.Pkcs7,
    }).toString()
  }
  static decrypt(encryptedData: string, key: string): string {
    if (!key) throw new Error('AES 解密密钥不能为空')
    if (![16, 24, 32].includes(key.length)) {
      throw new Error(`AES 解密密钥长度必须为 16/24/32 位，当前长度: ${key.length}`)
    }
    if (!encryptedData) throw new Error('AES 解密数据不能为空')
    const keyUtf8 = CryptoJS.enc.Utf8.parse(key)
    const result = CryptoJS.AES.decrypt(encryptedData, keyUtf8, {
      mode: CryptoJS.mode.ECB,
      padding: CryptoJS.pad.Pkcs7,
    }).toString(CryptoJS.enc.Utf8)
    if (!result) {
      throw new Error('AES 解密结果为空，可能是密钥错误或数据损坏')
    }
    return result
  }
}
/** RSA 加密工具类（jsencrypt 仅支持 PKCS1v1.5） */
export class RSA {
  static encrypt(data: string, publicKey: string): string | false {
    if (!publicKey) throw new Error('RSA 公钥不能为空')
    const encryptor = new JSEncrypt()
    encryptor.setPublicKey(publicKey)
    const result = encryptor.encrypt(data)
    if (result === false) {
      throw new Error('RSA 加密失败，可能是公钥格式错误或数据过长')
    }
    return result
  }
  static decrypt(encryptedData: string, privateKey: string): string | false {
    if (!privateKey) throw new Error('RSA 私钥不能为空')
    if (!encryptedData) throw new Error('RSA 解密数据不能为空')
    const encryptor = new JSEncrypt()
    encryptor.setPrivateKey(privateKey)
    const result = encryptor.decrypt(encryptedData)
    if (result === false) {
      throw new Error('RSA 解密失败，可能是私钥错误或数据损坏')
    }
    return result
  }
}
/** 生成会话对称密钥（32 个 ASCII 字符） */
export function generateSessionKey(length = 32): string {
  const n = SESSION_KEY_ALPHABET.length
  const limit = Math.floor(256 / n) * n
  let out = ''
  while (out.length < length) {
    const words = CryptoJS.lib.WordArray.random(length)
    for (let i = 0; i < length && out.length < length; i++) {
      const b = (words.words[i >>> 2] as number) >>> (24 - (i % 4) * 8) & 0xff
      if (b < limit) out += SESSION_KEY_ALPHABET[b % n]
    }
  }
  return out
}
/** 生成会话标识 */
export function generateSessionId(): string {
  return `${Date.now().toString(36)}-${generateSessionKey(16)}`
}
/**
 * 生成新会话密钥并把 RSA 密文暂存，等待下一个加密请求带出去
 */
export function prepareSession(): void {
  if (!API_ENCRYPT_ENABLE) return
  if (!RSA_PUBLIC_KEY) {
    console.error('[security] VITE_APP_RSA_PUBLIC_KEY 未配置，无法协商会话密钥')
    return
  }
  currentSessionId = generateSessionId()
  currentSessionKey = generateSessionKey()
  const wrapped = RSA.encrypt(currentSessionKey, RSA_PUBLIC_KEY)
  if (wrapped === false) {
    throw new Error('会话密钥包裹失败')
  }
  pendingWrappedKey = wrapped
}
/** API 加解密主类（静态风格，保持与旧调用点兼容） */
export class ApiEncrypt {
  static getEncryptHeader(): string {
    return API_ENCRYPT_HEADER
  }
  static getSessionId(): string {
    return currentSessionId
  }
  static hasSession(): boolean {
    return Boolean(currentSessionId && currentSessionKey)
  }
  /** 取出待发送的 RSA 密文（取一次即清空） */
  static takePendingWrappedKey(): string {
    const v = pendingWrappedKey
    pendingWrappedKey = ''
    return v
  }
  static clearSession(): void {
    currentSessionId = ''
    currentSessionKey = ''
    pendingWrappedKey = ''
  }
  /** 关键：必须已协商出会话密钥才算启用 */
  static isEnabled(): boolean {
    return API_ENCRYPT_ENABLE && Boolean(currentSessionKey)
  }
  static encryptRequest(data: any): string {
    if (!ApiEncrypt.isEnabled()) return data
    const jsonData = typeof data === 'string' ? data : JSON.stringify(data)
    if (API_ENCRYPT_ALGORITHM.toUpperCase() === 'AES') {
      return AES.encrypt(jsonData, currentSessionKey)
    }
    const result = RSA.encrypt(jsonData, currentSessionKey)
    if (result === false) throw new Error('RSA 加密失败')
    return result
  }
  static decryptResponse(encryptedData: string): any {
    if (!API_ENCRYPT_ENABLE) return encryptedData
    if (!currentSessionKey) {
      throw new Error('会话密钥缺失，无法解密响应')
    }
    let decryptedData: string | false = ''
    if (API_ENCRYPT_ALGORITHM.toUpperCase() === 'AES') {
      decryptedData = AES.decrypt(encryptedData, currentSessionKey)
    } else {
      decryptedData = RSA.decrypt(encryptedData, currentSessionKey)
      if (decryptedData === false) throw new Error('RSA 解密失败')
    }
    if (!decryptedData) throw new Error('解密结果为空')
    try {
      return JSON.parse(decryptedData)
    } catch {
      return decryptedData
    }
  }
}

3.3 M3 src/http/interceptor.ts — 挂会话头

把原第 78–91 行的加密分支替换为：

    // 5. API 加密（会话密钥）
    if (options.isEncrypt) {
      try {
        const sessionId = ApiEncrypt.getSessionId()
        if (sessionId) {
          options.header['X-Session-Id'] = sessionId
        }
        const wrapped = ApiEncrypt.takePendingWrappedKey()
        if (wrapped) {
          options.header['X-Session-Key'] = wrapped
        }
        if (options.data && ApiEncrypt.isEnabled()) {
          options.data = ApiEncrypt.encryptRequest(options.data)
          options.header[ApiEncrypt.getEncryptHeader()] = 'true'
        }
      } catch (error) {
        console.error('请求数据加密失败:', error)
        throw error
      }
    }

3.4 M4 src/api/login.ts — 登录前协商

import { ApiEncrypt, prepareSession } from '@/utils/encrypt'
export function login(data: IAuthLoginReq) {
  // ★ 登录前生成会话密钥；RSA 密文由本次登录请求带出
  prepareSession()
  // ★ 必须显式带 isEncrypt，否则密码明文进 body
  return http.post<IAuthLoginRes>('/system/auth/login', data, null, null, { isEncrypt: true })
}