@pubinfo/module-crypto 2.1.1

package/dist/interface.d.ts

@@ -0,0 +1,18 @@
+import { RequestInstance } from 'pubinfo';
+export interface CryptoOptions {
+    /**
+     * 接口请求实例
+     */
+    request: InternalContext['request'];
+    cryptoSetting: cryptoInternal;
+}
+export interface cryptoInternal {
+    name: string;
+    encrypt: (text: string) => Promise<string>;
+    decrypt: (text: string) => Promise<string>;
+    header?: Record<string, string>;
+}
+export interface InternalContext {
+    request: RequestInstance;
+}
+export { RequestInstance };

package/dist/pages/enum.d.ts

@@ -0,0 +1,7 @@
+export declare enum ACTION {
+    ADD = "\u65B0\u589E",
+    EDIT = "\u7F16\u8F91",
+    REMOVE = "\u5220\u9664",
+    ENABLE = "\u542F\u7528",
+    DISABLE = "\u505C\u7528"
+}

package/dist/setting-2FfcqVsW.js

@@ -0,0 +1,267 @@
+import { Form as G, FormItem as J, Switch as Q, CheckableTag as q, Space as H, Button as K } from "ant-design-vue/es";
+import { useAuth as X, PubinfoIcon as Y } from "pubinfo";
+import { QuestionCircleOutlined as Z, PlusCircleOutlined as ee } from "@ant-design/icons-vue";
+import { defineComponent as te, ref as k, reactive as oe, onMounted as se, resolveDirective as ae, createElementBlock as E, openBlock as u, createElementVNode as d, createVNode as a, withCtx as l, unref as s, normalizeClass as V, createTextVNode as h, createBlock as P, createCommentVNode as re, withDirectives as D, toDisplayString as L } from "vue";
+import { ProTable as ne } from "@pubinfo/pro-components";
+import { message as ie, Modal as le } from "ant-design-vue";
+import { g as ce, p as de, c as B } from "./index.js";
+import { u as pe, _ as fe } from "./drawerCryptoUrl.vue_vue_type_script_setup_true_lang-CztdWly1.js";
+import './setting.css';var n = /* @__PURE__ */ ((r) => (r.ADD = "新增", r.EDIT = "编辑", r.REMOVE = "删除", r.ENABLE = "启用", r.DISABLE = "停用", r))(n || {});
+const ue = {
+  "w-full": "",
+  "h-full": "",
+  "pt-10px": "",
+  "px-10px": "",
+  "overflow-auto": ""
+}, me = {
+  "h-full": "",
+  "min-w-1130px": ""
+}, _e = { class: "pt-20px pl-20px h-161px flex flex-col bg-[#ffffff] box-border bg-[url('@/assets/images/crypto-setting-bg.png')] bg-cover text-[#4e5969] dark:text-[#C9CDD4]" }, he = { class: "flex items-center" }, ye = { class: "p-5px bg-[#f2f3f5] rounded-5px flex items-center" }, xe = { class: "flex items-center ml-15px text-[#a3a4a8]" }, be = { class: "h-[calc(100%-165px)]" }, Ce = ["onClick"], ge = { class: "ml-4px" }, ve = ["onClick"], we = { class: "ml-4px" }, ke = /* @__PURE__ */ te({
+  __name: "setting",
+  setup(r) {
+    const y = k(), p = k(), f = k(), x = { style: { width: "auto" } }, O = { span: 24 }, { auth: T } = X(), o = oe({
+      isCrypto: !0,
+      mode: !0,
+      whiteListUrls: []
+    }), [i, b] = pe(!1);
+    se(I);
+    async function I() {
+      await ce().then((t) => {
+        b(!1), t && t.data && t.success && (o.isCrypto = t.data.cryptoEnabled || !1, o.whiteListUrls = t.data.cryptoWhitePath, o.mode = t.data.cryptoMode === void 0 ? !0 : t.data.cryptoMode);
+      });
+    }
+    function R(t, e) {
+      e && (o.mode = t, C());
+    }
+    async function C() {
+      if (!i.value) {
+        b(!0);
+        try {
+          await p.value?.validate();
+          const {
+            isCrypto: t,
+            mode: e,
+            whiteListUrls: v
+          } = o, m = {
+            cryptoEnabled: t,
+            cryptoMode: e,
+            cryptoWhitePath: v
+          }, { success: _ } = await de({ json: JSON.stringify(m) });
+          _ && (ie.success("配置更改成功"), B.callAsync({ ...B.use(), isCrypto: o.isCrypto, cryptoMode: o.mode, whiteListUrls: o.whiteListUrls }, () => {
+            I();
+          }));
+        } catch {
+          b(!1);
+        }
+      }
+    }
+    const A = [
+      {
+        minWidth: 60,
+        hideInTable: !1,
+        title: "url地址",
+        dataIndex: "url"
+      },
+      {
+        hideInSearch: !0,
+        minWidth: 200,
+        title: "描述",
+        dataIndex: "description",
+        ellipsis: !0
+      },
+      {
+        hideInSearch: !0,
+        title: "操作",
+        dataIndex: "action",
+        width: 200,
+        fixed: "right",
+        hideInTable() {
+          return !T([
+            "crypto_url_add",
+            "crypto_url_edit",
+            "crypto_url_delete"
+          ]);
+        }
+      }
+    ];
+    function g(t, e) {
+      if (!i.value)
+        switch (t) {
+          case n.ADD:
+            f.value.open(!1, o.whiteListUrls);
+            break;
+          case n.EDIT:
+            f.value.open(!0, o.whiteListUrls, e);
+            break;
+          case n.REMOVE:
+            W(o.whiteListUrls || [], e || 0);
+            break;
+        }
+    }
+    function W(t, e) {
+      le.confirm({
+        title: "删除",
+        content: "确定要删除该条数据吗？",
+        async onOk() {
+          t.splice(e, 1), U(t);
+        }
+      });
+    }
+    function U(t) {
+      o.whiteListUrls = t, C();
+    }
+    return (t, e) => {
+      const v = Q, m = J, _ = q, $ = G, F = ee, N = K, M = Y, j = H, w = ae("auth");
+      return u(), E("div", ue, [
+        d("div", me, [
+          d("div", _e, [
+            a($, {
+              ref_key: "formRef",
+              ref: p,
+              model: o,
+              "label-col": x,
+              "wrapper-col": O,
+              class: "safe-rule-form"
+            }, {
+              default: l(() => [
+                a(m, {
+                  label: "开启加密",
+                  name: "isCrypto"
+                }, {
+                  default: l(() => [
+                    a(v, {
+                      checked: o.isCrypto,
+                      "onUpdate:checked": e[0] || (e[0] = (c) => o.isCrypto = c),
+                      disabled: s(i),
+                      onChange: C
+                    }, null, 8, ["checked", "disabled"])
+                  ]),
+                  _: 1
+                }),
+                a(m, {
+                  label: "模式",
+                  name: "isCrypto"
+                }, {
+                  default: l(() => [
+                    d("div", he, [
+                      d("div", ye, [
+                        a(_, {
+                          checked: o.mode,
+                          disabled: s(i),
+                          class: V(s(i) ? "cursor-not-allowed!" : ""),
+                          onChange: e[1] || (e[1] = (c) => !s(i) && R(!0, c))
+                        }, {
+                          default: l(() => e[4] || (e[4] = [
+                            h(" 白名单 ")
+                          ])),
+                          _: 1,
+                          __: [4]
+                        }, 8, ["checked", "disabled", "class"]),
+                        a(_, {
+                          checked: !o.mode,
+                          class: V(["mr-0px!", s(i) ? "cursor-not-allowed!" : ""]),
+                          onChange: e[2] || (e[2] = (c) => !s(i) && R(!1, c))
+                        }, {
+                          default: l(() => e[5] || (e[5] = [
+                            h(" 黑名单 ")
+                          ])),
+                          _: 1,
+                          __: [5]
+                        }, 8, ["checked", "class"])
+                      ]),
+                      d("div", xe, [
+                        a(s(Z), { class: "mr-5px" }),
+                        e[6] || (e[6] = h("白名单模式下，仅不加密过滤列表中的接口；黑名单模式下，仅加密过滤列表中的接口。 "))
+                      ])
+                    ])
+                  ]),
+                  _: 1
+                })
+              ]),
+              _: 1
+            }, 8, ["model"])
+          ]),
+          d("div", be, [
+            a(s(ne), {
+              ref_key: "tableRef",
+              ref: y,
+              "row-key": "id",
+              "data-source": o.whiteListUrls,
+              columns: A,
+              "auto-height": "",
+              search: !1,
+              pagination: !1,
+              scroll: { x: 1e3 }
+            }, {
+              toolbar: l(() => [
+                D((u(), P(N, {
+                  type: "primary",
+                  disabled: s(i),
+                  onClick: e[3] || (e[3] = (c) => g(s(n).ADD))
+                }, {
+                  default: l(() => [
+                    a(F),
+                    h(" " + L(s(n).ADD), 1)
+                  ]),
+                  _: 1
+                }, 8, ["disabled"])), [
+                  [w, "crypto_url_add"]
+                ])
+              ]),
+              bodyCell: l(({ column: c, index: S }) => [
+                c.dataIndex === "action" ? (u(), P(j, { key: 0 }, {
+                  default: l(() => [
+                    D((u(), E("a", {
+                      class: "flex items-center hover:opacity-80",
+                      onClick: (z) => g(s(n).EDIT, S)
+                    }, [
+                      a(M, {
+                        name: "edit",
+                        class: "text-base"
+                      }),
+                      d("span", ge, L(s(n).EDIT), 1)
+                    ], 8, Ce)), [
+                      [w, "crypto_url_edit"]
+                    ]),
+                    D((u(), E("span", {
+                      flex: "",
+                      "items-center": "",
+                      "text-red-500": "",
+                      "hover:cursor-pointer": "",
+                      "hover:text-red-500": "",
+                      "hover:opacity-80": "",
+                      onClick: (z) => g(s(n).REMOVE, S)
+                    }, [
+                      a(M, {
+                        name: "remove",
+                        class: "text-base"
+                      }),
+                      d("span", we, L(s(n).REMOVE), 1)
+                    ], 8, ve)), [
+                      [w, "crypto_url_delete"]
+                    ])
+                  ]),
+                  _: 2
+                }, 1024)) : re("", !0)
+              ]),
+              _: 1
+            }, 8, ["data-source"])
+          ])
+        ]),
+        a(fe, {
+          ref_key: "drawerRef",
+          ref: f,
+          onSubmit: U
+        }, null, 512)
+      ]);
+    };
+  }
+}), Ee = (r, y) => {
+  const p = r.__vccOpts || r;
+  for (const [f, x] of y)
+    p[f] = x;
+  return p;
+}, Pe = /* @__PURE__ */ Ee(ke, [["__scopeId", "data-v-89197708"]]);
+export {
+  Pe as default
+};

