@polyv/request-plugin-aes-decrypt 2.0.0

package/README.md

@@ -0,0 +1,113 @@
+# AESDecryptRequestPlugin
+
+用途：AES 解密插件，用于对服务端返回的加密数据进行解密处理。
+
+## 实例化参数
+
+| 参数名 | 用途 | 类型 | 默认值 |
+| - | - | - | - |
+| `decryptKeys` | 解密密钥信息 | `AESKeyInfo` | - |
+| `decryptPosition` | 解密位置 | `AESDecryptPosition` | `AESDecryptPosition.ResponseData` |
+| `getDecryptInfo` | 获取解密信息的方法 | `function` | - |
+
+## 请求选项
+
+| 参数名 | 用途 | 类型 | 默认值 |
+| - | - | - | - |
+| `useAESDecrypt` | 是否使用 AES 解密 | `boolean` | `false` |
+| `aesDecryptInfo` | AES 解密信息 | `AESDecryptInfo` | - |
+
+## 解密密钥信息类型
+
+`AESKeyInfo` 类型如下：
+
+| 参数名 | 用途 | 类型 | 默认值 |
+| - | - | - | - |
+| `sign` | 解密签名（密钥） | `string` | - |
+| `iv` | 解密偏移量 | `string` | - |
+
+## 解密位置枚举
+
+`AESDecryptPosition` 枚举如下：
+
+| 枚举值 | 描述 |
+| - | - |
+| `AESDecryptPosition.WholeResponse` | 解密整个响应数据 |
+| `AESDecryptPosition.ResponseData` | 仅解密响应中的 data 字段 |
+
+## 使用方式
+
+```js
+import { PolyvRequest } from '@polyv/request-core';
+import { 
+  AESDecryptRequestPlugin, 
+  AESDecryptPosition
+} from '@polyv/request-plugin-aes-decrypt';
+
+// 基础用法：使用固定的解密密钥
+const requester = new PolyvRequest({
+  requestPlugins: [
+    new AESDecryptRequestPlugin({
+      decryptKeys: {
+        sign: 'yourDecryptKey',
+        iv: 'yourDecryptIV',
+      },
+    }),
+  ]
+});
+
+// 配置解密位置
+const requester = new PolyvRequest({
+  requestPlugins: [
+    new AESDecryptRequestPlugin({
+      decryptKeys: {
+        sign: 'yourDecryptKey',
+        iv: 'yourDecryptIV',
+      },
+      decryptPosition: AESDecryptPosition.WholeResponse,
+    }),
+  ]
+});
+
+// 使用 getDecryptInfo 方法动态获取解密信息
+const requester = new PolyvRequest({
+  requestPlugins: [
+    new AESDecryptRequestPlugin({
+      getDecryptInfo: async (options) => {
+        // 可以根据 options 中的信息动态获取解密密钥
+        return {
+          decryptKeys: {
+            sign: 'dynamicDecryptKey',
+            iv: 'dynamicDecryptIV',
+          },
+          decryptPosition: AESDecryptPosition.ResponseData,
+        };
+      },
+    }),
+  ]
+});
+
+// 在某个请求中启用 AES 解密
+requester.get('/api/data', {}, {
+  useAESDecrypt: true,
+});
+
+// 在某个请求中使用特定的解密信息
+requester.get('/api/data', {}, {
+  useAESDecrypt: true,
+  aesDecryptInfo: {
+    decryptKeys: {
+      sign: 'specificKey',
+      iv: 'specificIV',
+    },
+    decryptPosition: AESDecryptPosition.WholeResponse,
+  },
+});
+```
+
+## 解密处理逻辑
+
+1. 插件默认不启用，需要在请求选项中设置 `useAESDecrypt: true` 或全局配置启用
+2. 解密信息的优先级为：请求选项中的 `aesDecryptInfo` > `getDecryptInfo` 方法返回的信息 > 初始化时提供的配置
+3. 根据 `decryptPosition` 的设置，可以选择解密整个响应数据或只解密响应中的 data 字段
+4. 解密后，如果解密结果是有效的 JSON 字符串，会自动解析为 JavaScript 对象 

package/aes-decrypt-plugin.d.ts

@@ -0,0 +1,12 @@
+import type { RequestOptions, RequestPlugin, RequestResult } from '@polyv/request-core';
+import { AESDecryptRequestPluginConfig } from './types';
+/**
+ * aes 解密请求插件
+ */
+export declare class AESDecryptRequestPlugin implements RequestPlugin {
+    private __config;
+    constructor(config?: AESDecryptRequestPluginConfig);
+    usePlugin(options: RequestOptions): boolean;
+    interceptDecryptResponse(result: RequestResult, options: RequestOptions): Promise<RequestResult>;
+    private __getDecryptInfo;
+}

package/aes-decrypt-plugin.js

