@tmsfe/tms-core 0.0.154 → 0.0.156

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tmsfe/tms-core",
-  "version": "0.0.154",
+  "version": "0.0.156",
   "description": "tms运行时框架",
   "repository": {
     "type": "git",

package/src/encrypt/encrypt-util.ts

@@ -74,12 +74,7 @@ const baseUtil = {
     }
     return '';
   },
-  getClientEncryptOpen: (): boolean => {
-    if (wx.$_encryptEnvInfo) {
-      return wx.$_encryptEnvInfo.requestEncryptOpen;
-    }
-    return false;
-  },
+  getClientEncryptOpen: (): boolean => wx.$_encryptEnvInfo?.requestEncryptOpen,
   BaseRespFac: class BaseRespFac<T> implements BaseResp<T> {
     success: boolean;
     msg: string;
@@ -92,12 +87,12 @@ const baseUtil = {
     }
   },
 };
-let composeParamsFunc = null;
+let composeParamsFunc = null; // 请求参数处理函数，加密初始化调用后之后会赋值
 // 加密工具
 const eccUtil = {
   _refreshPromise: null,
   _refreshPubKeyInfo: async (forceRefresh: boolean): Promise<boolean> => {
-    // 未完成初始化或者关闭秘钥刷新能力，则不支持秘钥刷新
+    // 未完成初始化，则不支持秘钥刷新
     if (!composeParamsFunc) {
       return false;
     }
@@ -147,12 +142,13 @@ const eccUtil = {
       const keyPair = ecc.box.keyPair();  // 生成客户端公钥私钥
       eccUtil._privateKeyInfo = {
         serverPubId: serverPubInfo.pubId,                       // 服务端公钥id
-        sharedByte: ecc.box.before(baseUtil.decUrl(serverPubInfo.pubKey), keyPair.secretKey),
+        sharedByte: ecc.box.before(baseUtil.decUrl(serverPubInfo.pubKey), keyPair.secretKey),  // 共享秘钥
         clientPublicKey: baseUtil.encUrl(keyPair.publicKey),    // base64 url safe 编码后的客户端公钥
       };
     }
     return eccUtil._privateKeyInfo;
   },
+  // 解析gwCode
   resolveGwCode: async (codeStr: string): Promise<{ retry: boolean, success: boolean }> => {
     if (!codeStr) return { retry: false, success: true };
     const code = parseInt(codeStr, 10);
@@ -227,9 +223,9 @@ const eccUtil = {
 // 加密规则判断工具
 const cryptRuleUtil = {
   // 远程加密服务是否开启
-  _isServerOpen: (): boolean => !!wx.$_publicKey,
+  isServerOpen: (): boolean => !!wx.$_publicKey,
   // 检查path是否符合下发的路由前缀
-  _pathInEnablePrefix: (path: string): boolean => {
+  pathInEnablePrefix: (path: string): boolean => {
     if (!wx.$_publicKey) {
       return false;
     }
@@ -246,7 +242,7 @@ const cryptRuleUtil = {
     return false;
   },
   // 判断是否是性能埋点上报接口
-  _isPerformanceReport: (path: string, params: any): boolean => {
+  isPerformanceReport: (path: string, params: any): boolean => {
     // 如果是日志上报接口，需要过滤性能日志，不需要加密
     if (path.indexOf('basic/event/upload') > -1) {
       if (params.batch?.length === 1 && params.batch[0]?.[31] === 'tms-performance-log') {
@@ -265,7 +261,7 @@ const cryptRuleUtil = {
       '^/tde', '^/basic/crypto/lastkey',
     ],
   },
-  _isHostValid: (url) => {
+  isHostValid: (url) => {
     // 使用正则表达式解析URL
     const urlPattern = /^(https?:\/\/)?([^/?#]+)([/?#].*)?$/;
     const matches = url.match(urlPattern);
@@ -301,19 +297,19 @@ const isCryptoRuleMath = (path: string, reqData: any): BaseResp<boolean> => {
     return new baseUtil.BaseRespFac(false, false, '本地加密未开启');
   }
   // 如果服务端下发的加密开关关闭，不走加密
-  if (!cryptRuleUtil._isServerOpen()) {
+  if (!cryptRuleUtil.isServerOpen()) {
     return new baseUtil.BaseRespFac(false, false, '服务端加密未开启');
   }
   // 请求路由不满足服务端下发的加密规则，不走加密
-  if (!cryptRuleUtil._pathInEnablePrefix(path)) {
+  if (!cryptRuleUtil.pathInEnablePrefix(path)) {
     return new baseUtil.BaseRespFac(false, false, '未命中服务端加密规则');
   }
   // 请求接口是加密性能埋点上报接口，不加密
-  if (cryptRuleUtil._isPerformanceReport(path, reqData)) {
+  if (cryptRuleUtil.isPerformanceReport(path, reqData)) {
     return new baseUtil.BaseRespFac(false, false, '性能埋点');
   }
   // 请求路由不走sinan网关，不加密
-  if (!cryptRuleUtil._isHostValid(path)) {
+  if (!cryptRuleUtil.isHostValid(path)) {
     return new baseUtil.BaseRespFac(false, false, '非sinan网关加密接口');
   }
   return new baseUtil.BaseRespFac(true);;
@@ -431,7 +427,7 @@ const dealEncryptionSwitch = async (path: string, resHeader): Promise<void> => {
   } else if (formatHeader['x-crypto-enable'] === '1') {
     `${baseUtil.getSinanHost()}/user/login` === path && eccUtil._updateGlobalPublicKeyInfo(false, formatHeader);
     await eccUtil.openCrypto();
-  } // 0是关闭，2是开启, 1是保持
+  } // 0是关闭，1是开启, 2是保持
   dealEncryptionSwitching = false;
 };
 

package/src/encrypt/index.ts

@@ -1,12 +1,6 @@
 import encryptUtil from './encrypt-util';
 import { genTraceparent } from './traceUtils';
 
-interface Params {
-  filePath?: string,
-  name?: string,
-  data?: any,
-}
-
 const logger = wx.getLogManager({});
 const util = {
   // 统一格式化日志输出
@@ -22,20 +16,14 @@ const util = {
     return args;
   },
   logInfo: (...args) => {
-    console.log(...args);
+    args.unshift('request_encrypt_log');
     const items = util.formatLog(args);
+    console.log(...items);
     logger.log(...items);
   },
   reportFunc: (...args) => {
     util.logInfo('reportFunc init fail:', ...args);
   },
-  // 判断是否需要加密
-  needsEncryption: (path: string, reqData: Params): Boolean => {
-    // 小程序构建环境的加密开关关闭，不走加密
-    if (!wx.$_encryptEnvInfo.requestEncryptOpen) return false;
-    const isCryptoRuleMathRes = encryptUtil.isCryptoRuleMath(path, reqData);
-    return isCryptoRuleMathRes.res;
-  },
   reqEncrypt: (obj: { url: string, method: string, data: any, header: any }): {
     data: any, header: any, msg: string, cryptoKeyInfo?: any } => {
     const { url, method, data, header = {} } = obj;
@@ -52,16 +40,24 @@ const util = {
     return Object.assign({ msg }, reqEncryptRes.res);
   },
 };
-
+let originalRequestApi;
+let originalUploadFileApi;
 // 劫持wx.request和wx.uploadFile函数
-const requestInit = () => {
+const requestInit = (utilFunc) => {
   if (!wx.request.cryptoFlag) {
-    wx._request = wx.request;
+    originalRequestApi = wx.request;
+    // 初始化参数加签函数和性能上报函数
+    const { report, composeParamsFunc } = utilFunc;
+    encryptUtil.init(composeParamsFunc);
+    util.reportFunc = (...args) => {
+      util.logInfo(...args);
+      report('request_encrypt_log', ...args);
+    };
     proxyWxRequest();
     wx.request.cryptoFlag = true;
   }
   if (!wx.uploadFile.cryptoFlag) {
-    wx._uploadFile = wx.uploadFile;
+    originalUploadFileApi = wx.uploadFile;
     proxyWxUploadFile();
     wx.uploadFile.cryptoFlag = true;
   }
@@ -75,42 +71,47 @@ function proxyWxRequest(): void {
     value(options: any) {
       const { url, method, data, header = {}, success, fail, complete, dataType, responseType } = options;
       const traceparent = genTraceparent();
+      const originalOptions = { ...options };
+
       // 如果用户自定义了dataType或者responseType，则不做处理
       if (dataType || responseType) {
         util.reportFunc(url, traceparent, '用户自定义了dataType和responseType');
-        wx._request.call(this, Object.assign(options, {
+        originalRequestApi.call(this, {
+          ...originalOptions,
           success: (res) => {
             encryptUtil.dealEncryptionSwitch(url, res.header);
             success?.call(this, res);
           },
           header: { ...header, Traceparent: traceparent },
-        }));
+        });
         return;
       }
       // 加密请求数据
-      const { data: formatData, header: formatHeader, msg, cryptoKeyInfo } = util
-        .reqEncrypt({ url, method, data, header });
+      const { data: formatData, header: formatHeader, msg, cryptoKeyInfo } = util.reqEncrypt({ url, method, data, header });
       if (!cryptoKeyInfo) {
         // 如果没有加密信息，则不走加密
         util.logInfo(url, traceparent, msg);
-        wx._request.call(this, Object.assign(options, {
+        originalRequestApi.call(this, {
+          ...originalOptions,
           success: (res) => {
             encryptUtil.dealEncryptionSwitch(url, res.header);
             success?.call(this, res);
           },
           header: { ...header, Traceparent: traceparent },
-        }));
+        });
         return;
       }
+
       let completeResolver;
-      // eslint-disable-next-line
       const completePromp = new Promise(resolve => { completeResolver = resolve; });
-      wx._request.call(this, Object.assign(options, {
+
+      originalRequestApi.call(this, {
+        ...originalOptions,
         data: formatData,
+        header: { ...formatHeader, Traceparent: traceparent },
         dataType: '其他',
         responseType: 'arraybuffer',
         success: async (result) => {
-          // 解密响应
           const { header: resHeader, data: resData } = result;
           const { success: resSuccess, msg, res } = await encryptUtil.resDecrypt(resHeader, resData, cryptoKeyInfo);
           if (resSuccess) {
@@ -122,13 +123,14 @@ function proxyWxRequest(): void {
             complete?.call(this, completeRes);
           } else {
             util.reportFunc(url, traceparent, `解密失败：${msg}`);
-            wx._request.call(this, Object.assign(options, {
+            originalRequestApi.call(this, {
+              ...originalOptions,
               success: (res) => {
                 encryptUtil.dealEncryptionSwitch(url, res.header);
                 success?.call(this, res);
               },
-              header: { ...header, Traceparent: traceparent },
-            }));
+              header: { ...header, Traceparent: genTraceparent() },
+            });
           }
         },
         fail: async (err) => {
@@ -139,8 +141,7 @@ function proxyWxRequest(): void {
         complete: (res) => {
           completeResolver(res);
         },
-        header: { ...formatHeader, Traceparent: traceparent },
-      }));
+      });
     },
   });
 }
@@ -151,7 +152,7 @@ function proxyWxUploadFile(): void {
     enumerable: true,
     configurable: true,
     value(options: any) {
-      wx._uploadFile.call(this, Object.assign(options, {
+      originalUploadFileApi.call(this, Object.assign(options, {
         header: { ...options.header, Traceparent: genTraceparent() },
       }));
     },
@@ -162,14 +163,7 @@ export const encryptObjInit = (utilFunc: {
   composeParamsFunc: Function,
   report: Function,
 }) => {
-  // 初始化参数加签函数和性能上报函数
-  const { report, composeParamsFunc } = utilFunc;
-  encryptUtil.init(composeParamsFunc);
-  util.reportFunc = (...args) => {
-    util.logInfo('request_encrypt_log', ...args);
-    report('request_encrypt_log', ...args);
-  };
   // 劫持wx.request和wx.uploadFile函数
-  requestInit();
+  requestInit(utilFunc);
 };
 

package/src/index.js

@@ -151,6 +151,7 @@ const init = (options = {}) => {
 
   Request.defaultHost = defaultHost;
   Request.defaultSecretKey = secretKey;
+  Request.encryptInit(secretKey);
   // 初始化云环境
   wx.cloud.init({ env: cloudEnvId });
 };

package/src/request.js

@@ -16,12 +16,6 @@ import reporter from './report/index';
 
 const logger = wx.getLogManager({});
 
-// 加密模块初始化
-encryptObjInit({
-  composeParamsFunc: data => composeParam(data, true, {}),
-  report: (...args) => reporter.reportPerformance(...args),
-});
-
 /**
  * 用于序列化需要签名的参数
  * @private
@@ -165,6 +159,17 @@ export default class Request {
    */
   static defaultSecretKey = '';
 
+  static encryptInit(secretKey) {
+    // 加密模块初始化
+    encryptObjInit({
+      composeParamsFunc: async (data) => {
+        const params = await composeParam(data, true, {});
+        return sign(params, secretKey);
+      },
+      report: (...args) => reporter.reportPerformance(...args),
+    });
+  }
+
   static getInstance() {
     if (reqInstance === null) {
       reqInstance = new Request();