package/dist/setting.css

@@ -0,0 +1 @@
+.safe-rule-form .ant-input[data-v-89197708],.safe-rule-form .ant-select[data-v-89197708]{width:90%}.safe-rule-form[data-v-89197708] .ant-tag-checkable-checked{background:#fff;color:#1677ff;font-size:13px}.safe-rule-form[data-v-89197708] .ant-tag-checkable{font-size:13px}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@pubinfo/module-crypto",
+  "type": "module",
+  "version": "2.1.1",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./style.css": "./dist/index.css"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "peerDependencies": {
+    "@ant-design/icons-vue": "^7.0.1",
+    "@pubinfo/pro-components": "^1.8.0",
+    "ant-design-vue": "^4.2.6",
+    "pubinfo": "2.1.1"
+  },
+  "dependencies": {
+    "@vueuse/core": "^13.7.0",
+    "crypto-js": "^4.2.0",
+    "gm-crypto": "^0.1.12",
+    "jsencrypt": "^3.3.2"
+  },
+  "devDependencies": {
+    "@ant-design/icons-vue": "^7.0.1",
+    "@pubinfo/pro-components": "^1.8.0",
+    "@types/crypto-js": "^4.2.2",
+    "ant-design-vue": "^4.2.6",
+    "pubinfo": "2.1.1"
+  },
+  "scripts": {
+    "dev": "pubinfo build -w --sourcemap",
+    "build": "pubinfo build",
+    "openapi": "pnpx @pubinfo/openapi generate",
+    "test": "vitest"
+  }
+}

