@polyv/request-plugin-sm2 2.0.0

package/README.md

@@ -0,0 +1,77 @@
+# SM2RequestPlugin
+
+用途：SM2 加密插件，用于对请求和响应数据进行国密 SM2 加密和解密处理。
+
+## 实例化参数
+
+| 参数名 | 用途 | 类型 | 默认值 |
+| - | - | - | - |
+| `platformPublicKey` | 平台公钥（接口提交参数加密用） | `string` | - |
+| `userPrivateKey` | 用户私钥（接口响应内容解密用） | `string` | - |
+| `includeIgnoreEncryptFields` | 额外的忽略加密字段 | `string[]` | - |
+| `useSM2` | 是否使用 SM2 加密 | `boolean` | `true` |
+| `encryptPostSM2` | 是否对 POST 请求主体进行 SM2 加密 | `boolean` | `true` |
+
+## 请求选项
+
+| 参数名 | 用途 | 类型 | 默认值 |
+| - | - | - | - |
+| `useSM2` | 是否使用 SM2 加密 | `boolean` | `true` |
+| `encryptPostSM2` | 是否对 POST 请求主体进行 SM2 加密 | `boolean` | `true` |
+
+## 使用方式
+
+```js
+import { PolyvRequest } from '@polyv/request-core';
+import { SM2RequestPlugin } from '@polyv/request-plugin-sm2';
+
+// 基础用法：提供平台公钥和用户私钥
+const requester = new PolyvRequest({
+  requestPlugins: [
+    new SM2RequestPlugin({
+      platformPublicKey: 'yourPlatformPublicKey',
+      userPrivateKey: 'yourUserPrivateKey',
+    }),
+  ]
+});
+
+// 配置额外的忽略加密字段
+const requester = new PolyvRequest({
+  requestPlugins: [
+    new SM2RequestPlugin({
+      platformPublicKey: 'yourPlatformPublicKey',
+      userPrivateKey: 'yourUserPrivateKey',
+      includeIgnoreEncryptFields: ['customField1', 'customField2'],
+    }),
+  ]
+});
+// 此时请求时，被忽略的字段不会加入到加密内容中
+requester.post('/api/data', {
+  customField1: 'abc',
+}, {
+  params: {
+    customField2: 'def',
+  }
+});
+
+// 禁用 POST 请求主体加密
+const requester = new PolyvRequest({
+  requestPlugins: [
+    new SM2RequestPlugin({
+      platformPublicKey: 'yourPlatformPublicKey',
+      userPrivateKey: 'yourUserPrivateKey',
+      encryptPostSM2: false,
+    }),
+  ]
+});
+
+// 在某个请求中禁用 SM2 加密
+requester.get('/api/data', {}, {
+  useSM2: false,
+});
+
+// 在某个请求中禁用 POST 请求主体加密
+requester.post('/api/data', { name: 'test' }, {
+  encryptPostSM2: false,
+});
+```

package/config.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 忽略的加密字段
+ */
+export declare const defaultIgnoreEncryptFields: string[];
+/**
+ * @ignore
+ */
+export declare const INTERNAL_SM2_PUBLIC_KEY: string;
+/**
+ * @ignore
+ */
+export declare const INTERNAL_SM2_PRIVATE_KEY: string;

package/config.js

@@ -0,0 +1,17 @@
+import { decode } from 'js-base64';
+/**
+ * 忽略的加密字段
+ */
+export const defaultIgnoreEncryptFields = ['appId', 'signatureMethod', 'signatureNonce', 'timestamp', 'viewerToken', 'sign', 'encryptResponseType'];
+/**
+ * @ignore
+ */
+// 内部的加密公钥：045B8155E9747C283ACF842895D3048E6CA943CC454AFA6A9A452B5903CC30FCE278A6F88F602EDF803DAB40BD45E35F660676BF68FD7CCBE0F6AD32388136CD0D
+// 如果接口 params 中没带 appId 参数的，则使用该私钥进行解密
+export const INTERNAL_SM2_PUBLIC_KEY = decode('MDQ1QjgxNTVFOTc0N0MyODNBQ0Y4NDI4OTVEMzA0OEU2Q0E5NDNDQzQ1NEFGQTZBOUE0NTJCNTkwM0NDMzBGQ0UyNzhBNkY4OEY2MDJFREY4MDNEQUI0MEJENDVFMzVGNjYwNjc2QkY2OEZEN0NDQkUwRjZBRDMyMzg4MTM2Q0QwRA==');
+/**
+ * @ignore
+ */
+// 内部的解密私钥：00B319618B4B1BAEB8CC6765D8903C05A0B16D9D9FCD163271BB6F1B88F657A28E
+// 如果接口 params 中没带 appId 参数的，则使用该私钥进行解密
+export const INTERNAL_SM2_PRIVATE_KEY = decode('MDBCMzE5NjE4QjRCMUJBRUI4Q0M2NzY1RDg5MDNDMDVBMEIxNkQ5RDlGQ0QxNjMyNzFCQjZGMUI4OEY2NTdBMjhF');