@@ -0,0 +1,57 @@
+import { AESDecryptPosition, AESDecryptType } from './types';
+import { decryptTextAES } from './utils';
+/**
+ * aes 解密请求插件
+ */
+export class AESDecryptRequestPlugin {
+    __config;
+    constructor(config = {}) {
+        this.__config = config;
+    }
+    usePlugin(options) {
+        const { useAESDecrypt = false } = options;
+        return useAESDecrypt;
+    }
+    async interceptDecryptResponse(result, options) {
+        const decryptInfo = await this.__getDecryptInfo(options);
+        if (!decryptInfo || !decryptInfo.decryptKeys) {
+            return result;
+        }
+        let newResultData = result.data;
+        const decryptPosition = decryptInfo.decryptPosition || AESDecryptPosition.ResponseData;
+        // 整个 response 解密
+        if (decryptPosition === AESDecryptPosition.WholeResponse && typeof result.data === 'string') {
+            newResultData = decryptTextAES(result.data, decryptInfo.decryptKeys, AESDecryptType.Hex);
+        }
+        // response.data 解密
+        if (decryptPosition === AESDecryptPosition.ResponseData && typeof result.data === 'object' && result.data) {
+            const res = result.data;
+            if (typeof res.data === 'string') {
+                const decryptedData = decryptTextAES(res.data, decryptInfo.decryptKeys, AESDecryptType.Hex);
+                newResultData = {
+                    ...newResultData,
+                    data: decryptedData,
+                };
+            }
+        }
+        return {
+            ...result,
+            data: newResultData,
+        };
+    }
+    async __getDecryptInfo(options) {
+        let info = {
+            ...this.__config,
+        };
+        if (typeof this.__config.getDecryptInfo === 'function') {
+            // 第二优先：实例化参数的 getDecryptInfo
+            const res = await this.__config.getDecryptInfo(options) || {};
+            info = { ...info, ...res };
+        }
+        if (options.aesDecryptInfo) {
+            // 第一优先：请求选项
+            info = { ...info, ...options.aesDecryptInfo };
+        }
+        return info;
+    }
+}

package/index.d.ts

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

package/index.js

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

package/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@polyv/request-plugin-aes-decrypt",
+  "version": "2.0.0",
+  "main": "./index.js",
+  "dependencies": {
+    "@polyv/request-core": "2.0.0",
+    "aes-js": "^3.1.2",
+    "crypto-js": "^4.1.1",
+    "js-base64": "^3.7.5"
+  },
+  "types": "./index.d.ts"
+}

package/request-options.d.ts

@@ -0,0 +1,22 @@
+import { AESDecryptInfo } from './types';
+export interface AESDecryptRequestOptions {
+    /**
+     * 使用 aes 解密 data
+     * @default false
+     * @plugin `AESDecryptRequestPlugin`
+     */
+    useAESDecrypt?: boolean;
+    /**
+     * aes 解密信息
+     * @plugin `AESDecryptRequestPlugin`
+     */
+    aesDecryptInfo?: AESDecryptInfo;
+}
+declare module '@polyv/request-core' {
+    interface RequestCustomOptions extends AESDecryptRequestOptions {
+    }
+}
+declare module 'axios' {
+    interface AxiosRequestConfig extends AESDecryptRequestOptions {
+    }
+}

package/request-options.js

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

package/types.d.ts

@@ -0,0 +1,55 @@
+import type { RequestOptions } from '@polyv/request-core';
+export interface AESDecryptRequestPluginConfig extends AESDecryptInfo {
+    /**
+     * 获取解密信息
+     */
+    getDecryptInfo?: GetDecryptInfoFn;
+}
+export type GetDecryptInfoFn = (options: RequestOptions) => Promise<AESDecryptInfo | void> | AESDecryptInfo | void;
+/**
+ * aes 解密位置
+ */
+export declare enum AESDecryptPosition {
+    /**
+     * 整个 response 数据解密
+     */
+    WholeResponse = "wholeResponse",
+    /**
+     * 仅 response 中的 data 解密
+     */
+    ResponseData = "responseData"
+}
+/**
+ * AES 解密编码方式
+ */
+export declare enum AESDecryptType {
+    Hex = "hex",
+    Base64 = "base64"
+}
+/**
+ * AES 解密/加密密钥信息
+ */
+export interface AESKeyInfo {
+    /**
+     * 签名
+     */
+    sign: string;
+    /**
+     * 偏移量
+     */
+    iv: string;
+}
+/**
+ * 解密信息
+ */
+export interface AESDecryptInfo {
+    /**
+     * 解密 key 信息
+     */
+    decryptKeys?: AESKeyInfo;
+    /**
+     * 解密位置
+     * @default AESDecryptPosition.ResponseData
+     */
+    decryptPosition?: AESDecryptPosition;
+}

package/types.js

