module-develop-kit 1.4.1 → 1.4.3

package/dist/vendor/gm-crypt/src/sm4.js

@@ -0,0 +1,513 @@
+import { __require as B } from "./crypt.js";
+var b, k;
+function w() {
+  if (k) return b;
+  k = 1;
+  const h = B(), l = 16, y = Uint8Array.from([
+    214,
+    144,
+    233,
+    254,
+    204,
+    225,
+    61,
+    183,
+    22,
+    182,
+    20,
+    194,
+    40,
+    251,
+    44,
+    5,
+    43,
+    103,
+    154,
+    118,
+    42,
+    190,
+    4,
+    195,
+    170,
+    68,
+    19,
+    38,
+    73,
+    134,
+    6,
+    153,
+    156,
+    66,
+    80,
+    244,
+    145,
+    239,
+    152,
+    122,
+    51,
+    84,
+    11,
+    67,
+    237,
+    207,
+    172,
+    98,
+    228,
+    179,
+    28,
+    169,
+    201,
+    8,
+    232,
+    149,
+    128,
+    223,
+    148,
+    250,
+    117,
+    143,
+    63,
+    166,
+    71,
+    7,
+    167,
+    252,
+    243,
+    115,
+    23,
+    186,
+    131,
+    89,
+    60,
+    25,
+    230,
+    133,
+    79,
+    168,
+    104,
+    107,
+    129,
+    178,
+    113,
+    100,
+    218,
+    139,
+    248,
+    235,
+    15,
+    75,
+    112,
+    86,
+    157,
+    53,
+    30,
+    36,
+    14,
+    94,
+    99,
+    88,
+    209,
+    162,
+    37,
+    34,
+    124,
+    59,
+    1,
+    33,
+    120,
+    135,
+    212,
+    0,
+    70,
+    87,
+    159,
+    211,
+    39,
+    82,
+    76,
+    54,
+    2,
+    231,
+    160,
+    196,
+    200,
+    158,
+    234,
+    191,
+    138,
+    210,
+    64,
+    199,
+    56,
+    181,
+    163,
+    247,
+    242,
+    206,
+    249,
+    97,
+    21,
+    161,
+    224,
+    174,
+    93,
+    164,
+    155,
+    52,
+    26,
+    85,
+    173,
+    147,
+    50,
+    48,
+    245,
+    140,
+    177,
+    227,
+    29,
+    246,
+    226,
+    46,
+    130,
+    102,
+    202,
+    96,
+    192,
+    41,
+    35,
+    171,
+    13,
+    83,
+    78,
+    111,
+    213,
+    219,
+    55,
+    69,
+    222,
+    253,
+    142,
+    47,
+    3,
+    255,
+    106,
+    114,
+    109,
+    108,
+    91,
+    81,
+    141,
+    27,
+    175,
+    146,
+    187,
+    221,
+    188,
+    127,
+    17,
+    217,
+    92,
+    65,
+    31,
+    16,
+    90,
+    216,
+    10,
+    193,
+    49,
+    136,
+    165,
+    205,
+    123,
+    189,
+    45,
+    116,
+    208,
+    18,
+    184,
+    229,
+    180,
+    176,
+    137,
+    105,
+    151,
+    74,
+    12,
+    150,
+    119,
+    126,
+    101,
+    185,
+    241,
+    9,
+    197,
+    110,
+    198,
+    132,
+    24,
+    240,
+    125,
+    236,
+    58,
+    220,
+    77,
+    32,
+    121,
+    238,
+    95,
+    62,
+    215,
+    203,
+    57,
+    72
+  ]), p = Uint32Array.from([
+    462357,
+    472066609,
+    943670861,
+    1415275113,
+    1886879365,
+    2358483617,
+    2830087869,
+    3301692121,
+    3773296373,
+    4228057617,
+    404694573,
+    876298825,
+    1347903077,
+    1819507329,
+    2291111581,
+    2762715833,
+    3234320085,
+    3705924337,
+    4177462797,
+    337322537,
+    808926789,
+    1280531041,
+    1752135293,
+    2223739545,
+    2695343797,
+    3166948049,
+    3638552301,
+    4110090761,
+    269950501,
+    741554753,
+    1213159005,
+    1684763257
+  ]), u = Uint32Array.from([
+    2746333894,
+    1453994832,
+    1736282519,
+    2993693404
+  ]);
+  class T {
+    /**
+     * Creates an instance of SM4.
+     * @param {Object} config
+     * @memberof SM4
+     */
+    constructor(x) {
+      let e = h.stringToArrayBufferInUtf8(x.key);
+      if (e.length !== 16)
+        throw new Error("key should be a 16 bytes string");
+      this.key = e;
+      let t = new Uint8Array(0);
+      if (x.iv !== void 0 && x.iv !== null && (t = h.stringToArrayBufferInUtf8(x.iv), t.length !== 16))
+        throw new Error("iv should be a 16 bytes string");
+      this.iv = t, this.mode = "cbc", ["cbc", "ecb"].indexOf(x.mode) >= 0 && (this.mode = x.mode), this.cipherType = "base64", ["base64", "text"].indexOf(x.outType) >= 0 && (this.cipherType = x.outType), this.encryptRoundKeys = new Uint32Array(32), this.spawnEncryptRoundKeys(), this.decryptRoundKeys = Uint32Array.from(this.encryptRoundKeys), this.decryptRoundKeys.reverse();
+    }
+    /**
+     * general sm4 encrypt/decrypt algorithm for a 16 bytes block using roundKey
+     *
+     * @param {Uint32Array} blockData
+     * @param {Uint32Array} roundKeys
+     * @return {Uint32Array} return a 16 bytes cipher block
+     * @memberof SM4
+     */
+    doBlockCrypt(x, e) {
+      let t = new Uint32Array(36);
+      t.set(x, 0);
+      for (let n = 0; n < 32; n++)
+        t[n + 4] = t[n] ^ this.tTransform1(t[n + 1] ^ t[n + 2] ^ t[n + 3] ^ e[n]);
+      let o = new Uint32Array(4);
+      return o[0] = t[35], o[1] = t[34], o[2] = t[33], o[3] = t[32], o;
+    }
+    /**
+     * spawn round key array for encrypt. reverse this key array when decrypt.
+     * every round key's length is 32 bytes.
+     * there are 32 round keys.
+     * @return {Uint32Array}
+     * @memberof SM4
+     */
+    spawnEncryptRoundKeys() {
+      let x = new Uint32Array(4);
+      x[0] = this.key[0] << 24 | this.key[1] << 16 | this.key[2] << 8 | this.key[3], x[1] = this.key[4] << 24 | this.key[5] << 16 | this.key[6] << 8 | this.key[7], x[2] = this.key[8] << 24 | this.key[9] << 16 | this.key[10] << 8 | this.key[11], x[3] = this.key[12] << 24 | this.key[13] << 16 | this.key[14] << 8 | this.key[15];
+      let e = new Uint32Array(36);
+      e[0] = x[0] ^ u[0], e[1] = x[1] ^ u[1], e[2] = x[2] ^ u[2], e[3] = x[3] ^ u[3];
+      for (let t = 0; t < 32; t++)
+        e[t + 4] = e[t] ^ this.tTransform2(e[t + 1] ^ e[t + 2] ^ e[t + 3] ^ p[t]), this.encryptRoundKeys[t] = e[t + 4];
+    }
+    /**
+     * left rotate x by y bits
+     *
+     * @param {*} x
+     * @param {Number} y
+     * @returns
+     * @memberof SM4
+     */
+    rotateLeft(x, e) {
+      return x << e | x >>> 32 - e;
+    }
+    /**
+     * L transform function for encrypt
+     *
+     * @param {Uint32Number} b
+     * @returns {Uint32Number}
+     * @memberof SM4
+     */
+    linearTransform1(x) {
+      return x ^ this.rotateLeft(x, 2) ^ this.rotateLeft(x, 10) ^ this.rotateLeft(x, 18) ^ this.rotateLeft(x, 24);
+    }
+    /**
+     * L' transform function for key expand
+     *
+     * @param {Uint32Number} b
+     * @returns {Uint32Number}
+     * @memberof SM4
+     */
+    linearTransform2(x) {
+      return x ^ this.rotateLeft(x, 13) ^ this.rotateLeft(x, 23);
+    }
+    /**
+     * τ transform function
+     *
+     * @param {Uint32Number} a
+     * @returns {Uint32Number}
+     * @memberof SM4
+     */
+    tauTransform(x) {
+      return y[x >>> 24 & 255] << 24 | y[x >>> 16 & 255] << 16 | y[x >>> 8 & 255] << 8 | y[x & 255];
+    }
+    /**
+     * mix replacement T transform for encrypt
+     *
+     * @param {Uint32Number} z
+     * @returns {Uint32Number}
+     * @memberof SM4
+     */
+    tTransform1(x) {
+      let e = this.tauTransform(x);
+      return this.linearTransform1(e);
+    }
+    /**
+     * mix replacement T transform for key expand
+     *
+     * @param {Uint32Number} z
+     * @returns {Uint32Number}
+     * @memberof SM4
+     */
+    tTransform2(x) {
+      let e = this.tauTransform(x);
+      return this.linearTransform2(e);
+    }
+    /**
+     * padding the array length to multiple of BLOCK
+     *
+     * @param {ByteArray} originalBuffer
+     * @returns {ByteArray}
+     * @memberof SM4
+     */
+    padding(x) {
+      if (x === null)
+        return null;
+      let e = l - x.length % l, t = new Uint8Array(x.length + e);
+      return t.set(x, 0), t.fill(e, x.length), t;
+    }
+    /**
+     * depadding the byte array to its original length
+     *
+     * @param {ByteArray} paddedBuffer
+     * @returns {ByteArray}
+     * @memberof SM4
+     */
+    dePadding(x) {
+      if (x === null)
+        return null;
+      let e = x[x.length - 1];
+      return x.slice(0, x.length - e);
+    }
+    /**
+     * exctract uint32 array block from uint8 array
+     *
+     * @param {Uint8Array} uint8Array
+     * @param {Number} baseIndex
+     * @returns {Uint32Array}
+     * @memberof SM4
+     */
+    uint8ToUint32Block(x, e = 0) {
+      let t = new Uint32Array(4);
+      return t[0] = x[e] << 24 | x[e + 1] << 16 | x[e + 2] << 8 | x[e + 3], t[1] = x[e + 4] << 24 | x[e + 5] << 16 | x[e + 6] << 8 | x[e + 7], t[2] = x[e + 8] << 24 | x[e + 9] << 16 | x[e + 10] << 8 | x[e + 11], t[3] = x[e + 12] << 24 | x[e + 13] << 16 | x[e + 14] << 8 | x[e + 15], t;
+    }
+    /**
+     * encrypt the string plaintext
+     *
+     * @param {String} plaintext
+     * @memberof SM4
+     * @return {String} ciphertext
+     */
+    encrypt(x) {
+      let e = h.stringToArrayBufferInUtf8(x), t = this.padding(e), o = t.length / l, n = new Uint8Array(t.length);
+      if (this.mode === "cbc") {
+        if (this.iv === null || this.iv.length !== 16)
+          throw new Error("iv error");
+        let r = this.uint8ToUint32Block(this.iv);
+        for (let f = 0; f < o; f++) {
+          let a = f * l, s = this.uint8ToUint32Block(t, a);
+          r[0] = r[0] ^ s[0], r[1] = r[1] ^ s[1], r[2] = r[2] ^ s[2], r[3] = r[3] ^ s[3];
+          let i = this.doBlockCrypt(r, this.encryptRoundKeys);
+          r = i;
+          for (let c = 0; c < l; c++)
+            n[a + c] = i[parseInt(c / 4)] >> (3 - c) % 4 * 8 & 255;
+        }
+      } else
+        for (let r = 0; r < o; r++) {
+          let f = r * l, a = this.uint8ToUint32Block(t, f), s = this.doBlockCrypt(a, this.encryptRoundKeys);
+          for (let i = 0; i < l; i++)
+            n[f + i] = s[parseInt(i / 4)] >> (3 - i) % 4 * 8 & 255;
+        }
+      return this.cipherType === "base64" ? h.arrayBufferToBase64(n) : h.utf8ArrayBufferToString(n);
+    }
+    /**
+     * decrypt the string ciphertext
+     *
+     * @param {String} ciphertext
+     * @memberof SM4
+     */
+    decrypt(x) {
+      let e = new Uint8Array();
+      this.cipherType === "base64" ? e = h.base64ToArrayBuffer(x) : e = h.stringToArrayBufferInUtf8(x);
+      let t = e.length / l, o = new Uint8Array(e.length);
+      if (this.mode === "cbc") {
+        if (this.iv === null || this.iv.length !== 16)
+          throw new Error("iv error");
+        let r = this.uint8ToUint32Block(this.iv);
+        for (let f = 0; f < t; f++) {
+          let a = f * l, s = this.uint8ToUint32Block(e, a), i = this.doBlockCrypt(s, this.decryptRoundKeys), c = new Uint32Array(4);
+          c[0] = r[0] ^ i[0], c[1] = r[1] ^ i[1], c[2] = r[2] ^ i[2], c[3] = r[3] ^ i[3], r = s;
+          for (let d = 0; d < l; d++)
+            o[a + d] = c[parseInt(d / 4)] >> (3 - d) % 4 * 8 & 255;
+        }
+      } else
+        for (let r = 0; r < t; r++) {
+          let f = r * l, a = this.uint8ToUint32Block(e, f), s = this.doBlockCrypt(a, this.decryptRoundKeys);
+          for (let i = 0; i < l; i++)
+            o[f + i] = s[parseInt(i / 4)] >> (3 - i) % 4 * 8 & 255;
+        }
+      let n = this.dePadding(o);
+      return h.utf8ArrayBufferToString(n);
+    }
+  }
+  return b = T, b;
+}
+export {
+  w as __require
+};