package/index.d.ts

@@ -0,0 +1,4 @@
+export * from './sm2-plugin';
+export * from './types';
+export * from './utils';
+export * from './request-options';

package/index.js

@@ -0,0 +1,4 @@
+export * from './sm2-plugin';
+export * from './types';
+export * from './utils';
+export * from './request-options';

package/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@polyv/request-plugin-sm2",
+  "version": "2.0.0",
+  "main": "./index.js",
+  "dependencies": {
+    "@polyv/request-core": "2.0.0",
+    "sm-crypto": "^0.3.7",
+    "js-base64": "^3.7.5"
+  },
+  "types": "./index.d.ts"
+}

package/request-options.d.ts

@@ -0,0 +1,22 @@
+export interface SM2RequestOptions {
+    /**
+     * 是否使用 sm2 加密
+     * @default true
+     * @plugin `SM2RequestPlugin`
+     */
+    useSM2?: boolean;
+    /**
+     * 是否对 post 请求主体进行 sm2 加密
+     * @default true
+     * @plugin `SM2RequestPlugin`
+     */
+    encryptPostSM2?: boolean;
+}
+declare module '@polyv/request-core' {
+    interface RequestCustomOptions extends SM2RequestOptions {
+    }
+}
+declare module 'axios' {
+    interface AxiosRequestConfig extends SM2RequestOptions {
+    }
+}

package/request-options.js

@@ -0,0 +1 @@
+export {};

package/sm2-plugin.d.ts

@@ -0,0 +1,63 @@
+import type { RequestOptions, RequestPlugin, RequestResult } from '@polyv/request-core';
+import { SM2RequestPluginConfig } from './types';
+/**
+ * SM2 请求插件
+ */
+export declare class SM2RequestPlugin implements RequestPlugin {
+    /** 公钥（加密用） */
+    private __platformPublicKey;
+    /** 私钥（解密用） */
+    private __userPrivateKey;
+    /** 忽略加密的字段 */
+    private __ignoreEncryptFields;
+    private __useSM2;
+    private __encryptPostSM2;
+    constructor(config: SM2RequestPluginConfig);
+    usePlugin(options: RequestOptions): boolean;
+    interceptIncludeParams(): object | void;
+    interceptEncryptRequest(options: RequestOptions): RequestOptions;
+    interceptDecryptResponse(result: RequestResult, options: RequestOptions): RequestResult;
+    /**
+     * 处理 headers
+     * @param options 请求选项
+     */
+    private __handleHeaders;
+    /**
+     * 处理 params
+     * @param options 请求选项
+     */
+    private __handleParams;
+    /**
+     * 处理 data
+     * @param options 请求选项
+     */
+    private __handleData;
+    /**
+     * 加密 sm2 对象
+     * @param targetObj 处理对象
+     * @param options 请求选项
+     * @param encryptedField 密文字段
+     */
+    private __encryptObjectSM2;
+    /**
+     * 加密 sm2 文本
+     * @param targetText 需要加密的字符串
+     * @param options 请求选项
+     * @returns 加密后的密文
+     */
+    private __encryptTextSM2;
+    /**
+     * 解密 sm2 文本
+     * @param encryptedText 加密密文
+     */
+    private __decryptTextSM2;
+    /**
+     * 获取解密的私钥
+     * @param options 请求选项
+     */
+    private __getPrivateKey;
+    /**
+     * 获取加密的公钥
+     */
+    private __getPublicKey;
+}

package/sm2-plugin.js