package/src/api/modules/crypto/index.ts

@@ -0,0 +1 @@
+export * from './pubSysConfigController';

package/src/api/modules/crypto/pubSysConfigController.ts

@@ -0,0 +1,52 @@
+import { basic as request } from '@/api/request';
+
+/**
+ * @description 编辑加解密配置
+ * @url /crypto/editCryptoConfig
+ * @method POST
+ * @author @pubinfo/openapi
+ */
+export function postCryptoEditCryptoConfig<
+  R = API.ResponseDataBoolean,
+  T = API.ResponseDataBoolean,
+>(
+  body: API.EditCryptoConfigDto,
+  options?: Parameters<typeof request.Post<R, T>>[2],
+) {
+  return request.Post<R, T>('/crypto/editCryptoConfig', body, {
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    ...(options || {}),
+  });
+}
+
+/**
+ * @description 获取加解密配置
+ * @url /crypto/getCryptoConfig
+ * @method GET
+ * @author @pubinfo/openapi
+ */
+export function getCryptoGetCryptoConfig<
+  R = API.ResponseDataCryptoConfig,
+  T = API.ResponseDataCryptoConfig,
+>(options?: Parameters<typeof request.Get<R, T>>[1]) {
+  return request.Get<R, T>('/crypto/getCryptoConfig', {
+    ...(options || {}),
+  });
+}
+
+/**
+ * @description 获取公钥及加解密配置
+ * @url /crypto/getPublicKeyAndConfig
+ * @method GET
+ * @author @pubinfo/openapi
+ */
+export function getCryptoGetPublicKeyAndConfig<
+  R = API.ResponseDataCryptoConfigExt,
+  T = API.ResponseDataCryptoConfigExt,
+>(options?: Parameters<typeof request.Get<R, T>>[1]) {
+  return request.Get<R, T>('/crypto/getPublicKeyAndConfig', {
+    ...(options || {}),
+  });
+}

