sm-crypto-v2 1.7.0 → 1.9.0

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 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.9.0](https://github.com/Cubelrti/sm-crypto-v2/compare/v1.7.0...v1.9.0) (2023-12-27)
+
+
+### Features
+
+* **sm2:** support asn1 der encoded encryption/decryption ([f08b9fd](https://github.com/Cubelrti/sm-crypto-v2/commit/f08b9fd5b64a2a257d41694c1858d7a6b07326ae))
+* support miniprogram build ([bb4dddc](https://github.com/Cubelrti/sm-crypto-v2/commit/bb4dddcb4935299fe6db82912f393aa427961e40))
+
+## [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)
 
 

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'}) // 解密结果，输出数组

package/dist/index.d.mts

@@ -0,0 +1,175 @@
+import { ProjPointType } from '@noble/curves/abstract/weierstrass';
+
+interface KeyPair {
+    privateKey: string;
+    publicKey: string;
+}
+/**
+ * 生成密钥对：publicKey = privateKey * G
+ */
+declare function generateKeyPairHex(str?: string): KeyPair;
+/**
+ * 生成压缩公钥
+ */
+declare function compressPublicKeyHex(s: string): string;
+/**
+ * utf8串转16进制串
+ */
+declare function utf8ToHex(input: string): string;
+/**
+ * 补全16进制字符串
+ */
+declare function leftPad(input: string, num: number): string;
+/**
+ * 转成16进制串
+ */
+declare function arrayToHex(arr: number[]): string;
+/**
+ * 转成utf8串
+ */
+declare function arrayToUtf8(arr: Uint8Array): string;
+/**
+ * 转成字节数组
+ */
+declare function hexToArray(hexStr: string): Uint8Array;
+/**
+ * 验证公钥是否为椭圆曲线上的点
+ */
+declare function verifyPublicKey(publicKey: string): boolean;
+/**
+ * 验证公钥是否等价，等价返回true
+ */
+declare function comparePublicKeyHex(publicKey1: string, publicKey2: string): boolean;
+
+declare function initRNGPool(): Promise<void>;
+
+declare function calculateSharedKey(keypairA: KeyPair, ephemeralKeypairA: KeyPair, publicKeyB: string, ephemeralPublicKeyB: string, sharedKeyLength: number, isRecipient?: boolean, idA?: string, idB?: string): Uint8Array;
+
+declare const EmptyArray: Uint8Array;
+/**
+ * 加密
+ */
+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;
+    x1: bigint;
+}
+/**
+ * 签名
+ */
+declare function doSignature(msg: Uint8Array | string, privateKey: string, options?: {
+    pointPool?: SignaturePoint[];
+    der?: boolean;
+    hash?: boolean;
+    publicKey?: string;
+    userId?: string;
+}): string;
+/**
+ * 验签
+ */
+declare function doVerifySignature(msg: string | Uint8Array, signHex: string, publicKey: string | ProjPointType<bigint>, options?: {
+    der?: boolean;
+    hash?: boolean;
+    userId?: string;
+}): boolean;
+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>;
+/**
+ * 计算公钥
+ */
+declare function getPublicKeyFromPrivateKey(privateKey: string): string;
+/**
+ * 获取椭圆曲线点
+ */
+declare function getPoint(): {
+    k: bigint;
+    x1: bigint;
+    privateKey: string;
+    publicKey: string;
+};
+
+declare const index$1_EmptyArray: typeof EmptyArray;
+type index$1_KeyPair = KeyPair;
+type index$1_SignaturePoint = SignaturePoint;
+declare const index$1_arrayToHex: typeof arrayToHex;
+declare const index$1_arrayToUtf8: typeof arrayToUtf8;
+declare const index$1_calculateSharedKey: typeof calculateSharedKey;
+declare const index$1_comparePublicKeyHex: typeof comparePublicKeyHex;
+declare const index$1_compressPublicKeyHex: typeof compressPublicKeyHex;
+declare const index$1_doDecrypt: typeof doDecrypt;
+declare const index$1_doEncrypt: typeof doEncrypt;
+declare const index$1_doSignature: typeof doSignature;
+declare const index$1_doVerifySignature: typeof doVerifySignature;
+declare const index$1_generateKeyPairHex: typeof generateKeyPairHex;
+declare const index$1_getHash: typeof getHash;
+declare const index$1_getPoint: typeof getPoint;
+declare const index$1_getPublicKeyFromPrivateKey: typeof getPublicKeyFromPrivateKey;
+declare const index$1_getZ: typeof getZ;
+declare const index$1_hexToArray: typeof hexToArray;
+declare const index$1_initRNGPool: typeof initRNGPool;
+declare const index$1_leftPad: typeof leftPad;
+declare const index$1_precomputePublicKey: typeof precomputePublicKey;
+declare const index$1_utf8ToHex: typeof utf8ToHex;
+declare const index$1_verifyPublicKey: typeof verifyPublicKey;
+declare namespace index$1 {
+  export { index$1_EmptyArray as EmptyArray, type index$1_KeyPair as KeyPair, type index$1_SignaturePoint as SignaturePoint, index$1_arrayToHex as arrayToHex, index$1_arrayToUtf8 as arrayToUtf8, index$1_calculateSharedKey as calculateSharedKey, index$1_comparePublicKeyHex as comparePublicKeyHex, index$1_compressPublicKeyHex as compressPublicKeyHex, index$1_doDecrypt as doDecrypt, index$1_doEncrypt as doEncrypt, index$1_doSignature as doSignature, index$1_doVerifySignature as doVerifySignature, index$1_generateKeyPairHex as generateKeyPairHex, index$1_getHash as getHash, index$1_getPoint as getPoint, index$1_getPublicKeyFromPrivateKey as getPublicKeyFromPrivateKey, index$1_getZ as getZ, index$1_hexToArray as hexToArray, index$1_initRNGPool as initRNGPool, index$1_leftPad as leftPad, index$1_precomputePublicKey as precomputePublicKey, index$1_utf8ToHex as utf8ToHex, index$1_verifyPublicKey as verifyPublicKey };
+}
+
+declare function sm3(input: string | Uint8Array, options?: {
+    key: Uint8Array | string;
+    mode?: 'hmac' | 'mac';
+}): string;
+
+interface SM4Options {
+    padding?: 'pkcs#7' | 'pkcs#5' | 'none' | null;
+    mode?: 'cbc' | 'ecb';
+    iv?: Uint8Array | string;
+    output?: 'string' | 'array';
+}
+declare function sm4(inArray: Uint8Array | string, key: Uint8Array | string, cryptFlag: 0 | 1, options?: SM4Options): string | Uint8Array;
+declare function encrypt(inArray: Uint8Array | string, key: Uint8Array | string, options?: {
+    output: 'array';
+} | SM4Options): Uint8Array;
+declare function encrypt(inArray: Uint8Array | string, key: Uint8Array | string, options?: {
+    output: 'string';
+} | SM4Options): string;
+declare function decrypt(inArray: Uint8Array | string, key: Uint8Array | string, options?: {
+    output: 'array';
+} | SM4Options): Uint8Array;
+declare function decrypt(inArray: Uint8Array | string, key: Uint8Array | string, options?: {
+    output: 'string';
+} | SM4Options): string;
+
+type index_SM4Options = SM4Options;
+declare const index_decrypt: typeof decrypt;
+declare const index_encrypt: typeof encrypt;
+declare const index_sm4: typeof sm4;
+declare namespace index {
+  export { type index_SM4Options as SM4Options, index_decrypt as decrypt, index_encrypt as encrypt, index_sm4 as sm4 };
+}
+
+export { index$1 as sm2, sm3, index as sm4 };

package/dist/index.d.ts

@@ -49,15 +49,19 @@ declare const EmptyArray: Uint8Array;
 /**
  * 加密
  */
-declare function doEncrypt(msg: string | Uint8Array, publicKey: string | ProjPointType<bigint>, 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;
@@ -109,54 +113,30 @@ declare function getPoint(): {
 };
 
 declare const index$1_EmptyArray: typeof EmptyArray;
-declare const index$1_doEncrypt: typeof doEncrypt;
-declare const index$1_doDecrypt: typeof doDecrypt;
+type index$1_KeyPair = KeyPair;
 type index$1_SignaturePoint = SignaturePoint;
+declare const index$1_arrayToHex: typeof arrayToHex;
+declare const index$1_arrayToUtf8: typeof arrayToUtf8;
+declare const index$1_calculateSharedKey: typeof calculateSharedKey;
+declare const index$1_comparePublicKeyHex: typeof comparePublicKeyHex;
+declare const index$1_compressPublicKeyHex: typeof compressPublicKeyHex;
+declare const index$1_doDecrypt: typeof doDecrypt;
+declare const index$1_doEncrypt: typeof doEncrypt;
 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_generateKeyPairHex: typeof generateKeyPairHex;
 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_getPublicKeyFromPrivateKey: typeof getPublicKeyFromPrivateKey;
+declare const index$1_getZ: typeof getZ;
+declare const index$1_hexToArray: typeof hexToArray;
 declare const index$1_initRNGPool: typeof initRNGPool;
-declare const index$1_calculateSharedKey: typeof calculateSharedKey;
-type index$1_KeyPair = KeyPair;
-declare const index$1_generateKeyPairHex: typeof generateKeyPairHex;
-declare const index$1_compressPublicKeyHex: typeof compressPublicKeyHex;
-declare const index$1_utf8ToHex: typeof utf8ToHex;
 declare const index$1_leftPad: typeof leftPad;
-declare const index$1_arrayToHex: typeof arrayToHex;
-declare const index$1_arrayToUtf8: typeof arrayToUtf8;
-declare const index$1_hexToArray: typeof hexToArray;
+declare const index$1_precomputePublicKey: typeof precomputePublicKey;
+declare const index$1_utf8ToHex: typeof utf8ToHex;
 declare const index$1_verifyPublicKey: typeof verifyPublicKey;
-declare const index$1_comparePublicKeyHex: typeof comparePublicKeyHex;
 declare namespace index$1 {
-  export {
-    index$1_EmptyArray as EmptyArray,
-    index$1_doEncrypt as doEncrypt,
-    index$1_doDecrypt as doDecrypt,
-    index$1_SignaturePoint as SignaturePoint,
-    index$1_doSignature as doSignature,
-    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,
-    index$1_calculateSharedKey as calculateSharedKey,
-    index$1_KeyPair as KeyPair,
-    index$1_generateKeyPairHex as generateKeyPairHex,
-    index$1_compressPublicKeyHex as compressPublicKeyHex,
-    index$1_utf8ToHex as utf8ToHex,
-    index$1_leftPad as leftPad,
-    index$1_arrayToHex as arrayToHex,
-    index$1_arrayToUtf8 as arrayToUtf8,
-    index$1_hexToArray as hexToArray,
-    index$1_verifyPublicKey as verifyPublicKey,
-    index$1_comparePublicKeyHex as comparePublicKeyHex,
-  };
+  export { index$1_EmptyArray as EmptyArray, type index$1_KeyPair as KeyPair, type index$1_SignaturePoint as SignaturePoint, index$1_arrayToHex as arrayToHex, index$1_arrayToUtf8 as arrayToUtf8, index$1_calculateSharedKey as calculateSharedKey, index$1_comparePublicKeyHex as comparePublicKeyHex, index$1_compressPublicKeyHex as compressPublicKeyHex, index$1_doDecrypt as doDecrypt, index$1_doEncrypt as doEncrypt, index$1_doSignature as doSignature, index$1_doVerifySignature as doVerifySignature, index$1_generateKeyPairHex as generateKeyPairHex, index$1_getHash as getHash, index$1_getPoint as getPoint, index$1_getPublicKeyFromPrivateKey as getPublicKeyFromPrivateKey, index$1_getZ as getZ, index$1_hexToArray as hexToArray, index$1_initRNGPool as initRNGPool, index$1_leftPad as leftPad, index$1_precomputePublicKey as precomputePublicKey, index$1_utf8ToHex as utf8ToHex, index$1_verifyPublicKey as verifyPublicKey };
 }
 
 declare function sm3(input: string | Uint8Array, options?: {
@@ -185,16 +165,11 @@ declare function decrypt(inArray: Uint8Array | string, key: Uint8Array | string,
 } | SM4Options): string;
 
 type index_SM4Options = SM4Options;
-declare const index_sm4: typeof sm4;
-declare const index_encrypt: typeof encrypt;
 declare const index_decrypt: typeof decrypt;
+declare const index_encrypt: typeof encrypt;
+declare const index_sm4: typeof sm4;
 declare namespace index {
-  export {
-    index_SM4Options as SM4Options,
-    index_sm4 as sm4,
-    index_encrypt as encrypt,
-    index_decrypt as decrypt,
-  };
+  export { type index_SM4Options as SM4Options, index_decrypt as decrypt, index_encrypt as encrypt, index_sm4 as sm4 };
 }
 
 export { index$1 as sm2, sm3, index as sm4 };

package/dist/index.js

@@ -18,6 +18,10 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
   isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target,
   mod2
 ));
@@ -98,6 +102,9 @@ var ASN1Object = class {
     this.l = l;
     this.v = v;
   }
+  /**
+   * 获取 der 编码比特流16进制串
+   */
   getEncodedHex() {
     if (!this.tlv) {
       this.v = this.getValue();
@@ -133,6 +140,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();
@@ -167,11 +187,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);
@@ -180,6 +208,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"));
@@ -277,6 +322,7 @@ function toBytes(data) {
   return data;
 }
 var Hash = class {
+  // Safe version that clones internal state
   clone() {
     return this._cloneInto();
   }
@@ -326,6 +372,7 @@ var SHA2 = class extends Hash {
     this.buffer = new Uint8Array(blockLen);
     this.view = createView(this.buffer);
   }
+  // For partial updates less than block size
   buffer;
   view;
   finished = false;
@@ -407,6 +454,8 @@ var SM3_M = new Uint32Array(64);
 var T1 = 2043430169;
 var T2 = 2055708042;
 var SM3 = class extends SHA2 {
+  // We cannot use array here since array allows indexing by variable
+  // which means optimizer/compiler cannot use registers.
   A = IV[0] | 0;
   B = IV[1] | 0;
   C = IV[2] | 0;
@@ -422,6 +471,7 @@ var SM3 = class extends SHA2 {
     const { A, B, C, D, E, F, G, H } = this;
     return [A, B, C, D, E, F, G, H];
   }
+  // prettier-ignore
   set(A, B, C, D, E, F, G, H) {
     this.A = A | 0;
     this.B = B | 0;
@@ -547,6 +597,7 @@ hmac.create = (hash, key) => new HMAC(hash, key);
 var import_utils3 = require("@noble/curves/abstract/utils");
 var sm2Fp = (0, import_modular.Field)(BigInt("115792089210356248756420345214020892766250353991924191454421193933289684991999"));
 var sm2Curve = (0, import_weierstrass.weierstrass)({
+  // sm2: short weierstrass.
   a: BigInt("115792089210356248756420345214020892766250353991924191454421193933289684991996"),
   b: BigInt("18505919022281880113072981827955639221458448578012075254857346196103069175443"),
   Fp: sm2Fp,
@@ -714,7 +765,7 @@ 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 = typeof publicKey === "string" ? sm2Curve.ProjectivePoint.fromHex(publicKey) : publicKey;
   const keypair = generateKeyPairHex();
@@ -728,6 +779,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) {
@@ -752,17 +808,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));

package/dist/index.mjs

@@ -70,6 +70,9 @@ var ASN1Object = class {
     this.l = l;
     this.v = v;
   }
+  /**
+   * 获取 der 编码比特流16进制串
+   */
   getEncodedHex() {
     if (!this.tlv) {
       this.v = this.getValue();
@@ -105,6 +108,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();
@@ -139,11 +155,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);
@@ -152,6 +176,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";
@@ -249,6 +290,7 @@ function toBytes(data) {
   return data;
 }
 var Hash = class {
+  // Safe version that clones internal state
   clone() {
     return this._cloneInto();
   }
@@ -298,6 +340,7 @@ var SHA2 = class extends Hash {
     this.buffer = new Uint8Array(blockLen);
     this.view = createView(this.buffer);
   }
+  // For partial updates less than block size
   buffer;
   view;
   finished = false;
@@ -379,6 +422,8 @@ var SM3_M = new Uint32Array(64);
 var T1 = 2043430169;
 var T2 = 2055708042;
 var SM3 = class extends SHA2 {
+  // We cannot use array here since array allows indexing by variable
+  // which means optimizer/compiler cannot use registers.
   A = IV[0] | 0;
   B = IV[1] | 0;
   C = IV[2] | 0;
@@ -394,6 +439,7 @@ var SM3 = class extends SHA2 {
     const { A, B, C, D, E, F, G, H } = this;
     return [A, B, C, D, E, F, G, H];
   }
+  // prettier-ignore
   set(A, B, C, D, E, F, G, H) {
     this.A = A | 0;
     this.B = B | 0;
@@ -519,6 +565,7 @@ hmac.create = (hash, key) => new HMAC(hash, key);
 import { concatBytes } from "@noble/curves/abstract/utils";
 var sm2Fp = Field(BigInt("115792089210356248756420345214020892766250353991924191454421193933289684991999"));
 var sm2Curve = weierstrass({
+  // sm2: short weierstrass.
   a: BigInt("115792089210356248756420345214020892766250353991924191454421193933289684991996"),
   b: BigInt("18505919022281880113072981827955639221458448578012075254857346196103069175443"),
   Fp: sm2Fp,
@@ -686,7 +733,7 @@ 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 = typeof publicKey === "string" ? sm2Curve.ProjectivePoint.fromHex(publicKey) : publicKey;
   const keypair = generateKeyPairHex();
@@ -700,6 +747,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) {
@@ -724,17 +776,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));