sm-crypto-v2 0.3.12 → 1.2.0

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,7 +17,11 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __toESM = (mod4, isNodeMode, target) => (target = mod4 != null ? __create(__getProtoOf(mod4)) : {}, __copyProps(
+  isNodeMode || !mod4 || !mod4.__esModule ? __defProp(target, "default", { value: mod4, enumerable: true }) : target,
+  mod4
+));
+var __toCommonJS = (mod4) => __copyProps(__defProp({}, "__esModule", { value: true }), mod4);
 
 // src/index.ts
 var src_exports = {};
@@ -38,21 +44,26 @@ __export(sm2_exports, {
   doEncrypt: () => doEncrypt,
   doSignature: () => doSignature,
   doVerifySignature: () => doVerifySignature,
-  generateEcparam: () => generateEcparam,
   generateKeyPairHex: () => generateKeyPairHex,
-  getGlobalCurve: () => getGlobalCurve,
   getHash: () => getHash,
   getPoint: () => getPoint,
   getPublicKeyFromPrivateKey: () => getPublicKeyFromPrivateKey,
   hexToArray: () => hexToArray,
-  leftPad: () => leftPad,
+  leftPad: () => leftPad2,
   utf8ToHex: () => utf8ToHex,
   verifyPublicKey: () => verifyPublicKey
 });
-var import_jsbn4 = require("jsbn");
 
 // src/sm2/asn1.ts