package/src/api/modules/crypto/typings.d.ts

@@ -0,0 +1,49 @@
+/* eslint-disable */
+// @ts-nocheck
+declare namespace API {
+  type CryptoConfig = {
+    cryptoEnabled?: boolean;
+    cryptoMode?: boolean;
+    cryptoWhitePath?: UrlEntry[];
+  };
+
+  type CryptoConfigExt = {
+    cryptoEnabled?: boolean;
+    cryptoMode?: boolean;
+    cryptoWhitePath?: UrlEntry[];
+    publicKey?: string;
+  };
+
+  type EditCryptoConfigDto = {
+    json?: string;
+  };
+
+  type ResponseDataBoolean = {
+    code?: number;
+    msg?: string;
+    hint?: string;
+    data?: boolean;
+    success?: boolean;
+  };
+
+  type ResponseDataCryptoConfig = {
+    code?: number;
+    msg?: string;
+    hint?: string;
+    data?: CryptoConfig;
+    success?: boolean;
+  };
+
+  type ResponseDataCryptoConfigExt = {
+    code?: number;
+    msg?: string;
+    hint?: string;
+    data?: CryptoConfigExt;
+    success?: boolean;
+  };
+
+  type UrlEntry = {
+    url?: string;
+    description?: string;
+  };
+}