@@ -0,0 +1,205 @@
+import { sm2 } from 'sm-crypto';
+import { defaultIgnoreEncryptFields, INTERNAL_SM2_PRIVATE_KEY, INTERNAL_SM2_PUBLIC_KEY } from './config';
+import { SM2EncryptMode } from './types';
+import { padding04 } from './utils';
+// 1. 插件会在请求中自动添加 `encryptResponseType: 2` 参数，告知服务端需要返回 SM2 加密数据
+// 2. 对于 POST 请求，默认会对请求体进行 SM2 加密，并添加 `x-e-type: 2` 请求头
+// 3. 在加密请求参数时，会自动分离需要加密和不需要加密的字段：
+//    - 默认忽略的字段: `appId`, `signatureMethod`, `signatureNonce`, `timestamp`, `viewerToken`, `sign`, `encryptResponseType`
+//    - 可以通过 `includeIgnoreEncryptFields` 配置额外的忽略加密字段
+// 4. 加密后的字段会被重新组织：
+//    - 对 POST 请求的 URL 参数，加密内容会放在 `xurlparam` 字段中
+//    - 对 POST 请求的 body 数据（requetType 为 json），加密内容会作为请求提提交
+//    - 对 POST 请求的 body 数据（requetType 为 form），加密内容会放在 `xparam` 字段中
+// 5. 当服务端返回加密数据时（`encryption: true`），插件会自动对响应数据进行解密
+// 6. 如果请求中包含 `appId` 参数，将使用配置的公钥和私钥；否则使用内部的默认密钥 
+/**
+ * SM2 请求插件
+ */
+export class SM2RequestPlugin {
+    /** 公钥（加密用） */
+    __platformPublicKey;
+    /** 私钥（解密用） */
+    __userPrivateKey;
+    /** 忽略加密的字段 */
+    __ignoreEncryptFields;
+    __useSM2;
+    __encryptPostSM2;
+    constructor(config) {
+        this.__platformPublicKey = config.platformPublicKey;
+        this.__userPrivateKey = config.userPrivateKey;
+        this.__ignoreEncryptFields = [...defaultIgnoreEncryptFields];
+        if (config.includeIgnoreEncryptFields) {
+            this.__ignoreEncryptFields.push(...config.includeIgnoreEncryptFields);
+        }
+        this.__useSM2 = config.useSM2 ?? true;
+        this.__encryptPostSM2 = config.encryptPostSM2 ?? true;
+    }
+    usePlugin(options) {
+        const { useSM2 = this.__useSM2 } = options;
+        return useSM2;
+    }
+    interceptIncludeParams() {
+        return {
+            // 插入 encryptResponseType 为 2，表示需要进行 sm2 加密
+            encryptResponseType: 2,
+        };
+    }
+    interceptEncryptRequest(options) {
+        // 处理 params
+        const params = this.__handleParams(options);
+        // 处理 data
+        const data = this.__handleData(options);
+        // 处理 header
+        const headers = this.__handleHeaders(options);
+        return {
+            ...options,
+            params,
+            data,
+            headers,
+        };
+    }
+    interceptDecryptResponse(result, options) {
+        const res = result.data;
+        if (!res.encryption || typeof res.data !== 'string') {
+            return result;
+        }
+        const data = res.data;
+        res.data = this.__decryptTextSM2(data, options);
+        return result;
+    }
+    /**
+     * 处理 headers
+     * @param options 请求选项
+     */
+    __handleHeaders(options) {
+        const headers = (options.headers || {});
+        const { encryptPostSM2 = this.__encryptPostSM2 } = options;
+        if (options.method?.toLocaleUpperCase() === 'POST' && encryptPostSM2) {
+            headers['x-e-type'] = 2;
+        }
+        return headers;
+    }
+    /**
+     * 处理 params
+     * @param options 请求选项
+     */
+    __handleParams(options) {
+        const { encryptPostSM2 = this.__encryptPostSM2 } = options;
+        const params = (options.params || {});
+        if (options.method?.toLocaleUpperCase() !== 'POST' || !encryptPostSM2) {
+            return params;
+        }
+        return this.__encryptObjectSM2(params, options, 'xurlparam');
+    }
+    /**
+     * 处理 data
+     * @param options 请求选项
+     */
+    __handleData(options) {
+        const data = options.data || {};
+        if (options.method?.toLocaleUpperCase() !== 'POST') {
+            return data;
+        }
+        let newData = data;
+        const { encryptPostSM2 = this.__encryptPostSM2 } = options;
+        if (encryptPostSM2) {
+            if (typeof data === 'string') {
+                newData = this.__encryptTextSM2(data, options);
+            }
+            else if (options.requestType === 'json') {
+                // 如果明确使用 json 为 content-type，则直接把密文作为请求体
+                newData = this.__encryptTextSM2(JSON.stringify(options.data || {}), options);
+            }
+            else {
+                // 其他情况，则把密文放在 xparam 字段中进行提交
+                newData = this.__encryptObjectSM2(data, options, 'xparam');
+            }
+        }
+        return newData;
+    }
+    /**
+     * 加密 sm2 对象
+     * @param targetObj 处理对象
+     * @param options 请求选项
+     * @param encryptedField 密文字段
+     */
+    __encryptObjectSM2(targetObj, options, encryptedField) {
+        const keys = Object.keys(targetObj);
+        if (keys.length === 0)
+            return targetObj;
+        // 忽略参数
+        const ignoreObj = {};
+        // 业务参数
+        const businessObj = {};
+        keys.forEach((item) => {
+            if (this.__ignoreEncryptFields.includes(item)) {
+                ignoreObj[item] = targetObj[item];
+            }
+            else {
+                businessObj[item] = targetObj[item];
+            }
+        });
+        // 重新构建的对象
+        const newObj = {
+            ...ignoreObj,
+        };
+        // 注入密文字段
+        if (Object.keys(businessObj).length) {
+            const encryptedText = this.__encryptTextSM2(JSON.stringify(businessObj), options);
+            newObj[encryptedField] = encryptedText;
+        }
+        return newObj;
+    }
+    /**
+     * 加密 sm2 文本
+     * @param targetText 需要加密的字符串
+     * @param options 请求选项
+     * @returns 加密后的密文
+     */
+    __encryptTextSM2(targetText, options) {
+        const publicKey = this.__getPublicKey(options);
+        return padding04(sm2.doEncrypt(targetText, publicKey, SM2EncryptMode.C1C2C3), true);
+    }
+    /**
+     * 解密 sm2 文本
+     * @param encryptedText 加密密文
+     */
+    __decryptTextSM2(encryptedText, options) {
+        const privateKey = this.__getPrivateKey(options);
+        let decryptedText = '';
+        try {
+            decryptedText = sm2.doDecrypt(padding04(encryptedText, false), privateKey, SM2EncryptMode.C1C2C3);
+        }
+        catch (e) {
+            console.error('decryptTextSM2 decrypt error', e, { encryptedText });
+        }
+        let res = decryptedText;
+        try {
+            res = JSON.parse(res);
+        }
+        catch (e) { }
+        return res;
+    }
+    /**
+     * 获取解密的私钥
+     * @param options 请求选项
+     */
+    __getPrivateKey(options) {
+        const params = options.params || {};
+        if ('appId' in params) {
+            return this.__userPrivateKey;
+        }
+        return INTERNAL_SM2_PRIVATE_KEY;
+    }
+    /**
+     * 获取加密的公钥
+     */
+    __getPublicKey(options) {
+        const params = options.params || {};
+        if ('appId' in params) {
+            return this.__platformPublicKey;
+        }
+        return INTERNAL_SM2_PUBLIC_KEY;
+    }
+}