-var import_jsbn = require("jsbn");
+var utils = __toESM(require("@noble/curves/abstract/utils"));
+
+// src/sm2/bn.ts
+var ZERO = BigInt(0);
+var ONE = BigInt(1);
+var TWO = BigInt(2);
+var THREE = BigInt(3);
+
+// src/sm2/asn1.ts
 function bigintToValue(bigint) {
   let h = bigint.toString(16);
   if (h[0] !== "-") {
@@ -61,7 +72,7 @@ function bigintToValue(bigint) {
     else if (!h.match(/^[0-7]/))
       h = "00" + h;
   } else {
-    h = h.substr(1);
+    h = h.substring(1);
     let len = h.length;
     if (len % 2 === 1)
       len += 1;
@@ -70,8 +81,8 @@ function bigintToValue(bigint) {
     let maskString = "";
     for (let i = 0; i < len; i++)
       maskString += "f";
-    let mask = new import_jsbn.BigInteger(maskString, 16);
-    let output = mask.xor(bigint).add(import_jsbn.BigInteger.ONE);
+    let mask = utils.hexToNumber(maskString);
+    let output = (mask ^ bigint) + ONE;
     h = output.toString(16).replace(/^-/, "");
   }
   return h;
@@ -92,11 +103,11 @@ var ASN1Object = class {
     return this.tlv;
   }
   getLength() {
-    const n3 = this.v.length / 2;
-    let nHex = n3.toString(16);
+    const n = this.v.length / 2;
+    let nHex = n.toString(16);
     if (nHex.length % 2 === 1)
       nHex = "0" + nHex;
-    if (n3 < 128) {
+    if (n < 128) {
       return nHex;
     } else {
       const head = 128 + nHex.length / 2;
@@ -139,8 +150,8 @@ function getL(str, start) {
   const l = str.substring(start + 2, start + 2 + len * 2);
   if (!l)
     return -1;
-  const bigint = +l[0] < 8 ? new import_jsbn.BigInteger(l, 16) : new import_jsbn.BigInteger(l.substring(2), 16);
-  return bigint.intValue();
+  const bigint = +l[0] < 8 ? utils.hexToNumber(l) : utils.hexToNumber(l.substring(2));
+  return +bigint.toString();
 }
 function getStartOfV(str, start) {
   const len = getLenOfL(str, start);
@@ -161,344 +172,23 @@ function decodeDer(input) {
   const vIndexS = getStartOfV(input, nextStart);
   const lS = getL(input, nextStart);
   const vS = input.substring(vIndexS, vIndexS + lS * 2);
-  const r = new import_jsbn.BigInteger(vR, 16);
-  const s = new import_jsbn.BigInteger(vS, 16);
+  const r = utils.hexToNumber(vR);
+  const s = utils.hexToNumber(vS);
   return { r, s };
 }
 
 // src/sm2/utils.ts
-var import_jsbn3 = require("jsbn");
+var utils2 = __toESM(require("@noble/curves/abstract/utils"));
 
 // src/sm2/ec.ts
-var import_jsbn2 = require("jsbn");
-var TWO = new import_jsbn2.BigInteger("2");
-var THREE = new import_jsbn2.BigInteger("3");
-var ECFieldElementFp = class {
-  constructor(q, x) {
-    this.q = q;
-    this.x = x;
-  }
-  equals(other) {
-    if (other === this)
-      return true;
-    return this.q.equals(other.q) && this.x.equals(other.x);
-  }
-  toBigInteger() {
-    return this.x;
-  }
-  negate() {
-    return new ECFieldElementFp(this.q, this.x.negate().mod(this.q));
-  }
-  add(b) {
-    return new ECFieldElementFp(this.q, this.x.add(b.toBigInteger()).mod(this.q));
-  }
-  subtract(b) {
-    return new ECFieldElementFp(this.q, this.x.subtract(b.toBigInteger()).mod(this.q));
-  }
-  multiply(b) {
-    return new ECFieldElementFp(this.q, this.x.multiply(b.toBigInteger()).mod(this.q));
-  }
-  divide(b) {
-    return new ECFieldElementFp(this.q, this.x.multiply(b.toBigInteger().modInverse(this.q)).mod(this.q));
-  }
-  square() {
-    return new ECFieldElementFp(this.q, this.x.square().mod(this.q));
-  }
-};
-var ECPointFp = class {
-  constructor(curve3, x, y, z) {
-    this.curve = curve3;
-    this.x = x;
-    this.y = y;
-    this.z = z == null ? import_jsbn2.BigInteger.ONE : z;
-    this.zinv = null;
-  }
-  zinv;
-  z;
-  getX() {
-    if (this.zinv === null)
-      this.zinv = this.z.modInverse(this.curve.q);
-    return this.curve.fromBigInteger(this.x.toBigInteger().multiply(this.zinv).mod(this.curve.q));
-  }
-  getY() {
-    if (this.zinv === null)
-      this.zinv = this.z.modInverse(this.curve.q);
-    return this.curve.fromBigInteger(this.y.toBigInteger().multiply(this.zinv).mod(this.curve.q));
-  }
-  equals(other) {
-    if (other === this)
-      return true;
-    if (this.isInfinity())
-      return other.isInfinity();
-    if (other.isInfinity())
-      return this.isInfinity();
-    const u = other.y.toBigInteger().multiply(this.z).subtract(this.y.toBigInteger().multiply(other.z)).mod(this.curve.q);
-    if (!u.equals(import_jsbn2.BigInteger.ZERO))
-      return false;
-    const v = other.x.toBigInteger().multiply(this.z).subtract(this.x.toBigInteger().multiply(other.z)).mod(this.curve.q);
-    return v.equals(import_jsbn2.BigInteger.ZERO);
-  }
-  isInfinity() {
-    if (this.x === null && this.y === null)
-      return true;
-    return this.z.equals(import_jsbn2.BigInteger.ZERO) && !this.y.toBigInteger().equals(import_jsbn2.BigInteger.ZERO);
-  }
-  negate() {
-    return new ECPointFp(this.curve, this.x, this.y.negate(), this.z);
-  }
-  add(b) {
-    if (this.isInfinity())
-      return b;
-    if (b.isInfinity())
-      return this;
-    const x1 = this.x.toBigInteger();
-    const y1 = this.y.toBigInteger();
-    const z1 = this.z;
-    const x2 = b.x.toBigInteger();
-    const y2 = b.y.toBigInteger();
-    const z2 = b.z;
-    const q = this.curve.q;
-    const w1 = x1.multiply(z2).mod(q);
-    const w2 = x2.multiply(z1).mod(q);
-    const w3 = w1.subtract(w2);
-    const w4 = y1.multiply(z2).mod(q);
-    const w5 = y2.multiply(z1).mod(q);
-    const w6 = w4.subtract(w5);
-    if (import_jsbn2.BigInteger.ZERO.equals(w3)) {
-      if (import_jsbn2.BigInteger.ZERO.equals(w6)) {
-        return this.twice();
-      }
-      return this.curve.infinity;
-    }
-    const w7 = w1.add(w2);
-    const w8 = z1.multiply(z2).mod(q);
-    const w9 = w3.square().mod(q);
-    const w10 = w3.multiply(w9).mod(q);
-    const w11 = w8.multiply(w6.square()).subtract(w7.multiply(w9)).mod(q);
-    const x3 = w3.multiply(w11).mod(q);
-    const y3 = w6.multiply(w9.multiply(w1).subtract(w11)).subtract(w4.multiply(w10)).mod(q);
-    const z3 = w10.multiply(w8).mod(q);
-    return new ECPointFp(this.curve, this.curve.fromBigInteger(x3), this.curve.fromBigInteger(y3), z3);
-  }
-  twice() {
-    if (this.isInfinity())
-      return this;
-    if (!this.y.toBigInteger().signum())
-      return this.curve.infinity;
-    const x1 = this.x.toBigInteger();
-    const y1 = this.y.toBigInteger();
-    const z1 = this.z;
-    const q = this.curve.q;
-    const a = this.curve.a.toBigInteger();
-    const w1 = x1.square().multiply(THREE).add(a.multiply(z1.square())).mod(q);
-    const w2 = y1.shiftLeft(1).multiply(z1).mod(q);
-    const w3 = y1.square().mod(q);
-    const w4 = w3.multiply(x1).multiply(z1).mod(q);
-    const w5 = w2.square().mod(q);
-    const w6 = w1.square().subtract(w4.shiftLeft(3)).mod(q);
-    const x3 = w2.multiply(w6).mod(q);
-    const y3 = w1.multiply(w4.shiftLeft(2).subtract(w6)).subtract(w5.shiftLeft(1).multiply(w3)).mod(q);
-    const z3 = w2.multiply(w5).mod(q);
-    return new ECPointFp(this.curve, this.curve.fromBigInteger(x3), this.curve.fromBigInteger(y3), z3);
-  }
-  multiply(k) {
-    if (this.isInfinity())
-      return this;
-    if (!k.signum())
-      return this.curve.infinity;
-    const k3 = k.multiply(THREE);
-    const neg = this.negate();
-    let Q = this;
-    for (let i = k3.bitLength() - 2; i > 0; i--) {
-      Q = Q.twice();
-      const k3Bit = k3.testBit(i);
-      const kBit = k.testBit(i);
-      if (k3Bit !== kBit) {
-        Q = Q.add(k3Bit ? this : neg);
-      }
-    }
-    return Q;
-  }
-};
-var ECCurveFp = class {
-  constructor(q, a, b) {
-    this.q = q;
-    this.q = q;
-    this.a = this.fromBigInteger(a);
-    this.b = this.fromBigInteger(b);
-    this.infinity = new ECPointFp(this, null, null);
-  }
-  infinity;
-  a;
-  b;
-  equals(other) {
-    if (other === this)
-      return true;
-    return this.q.equals(other.q) && this.a.equals(other.a) && this.b.equals(other.b);
-  }
-  fromBigInteger(x) {
-    return new ECFieldElementFp(this.q, x);
-  }
-  decodePointHex(s) {
-    switch (parseInt(s.substring(0, 2), 16)) {
-      case 0:
-        return this.infinity;
-      case 2:
-      case 3:
-        const x = this.fromBigInteger(new import_jsbn2.BigInteger(s.substring(2), 16));
-        let y = this.fromBigInteger(x.multiply(x.square()).add(
-          x.multiply(this.a)
-        ).add(this.b).toBigInteger().modPow(
-          this.q.divide(new import_jsbn2.BigInteger("4")).add(import_jsbn2.BigInteger.ONE),
-          this.q
-        ));
-        if (!y.toBigInteger().mod(TWO).equals(new import_jsbn2.BigInteger(s.substring(0, 2), 16).subtract(TWO))) {
-          y = y.negate();
-        }
-        return new ECPointFp(this, x, y);
-      case 4:
-      case 6:
-      case 7:
-        const len = (s.length - 2) / 2;
-        const xHex = s.substring(2, 2 + len);
-        const yHex = s.substring(len + 2, len + 2 + len);
-        return new ECPointFp(this, this.fromBigInteger(new import_jsbn2.BigInteger(xHex, 16)), this.fromBigInteger(new import_jsbn2.BigInteger(yHex, 16)));
-      default:
-        return null;
-    }
-  }
-};
-
-// src/sm2/utils.ts
-var rng = new import_jsbn3.SecureRandom();
-var { curve, G, n } = generateEcparam();
-function getGlobalCurve() {
-  return curve;
-}
-function generateEcparam() {
-  const p = new import_jsbn3.BigInteger("FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFF", 16);
-  const a = new import_jsbn3.BigInteger("FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFC", 16);
-  const b = new import_jsbn3.BigInteger("28E9FA9E9D9F5E344D5A9E4BCF6509A7F39789F515AB8F92DDBCBD414D940E93", 16);
-  const curve3 = new ECCurveFp(p, a, b);
-  const gxHex = "32C4AE2C1F1981195F9904466A39C9948FE30BBFF2660BE1715A4589334C74C7";
-  const gyHex = "BC3736A2F4F6779C59BDCEE36B692153D0A9877CC62A474002DF32E52139F0A0";
-  const G3 = curve3.decodePointHex("04" + gxHex + gyHex);
-  const n3 = new import_jsbn3.BigInteger("FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFF7203DF6B21C6052B53BBF40939D54123", 16);
-  return { curve: curve3, G: G3, n: n3 };
-}
-function generateKeyPairHex(a, b, c) {
-  const random = typeof a === "string" ? new import_jsbn3.BigInteger(a, b) : a ? new import_jsbn3.BigInteger(a, b, c) : new import_jsbn3.BigInteger(n.bitLength(), rng);
-  const d = random.mod(n.subtract(import_jsbn3.BigInteger.ONE)).add(import_jsbn3.BigInteger.ONE);
-  const privateKey = leftPad(d.toString(16), 64);
-  const P = G.multiply(d);
-  const Px = leftPad(P.getX().toBigInteger().toString(16), 64);
-  const Py = leftPad(P.getY().toBigInteger().toString(16), 64);
-  const publicKey = "04" + Px + Py;
-  return { privateKey, publicKey };
-}
-function compressPublicKeyHex(s) {
-  if (s.length !== 130)
-    throw new Error("Invalid public key to compress");
-  const len = (s.length - 2) / 2;
-  const xHex = s.substring(2, 2 + len);
-  const y = new import_jsbn3.BigInteger(s.substring(len + 2, len + len + 2), 16);
-  let prefix = "03";
-  if (y.mod(new import_jsbn3.BigInteger("2")).equals(import_jsbn3.BigInteger.ZERO))
-    prefix = "02";
-  return prefix + xHex;
-}
-function utf8ToHex(input) {
-  input = decodeURIComponent(encodeURIComponent(input));
-  const length = input.length;
-  const words = new Uint32Array((length >>> 2) + 1);
-  for (let i = 0; i < length; i++) {
-    words[i >>> 2] |= (input.charCodeAt(i) & 255) << 24 - i % 4 * 8;
-  }
-  const hexChars = [];
-  for (let i = 0; i < length; i++) {
-    const bite = words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
-    hexChars.push((bite >>> 4).toString(16));
-    hexChars.push((bite & 15).toString(16));
-  }
-  return hexChars.join("");
-}
-function leftPad(input, num) {
-  if (input.length >= num)
-    return input;
-  return new Array(num - input.length + 1).join("0") + input;
-}
-function arrayToHex(arr) {
-  return arr.map((item) => {
-    const hex = item.toString(16);
-    return hex.length === 1 ? "0" + hex : hex;
-  }).join("");
-}
-function arrayToUtf8(arr) {
-  const str = [];
-  for (let i = 0, len = arr.length; i < len; i++) {
-    if (arr[i] >= 240 && arr[i] <= 247) {
-      str.push(String.fromCodePoint(((arr[i] & 7) << 18) + ((arr[i + 1] & 63) << 12) + ((arr[i + 2] & 63) << 6) + (arr[i + 3] & 63)));
-      i += 3;
-    } else if (arr[i] >= 224 && arr[i] <= 239) {
-      str.push(String.fromCodePoint(((arr[i] & 15) << 12) + ((arr[i + 1] & 63) << 6) + (arr[i + 2] & 63)));
-      i += 2;
-    } else if (arr[i] >= 192 && arr[i] <= 223) {
-      str.push(String.fromCodePoint(((arr[i] & 31) << 6) + (arr[i + 1] & 63)));
-      i++;
-    } else {
-      str.push(String.fromCodePoint(arr[i]));
-    }
-  }
-  return str.join("");
-}
-function hexToArray(hexStr) {
-  let hexStrLength = hexStr.length;
-  if (hexStrLength % 2 !== 0) {
-    hexStr = leftPad(hexStr, hexStrLength + 1);
-  }
-  hexStrLength = hexStr.length;
-  const wordLength = hexStrLength / 2;
-  const words = new Uint8Array(wordLength);
-  for (let i = 0; i < wordLength; i++) {
-    words[i] = parseInt(hexStr.substring(i * 2, i * 2 + 2), 16);
-  }
-  return words;
-}
-function verifyPublicKey(publicKey) {
-  const point = curve.decodePointHex(publicKey);
-  if (!point)
-    return false;
-  const x = point.getX();
-  const y = point.getY();
-  return y.square().equals(x.multiply(x.square()).add(x.multiply(curve.a)).add(curve.b));
-}
-function comparePublicKeyHex(publicKey1, publicKey2) {
-  const point1 = curve.decodePointHex(publicKey1);
-  if (!point1)
-    return false;
-  const point2 = curve.decodePointHex(publicKey2);
-  if (!point2)
-    return false;
-  return point1.equals(point2);
-}
-function concatArray(...arrays) {
-  let totalLength = arrays.reduce((acc, value) => acc + value.length, 0);
-  if (!arrays.length)
-    return new Uint8Array();
-  let result = new Uint8Array(totalLength);
-  let length = 0;
-  for (let array of arrays) {
-    result.set(array, length);
-    length += array.length;
-  }
-  return result;
-}
+var import_weierstrass = require("@noble/curves/abstract/weierstrass");
+var import_modular = require("@noble/curves/abstract/modular");
 
 // src/sm2/sm3.ts
 var W = new Uint32Array(68);
 var M = new Uint32Array(64);
-function rotl(x, n3) {
-  const s = n3 & 31;
+function rotl(x, n) {
+  const s = n & 31;
   return x << s | x >>> 32 - s;
 }
 function xor(x, y) {
@@ -536,9 +226,9 @@ function sm3(array) {
   }
   const m = Uint8Array.from([...array, 128, ...kArr, ...lenArr]);
   const dataView = new DataView(m.buffer, 0);
-  const n3 = m.length / 64;
+  const n = m.length / 64;
   const V = new Uint32Array([1937774191, 1226093241, 388252375, 3666478592, 2842636476, 372324522, 3817729613, 2969243214]);
-  for (let i = 0; i < n3; i++) {
+  for (let i = 0; i < n; i++) {
     W.fill(0);
     M.fill(0);
     const start = 16 * i;
@@ -559,7 +249,7 @@ function sm3(array) {
     let D = V[3];
     let E = V[4];
     let F = V[5];
-    let G3 = V[6];
+    let G = V[6];
     let H = V[7];
     let SS1;
     let SS2;
@@ -571,13 +261,13 @@ function sm3(array) {
       SS1 = rotl(rotl(A, 12) + E + rotl(T, j), 7);
       SS2 = SS1 ^ rotl(A, 12);
       TT1 = (j >= 0 && j <= 15 ? A ^ B ^ C : A & B | A & C | B & C) + D + SS2 + M[j];
-      TT2 = (j >= 0 && j <= 15 ? E ^ F ^ G3 : E & F | ~E & G3) + H + SS1 + W[j];
+      TT2 = (j >= 0 && j <= 15 ? E ^ F ^ G : E & F | ~E & G) + H + SS1 + W[j];
       D = C;
       C = rotl(B, 9);
       B = A;
       A = TT1;
-      H = G3;
-      G3 = rotl(F, 19);
+      H = G;
+      G = rotl(F, 19);
       F = E;
       E = P0(TT2);
     }
@@ -587,7 +277,7 @@ function sm3(array) {
     V[3] ^= D;
     V[4] ^= E;
     V[5] ^= F;
-    V[6] ^= G3;
+    V[6] ^= G;
     V[7] ^= H;
   }
   const result = new Uint8Array(V.length * 4);
@@ -621,20 +311,246 @@ function hmac(input, key) {
   return sm3(concatArray(oPadKey, hash));
 }
 
+// src/sm3/index.ts
+var sm3_exports = {};
+__export(sm3_exports, {
+  sm3: () => sm32,
+  utf8ToArray: () => utf8ToArray
+});
+function utf8ToArray(str) {
+  const arr = [];
+  for (let i = 0, len = str.length; i < len; i++) {
+    const point = str.codePointAt(i);
+    if (point <= 127) {
+      arr.push(point);
+    } else if (point <= 2047) {
+      arr.push(192 | point >>> 6);
+      arr.push(128 | point & 63);
+    } else if (point <= 55295 || point >= 57344 && point <= 65535) {
+      arr.push(224 | point >>> 12);
+      arr.push(128 | point >>> 6 & 63);
+      arr.push(128 | point & 63);
+    } else if (point >= 65536 && point <= 1114111) {
+      i++;
+      arr.push(240 | point >>> 18 & 28);
+      arr.push(128 | point >>> 12 & 63);
+      arr.push(128 | point >>> 6 & 63);
+      arr.push(128 | point & 63);
+    } else {
+      arr.push(point);
+      throw new Error("input is not supported");
+    }
+  }
+  return new Uint8Array(arr);
+}
+function sm32(input, options) {
+  input = typeof input === "string" ? utf8ToArray(input) : input;
+  if (options) {
+    const mode = options.mode || "hmac";
+    if (mode !== "hmac")
+      throw new Error("invalid mode");
+    let key = options.key;
+    if (!key)
+      throw new Error("invalid key");
+    key = typeof key === "string" ? hexToArray(key) : key;
+    return arrayToHex(Array.from(hmac(input, key)));
+  }
+  return arrayToHex(Array.from(sm3(input)));
+}
+
+// src/sm2/ec.ts
+var DEFAULT_PRNG_POOL_SIZE = 4096;
+var prngPool = new Uint8Array(DEFAULT_PRNG_POOL_SIZE);
+async function FillPRNGPoolIfNeeded() {
+  if ("crypto" in globalThis)
+    return;
+  if (prngPool.length > DEFAULT_PRNG_POOL_SIZE / 2)
+    return;
+  if ("wx" in globalThis) {
+    prngPool = await new Promise((r) => {
+      wx.getRandomValues({
+        length: DEFAULT_PRNG_POOL_SIZE,
+        success(res) {
+          r(new Uint8Array(res.randomValues));
+        }
+      });
+    });
+  } else {
+    try {
+      const crypto = await import(
+        /* webpackIgnore: true */
+        "crypto"
+      );
+      const array = new Uint8Array(DEFAULT_PRNG_POOL_SIZE);
+      crypto.webcrypto.getRandomValues(array);
+      prngPool = array;
+    } catch (error) {
+      throw new Error("no available csprng, abort.");
+    }
+  }
+}
+FillPRNGPoolIfNeeded();
+function consumePool(length) {
+  if (prngPool.length > length) {
+    const prng = prngPool.slice(0, length);
+    prngPool = prngPool.slice(length);
+    FillPRNGPoolIfNeeded();
+    return prng;
+  } else {
+    throw new Error("random number pool is insufficient, prevent getting too long random values or too often.");
+  }
+}
+function randomBytes(length = 0) {
+  const array = new Uint8Array(length);
+  if ("crypto" in globalThis) {
+    return globalThis.crypto.getRandomValues(array);
+  } else {
+    return consumePool(length);
+  }
+}
+function createHash() {
+  const hashC = (msg) => sm3(typeof msg === "string" ? utf8ToArray(msg) : msg);
+  hashC.outputLen = 256;
+  hashC.blockLen = 512;
+  hashC.create = () => sm3(Uint8Array.from([]));
+  return hashC;
+}
+var sm2Fp = (0, import_modular.Field)(BigInt("115792089210356248756420345214020892766250353991924191454421193933289684991999"));
+var sm2Curve = (0, import_weierstrass.weierstrass)({
+  a: BigInt("115792089210356248756420345214020892766250353991924191454421193933289684991996"),
+  b: BigInt("18505919022281880113072981827955639221458448578012075254857346196103069175443"),
+  Fp: sm2Fp,
+  h: ONE,
+  n: BigInt("115792089210356248756420345214020892766061623724957744567843809356293439045923"),
+  Gx: BigInt("22963146547237050559479531362550074578802567295341616970375194840604139615431"),
+  Gy: BigInt("85132369209828568825618990617112496413088388631904505083283536607588877201568"),
+  hash: createHash(),
+  hmac: (key, ...msgs) => hmac(concatArray(...msgs), key),
+  randomBytes
+});
+
+// src/sm2/utils.ts
+var import_modular2 = require("@noble/curves/abstract/modular");
+function generateKeyPairHex() {
+  const privateKey = sm2Curve.utils.randomPrivateKey();
+  const publicKey = sm2Curve.getPublicKey(privateKey, false);
+  const privPad = leftPad2(utils2.bytesToHex(privateKey), 64);
+  const pubPad = leftPad2(utils2.bytesToHex(publicKey), 64);
+  return { privateKey: privPad, publicKey: pubPad };
+}
+function compressPublicKeyHex(s) {
+  if (s.length !== 130)
+    throw new Error("Invalid public key to compress");
+  const len = (s.length - 2) / 2;
+  const xHex = s.substring(2, 2 + len);
+  const y = utils2.hexToNumber(s.substring(len + 2, len + len + 2));
+  let prefix = "03";
+  if ((0, import_modular2.mod)(y, TWO) === ZERO)
+    prefix = "02";
+  return prefix + xHex;
+}
+function utf8ToHex(input) {
+  input = decodeURIComponent(encodeURIComponent(input));
+  const length = input.length;
+  const words = new Uint32Array((length >>> 2) + 1);
+  for (let i = 0; i < length; i++) {
+    words[i >>> 2] |= (input.charCodeAt(i) & 255) << 24 - i % 4 * 8;
+  }
+  const hexChars = [];
+  for (let i = 0; i < length; i++) {
+    const bite = words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+    hexChars.push((bite >>> 4).toString(16));
+    hexChars.push((bite & 15).toString(16));
+  }
+  return hexChars.join("");
+}
+function leftPad2(input, num) {
+  if (input.length >= num)
+    return input;
+  return new Array(num - input.length + 1).join("0") + input;
+}
+function arrayToHex(arr) {
+  return arr.map((item) => {
+    const hex = item.toString(16);
+    return hex.length === 1 ? "0" + hex : hex;
+  }).join("");
+}
+function arrayToUtf8(arr) {
+  const str = [];
+  for (let i = 0, len = arr.length; i < len; i++) {
+    if (arr[i] >= 240 && arr[i] <= 247) {
+      str.push(String.fromCodePoint(((arr[i] & 7) << 18) + ((arr[i + 1] & 63) << 12) + ((arr[i + 2] & 63) << 6) + (arr[i + 3] & 63)));
+      i += 3;
+    } else if (arr[i] >= 224 && arr[i] <= 239) {
+      str.push(String.fromCodePoint(((arr[i] & 15) << 12) + ((arr[i + 1] & 63) << 6) + (arr[i + 2] & 63)));
+      i += 2;
+    } else if (arr[i] >= 192 && arr[i] <= 223) {
+      str.push(String.fromCodePoint(((arr[i] & 31) << 6) + (arr[i + 1] & 63)));
+      i++;
+    } else {
+      str.push(String.fromCodePoint(arr[i]));
+    }
+  }
+  return str.join("");
+}
+function hexToArray(hexStr) {
+  let hexStrLength = hexStr.length;
+  if (hexStrLength % 2 !== 0) {
+    hexStr = leftPad2(hexStr, hexStrLength + 1);
+  }
+  hexStrLength = hexStr.length;
+  const wordLength = hexStrLength / 2;
+  const words = new Uint8Array(wordLength);
+  for (let i = 0; i < wordLength; i++) {
+    words[i] = parseInt(hexStr.substring(i * 2, i * 2 + 2), 16);
+  }
+  return words;
+}
+function verifyPublicKey(publicKey) {
+  const point = sm2Curve.ProjectivePoint.fromHex(publicKey);
+  if (!point)
+    return false;
+  const x = point.x;
+  const y = point.y;
+  return sm2Fp.sqr(y) === sm2Fp.add(sm2Fp.add(sm2Fp.mul(x, sm2Fp.sqr(x)), sm2Fp.mul(x, sm2Curve.CURVE.a)), sm2Curve.CURVE.b);
+}
+function comparePublicKeyHex(publicKey1, publicKey2) {
+  const point1 = sm2Curve.ProjectivePoint.fromHex(publicKey1);
+  if (!point1)
+    return false;
+  const point2 = sm2Curve.ProjectivePoint.fromHex(publicKey2);
+  if (!point2)
+    return false;
+  return point1.equals(point2);
+}
+function concatArray(...arrays) {
+  let totalLength = arrays.reduce((acc, value) => acc + value.length, 0);
+  if (!arrays.length)
+    return new Uint8Array();
+  let result = new Uint8Array(totalLength);
+  let length = 0;
+  for (let array of arrays) {
+    result.set(array, length);
+    length += array.length;
+  }
+  return result;
+}
+
 // src/sm2/index.ts
-var { G: G2, curve: curve2, n: n2 } = generateEcparam();
+var mod2 = __toESM(require("@noble/curves/abstract/modular"));
+var utils3 = __toESM(require("@noble/curves/abstract/utils"));
 var C1C2C3 = 0;
 function doEncrypt(msg, publicKey, cipherMode = 1) {
   const msgArr = typeof msg === "string" ? hexToArray(utf8ToHex(msg)) : Uint8Array.from(msg);
-  const publicKeyPoint = getGlobalCurve().decodePointHex(publicKey);
+  const publicKeyPoint = sm2Curve.ProjectivePoint.fromHex(publicKey);
   const keypair = generateKeyPairHex();
-  const k = new import_jsbn4.BigInteger(keypair.privateKey, 16);
+  const k = utils3.hexToNumber(keypair.privateKey);
   let c1 = keypair.publicKey;
   if (c1.length > 128)
     c1 = c1.substring(c1.length - 128);
   const p = publicKeyPoint.multiply(k);
-  const x2 = hexToArray(leftPad(p.getX().toBigInteger().toRadix(16), 64));
-  const y2 = hexToArray(leftPad(p.getY().toBigInteger().toRadix(16), 64));
+  const x2 = hexToArray(leftPad2(utils3.numberToHexUnpadded(p.x), 64));
+  const y2 = hexToArray(leftPad2(utils3.numberToHexUnpadded(p.y), 64));
   const c3 = arrayToHex(Array.from(sm3(concatArray(x2, msgArr, y2))));
   let ct = 1;
   let offset = 0;
@@ -657,7 +573,7 @@ function doEncrypt(msg, publicKey, cipherMode = 1) {
 function doDecrypt(encryptData, privateKey, cipherMode = 1, {
   output = "string"
 } = {}) {
-  const privateKeyInteger = new import_jsbn4.BigInteger(privateKey, 16);
+  const privateKeyInteger = utils3.hexToNumber(privateKey);
   let c3 = encryptData.substring(128, 128 + 64);
   let c2 = encryptData.substring(128 + 64);
   if (cipherMode === C1C2C3) {
@@ -665,10 +581,10 @@ function doDecrypt(encryptData, privateKey, cipherMode = 1, {
     c2 = encryptData.substring(128, encryptData.length - 64);
   }
   const msg = hexToArray(c2);
-  const c1 = getGlobalCurve().decodePointHex("04" + encryptData.substring(0, 128));
+  const c1 = sm2Curve.ProjectivePoint.fromHex("04" + encryptData.substring(0, 128));
   const p = c1.multiply(privateKeyInteger);
-  const x2 = hexToArray(leftPad(p.getX().toBigInteger().toRadix(16), 64));
-  const y2 = hexToArray(leftPad(p.getY().toBigInteger().toRadix(16), 64));
+  const x2 = hexToArray(leftPad2(utils3.numberToHexUnpadded(p.x), 64));
+  const y2 = hexToArray(leftPad2(utils3.numberToHexUnpadded(p.y), 64));
   let ct = 1;
   let offset = 0;
   let t = new Uint8Array();
@@ -704,8 +620,8 @@ function doSignature(msg, privateKey, options = {}) {
     publicKey = publicKey || getPublicKeyFromPrivateKey(privateKey);
     hashHex = getHash(hashHex, publicKey, userId);
   }
-  const dA = new import_jsbn4.BigInteger(privateKey, 16);
-  const e = new import_jsbn4.BigInteger(hashHex, 16);
+  const dA = utils3.hexToNumber(privateKey);
+  const e = utils3.hexToNumber(hashHex);
   let k = null;
   let r = null;
   let s = null;
@@ -718,13 +634,13 @@ function doSignature(msg, privateKey, options = {}) {
         point = getPoint();
       }
       k = point.k;
-      r = e.add(point.x1).mod(n2);
-    } while (r.equals(import_jsbn4.BigInteger.ZERO) || r.add(k).equals(n2));
-    s = dA.add(import_jsbn4.BigInteger.ONE).modInverse(n2).multiply(k.subtract(r.multiply(dA))).mod(n2);
-  } while (s.equals(import_jsbn4.BigInteger.ZERO));
+      r = mod2.mod(e + point.x1, sm2Curve.CURVE.n);
+    } while (r === ZERO || r + k === sm2Curve.CURVE.n);
+    s = mod2.mod(mod2.invert(dA + ONE, sm2Curve.CURVE.n) * (k - r * dA), sm2Curve.CURVE.n);
+  } while (s === ZERO);
   if (der)
     return encodeDer(r, s);
-  return leftPad(r.toString(16), 64) + leftPad(s.toString(16), 64);
+  return leftPad2(utils3.numberToHexUnpadded(r), 64) + leftPad2(utils3.numberToHexUnpadded(s), 64);
 }
 function doVerifySignature(msg, signHex, publicKey, options = {}) {
   let hashHex;
@@ -745,33 +661,33 @@ function doVerifySignature(msg, signHex, publicKey, options = {}) {
     r = decodeDerObj.r;
     s = decodeDerObj.s;
   } else {
-    r = new import_jsbn4.BigInteger(signHex.substring(0, 64), 16);
-    s = new import_jsbn4.BigInteger(signHex.substring(64), 16);
+    r = utils3.hexToNumber(signHex.substring(0, 64));
+    s = utils3.hexToNumber(signHex.substring(64));
   }
-  const PA = curve2.decodePointHex(publicKey);
-  const e = new import_jsbn4.BigInteger(hashHex, 16);
-  const t = r.add(s).mod(n2);
-  if (t.equals(import_jsbn4.BigInteger.ZERO))
+  const PA = sm2Curve.ProjectivePoint.fromHex(publicKey);
+  const e = utils3.hexToNumber(hashHex);
+  const t = mod2.mod(r + s, sm2Curve.CURVE.n);
+  if (t === ZERO)
     return false;
-  const x1y1 = G2.multiply(s).add(PA.multiply(t));
-  const R = e.add(x1y1.getX().toBigInteger()).mod(n2);
-  return r.equals(R);
+  const x1y1 = sm2Curve.ProjectivePoint.BASE.multiply(s).add(PA.multiply(t));
+  const R = mod2.mod(e + x1y1.x, sm2Curve.CURVE.n);
+  return r === R;
 }
 function getHash(hashHex, publicKey, userId = "1234567812345678") {
   userId = utf8ToHex(userId);
-  const a = leftPad(G2.curve.a.toBigInteger().toRadix(16), 64);
-  const b = leftPad(G2.curve.b.toBigInteger().toRadix(16), 64);
-  const gx = leftPad(G2.getX().toBigInteger().toRadix(16), 64);
-  const gy = leftPad(G2.getY().toBigInteger().toRadix(16), 64);
+  const a = leftPad2(utils3.numberToHexUnpadded(sm2Curve.CURVE.a), 64);
+  const b = leftPad2(utils3.numberToHexUnpadded(sm2Curve.CURVE.b), 64);
+  const gx = leftPad2(utils3.numberToHexUnpadded(sm2Curve.ProjectivePoint.BASE.x), 64);
+  const gy = leftPad2(utils3.numberToHexUnpadded(sm2Curve.ProjectivePoint.BASE.y), 64);
   let px;
   let py;
   if (publicKey.length === 128) {
     px = publicKey.substring(0, 64);
     py = publicKey.substring(64, 128);
   } else {
-    const point = G2.curve.decodePointHex(publicKey);
-    px = leftPad(point.getX().toBigInteger().toRadix(16), 64);
-    py = leftPad(point.getY().toBigInteger().toRadix(16), 64);
+    const point = sm2Curve.ProjectivePoint.fromHex(publicKey);
+    px = leftPad2(utils3.numberToHexUnpadded(point.x), 64);
+    py = leftPad2(utils3.numberToHexUnpadded(point.y), 64);
   }
   const data = hexToArray(userId + a + b + gx + gy + px + py);
   const entl = userId.length * 4;
@@ -779,68 +695,21 @@ function getHash(hashHex, publicKey, userId = "1234567812345678") {
   return arrayToHex(Array.from(sm3(concatArray(z, typeof hashHex === "string" ? hexToArray(hashHex) : hashHex))));
 }
 function getPublicKeyFromPrivateKey(privateKey) {
-  const PA = G2.multiply(new import_jsbn4.BigInteger(privateKey, 16));
-  const x = leftPad(PA.getX().toBigInteger().toString(16), 64);
-  const y = leftPad(PA.getY().toBigInteger().toString(16), 64);
-  return "04" + x + y;
+  const pubKey = sm2Curve.getPublicKey(privateKey, false);
+  const pubPad = leftPad2(utils3.bytesToHex(pubKey), 64);
+  return pubPad;
 }
 function getPoint() {
   const keypair = generateKeyPairHex();
-  const PA = curve2.decodePointHex(keypair.publicKey);
+  const PA = sm2Curve.ProjectivePoint.fromHex(keypair.publicKey);
+  const k = utils3.hexToNumber(keypair.privateKey);
   return {
     ...keypair,
-    k: new import_jsbn4.BigInteger(keypair.privateKey, 16),
-    x1: PA.getX().toBigInteger()
+    k,
+    x1: PA.x
   };
 }
 
-// src/sm3/index.ts
-var sm3_exports = {};
-__export(sm3_exports, {
-  sm3: () => sm32,
-  utf8ToArray: () => utf8ToArray
-});
-function utf8ToArray(str) {
-  const arr = [];
-  for (let i = 0, len = str.length; i < len; i++) {
-    const point = str.codePointAt(i);
-    if (point <= 127) {
-      arr.push(point);
-    } else if (point <= 2047) {
-      arr.push(192 | point >>> 6);
-      arr.push(128 | point & 63);
-    } else if (point <= 55295 || point >= 57344 && point <= 65535) {
-      arr.push(224 | point >>> 12);
-      arr.push(128 | point >>> 6 & 63);
-      arr.push(128 | point & 63);
-    } else if (point >= 65536 && point <= 1114111) {
-      i++;
-      arr.push(240 | point >>> 18 & 28);
-      arr.push(128 | point >>> 12 & 63);
-      arr.push(128 | point >>> 6 & 63);
-      arr.push(128 | point & 63);
-    } else {
-      arr.push(point);
-      throw new Error("input is not supported");
-    }
-  }
-  return new Uint8Array(arr);
-}
-function sm32(input, options) {
-  input = typeof input === "string" ? utf8ToArray(input) : input;
-  if (options) {
-    const mode = options.mode || "hmac";
-    if (mode !== "hmac")
-      throw new Error("invalid mode");
-    let key = options.key;
-    if (!key)
-      throw new Error("invalid key");
-    key = typeof key === "string" ? hexToArray(key) : key;
-    return arrayToHex(Array.from(hmac(input, key)));
-  }
-  return arrayToHex(Array.from(sm3(input)));
-}
-
 // src/sm4/index.ts
 var sm4_exports = {};
 __export(sm4_exports, {