package/src/api/request.ts

@@ -0,0 +1,4 @@
+import { wrapProxy } from 'pubinfo';
+import { apictx } from '@/apiContext';
+
+export const basic = wrapProxy(apictx.use, 'request');

package/src/apiContext.ts

@@ -0,0 +1,4 @@
+import type { InternalContext } from './interface';
+import { createContext } from 'pubinfo';
+
+export const apictx = createContext<InternalContext>('crypto-api');

package/src/context.ts

@@ -0,0 +1,12 @@
+import type { cryptoInternal } from './interface';
+import { createContext } from 'pubinfo';
+
+export const ctx = createContext<{
+  isCrypto: boolean
+  cryptoSetting: cryptoInternal
+  whiteListUrls?: API.UrlEntry[]
+  publicKey?: string
+  key?: string
+  cryptoMode: boolean
+  iv?: string
+}>('crypto');

package/src/cryptoAlg/aes.ts

@@ -0,0 +1,52 @@
+import type { cryptoInternal } from '@/interface';
+import CryptoJS from 'crypto-js';
+import { ctx } from '../context';
+
+// aes加密
+export function aesEncrypt(plainText: string): Promise<string> {
+  return new Promise((resolve) => {
+    const AES_KEY = ctx.use().key || 'chartext12345677';
+    const encrypted = CryptoJS.AES.encrypt(
+      plainText,
+      CryptoJS.enc.Utf8.parse(AES_KEY),
+      {
+        mode: CryptoJS.mode.ECB,
+        padding: CryptoJS.pad.Pkcs7,
+      },
+    );
+    resolve(encrypted.toString().replaceAll(/\+/g, '-').replaceAll(/\//g, '_').replaceAll(/=/g, ''));
+  });
+}
+
+// aes解密
+export function aesDecrypt(cipherText: string): Promise<string> {
+  return new Promise((resolve) => {
+    const AES_KEY = ctx.use().key || 'chartext12345677';
+    let cipherTextC = cipherText.replaceAll(/-/g, '+').replaceAll(/_/g, '/');
+    while (cipherTextC.length % 4) {
+      cipherTextC += '=';
+    }
+    const decrypted = CryptoJS.AES.decrypt(
+      cipherTextC,
+      CryptoJS.enc.Utf8.parse(AES_KEY),
+      {
+        mode: CryptoJS.mode.ECB,
+        padding: CryptoJS.pad.Pkcs7,
+      },
+    );
+    try {
+      resolve(JSON.parse(decrypted.toString(CryptoJS.enc.Utf8)));
+    }
+    catch (e) {
+      resolve(decrypted.toString(CryptoJS.enc.Utf8));
+    }
+  });
+}
+
+export function setupAes(): cryptoInternal {
+  return {
+    name: 'aes',
+    encrypt: aesEncrypt,
+    decrypt: aesDecrypt,
+  };
+}

package/src/cryptoAlg/rsa.ts

@@ -0,0 +1,13 @@
+import JSEncrypt from 'jsencrypt';
+import { ctx } from '../context';
+
+// rsa加密
+export function rsaEncrypt(plainText: string): Promise<string> {
+  return new Promise((resolve) => {
+    const KEY = ctx.use().publicKey;
+    const encrypt = new JSEncrypt();
+    encrypt.setPublicKey(`-----BEGIN PUBLIC KEY-----\n${KEY}\n-----END PUBLIC KEY-----`);
+
+    resolve(KEY ? (encrypt.encrypt(plainText) || '') : plainText);
+  });
+}

package/src/cryptoAlg/sm4-cbc.ts

@@ -0,0 +1,49 @@
+import type { cryptoInternal } from '@/interface';
+import { SM4 } from 'gm-crypto';
+import { ctx } from '../context';
+
+// sm4加密
+export function sm4CBCEncrypt(plainText: string): Promise<string> {
+  return new Promise((resolve) => {
+    const KEY = ctx.use().key || '0123456789abcdeffedcba9876543210';
+    const iv = ctx.use().iv || '0123456789abcdeffedcba9876543210';
+    const encryptedData = SM4.encrypt(plainText, KEY.toLowerCase(), {
+      iv,
+      mode: SM4.constants.CBC,
+      inputEncoding: 'utf8',
+      outputEncoding: 'base64',
+    });
+    resolve(encryptedData.replaceAll(/\+/g, '-').replaceAll(/\//g, '_').replaceAll(/=/g, ''));
+  });
+}
+
+// sm4解密
+export function sm4CBCDecrypt(cipherText: string): Promise<string> {
+  return new Promise((resolve) => {
+    const KEY = ctx.use().key || '0123456789abcdeffedcba9876543210';
+    const iv = ctx.use().iv || '0123456789abcdeffedcba9876543210';
+    let cipherTextC = cipherText.replaceAll(/-/g, '+').replaceAll(/_/g, '/');
+    while (cipherTextC.length % 4) {
+      cipherTextC += '=';
+    }
+    const decryptedData = SM4.decrypt(cipherTextC, KEY.toLowerCase(), {
+      iv,
+      mode: SM4.constants.CBC,
+      inputEncoding: 'base64',
+      outputEncoding: 'utf8',
+    });
+    try {
+      resolve(JSON.parse(decryptedData));
+    }
+    catch (e) {
+      resolve(decryptedData);
+    }
+  });
+}
+export function setupSm4Cbc(): cryptoInternal {
+  return {
+    name: 'sm4-cbc',
+    encrypt: sm4CBCEncrypt,
+    decrypt: sm4CBCDecrypt,
+  };
+}

package/src/cryptoAlg/sm4-ecb.ts

@@ -0,0 +1,46 @@
+import type { cryptoInternal } from '@/interface';
+import { SM4 } from 'gm-crypto';
+import { ctx } from '../context';
+
+// sm4加密
+export function sm4ECBEncrypt(plainText: string): Promise<string> {
+  return new Promise((resolve) => {
+    const KEY = ctx.use().key || '0123456789abcdeffedcba9876543210';
+    const encryptedData = SM4.encrypt(plainText, KEY.toLowerCase(), {
+      mode: SM4.constants.ECB,
+      inputEncoding: 'utf8',
+      outputEncoding: 'base64',
+    });
+    resolve(encryptedData.replaceAll(/\+/g, '-').replaceAll(/\//g, '_').replaceAll(/=/g, ''));
+  });
+}
+
+// sm4解密
+export function sm4ECBDecrypt(cipherText: string): Promise<string> {
+  return new Promise((resolve) => {
+    const KEY = ctx.use().key || '0123456789abcdeffedcba9876543210';
+    let cipherTextC = cipherText.replaceAll(/-/g, '+').replaceAll(/_/g, '/');
+    while (cipherTextC.length % 4) {
+      cipherTextC += '=';
+    }
+    const decryptedData = SM4.decrypt(cipherTextC, KEY.toLowerCase(), {
+      mode: SM4.constants.ECB,
+      inputEncoding: 'base64',
+      outputEncoding: 'utf8',
+    });
+    try {
+      resolve(JSON.parse(decryptedData));
+    }
+    catch (e) {
+      resolve(decryptedData);
+    }
+  });
+}
+
+export function setupSm4Ecb(): cryptoInternal {
+  return {
+    name: 'sm4-ecb',
+    encrypt: sm4ECBEncrypt,
+    decrypt: sm4ECBDecrypt,
+  };
+}