sm-crypto-v2 1.9.3 → 1.10.0

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 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.10.0](https://github.com/Cubelrti/sm-crypto-v2/compare/v1.9.3...v1.10.0) (2025-04-14)
+
+
+### Features
+
+* **sm4:** support gcm mode for `sm4` ([2c6a0df](https://github.com/Cubelrti/sm-crypto-v2/commit/2c6a0df8d591d802fd4816c6b1824e20e0b23e31))
+
 ### [1.9.3](https://github.com/Cubelrti/sm-crypto-v2/compare/v1.9.2...v1.9.3) (2024-10-10)
 
 

package/dist/index.d.mts

@@ -146,30 +146,52 @@ declare function sm3(input: string | Uint8Array, options?: {
 
 interface SM4Options {
     padding?: 'pkcs#7' | 'pkcs#5' | 'none' | null;
-    mode?: 'cbc' | 'ecb';
+    mode?: 'cbc' | 'ecb' | 'gcm';
     iv?: Uint8Array | string;
     output?: 'string' | 'array';
+    associatedData?: Uint8Array | string;
+    outputTag?: boolean;
+    tag?: Uint8Array | string;
 }
-declare function sm4(inArray: Uint8Array | string, key: Uint8Array | string, cryptFlag: 0 | 1, options?: SM4Options): string | Uint8Array;
+declare function sm4(inArray: Uint8Array | string, key: Uint8Array | string, cryptFlag: 0 | 1, options?: SM4Options): string | Uint8Array | {
+    output: Uint8Array;
+    tag?: Uint8Array | undefined;
+} | {
+    output: string;
+    tag: string | undefined;
+};
+interface GCMResult<T = Uint8Array | string> {
+    output: T;
+    tag?: T;
+}
+declare function encrypt(inArray: Uint8Array | string, key: Uint8Array | string, options: {
+    mode: 'gcm';
+    output: 'array';
+} & SM4Options): GCMResult<Uint8Array>;
+declare function encrypt(inArray: Uint8Array | string, key: Uint8Array | string, options: {
+    mode: 'gcm';
+    output?: 'string';
+} & SM4Options): GCMResult<string>;
 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';
+    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';
+    output?: 'string';
 } & SM4Options): string;
 
+type index_GCMResult<T = Uint8Array | string> = GCMResult<T>;
 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 { type index_GCMResult as GCMResult, 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

@@ -146,30 +146,52 @@ declare function sm3(input: string | Uint8Array, options?: {
 
 interface SM4Options {
     padding?: 'pkcs#7' | 'pkcs#5' | 'none' | null;
-    mode?: 'cbc' | 'ecb';
+    mode?: 'cbc' | 'ecb' | 'gcm';
     iv?: Uint8Array | string;
     output?: 'string' | 'array';
+    associatedData?: Uint8Array | string;
+    outputTag?: boolean;
+    tag?: Uint8Array | string;
 }
-declare function sm4(inArray: Uint8Array | string, key: Uint8Array | string, cryptFlag: 0 | 1, options?: SM4Options): string | Uint8Array;
+declare function sm4(inArray: Uint8Array | string, key: Uint8Array | string, cryptFlag: 0 | 1, options?: SM4Options): string | Uint8Array | {
+    output: Uint8Array;
+    tag?: Uint8Array | undefined;
+} | {
+    output: string;
+    tag: string | undefined;
+};
+interface GCMResult<T = Uint8Array | string> {
+    output: T;
+    tag?: T;
+}
+declare function encrypt(inArray: Uint8Array | string, key: Uint8Array | string, options: {
+    mode: 'gcm';
+    output: 'array';
+} & SM4Options): GCMResult<Uint8Array>;
+declare function encrypt(inArray: Uint8Array | string, key: Uint8Array | string, options: {
+    mode: 'gcm';
+    output?: 'string';
+} & SM4Options): GCMResult<string>;
 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';
+    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';
+    output?: 'string';
 } & SM4Options): string;
 
+type index_GCMResult<T = Uint8Array | string> = GCMResult<T>;
 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 { type index_GCMResult as GCMResult, 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

@@ -998,6 +998,8 @@ __export(sm4_exports, {
   encrypt: () => encrypt,
   sm4: () => sm4
 });
+var import_polyval = require("@noble/ciphers/_polyval");
+var import_utils11 = require("@noble/ciphers/utils");
 var DECRYPT = 0;
 var ROUND = 32;
 var BLOCK = 16;
@@ -1385,14 +1387,148 @@ function sms4KeyExt(key, roundKey, cryptFlag) {
     }
   }
 }
+function incrementCounter(counter) {
+  for (let i = counter.length - 1; i >= 0; i--) {
+    counter[i]++;
+    if (counter[i] !== 0)
+      break;
+  }
+}
+function sm4Gcm(inArray, key, ivArray, aadArray, cryptFlag, tagArray) {
+  const tagLength = 16;
+  function deriveKeys() {
+    const roundKey2 = new Uint32Array(ROUND);
+    sms4KeyExt(key, roundKey2, 1);
+    const authKey = new Uint8Array(16).fill(0);
+    const h2 = new Uint8Array(16);
+    sms4Crypt(authKey, h2, roundKey2);
+    let j02;
+    if (ivArray.length === 12) {
+      j02 = new Uint8Array(16);
+      j02.set(ivArray, 0);
+      j02[15] = 1;
+    } else {
+      const g = import_polyval.ghash.create(h2);
+      g.update(ivArray);
+      const lenIv = new Uint8Array(16);
+      const view = (0, import_utils11.createView)(lenIv);
+      (0, import_utils11.setBigUint64)(view, 8, BigInt(ivArray.length * 8), false);
+      g.update(lenIv);
+      j02 = g.digest();
+    }
+    const counter2 = new Uint8Array(j02);
+    incrementCounter(counter2);
+    const tagMask2 = new Uint8Array(16);
+    sms4Crypt(j02, tagMask2, roundKey2);
+    return { roundKey: roundKey2, h: h2, j0: j02, counter: counter2, tagMask: tagMask2 };
+  }
+  function computeTag(h2, data) {
+    const aadLength = aadArray.length;
+    const dataLength = data.length;
+    const g = import_polyval.ghash.create(h2);
+    if (aadLength > 0) {
+      g.update(aadArray);
+    }
+    g.update(data);
+    const lenBlock = new Uint8Array(16);
+    const view = (0, import_utils11.createView)(lenBlock);
+    (0, import_utils11.setBigUint64)(view, 0, BigInt(aadLength * 8), false);
+    (0, import_utils11.setBigUint64)(view, 8, BigInt(dataLength * 8), false);
+    g.update(lenBlock);
+    return g.digest();
+  }
+  const { roundKey, h, j0, counter, tagMask } = deriveKeys();
+  if (cryptFlag === DECRYPT && tagArray) {
+    const calculatedTag = computeTag(h, inArray);
+    for (let i = 0; i < 16; i++) {
+      calculatedTag[i] ^= tagMask[i];
+    }
+    let tagMatch = 0;
+    for (let i = 0; i < 16; i++) {
+      tagMatch |= calculatedTag[i] ^ tagArray[i];
+    }
+    if (tagMatch !== 0) {
+      throw new Error("authentication tag mismatch");
+    }
+  }
+  const outArray = new Uint8Array(inArray.length);
+  let point = 0;
+  let restLen = inArray.length;
+  while (restLen >= BLOCK) {
+    const blockOut = new Uint8Array(BLOCK);
+    sms4Crypt(counter, blockOut, roundKey);
+    for (let i = 0; i < BLOCK && i < restLen; i++) {
+      outArray[point + i] = inArray[point + i] ^ blockOut[i];
+    }
+    incrementCounter(counter);
+    point += BLOCK;
+    restLen -= BLOCK;
+  }
+  if (restLen > 0) {
+    const blockOut = new Uint8Array(BLOCK);
+    sms4Crypt(counter, blockOut, roundKey);
+    for (let i = 0; i < restLen; i++) {
+      outArray[point + i] = inArray[point + i] ^ blockOut[i];
+    }
+  }
+  if (cryptFlag !== DECRYPT) {
+    const calculatedTag = computeTag(h, outArray);
+    for (let i = 0; i < 16; i++) {
+      calculatedTag[i] ^= tagMask[i];
+    }
+    return { output: outArray, tag: calculatedTag };
+  }
+  return { output: outArray };
+}
 var blockOutput = new Uint8Array(16);
 function sm4(inArray, key, cryptFlag, options = {}) {
   let {
     padding = "pkcs#7",
     mode,
     iv = new Uint8Array(16),
-    output
+    output,
+    associatedData,
+    outputTag,
+    tag
   } = options;
+  if (mode === "gcm") {
+    const keyArray = typeof key === "string" ? hexToArray(key) : Uint8Array.from(key);
+    const ivArray = typeof iv === "string" ? hexToArray(iv) : Uint8Array.from(iv);
+    const aadArray = associatedData ? typeof associatedData === "string" ? hexToArray(associatedData) : Uint8Array.from(associatedData) : new Uint8Array(0);
+    let inputArray;
+    if (typeof inArray === "string") {
+      if (cryptFlag !== DECRYPT) {
+        inputArray = utf8ToArray(inArray);
+      } else {
+        inputArray = hexToArray(inArray);
+      }
+    } else {
+      inputArray = Uint8Array.from(inArray);
+    }
+    const tagArray = tag ? typeof tag === "string" ? hexToArray(tag) : Uint8Array.from(tag) : void 0;
+    const result = sm4Gcm(inputArray, keyArray, ivArray, aadArray, cryptFlag, tagArray);
+    if (output === "array") {
+      if (outputTag && cryptFlag !== DECRYPT) {
+        return result;
+      }
+      return result.output;
+    } else {
+      if (outputTag && cryptFlag !== DECRYPT) {
+        return {
+          output: bytesToHex(result.output),
+          tag: result.tag ? bytesToHex(result.tag) : void 0
+        };
+      }
+      if (cryptFlag !== DECRYPT) {
+        return {
+          output: bytesToHex(result.output),
+          tag: result.tag ? bytesToHex(result.tag) : void 0
+        };
+      } else {
+        return arrayToUtf8(result.output);
+      }
+    }
+  }
   if (mode === "cbc") {
     if (typeof iv === "string")
       iv = hexToArray(iv);

package/dist/index.mjs

@@ -966,6 +966,8 @@ __export(sm4_exports, {
   encrypt: () => encrypt,
   sm4: () => sm4
 });
+import { ghash } from "@noble/ciphers/_polyval";
+import { createView as createView2, setBigUint64 as setBigUint642 } from "@noble/ciphers/utils";
 var DECRYPT = 0;
 var ROUND = 32;
 var BLOCK = 16;
@@ -1353,14 +1355,148 @@ function sms4KeyExt(key, roundKey, cryptFlag) {
     }
   }
 }
+function incrementCounter(counter) {
+  for (let i = counter.length - 1; i >= 0; i--) {
+    counter[i]++;
+    if (counter[i] !== 0)
+      break;
+  }
+}
+function sm4Gcm(inArray, key, ivArray, aadArray, cryptFlag, tagArray) {
+  const tagLength = 16;
+  function deriveKeys() {
+    const roundKey2 = new Uint32Array(ROUND);
+    sms4KeyExt(key, roundKey2, 1);
+    const authKey = new Uint8Array(16).fill(0);
+    const h2 = new Uint8Array(16);
+    sms4Crypt(authKey, h2, roundKey2);
+    let j02;
+    if (ivArray.length === 12) {
+      j02 = new Uint8Array(16);
+      j02.set(ivArray, 0);
+      j02[15] = 1;
+    } else {
+      const g = ghash.create(h2);
+      g.update(ivArray);
+      const lenIv = new Uint8Array(16);
+      const view = createView2(lenIv);
+      setBigUint642(view, 8, BigInt(ivArray.length * 8), false);
+      g.update(lenIv);
+      j02 = g.digest();
+    }
+    const counter2 = new Uint8Array(j02);
+    incrementCounter(counter2);
+    const tagMask2 = new Uint8Array(16);
+    sms4Crypt(j02, tagMask2, roundKey2);
+    return { roundKey: roundKey2, h: h2, j0: j02, counter: counter2, tagMask: tagMask2 };
+  }
+  function computeTag(h2, data) {
+    const aadLength = aadArray.length;
+    const dataLength = data.length;
+    const g = ghash.create(h2);
+    if (aadLength > 0) {
+      g.update(aadArray);
+    }
+    g.update(data);
+    const lenBlock = new Uint8Array(16);
+    const view = createView2(lenBlock);
+    setBigUint642(view, 0, BigInt(aadLength * 8), false);
+    setBigUint642(view, 8, BigInt(dataLength * 8), false);
+    g.update(lenBlock);
+    return g.digest();
+  }
+  const { roundKey, h, j0, counter, tagMask } = deriveKeys();
+  if (cryptFlag === DECRYPT && tagArray) {
+    const calculatedTag = computeTag(h, inArray);
+    for (let i = 0; i < 16; i++) {
+      calculatedTag[i] ^= tagMask[i];
+    }
+    let tagMatch = 0;
+    for (let i = 0; i < 16; i++) {
+      tagMatch |= calculatedTag[i] ^ tagArray[i];
+    }
+    if (tagMatch !== 0) {
+      throw new Error("authentication tag mismatch");
+    }
+  }
+  const outArray = new Uint8Array(inArray.length);
+  let point = 0;
+  let restLen = inArray.length;
+  while (restLen >= BLOCK) {
+    const blockOut = new Uint8Array(BLOCK);
+    sms4Crypt(counter, blockOut, roundKey);
+    for (let i = 0; i < BLOCK && i < restLen; i++) {
+      outArray[point + i] = inArray[point + i] ^ blockOut[i];
+    }
+    incrementCounter(counter);
+    point += BLOCK;
+    restLen -= BLOCK;
+  }
+  if (restLen > 0) {
+    const blockOut = new Uint8Array(BLOCK);
+    sms4Crypt(counter, blockOut, roundKey);
+    for (let i = 0; i < restLen; i++) {
+      outArray[point + i] = inArray[point + i] ^ blockOut[i];
+    }
+  }
+  if (cryptFlag !== DECRYPT) {
+    const calculatedTag = computeTag(h, outArray);
+    for (let i = 0; i < 16; i++) {
+      calculatedTag[i] ^= tagMask[i];
+    }
+    return { output: outArray, tag: calculatedTag };
+  }
+  return { output: outArray };
+}
 var blockOutput = new Uint8Array(16);
 function sm4(inArray, key, cryptFlag, options = {}) {
   let {
     padding = "pkcs#7",
     mode,
     iv = new Uint8Array(16),
-    output
+    output,
+    associatedData,
+    outputTag,
+    tag
   } = options;
+  if (mode === "gcm") {
+    const keyArray = typeof key === "string" ? hexToArray(key) : Uint8Array.from(key);
+    const ivArray = typeof iv === "string" ? hexToArray(iv) : Uint8Array.from(iv);
+    const aadArray = associatedData ? typeof associatedData === "string" ? hexToArray(associatedData) : Uint8Array.from(associatedData) : new Uint8Array(0);
+    let inputArray;
+    if (typeof inArray === "string") {
+      if (cryptFlag !== DECRYPT) {
+        inputArray = utf8ToArray(inArray);
+      } else {
+        inputArray = hexToArray(inArray);
+      }
+    } else {
+      inputArray = Uint8Array.from(inArray);
+    }
+    const tagArray = tag ? typeof tag === "string" ? hexToArray(tag) : Uint8Array.from(tag) : void 0;
+    const result = sm4Gcm(inputArray, keyArray, ivArray, aadArray, cryptFlag, tagArray);
+    if (output === "array") {
+      if (outputTag && cryptFlag !== DECRYPT) {
+        return result;
+      }
+      return result.output;
+    } else {
+      if (outputTag && cryptFlag !== DECRYPT) {
+        return {
+          output: bytesToHex(result.output),
+          tag: result.tag ? bytesToHex(result.tag) : void 0
+        };
+      }
+      if (cryptFlag !== DECRYPT) {
+        return {
+          output: bytesToHex(result.output),
+          tag: result.tag ? bytesToHex(result.tag) : void 0
+        };
+      } else {
+        return arrayToUtf8(result.output);
+      }
+    }
+  }
   if (mode === "cbc") {
     if (typeof iv === "string")
       iv = hexToArray(iv);

package/miniprogram_dist/index.d.ts

@@ -146,30 +146,52 @@ declare function sm3(input: string | Uint8Array, options?: {
 
 interface SM4Options {
     padding?: 'pkcs#7' | 'pkcs#5' | 'none' | null;
-    mode?: 'cbc' | 'ecb';
+    mode?: 'cbc' | 'ecb' | 'gcm';
     iv?: Uint8Array | string;
     output?: 'string' | 'array';
+    associatedData?: Uint8Array | string;
+    outputTag?: boolean;
+    tag?: Uint8Array | string;
 }
-declare function sm4(inArray: Uint8Array | string, key: Uint8Array | string, cryptFlag: 0 | 1, options?: SM4Options): string | Uint8Array;
+declare function sm4(inArray: Uint8Array | string, key: Uint8Array | string, cryptFlag: 0 | 1, options?: SM4Options): string | Uint8Array | {
+    output: Uint8Array;
+    tag?: Uint8Array | undefined;
+} | {
+    output: string;
+    tag: string | undefined;
+};
+interface GCMResult<T = Uint8Array | string> {
+    output: T;
+    tag?: T;
+}
+declare function encrypt(inArray: Uint8Array | string, key: Uint8Array | string, options: {
+    mode: 'gcm';
+    output: 'array';
+} & SM4Options): GCMResult<Uint8Array>;
+declare function encrypt(inArray: Uint8Array | string, key: Uint8Array | string, options: {
+    mode: 'gcm';
+    output?: 'string';
+} & SM4Options): GCMResult<string>;
 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';
+    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';
+    output?: 'string';
 } & SM4Options): string;
 
+type index_GCMResult<T = Uint8Array | string> = GCMResult<T>;
 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 { type index_GCMResult as GCMResult, 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/miniprogram_dist/index.js

@@ -3271,6 +3271,8 @@ __export(sm4_exports, {
         return sm4;
     }
 });
+var import_polyval = require("@noble/ciphers/_polyval");
+var import_utils14 = require("@noble/ciphers/utils");
 var DECRYPT = 0;
 var ROUND = 32;
 var BLOCK = 16;
@@ -3662,10 +3664,151 @@ function sms4KeyExt(key, roundKey, cryptFlag) {
         }
     }
 }
+function incrementCounter(counter) {
+    for(var i = counter.length - 1; i >= 0; i--){
+        counter[i]++;
+        if (counter[i] !== 0) break;
+    }
+}
+function sm4Gcm(inArray, key, ivArray, aadArray, cryptFlag, tagArray) {
+    var deriveKeys = function deriveKeys() {
+        var roundKey2 = new Uint32Array(ROUND);
+        sms4KeyExt(key, roundKey2, 1);
+        var authKey = new Uint8Array(16).fill(0);
+        var h2 = new Uint8Array(16);
+        sms4Crypt(authKey, h2, roundKey2);
+        var j02;
+        if (ivArray.length === 12) {
+            j02 = new Uint8Array(16);
+            j02.set(ivArray, 0);
+            j02[15] = 1;
+        } else {
+            var g = import_polyval.ghash.create(h2);
+            g.update(ivArray);
+            var lenIv = new Uint8Array(16);
+            var view = (0, import_utils14.createView)(lenIv);
+            (0, import_utils14.setBigUint64)(view, 8, BigInt(ivArray.length * 8), false);
+            g.update(lenIv);
+            j02 = g.digest();
+        }
+        var counter2 = new Uint8Array(j02);
+        incrementCounter(counter2);
+        var tagMask2 = new Uint8Array(16);
+        sms4Crypt(j02, tagMask2, roundKey2);
+        return {
+            roundKey: roundKey2,
+            h: h2,
+            j0: j02,
+            counter: counter2,
+            tagMask: tagMask2
+        };
+    };
+    var computeTag = function computeTag(h2, data) {
+        var aadLength = aadArray.length;
+        var dataLength = data.length;
+        var g = import_polyval.ghash.create(h2);
+        if (aadLength > 0) {
+            g.update(aadArray);
+        }
+        g.update(data);
+        var lenBlock = new Uint8Array(16);
+        var view = (0, import_utils14.createView)(lenBlock);
+        (0, import_utils14.setBigUint64)(view, 0, BigInt(aadLength * 8), false);
+        (0, import_utils14.setBigUint64)(view, 8, BigInt(dataLength * 8), false);
+        g.update(lenBlock);
+        return g.digest();
+    };
+    var tagLength = 16;
+    var _deriveKeys = deriveKeys(), roundKey = _deriveKeys.roundKey, h = _deriveKeys.h, j0 = _deriveKeys.j0, counter = _deriveKeys.counter, tagMask = _deriveKeys.tagMask;
+    if (cryptFlag === DECRYPT && tagArray) {
+        var calculatedTag = computeTag(h, inArray);
+        for(var i = 0; i < 16; i++){
+            calculatedTag[i] ^= tagMask[i];
+        }
+        var tagMatch = 0;
+        for(var i1 = 0; i1 < 16; i1++){
+            tagMatch |= calculatedTag[i1] ^ tagArray[i1];
+        }
+        if (tagMatch !== 0) {
+            throw new Error("authentication tag mismatch");
+        }
+    }
+    var outArray = new Uint8Array(inArray.length);
+    var point = 0;
+    var restLen = inArray.length;
+    while(restLen >= BLOCK){
+        var blockOut = new Uint8Array(BLOCK);
+        sms4Crypt(counter, blockOut, roundKey);
+        for(var i2 = 0; i2 < BLOCK && i2 < restLen; i2++){
+            outArray[point + i2] = inArray[point + i2] ^ blockOut[i2];
+        }
+        incrementCounter(counter);
+        point += BLOCK;
+        restLen -= BLOCK;
+    }
+    if (restLen > 0) {
+        var blockOut1 = new Uint8Array(BLOCK);
+        sms4Crypt(counter, blockOut1, roundKey);
+        for(var i3 = 0; i3 < restLen; i3++){
+            outArray[point + i3] = inArray[point + i3] ^ blockOut1[i3];
+        }
+    }
+    if (cryptFlag !== DECRYPT) {
+        var calculatedTag1 = computeTag(h, outArray);
+        for(var i4 = 0; i4 < 16; i4++){
+            calculatedTag1[i4] ^= tagMask[i4];
+        }
+        return {
+            output: outArray,
+            tag: calculatedTag1
+        };
+    }
+    return {
+        output: outArray
+    };
+}
 var blockOutput = new Uint8Array(16);
 function sm4(inArray, key, cryptFlag) {
     var options = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
-    var _options_padding = options.padding, padding = _options_padding === void 0 ? "pkcs#7" : _options_padding, mode = options.mode, _options_iv = options.iv, iv = _options_iv === void 0 ? new Uint8Array(16) : _options_iv, output = options.output;
+    var _options_padding = options.padding, padding = _options_padding === void 0 ? "pkcs#7" : _options_padding, mode = options.mode, _options_iv = options.iv, iv = _options_iv === void 0 ? new Uint8Array(16) : _options_iv, output = options.output, associatedData = options.associatedData, outputTag = options.outputTag, tag = options.tag;
+    if (mode === "gcm") {
+        var keyArray = typeof key === "string" ? hexToArray(key) : Uint8Array.from(key);
+        var ivArray = typeof iv === "string" ? hexToArray(iv) : Uint8Array.from(iv);
+        var aadArray = associatedData ? typeof associatedData === "string" ? hexToArray(associatedData) : Uint8Array.from(associatedData) : new Uint8Array(0);
+        var inputArray;
+        if (typeof inArray === "string") {
+            if (cryptFlag !== DECRYPT) {
+                inputArray = utf8ToArray(inArray);
+            } else {
+                inputArray = hexToArray(inArray);
+            }
+        } else {
+            inputArray = Uint8Array.from(inArray);
+        }
+        var tagArray = tag ? typeof tag === "string" ? hexToArray(tag) : Uint8Array.from(tag) : void 0;
+        var result = sm4Gcm(inputArray, keyArray, ivArray, aadArray, cryptFlag, tagArray);
+        if (output === "array") {
+            if (outputTag && cryptFlag !== DECRYPT) {
+                return result;
+            }
+            return result.output;
+        } else {
+            if (outputTag && cryptFlag !== DECRYPT) {
+                return {
+                    output: bytesToHex2(result.output),
+                    tag: result.tag ? bytesToHex2(result.tag) : void 0
+                };
+            }
+            if (cryptFlag !== DECRYPT) {
+                return {
+                    output: bytesToHex2(result.output),
+                    tag: result.tag ? bytesToHex2(result.tag) : void 0
+                };
+            } else {
+                return arrayToUtf8(result.output);
+            }
+        }
+    }
     if (mode === "cbc") {
         if (typeof iv === "string") iv = hexToArray(iv);
         if (iv.length !== 128 / 8) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sm-crypto-v2",
-  "version": "1.9.3",
+  "version": "1.10.0",
   "description": "sm-crypto-v2",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -33,6 +33,7 @@
   "author": "june_01",
   "license": "MIT",
   "dependencies": {
+    "@noble/ciphers": "^1.2.1",
     "@noble/curves": "^1.1.0"
   },
   "devDependencies": {
@@ -57,5 +58,9 @@
     "typescript": "^4.7.2",
     "vite": "^4.3.9",
     "vitest": "^0.31.0"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
   }
 }