package/dist/vendor/ieee754/index.js

@@ -1,4 +1,4 @@
-import { __exports as n } from "../../commonjs-virtual-dir/index5.js";
+import { __exports as n } from "../../commonjs-virtual-dir/index7.js";
 /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
 var d;
 function q() {

package/dist/vendor/sdp-transform/lib/index.js

@@ -1,4 +1,4 @@
-import { __exports as r } from "../../../commonjs-virtual-dir/index4.js";
+import { __exports as r } from "../../../commonjs-virtual-dir/index5.js";
 import { __require as t } from "./parser.js";
 import { __require as m } from "./writer.js";
 import { __require as p } from "./grammar.js";

package/dist/vendor/token-types/lib/index.js

@@ -1,4 +1,4 @@
-import "../../../commonjs-virtual-dir/index3.js";
+import "../../../commonjs-virtual-dir/index4.js";
 import { textDecode as i } from "../../@borewit/text-codec/lib/index.js";
 function r(e) {
   return new DataView(e.buffer, e.byteOffset);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "module-develop-kit",
   "author": "Front-End team",
-  "version": "1.4.1",
+  "version": "1.4.3",
   "type": "module",
   "description": "前端项目通用工具包",
   "module": "dist/main.js",

package/dist/src/shield/gcm-crypto/gcm.service.js

@@ -1,29 +0,0 @@
-class i {
-  /**
-   * 公钥
-   */
-  publicKey = "";
-  /**
-   * 是否加密
-   */
-  isEncrypt = !1;
-  /**
-   * 获取公钥
-   */
-  // eslint-disable-next-line
-  getPublicKeyApi = () => Promise.resolve("");
-  requestBeforeCryptoCallBacks = [];
-  init(e) {
-    this.getPublicKeyApi = e.getPublicKeyApi, this.isEncrypt = e.isEncrypt;
-  }
-  async initPublicKey() {
-    this.publicKey || (this.publicKey = await this.getPublicKeyApi());
-  }
-  addRequestBeforeCryptoCallback(e) {
-    this.requestBeforeCryptoCallBacks.push(e);
-  }
-}
-const c = new i();
-export {
-  c as gcmService
-};

package/dist/src/shield/gcm-crypto/hex.js

@@ -1,18 +0,0 @@
-const o = (e) => Array.from(crypto.getRandomValues(new Uint8Array(e))).map((n) => n.toString(16).padStart(2, "0")).join(""), a = (e) => {
-  let n = "";
-  for (let t = 0; t < e.length; t += 32768)
-    n += String.fromCharCode(...e.subarray(t, t + 32768));
-  return btoa(n);
-}, c = (e) => new TextEncoder().encode(e), i = (e) => new TextDecoder().decode(e), s = (e) => {
-  const n = atob(e), r = new Uint8Array(n.length);
-  for (let t = 0; t < n.length; t++)
-    r[t] = n.charCodeAt(t);
-  return Array.from(r, (t) => t.toString(16).padStart(2, "0")).join("");
-};
-export {
-  s as base64ToHex,
-  a as bytesToBase64,
-  o as generateHex,
-  c as stringToUtf8Bytes,
-  i as utf8BytesToString
-};

package/dist/src/shield/gcm-crypto/init.js

@@ -1,61 +0,0 @@
-import { sm2 as K } from "../../../vendor/sm-crypto-v2/dist/index.js";
-import { EHeaderKey as r } from "../crypto/const.js";
-import { sm2Decrypt as b } from "../crypto/sm2.js";
-import { base64ToHex as f } from "../crypto/util.js";
-import { gcmService as o } from "./gcm.service.js";
-import { requestDataEncryption as C, responseDataDecryption as D } from "./index.js";
-import { formatUrlToGcmCryptoUri as s } from "./string.js";
-import { isNullOrUndefined as n } from "../../utils/is.js";
-import "vue";
-const B = {
-  install: (t, e) => {
-    o.init(e);
-  }
-}, G = () => o.initPublicKey(), I = (t) => {
-  o.addRequestBeforeCryptoCallback(t);
-}, m = /* @__PURE__ */ new Map(), c = (t, e) => t && (t[e] || t.get(e)) || "", k = (t) => {
-  if (!o.isEncrypt || !o.publicKey)
-    return t;
-  if (!t.isNotAutoEncryption && t.url) {
-    o.requestBeforeCryptoCallBacks.forEach((a) => {
-      a(t);
-    });
-    const { headers: e, data: p } = C(
-      o.publicKey,
-      t.data,
-      s(t.url)
-    );
-    if (c(t.headers, "Content-Type") !== "multipart/form-data" && (t.data = n(t.data) ? t.data : p), t.isAutoDecryptionResponse) {
-      const { publicKey: a, privateKey: i } = K.generateKeyPairHex();
-      m.set(a, i), t.headers.set(r.gcmPublicKey, a);
-    }
-    t.headers.set(e);
-  }
-  return t;
-}, R = (t) => {
-  if (t.config.isAutoDecryptionResponse && t.request.responseType !== "blob") {
-    const { data: e, ...p } = t.data, a = c(t.headers, r.gcmPublicKey);
-    if (!a)
-      return t;
-    const i = m.get(a);
-    if (i && !n(e)) {
-      const u = c(t.headers, r.encryptIv), d = c(t.headers, r.encryptKey), l = c(t.headers, r.encryptTag), y = b(i, f(d));
-      t.data = {
-        ...p,
-        data: D(y, e, s(t.config.url), {
-          [r.encryptIv]: u,
-          [r.encryptKey]: y,
-          [r.encryptTag]: l
-        })
-      };
-    }
-  }
-  return t;
-};
-export {
-  B as gcmCrypto,
-  G as initPublicKey,
-  I as requestDataBeforeGcmCrypto,
-  k as requestDataGcmCryptoInterceptor,
-  R as responseDataGcmCryptoInterceptor
-};

package/dist/src/shield/gcm-crypto/string.js

@@ -1,10 +0,0 @@
-const t = (o) => typeof o == "object" ? JSON.stringify(o ?? {}) : typeof o == "number" ? String(o) : o ?? "", i = (o) => {
-  if (!o)
-    return "";
-  const r = o.split("/").filter(Boolean);
-  return r.shift(), `/${r.join("/")}`;
-};
-export {
-  t as dataToStr,
-  i as formatUrlToGcmCryptoUri
-};