sm-crypto-v2 1.6.0 → 1.8.0

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [1.8.0](https://github.com/Cubelrti/sm-crypto-v2/compare/v1.7.0...v1.8.0) (2023-12-15)
+
+
+### Features
+
+* **sm2:** support asn1 der encoded encryption/decryption ([f08b9fd](https://github.com/Cubelrti/sm-crypto-v2/commit/f08b9fd5b64a2a257d41694c1858d7a6b07326ae))
+
+## [1.7.0](https://github.com/Cubelrti/sm-crypto-v2/compare/v1.6.0...v1.7.0) (2023-07-17)
+
+
+### Features
+
+* **sm2:** support precompute sm2 point ([ae347bf](https://github.com/Cubelrti/sm-crypto-v2/commit/ae347bfff6c306318276a31f5958290ac7f07b9c))
+
 ## [1.6.0](https://github.com/Cubelrti/sm-crypto-v2/compare/v1.5.1...v1.6.0) (2023-07-11)
 
 

package/README.md

@@ -57,9 +57,11 @@ verifyResult = sm2.verifyPublicKey(compressedPublicKey) // 验证公钥
 ```js
 import { sm2 } from 'sm-crypto-v2'
 const cipherMode = 1 // 1 - C1C3C2，0 - C1C2C3，默认为1
+// 支持使用 asn1 对加密结果进行编码，在 options 参数中传入 { asn1: true } 即可，默认不开启
+let encryptData = sm2.doEncrypt(msgString, publicKey, cipherMode, { asn1: false }) // 加密结果
 
-let encryptData = sm2.doEncrypt(msgString, publicKey, cipherMode) // 加密结果
-let decryptData = sm2.doDecrypt(encryptData, privateKey, cipherMode) // 解密结果
+// 支持使用 asn1 对密文进行解码再解密，在 options 参数中传入 { asn1: true } 即可，默认不开启
+let decryptData = sm2.doDecrypt(encryptData, privateKey, cipherMode, { asn1: false }) // 解密结果
 
 encryptData = sm2.doEncrypt(msgArray, publicKey, cipherMode) // 加密结果，输入数组
 decryptData = sm2.doDecrypt(encryptData, privateKey, cipherMode, {output: 'array'}) // 解密结果，输出数组
@@ -127,6 +129,21 @@ import { sm2 } from 'sm-crypto-v2'
 let point = sm2.getPoint() // 获取一个椭圆曲线点，可在sm2签名时传入
 ```
 
+### 预计算公钥
+
+```js
+import { sm2 } from 'sm-crypto-v2'
+let keypair = sm2.generateKeyPairHex()
+
+const precomputedPublicKey = sm2.precomputePublicKey(keypair.publicKey)
+// 加密和验签可以传入预计算后的点
+let encryptData = sm2.doEncrypt(msgString, precomputedPublicKey, cipherMode) // 加密结果
+let verifyResult4 = sm2.doVerifySignature(msg, sigValueHex4, precomputedPublicKey, {
+    hash: true,
+}) // 验签结果
+
+```
+
 ## sm3
 
 ```js

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import { ProjPointType } from '@noble/curves/abstract/weierstrass';
+
 interface KeyPair {
     privateKey: string;
     publicKey: string;
@@ -47,15 +49,19 @@ declare const EmptyArray: Uint8Array;
 /**
  * 加密
  */
-declare function doEncrypt(msg: string | Uint8Array, publicKey: string, cipherMode?: number): string;
+declare function doEncrypt(msg: string | Uint8Array, publicKey: string | ProjPointType<bigint>, cipherMode?: number, options?: {
+    asn1?: boolean;
+}): string;
 /**
  * 解密
  */
 declare function doDecrypt(encryptData: string, privateKey: string, cipherMode?: number, options?: {
     output: 'array';
+    asn1?: boolean;
 }): Uint8Array;
 declare function doDecrypt(encryptData: string, privateKey: string, cipherMode?: number, options?: {
     output: 'string';
+    asn1?: boolean;
 }): string;
 interface SignaturePoint {
     k: bigint;
@@ -74,7 +80,7 @@ declare function doSignature(msg: Uint8Array | string, privateKey: string, optio
 /**
  * 验签
  */
-declare function doVerifySignature(msg: string | Uint8Array, signHex: string, publicKey: string, options?: {
+declare function doVerifySignature(msg: string | Uint8Array, signHex: string, publicKey: string | ProjPointType<bigint>, options?: {
     der?: boolean;
     hash?: boolean;
     userId?: string;
@@ -84,6 +90,14 @@ declare function getZ(publicKey: string, userId?: string): Uint8Array;
  * sm3杂凑算法
  */
 declare function getHash(hashHex: string | Uint8Array, publicKey: string, userId?: string): string;
+/**
+ * 预计算公钥点，可用于提升加密性能
+ * @export
+ * @param {string} publicKey 公钥
+ * @param windowSize 计算窗口大小，默认为 8
+ * @returns {ProjPointType<bigint>} 预计算的点
+ */
+declare function precomputePublicKey(publicKey: string, windowSize?: number): ProjPointType<bigint>;
 /**
  * 计算公钥
  */
@@ -106,6 +120,7 @@ declare const index$1_doSignature: typeof doSignature;
 declare const index$1_doVerifySignature: typeof doVerifySignature;
 declare const index$1_getZ: typeof getZ;
 declare const index$1_getHash: typeof getHash;
+declare const index$1_precomputePublicKey: typeof precomputePublicKey;
 declare const index$1_getPublicKeyFromPrivateKey: typeof getPublicKeyFromPrivateKey;
 declare const index$1_getPoint: typeof getPoint;
 declare const index$1_initRNGPool: typeof initRNGPool;
@@ -130,6 +145,7 @@ declare namespace index$1 {
     index$1_doVerifySignature as doVerifySignature,
     index$1_getZ as getZ,
     index$1_getHash as getHash,
+    index$1_precomputePublicKey as precomputePublicKey,
     index$1_getPublicKeyFromPrivateKey as getPublicKeyFromPrivateKey,
     index$1_getPoint as getPoint,
     index$1_initRNGPool as initRNGPool,

package/dist/index.js

@@ -53,6 +53,7 @@ __export(sm2_exports, {
   hexToArray: () => hexToArray,
   initRNGPool: () => initRNGPool,
   leftPad: () => leftPad,
+  precomputePublicKey: () => precomputePublicKey,
   utf8ToHex: () => utf8ToHex,
   verifyPublicKey: () => verifyPublicKey
 });
@@ -132,6 +133,19 @@ var DERInteger = class extends ASN1Object {
     return this.v;
   }
 };
+var DEROctetString = class extends ASN1Object {
+  constructor(s) {
+    super();
+    this.s = s;
+    this.t = "04";
+    if (s)
+      this.v = s.toLowerCase();
+  }
+  hV = "";
+  getValue() {
+    return this.v;
+  }
+};
 var DERSequence = class extends ASN1Object {
   constructor(asn1Array) {
     super();
@@ -166,11 +180,19 @@ function encodeDer(r, s) {
   const derSeq = new DERSequence([derR, derS]);
   return derSeq.getEncodedHex();
 }
+function encodeEnc(x2, y, hash, cipher) {
+  const derX = new DERInteger(x2);
+  const derY = new DERInteger(y);
+  const derHash = new DEROctetString(hash);
+  const derCipher = new DEROctetString(cipher);
+  const derSeq = new DERSequence([derX, derY, derHash, derCipher]);
+  return derSeq.getEncodedHex();
+}
 function decodeDer(input) {
   const start = getStartOfV(input, 0);
   const vIndexR = getStartOfV(input, start);
   const lR = getL(input, start);
-  const vR = input.substr(vIndexR, lR * 2);
+  const vR = input.substring(vIndexR, vIndexR + lR * 2);
   const nextStart = vIndexR + vR.length;
   const vIndexS = getStartOfV(input, nextStart);
   const lS = getL(input, nextStart);
@@ -179,6 +201,23 @@ function decodeDer(input) {
   const s = utils.hexToNumber(vS);
   return { r, s };
 }
+function decodeEnc(input) {
+  function extractSequence(input2, start2) {
+    const vIndex = getStartOfV(input2, start2);
+    const length = getL(input2, start2);
+    const value = input2.substring(vIndex, vIndex + length * 2);
+    const nextStart = vIndex + value.length;
+    return { value, nextStart };
+  }
+  const start = getStartOfV(input, 0);
+  const { value: vR, nextStart: startS } = extractSequence(input, start);
+  const { value: vS, nextStart: startHash } = extractSequence(input, startS);
+  const { value: hash, nextStart: startCipher } = extractSequence(input, startHash);
+  const { value: cipher } = extractSequence(input, startCipher);
+  const x2 = utils.hexToNumber(vR);
+  const y = utils.hexToNumber(vS);
+  return { x: x2, y, hash, cipher };
+}
 
 // src/sm2/utils.ts
 var utils2 = __toESM(require("@noble/curves/abstract/utils"));
@@ -640,9 +679,12 @@ function verifyPublicKey(publicKey) {
   const point = sm2Curve.ProjectivePoint.fromHex(publicKey);
   if (!point)
     return false;
-  const x2 = point.x;
-  const y = point.y;
-  return sm2Fp.sqr(y) === sm2Fp.add(sm2Fp.addN(sm2Fp.mulN(x2, sm2Fp.sqrN(x2)), sm2Fp.mulN(x2, sm2Curve.CURVE.a)), sm2Curve.CURVE.b);
+  try {
+    point.assertValidity();
+    return true;
+  } catch (error) {
+    return false;
+  }
 }
 function comparePublicKeyHex(publicKey1, publicKey2) {
   const point1 = sm2Curve.ProjectivePoint.fromHex(publicKey1);
@@ -710,9 +752,9 @@ function calculateSharedKey(keypairA, ephemeralKeypairA, publicKeyB, ephemeralPu
 // src/sm2/index.ts
 var C1C2C3 = 0;
 var EmptyArray = new Uint8Array();
-function doEncrypt(msg, publicKey, cipherMode = 1) {
+function doEncrypt(msg, publicKey, cipherMode = 1, options) {
   const msgArr = typeof msg === "string" ? hexToArray(utf8ToHex(msg)) : Uint8Array.from(msg);
-  const publicKeyPoint = sm2Curve.ProjectivePoint.fromHex(publicKey);
+  const publicKeyPoint = typeof publicKey === "string" ? sm2Curve.ProjectivePoint.fromHex(publicKey) : publicKey;
   const keypair = generateKeyPairHex();
   const k = utils4.hexToNumber(keypair.privateKey);
   let c1 = keypair.publicKey;
@@ -724,6 +766,11 @@ function doEncrypt(msg, publicKey, cipherMode = 1) {
   const c3 = bytesToHex(sm3(utils4.concatBytes(x2, msgArr, y2)));
   xorCipherStream(x2, y2, msgArr);
   const c2 = bytesToHex(msgArr);
+  if (options?.asn1) {
+    const point = sm2Curve.ProjectivePoint.fromHex(keypair.publicKey);
+    const encode = cipherMode === C1C2C3 ? encodeEnc(point.x, point.y, c2, c3) : encodeEnc(point.x, point.y, c3, c2);
+    return encode;
+  }
   return cipherMode === C1C2C3 ? c1 + c2 + c3 : c1 + c3 + c2;
 }
 function xorCipherStream(x2, y2, msg) {
@@ -748,17 +795,31 @@ function xorCipherStream(x2, y2, msg) {
   }
 }
 function doDecrypt(encryptData, privateKey, cipherMode = 1, {
-  output = "string"
+  output = "string",
+  asn1 = false
 } = {}) {
   const privateKeyInteger = utils4.hexToNumber(privateKey);
-  let c3 = encryptData.substring(128, 128 + 64);
-  let c2 = encryptData.substring(128 + 64);
-  if (cipherMode === C1C2C3) {
-    c3 = encryptData.substring(encryptData.length - 64);
-    c2 = encryptData.substring(128, encryptData.length - 64);
+  let c1;
+  let c2;
+  let c3;
+  if (asn1) {
+    const { x: x3, y, cipher, hash } = decodeEnc(encryptData);
+    c1 = sm2Curve.ProjectivePoint.fromAffine({ x: x3, y });
+    c3 = hash;
+    c2 = cipher;
+    if (cipherMode === C1C2C3) {
+      [c2, c3] = [c3, c2];
+    }
+  } else {
+    c1 = sm2Curve.ProjectivePoint.fromHex("04" + encryptData.substring(0, 128));
+    c3 = encryptData.substring(128, 128 + 64);
+    c2 = encryptData.substring(128 + 64);
+    if (cipherMode === C1C2C3) {
+      c3 = encryptData.substring(encryptData.length - 64);
+      c2 = encryptData.substring(128, encryptData.length - 64);
+    }
   }
   const msg = hexToArray(c2);
-  const c1 = sm2Curve.ProjectivePoint.fromHex("04" + encryptData.substring(0, 128));
   const p = c1.multiply(privateKeyInteger);
   const x2 = hexToArray(leftPad(utils4.numberToHexUnpadded(p.x), 64));
   const y2 = hexToArray(leftPad(utils4.numberToHexUnpadded(p.y), 64));
@@ -812,8 +873,9 @@ function doVerifySignature(msg, signHex, publicKey, options = {}) {
     der,
     userId
   } = options;
+  const publicKeyHex = typeof publicKey === "string" ? publicKey : publicKey.toHex(false);
   if (hash) {
-    hashHex = getHash(typeof msg === "string" ? utf8ToHex(msg) : msg, publicKey, userId);
+    hashHex = getHash(typeof msg === "string" ? utf8ToHex(msg) : msg, publicKeyHex, userId);
   } else {
     hashHex = typeof msg === "string" ? utf8ToHex(msg) : arrayToHex(Array.from(msg));
   }
@@ -827,7 +889,7 @@ function doVerifySignature(msg, signHex, publicKey, options = {}) {
     r = utils4.hexToNumber(signHex.substring(0, 64));
     s = utils4.hexToNumber(signHex.substring(64));
   }
-  const PA = sm2Curve.ProjectivePoint.fromHex(publicKey);
+  const PA = typeof publicKey === "string" ? sm2Curve.ProjectivePoint.fromHex(publicKey) : publicKey;
   const e = utils4.hexToNumber(hashHex);
   const t = field.add(r, s);
   if (t === ZERO)
@@ -861,6 +923,10 @@ function getHash(hashHex, publicKey, userId = "1234567812345678") {
   const z = getZ(publicKey, userId);
   return bytesToHex(sm3(utils4.concatBytes(z, typeof hashHex === "string" ? hexToArray(hashHex) : hashHex)));
 }
+function precomputePublicKey(publicKey, windowSize) {
+  const point = sm2Curve.ProjectivePoint.fromHex(publicKey);
+  return sm2Curve.utils.precompute(windowSize, point);
+}
 function getPublicKeyFromPrivateKey(privateKey) {
   const pubKey = sm2Curve.getPublicKey(privateKey, false);
   const pubPad = leftPad(utils4.bytesToHex(pubKey), 64);

package/dist/index.mjs

@@ -25,6 +25,7 @@ __export(sm2_exports, {
   hexToArray: () => hexToArray,
   initRNGPool: () => initRNGPool,
   leftPad: () => leftPad,
+  precomputePublicKey: () => precomputePublicKey,
   utf8ToHex: () => utf8ToHex,
   verifyPublicKey: () => verifyPublicKey
 });
@@ -104,6 +105,19 @@ var DERInteger = class extends ASN1Object {
     return this.v;
   }
 };
+var DEROctetString = class extends ASN1Object {
+  constructor(s) {
+    super();
+    this.s = s;
+    this.t = "04";
+    if (s)
+      this.v = s.toLowerCase();
+  }
+  hV = "";
+  getValue() {
+    return this.v;
+  }
+};
 var DERSequence = class extends ASN1Object {
   constructor(asn1Array) {
     super();
@@ -138,11 +152,19 @@ function encodeDer(r, s) {
   const derSeq = new DERSequence([derR, derS]);
   return derSeq.getEncodedHex();
 }
+function encodeEnc(x2, y, hash, cipher) {
+  const derX = new DERInteger(x2);
+  const derY = new DERInteger(y);
+  const derHash = new DEROctetString(hash);
+  const derCipher = new DEROctetString(cipher);
+  const derSeq = new DERSequence([derX, derY, derHash, derCipher]);
+  return derSeq.getEncodedHex();
+}
 function decodeDer(input) {
   const start = getStartOfV(input, 0);
   const vIndexR = getStartOfV(input, start);
   const lR = getL(input, start);
-  const vR = input.substr(vIndexR, lR * 2);
+  const vR = input.substring(vIndexR, vIndexR + lR * 2);
   const nextStart = vIndexR + vR.length;
   const vIndexS = getStartOfV(input, nextStart);
   const lS = getL(input, nextStart);
@@ -151,6 +173,23 @@ function decodeDer(input) {
   const s = utils.hexToNumber(vS);
   return { r, s };
 }
+function decodeEnc(input) {
+  function extractSequence(input2, start2) {
+    const vIndex = getStartOfV(input2, start2);
+    const length = getL(input2, start2);
+    const value = input2.substring(vIndex, vIndex + length * 2);
+    const nextStart = vIndex + value.length;
+    return { value, nextStart };
+  }
+  const start = getStartOfV(input, 0);
+  const { value: vR, nextStart: startS } = extractSequence(input, start);
+  const { value: vS, nextStart: startHash } = extractSequence(input, startS);
+  const { value: hash, nextStart: startCipher } = extractSequence(input, startHash);
+  const { value: cipher } = extractSequence(input, startCipher);
+  const x2 = utils.hexToNumber(vR);
+  const y = utils.hexToNumber(vS);
+  return { x: x2, y, hash, cipher };
+}
 
 // src/sm2/utils.ts
 import * as utils2 from "@noble/curves/abstract/utils";
@@ -612,9 +651,12 @@ function verifyPublicKey(publicKey) {
   const point = sm2Curve.ProjectivePoint.fromHex(publicKey);
   if (!point)
     return false;
-  const x2 = point.x;
-  const y = point.y;
-  return sm2Fp.sqr(y) === sm2Fp.add(sm2Fp.addN(sm2Fp.mulN(x2, sm2Fp.sqrN(x2)), sm2Fp.mulN(x2, sm2Curve.CURVE.a)), sm2Curve.CURVE.b);
+  try {
+    point.assertValidity();
+    return true;
+  } catch (error) {
+    return false;
+  }
 }
 function comparePublicKeyHex(publicKey1, publicKey2) {
   const point1 = sm2Curve.ProjectivePoint.fromHex(publicKey1);
@@ -682,9 +724,9 @@ function calculateSharedKey(keypairA, ephemeralKeypairA, publicKeyB, ephemeralPu
 // src/sm2/index.ts
 var C1C2C3 = 0;
 var EmptyArray = new Uint8Array();
-function doEncrypt(msg, publicKey, cipherMode = 1) {
+function doEncrypt(msg, publicKey, cipherMode = 1, options) {
   const msgArr = typeof msg === "string" ? hexToArray(utf8ToHex(msg)) : Uint8Array.from(msg);
-  const publicKeyPoint = sm2Curve.ProjectivePoint.fromHex(publicKey);
+  const publicKeyPoint = typeof publicKey === "string" ? sm2Curve.ProjectivePoint.fromHex(publicKey) : publicKey;
   const keypair = generateKeyPairHex();
   const k = utils4.hexToNumber(keypair.privateKey);
   let c1 = keypair.publicKey;
@@ -696,6 +738,11 @@ function doEncrypt(msg, publicKey, cipherMode = 1) {
   const c3 = bytesToHex(sm3(utils4.concatBytes(x2, msgArr, y2)));
   xorCipherStream(x2, y2, msgArr);
   const c2 = bytesToHex(msgArr);
+  if (options?.asn1) {
+    const point = sm2Curve.ProjectivePoint.fromHex(keypair.publicKey);
+    const encode = cipherMode === C1C2C3 ? encodeEnc(point.x, point.y, c2, c3) : encodeEnc(point.x, point.y, c3, c2);
+    return encode;
+  }
   return cipherMode === C1C2C3 ? c1 + c2 + c3 : c1 + c3 + c2;
 }
 function xorCipherStream(x2, y2, msg) {
@@ -720,17 +767,31 @@ function xorCipherStream(x2, y2, msg) {
   }
 }
 function doDecrypt(encryptData, privateKey, cipherMode = 1, {
-  output = "string"
+  output = "string",
+  asn1 = false
 } = {}) {
   const privateKeyInteger = utils4.hexToNumber(privateKey);
-  let c3 = encryptData.substring(128, 128 + 64);
-  let c2 = encryptData.substring(128 + 64);
-  if (cipherMode === C1C2C3) {
-    c3 = encryptData.substring(encryptData.length - 64);
-    c2 = encryptData.substring(128, encryptData.length - 64);
+  let c1;
+  let c2;
+  let c3;
+  if (asn1) {
+    const { x: x3, y, cipher, hash } = decodeEnc(encryptData);
+    c1 = sm2Curve.ProjectivePoint.fromAffine({ x: x3, y });
+    c3 = hash;
+    c2 = cipher;
+    if (cipherMode === C1C2C3) {
+      [c2, c3] = [c3, c2];
+    }
+  } else {
+    c1 = sm2Curve.ProjectivePoint.fromHex("04" + encryptData.substring(0, 128));
+    c3 = encryptData.substring(128, 128 + 64);
+    c2 = encryptData.substring(128 + 64);
+    if (cipherMode === C1C2C3) {
+      c3 = encryptData.substring(encryptData.length - 64);
+      c2 = encryptData.substring(128, encryptData.length - 64);
+    }
   }
   const msg = hexToArray(c2);
-  const c1 = sm2Curve.ProjectivePoint.fromHex("04" + encryptData.substring(0, 128));
   const p = c1.multiply(privateKeyInteger);
   const x2 = hexToArray(leftPad(utils4.numberToHexUnpadded(p.x), 64));
   const y2 = hexToArray(leftPad(utils4.numberToHexUnpadded(p.y), 64));
@@ -784,8 +845,9 @@ function doVerifySignature(msg, signHex, publicKey, options = {}) {
     der,
     userId
   } = options;
+  const publicKeyHex = typeof publicKey === "string" ? publicKey : publicKey.toHex(false);
   if (hash) {
-    hashHex = getHash(typeof msg === "string" ? utf8ToHex(msg) : msg, publicKey, userId);
+    hashHex = getHash(typeof msg === "string" ? utf8ToHex(msg) : msg, publicKeyHex, userId);
   } else {
     hashHex = typeof msg === "string" ? utf8ToHex(msg) : arrayToHex(Array.from(msg));
   }
@@ -799,7 +861,7 @@ function doVerifySignature(msg, signHex, publicKey, options = {}) {
     r = utils4.hexToNumber(signHex.substring(0, 64));
     s = utils4.hexToNumber(signHex.substring(64));
   }
-  const PA = sm2Curve.ProjectivePoint.fromHex(publicKey);
+  const PA = typeof publicKey === "string" ? sm2Curve.ProjectivePoint.fromHex(publicKey) : publicKey;
   const e = utils4.hexToNumber(hashHex);
   const t = field.add(r, s);
   if (t === ZERO)
@@ -833,6 +895,10 @@ function getHash(hashHex, publicKey, userId = "1234567812345678") {
   const z = getZ(publicKey, userId);
   return bytesToHex(sm3(utils4.concatBytes(z, typeof hashHex === "string" ? hexToArray(hashHex) : hashHex)));
 }
+function precomputePublicKey(publicKey, windowSize) {
+  const point = sm2Curve.ProjectivePoint.fromHex(publicKey);
+  return sm2Curve.utils.precompute(windowSize, point);
+}
 function getPublicKeyFromPrivateKey(privateKey) {
   const pubKey = sm2Curve.getPublicKey(privateKey, false);
   const pubPad = leftPad(utils4.bytesToHex(pubKey), 64);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sm-crypto-v2",
-  "version": "1.6.0",
+  "version": "1.8.0",
   "description": "sm-crypto-v2",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -33,6 +33,7 @@
     "@noble/curves": "^1.1.0"
   },
   "devDependencies": {
+    "@swc-node/register": "^1.6.6",
     "@swc/core": "^1.3.62",
     "@types/node": "^16",
     "@typescript-eslint/eslint-plugin": "^5.23.0",
@@ -40,6 +41,7 @@
     "@vitest/coverage-c8": "^0.31.0",
     "@vitest/coverage-istanbul": "^0.31.0",
     "@vitest/expect": "^0.31.4",
+    "@vitest/runner": "^0.33.0",
     "@vitest/ui": "^0.31.0",
     "conventional-changelog-cli": "^2.2.2",
     "eslint": "^8.15.0",

package/src/sm2/asn1.ts

@@ -2,6 +2,7 @@
 
 import * as utils from '@noble/curves/abstract/utils';
 import { ONE } from './bn';
+import { utf8ToHex } from './utils';
 
 export function bigintToValue(bigint: bigint) {
   let h = bigint.toString(16)
@@ -81,6 +82,20 @@ class DERInteger extends ASN1Object {
   }
 }
 
+class DEROctetString extends ASN1Object {
+  public hV: string = ''
+  constructor(public s: string) {
+    super()
+
+    this.t = '04' // octstr 标签说明
+    if (s) this.v = s.toLowerCase()
+  }
+
+  getValue() {
+    return this.v
+  }
+}
+
 class DERSequence extends ASN1Object {
   public t = '30'
   constructor(public asn1Array: ASN1Object[]) {
@@ -134,6 +149,14 @@ export function encodeDer(r: bigint, s: bigint) {
   return derSeq.getEncodedHex()
 }
 
+export function encodeEnc(x: bigint, y: bigint, hash: string, cipher: string) {
+  const derX = new DERInteger(x)
+  const derY = new DERInteger(y)
+  const derHash = new DEROctetString(hash)
+  const derCipher = new DEROctetString(cipher)
+  const derSeq = new DERSequence([derX, derY, derHash, derCipher])
+  return derSeq.getEncodedHex()
+}
 /**
  * 解析 ASN.1 der，针对 sm2 验签
  */
@@ -145,7 +168,7 @@ export function decodeDer(input: string) {
 
   const vIndexR = getStartOfV(input, start)
   const lR = getL(input, start)
-  const vR = input.substr(vIndexR, lR * 2)
+  const vR = input.substring(vIndexR, vIndexR +lR * 2)
 
   const nextStart = vIndexR + vR.length
   const vIndexS = getStartOfV(input, nextStart)
@@ -159,3 +182,29 @@ export function decodeDer(input: string) {
 
   return { r, s }
 }
+
+/**
+ * 解析 ASN.1 der，针对 sm2 加密
+ */
+export function decodeEnc(input: string) {
+  // Extracts a sequence from the input based on the current start index.
+  function extractSequence(input: string, start: number): { value: string; nextStart: number } {
+    const vIndex = getStartOfV(input, start);
+    const length = getL(input, start);
+    const value = input.substring(vIndex, vIndex + length * 2);
+    const nextStart = vIndex + value.length;
+    return { value, nextStart };
+  }
+
+  const start = getStartOfV(input, 0);
+
+  const { value: vR, nextStart: startS } = extractSequence(input, start);
+  const { value: vS, nextStart: startHash } = extractSequence(input, startS);
+  const { value: hash, nextStart: startCipher } = extractSequence(input, startHash);
+  const { value: cipher } = extractSequence(input, startCipher);
+
+  const x = utils.hexToNumber(vR);
+  const y = utils.hexToNumber(vS);
+
+  return { x, y, hash, cipher };
+}

package/src/sm2/index.ts

@@ -1,11 +1,12 @@
 /* eslint-disable no-use-before-define */
-import { encodeDer, decodeDer } from './asn1'
+import { encodeDer, decodeDer, encodeEnc, decodeEnc } from './asn1'
 import { arrayToHex, arrayToUtf8, generateKeyPairHex, hexToArray, leftPad, utf8ToHex } from './utils'
 import { sm3 } from './sm3'
 import * as utils from '@noble/curves/abstract/utils';
 import { field, sm2Curve } from './ec';
 import { ONE, ZERO } from './bn';
 import { bytesToHex } from '@/sm3/utils';
+import { ProjPointType } from '@noble/curves/abstract/weierstrass';
 
 export * from './utils'
 export { initRNGPool } from './rng'
@@ -17,18 +18,22 @@ export const EmptyArray = new Uint8Array()
 /**
  * 加密
  */
-export function doEncrypt(msg: string | Uint8Array, publicKey: string, cipherMode = 1) {
+export function doEncrypt(msg: string | Uint8Array, publicKey: string | ProjPointType<bigint>, cipherMode = 1, options?: {
+  asn1?: boolean // 使用 ASN.1 对 C1 编码
+}) {
 
   const msgArr = typeof msg === 'string' ? hexToArray(utf8ToHex(msg)) : Uint8Array.from(msg)
-  const publicKeyPoint = sm2Curve.ProjectivePoint.fromHex(publicKey)
+  const publicKeyPoint = typeof publicKey === 'string' ? sm2Curve.ProjectivePoint.fromHex(publicKey) :
+    publicKey
 
   const keypair = generateKeyPairHex()
   const k = utils.hexToNumber(keypair.privateKey)
 
   // c1 = k * G
   let c1 = keypair.publicKey
+
   if (c1.length > 128) c1 = c1.substring(c1.length - 128)
-  const p = publicKeyPoint!.multiply(k)
+  const p = publicKeyPoint.multiply(k)
   
   // (x2, y2) = k * publicKey
   const x2 = hexToArray(leftPad(utils.numberToHexUnpadded(p.x), 64))
@@ -39,7 +44,13 @@ export function doEncrypt(msg: string | Uint8Array, publicKey: string, cipherMod
 
   xorCipherStream(x2, y2, msgArr)
   const c2 = bytesToHex(msgArr)
-
+  if (options?.asn1) {
+    const point = sm2Curve.ProjectivePoint.fromHex(keypair.publicKey)
+    const encode = cipherMode === C1C2C3 ? 
+     encodeEnc(point.x, point.y, c2, c3) :
+     encodeEnc(point.x, point.y, c3, c2)
+    return encode
+  }
   return cipherMode === C1C2C3 ? c1 + c2 + c3 : c1 + c3 + c2
 }
 
@@ -76,26 +87,45 @@ function xorCipherStream(x2: Uint8Array, y2: Uint8Array, msg: Uint8Array) {
  */
 export function doDecrypt(encryptData: string, privateKey: string, cipherMode?: number, options?: {
   output: 'array'
+  asn1?: boolean
 }): Uint8Array
 export function doDecrypt(encryptData: string, privateKey: string, cipherMode?: number, options?: {
-  output: 'string'
+  output: 'string',
+  asn1?: boolean
 }): string
 export function doDecrypt(encryptData: string, privateKey: string, cipherMode = 1, {
   output = 'string',
+  asn1 = false,
 } = {}) {
   const privateKeyInteger = utils.hexToNumber(privateKey)
 
-  let c3 = encryptData.substring(128, 128 + 64)
-  let c2 = encryptData.substring(128 + 64)
+  let c1: ProjPointType<bigint>
+  let c2: string
+  let c3: string
+  
 
-  if (cipherMode === C1C2C3) {
-    c3 = encryptData.substring(encryptData.length - 64)
-    c2 = encryptData.substring(128, encryptData.length - 64)
+  if (asn1) {
+    const {x, y, cipher, hash} = decodeEnc(encryptData)
+    c1 = sm2Curve.ProjectivePoint.fromAffine({ x, y })
+    c3 = hash
+    c2 = cipher
+    if (cipherMode === C1C2C3) {
+      [c2, c3] = [c3, c2]
+    }
+  } else {
+    // c1c3c2
+    c1 = sm2Curve.ProjectivePoint.fromHex('04' + encryptData.substring(0, 128))!
+    c3 = encryptData.substring(128, 128 + 64)
+    c2 = encryptData.substring(128 + 64)
+  
+    if (cipherMode === C1C2C3) {
+      c3 = encryptData.substring(encryptData.length - 64)
+      c2 = encryptData.substring(128, encryptData.length - 64)
+    }
   }
+  
 
   const msg = hexToArray(c2)
-  const c1 = sm2Curve.ProjectivePoint.fromHex('04' + encryptData.substring(0, 128))!
-
   const p = c1.multiply(privateKeyInteger)
   const x2 = hexToArray(leftPad(utils.numberToHexUnpadded(p.x), 64))
   const y2 = hexToArray(leftPad(utils.numberToHexUnpadded(p.y), 64))
@@ -103,7 +133,7 @@ export function doDecrypt(encryptData: string, privateKey: string, cipherMode =
   xorCipherStream(x2, y2, msg)
   // c3 = hash(x2 || msg || y2)
   const checkC3 = arrayToHex(Array.from(sm3(utils.concatBytes(x2, msg, y2))))
-
+  
   if (checkC3 === c3.toLowerCase()) {
     return output === 'array' ? msg : arrayToUtf8(msg)
   } else {
@@ -165,16 +195,17 @@ export function doSignature(msg: Uint8Array | string, privateKey: string, option
 /**
  * 验签
  */
-export function doVerifySignature(msg: string | Uint8Array, signHex: string, publicKey: string, options: { der?: boolean, hash?: boolean, userId?: string } = {}) {
+export function doVerifySignature(msg: string | Uint8Array, signHex: string, publicKey: string | ProjPointType<bigint>, options: { der?: boolean, hash?: boolean, userId?: string } = {}) {
   let hashHex: string
   const {
     hash,
     der,
     userId,
   } = options
+  const publicKeyHex = typeof publicKey === 'string' ? publicKey : publicKey.toHex(false)
   if (hash) {
     // sm3杂凑
-    hashHex = getHash(typeof msg === 'string' ? utf8ToHex(msg) : msg, publicKey, userId)
+    hashHex = getHash(typeof msg === 'string' ? utf8ToHex(msg) : msg, publicKeyHex, userId)
   } else {
     hashHex = typeof msg === 'string' ? utf8ToHex(msg) : arrayToHex(Array.from(msg))
   }
@@ -190,7 +221,7 @@ export function doVerifySignature(msg: string | Uint8Array, signHex: string, pub
     s = utils.hexToNumber(signHex.substring(64))
   }
   
-  const PA = sm2Curve.ProjectivePoint.fromHex(publicKey)!
+  const PA = typeof publicKey === 'string' ? sm2Curve.ProjectivePoint.fromHex(publicKey) : publicKey
   const e = utils.hexToNumber(hashHex)
   
   // t = (r + s) mod n
@@ -250,6 +281,18 @@ export function getHash(hashHex: string | Uint8Array, publicKey: string, userId
   return bytesToHex(sm3(utils.concatBytes(z, typeof hashHex === 'string' ? hexToArray(hashHex) : hashHex)))
 }
 
+/**
+ * 预计算公钥点，可用于提升加密性能
+ * @export
+ * @param {string} publicKey 公钥
+ * @param windowSize 计算窗口大小，默认为 8
+ * @returns {ProjPointType<bigint>} 预计算的点
+ */
+export function precomputePublicKey(publicKey: string, windowSize?: number) {
+  const point = sm2Curve.ProjectivePoint.fromHex(publicKey)
+  return sm2Curve.utils.precompute(windowSize, point)
+}
+
 /**
  * 计算公钥
  */

package/src/sm2/utils.ts

@@ -142,11 +142,12 @@ export function hexToArray(hexStr: string) {
 export function verifyPublicKey(publicKey: string) {
   const point = sm2Curve.ProjectivePoint.fromHex(publicKey)
   if (!point) return false
-
-  const x = point.x
-  const y = point.y
-  // 验证 y^2 是否等于 x^3 + ax + b
-  return sm2Fp.sqr(y) === sm2Fp.add(sm2Fp.addN(sm2Fp.mulN(x, sm2Fp.sqrN(x)), sm2Fp.mulN(x, sm2Curve.CURVE.a)), sm2Curve.CURVE.b)
+  try {
+    point.assertValidity()
+    return true
+  } catch (error) {
+    return false
+  }
 }
 
 /**

package/src/sm3/index.ts

@@ -1,6 +1,6 @@
 import { hmac } from '@/sm2/hmac'
 import { sm3 as sm2sm3 } from '../sm2/sm3'
-import { arrayToHex, hexToArray, leftPad } from '../sm2/utils'
+import { hexToArray } from '../sm2/utils'
 import { bytesToHex } from './utils'
 
 /**