@@ -0,0 +1,22 @@
+/**
+ * aes 解密位置
+ */
+export var AESDecryptPosition;
+(function (AESDecryptPosition) {
+    /**
+     * 整个 response 数据解密
+     */
+    AESDecryptPosition["WholeResponse"] = "wholeResponse";
+    /**
+     * 仅 response 中的 data 解密
+     */
+    AESDecryptPosition["ResponseData"] = "responseData";
+})(AESDecryptPosition || (AESDecryptPosition = {}));
+/**
+ * AES 解密编码方式
+ */
+export var AESDecryptType;
+(function (AESDecryptType) {
+    AESDecryptType["Hex"] = "hex";
+    AESDecryptType["Base64"] = "base64";
+})(AESDecryptType || (AESDecryptType = {}));

package/utils.d.ts

@@ -0,0 +1,25 @@
+import { AESDecryptType, AESKeyInfo } from './types';
+/**
+ * 解密数据（hex 方式）
+ * @param encryptedText 加密内容
+ * @param decryptKeys 解密 key 信息
+ * @param decryptType 解密类型
+ * @returns 返回解密后的明文数据
+ */
+export declare function decryptTextAES(encryptedText: string, decryptKeys: AESKeyInfo, decryptType: AESDecryptType): unknown;
+/**
+ * 解密数据（hex 方式）
+ * @param encryptedText 加密内容
+ * @param sign 解密签名
+ * @param customIV 解密偏移量
+ * @returns 返回解密后的明文
+ */
+export declare function decryptTextBase64(encryptedText: string, sign: string, customIV: string): string;
+/**
+ * 解密数据（hex 方式）
+ * @param encryptedText 加密内容
+ * @param sign 解密签名
+ * @param customIV 解密偏移量
+ * @returns 返回解密后的明文
+ */
+export declare function decryptTextHex(encryptedText: string, sign: string, customIV: string): string;

package/utils.js

@@ -0,0 +1,83 @@
+import aesjs from 'aes-js';
+import CryptoJS from 'crypto-js';
+import { Base64 } from 'js-base64';
+import { AESDecryptType } from './types';
+/**
+ * 获取解密所需要的密钥
+ * @param str 密钥所需数据
+ * @param len 字节数
+ * @returns 返回128位（16字节）密钥
+ */
+const str2ab = (str, len) => {
+    const bytes = aesjs.utils.utf8.toBytes(str);
+    const bytesLen = bytes.length;
+    if (bytesLen >= len) {
+        return bytes.slice(0, len);
+    }
+    return ([].concat(...(new Array(Math.ceil(len / bytesLen)).fill(bytes)))).slice(0, len);
+};
+/**
+ * 解密数据（hex 方式）
+ * @param encryptedText 加密内容
+ * @param decryptKeys 解密 key 信息
+ * @param decryptType 解密类型
+ * @returns 返回解密后的明文数据
+ */
+export function decryptTextAES(encryptedText, decryptKeys, decryptType) {
+    const { sign, iv } = decryptKeys;
+    let decryptedText = '';
+    try {
+        if (decryptType === AESDecryptType.Hex) {
+            decryptedText = decryptTextHex(encryptedText, sign, iv);
+        }
+        else {
+            decryptedText = decryptTextBase64(encryptedText, sign, iv);
+        }
+    }
+    catch (e) {
+        console.error('decryptTextAES decrypt error', e, { encryptedText, decryptKeys, decryptType });
+    }
+    let res = decryptedText;
+    try {
+        res = JSON.parse(res);
+    }
+    catch (e) { }
+    return res;
+}
+/**
+ * 解密数据（hex 方式）
+ * @param encryptedText 加密内容
+ * @param sign 解密签名
+ * @param customIV 解密偏移量
+ * @returns 返回解密后的明文
+ */
+export function decryptTextBase64(encryptedText, sign, customIV) {
+    const cryptoKey = CryptoJS.enc.Utf8.parse(sign);
+    const cfg = {};
+    cfg.iv = CryptoJS.enc.Utf8.parse(customIV);
+    cfg.mode = CryptoJS.mode.CBC;
+    cfg.pad = CryptoJS.pad.Pkcs7;
+    const crypto = CryptoJS.AES;
+    const cj = crypto.decrypt(encryptedText, cryptoKey, cfg);
+    return cj.toString(CryptoJS.enc.Utf8);
+}
+/**
+ * 解密数据（hex 方式）
+ * @param encryptedText 加密内容
+ * @param sign 解密签名
+ * @param customIV 解密偏移量
+ * @returns 返回解密后的明文
+ */
+export function decryptTextHex(encryptedText, sign, customIV) {
+    const encryptedBytes = aesjs.utils.hex.toBytes(encryptedText);
+    const key = str2ab(sign, 16);
+    let iv = key;
+    if (customIV) {
+        iv = str2ab(customIV, 16);
+    }
+    // eslint-disable-next-line
+    const aesCfb = new aesjs.ModeOfOperation.cbc(key, iv);
+    const decryptedBytes = aesCfb.decrypt(encryptedBytes);
+    const decryptedText = aesjs.utils.utf8.fromBytes(decryptedBytes);
+    return Base64.decode(decryptedText);
+}