package/types.d.ts

@@ -0,0 +1,37 @@
+export interface SM2RequestPluginConfig {
+    /**
+     * 平台公钥（接口提交参数加密用）
+     */
+    platformPublicKey: string;
+    /**
+     * 用户私钥（接口响应内容解密用）
+     */
+    userPrivateKey: string;
+    /**
+     * 加入忽略加密字段
+     */
+    includeIgnoreEncryptFields?: string[];
+    /**
+     * 是否使用 sm2
+     * @default true
+     */
+    useSM2?: boolean;
+    /**
+     * 是否对 post 请求主体进行 sm2 加密
+     * @default true
+     */
+    encryptPostSM2?: boolean;
+}
+/**
+ * SM2加密模式
+ */
+export declare enum SM2EncryptMode {
+    /** C1C3C2 */
+    C1C3C2 = 1,
+    /** C1C2C3顺序 */
+    C1C2C3 = 0
+}
+export interface SM2InnerResData {
+    encryption: boolean;
+    data: unknown;
+}

package/types.js

@@ -0,0 +1,10 @@
+/**
+ * SM2加密模式
+ */
+export var SM2EncryptMode;
+(function (SM2EncryptMode) {
+    /** C1C3C2 */
+    SM2EncryptMode[SM2EncryptMode["C1C3C2"] = 1] = "C1C3C2";
+    /** C1C2C3顺序 */
+    SM2EncryptMode[SM2EncryptMode["C1C2C3"] = 0] = "C1C2C3";
+})(SM2EncryptMode || (SM2EncryptMode = {}));

package/utils.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 控制是否开头填充04
+ * 注意:
+ * 1.前端sm-crypto加密后密文需要在开头补充04再传给后端 (https://juejin.cn/post/7084038026971578398)
+ * 2.后端加密密文已有添加04，前端sm-crypto解密时默认在开头再补充添加04，需要将后端密文手动剔除04
+ * @param encryptedText 密文
+ * @param isNeed 是否需要开头04
+ * @returns
+ */
+export declare function padding04(encryptedText: string, isNeed: boolean): string;

package/utils.js

@@ -0,0 +1,19 @@
+/**
+ * 控制是否开头填充04
+ * 注意:
+ * 1.前端sm-crypto加密后密文需要在开头补充04再传给后端 (https://juejin.cn/post/7084038026971578398)
+ * 2.后端加密密文已有添加04，前端sm-crypto解密时默认在开头再补充添加04，需要将后端密文手动剔除04
+ * @param encryptedText 密文
+ * @param isNeed 是否需要开头04
+ * @returns
+ */
+export function padding04(encryptedText, isNeed) {
+    const hasPadding = /^04/.test(encryptedText);
+    if (hasPadding && !isNeed) {
+        return encryptedText.substring(2);
+    }
+    if (!hasPadding && isNeed) {
+        return `04${encryptedText}`;
+    }
+    return encryptedText;
+}