零外部依赖的纯算法实现 SM4 国密加解密工具（JavaScript实现，可用 Bun 运行）

2026-08-01

有时候需要对在项目中临时使用 SM4 加解密计算一些东西，但是又不想启动程序运行工具，或者不想打开在线工具网页，或者只能在命令行终端等场景使用。如果用Java的话，有可能还需要提前编译好。下面提供一个使用 Bun 运行的脚本。

工具使用说明：

SM4 国密算法工具 — 密钥生成 / 加解密

用法: bun run scripts/sm4-utils.ts [选项]

选项:
  -m, --mode <ECB|CBC>  加密模式（默认 ECB）
  -k, --key <hex>       SM4 密钥（32 字符 HEX，可选，未指定则自动生成）
  -i, --iv <hex>        初始化向量 IV（CBC 模式使用，32 字符 HEX，未指定则自动生成）
  -e, --encrypt <text>  待加密的明文字符串
  -d, --decrypt <hex>   待解密的密文（HEX 格式，兼容 SM4ENC(...) 格式）
  -h, --help            显示此帮助信息

使用示例:
  bun run scripts/sm4-utils.ts -k 0123456789ABCDEFFEDCBA9876543210 -e HelloWorld
  bun run scripts/sm4-utils.ts -k 0123456789ABCDEFFEDCBA9876543210 -d 3F4A...
  bun run scripts/sm4-utils.ts -e HelloWorld
  bun run scripts/sm4-utils.ts -m CBC -k 0123456789ABCDEFFEDCBA9876543210 -i 0123456789ABCDEFFEDCBA9876543210 -e HelloWorld
  bun run scripts/sm4-utils.ts -m CBC -k 0123456789ABCDEFFEDCBA9876543210 -d 3F4A...

以下是 sm4-utils.js 文件内容：

#!/usr/bin/env bun
/**
 * 纯 TypeScript 实现的 SM4 国密算法工具（无外部依赖），由 Bun 运行。
 *
 * 支持 ECB / CBC 模式加解密、16 进制 HEX 编码输出，与 Java 版 SM4Utils 完全兼容。
 * 可直接通过 `bun run scripts/sm4-utils.ts` 命令行调用。
 *
 * 命令行参数：
 *   -m <ECB|CBC> / --mode <ECB|CBC> — 加密模式（默认 ECB）
 *   -k <hex> / --key <hex> — SM4 密钥（32 字符 HEX，可选，未指定则自动生成）
 *   -i <hex> / --iv <hex> — 初始化向量 IV（CBC 模式使用，未指定则自动生成）
 *   -e <text> / --encrypt <text> — 待加密的明文字符串
 *   -d <hex> / --decrypt <hex> — 待解密的密文（HEX 格式，兼容 SM4ENC(...) 格式）
 *   -h / --help — 显示帮助信息
 *
 * 使用示例：
 *   bun run scripts/sm4-utils.ts -k 0123456789ABCDEFFEDCBA9876543210 -e HelloWorld
 *   bun run scripts/sm4-utils.ts -m CBC -k 0123456789ABCDEFFEDCBA9876543210 -i 0123456789ABCDEFFEDCBA9876543210 -e HelloWorld
 *   bun run scripts/sm4-utils.ts -k 0123456789ABCDEFFEDCBA9876543210 -d 3F4A...
 *   bun run scripts/sm4-utils.ts -e HelloWorld
 */

// @ts-nocheck

// ======================== S 盒（16x16 = 256 字节） ========================

const S_BOX = [
  0xd6, 0x90, 0xe9, 0xfe, 0xcc, 0xe1, 0x3d, 0xb7, 0x16, 0xb6, 0x14, 0xc2, 0x28, 0xfb, 0x2c, 0x05,
  0x2b, 0x67, 0x9a, 0x76, 0x2a, 0xbe, 0x04, 0xc3, 0xaa, 0x44, 0x13, 0x26, 0x49, 0x86, 0x06, 0x99,
  0x9c, 0x42, 0x50, 0xf4, 0x91, 0xef, 0x98, 0x7a, 0x33, 0x54, 0x0b, 0x43, 0xed, 0xcf, 0xac, 0x62,
  0xe4, 0xb3, 0x1c, 0xa9, 0xc9, 0x08, 0xe8, 0x95, 0x80, 0xdf, 0x94, 0xfa, 0x75, 0x8f, 0x3f, 0xa6,
  0x47, 0x07, 0xa7, 0xfc, 0xf3, 0x73, 0x17, 0xba, 0x83, 0x59, 0x3c, 0x19, 0xe6, 0x85, 0x4f, 0xa8,
  0x68, 0x6b, 0x81, 0xb2, 0x71, 0x64, 0xda, 0x8b, 0xf8, 0xeb, 0x0f, 0x4b, 0x70, 0x56, 0x9d, 0x35,
  0x1e, 0x24, 0x0e, 0x5e, 0x63, 0x58, 0xd1, 0xa2, 0x25, 0x22, 0x7c, 0x3b, 0x01, 0x21, 0x78, 0x87,
  0xd4, 0x00, 0x46, 0x57, 0x9f, 0xd3, 0x27, 0x52, 0x4c, 0x36, 0x02, 0xe7, 0xa0, 0xc4, 0xc8, 0x9e,
  0xea, 0xbf, 0x8a, 0xd2, 0x40, 0xc7, 0x38, 0xb5, 0xa3, 0xf7, 0xf2, 0xce, 0xf9, 0x61, 0x15, 0xa1,
  0xe0, 0xae, 0x5d, 0xa4, 0x9b, 0x34, 0x1a, 0x55, 0xad, 0x93, 0x32, 0x30, 0xf5, 0x8c, 0xb1, 0xe3,
  0x1d, 0xf6, 0xe2, 0x2e, 0x82, 0x66, 0xca, 0x60, 0xc0, 0x29, 0x23, 0xab, 0x0d, 0x53, 0x4e, 0x6f,
  0xd5, 0xdb, 0x37, 0x45, 0xde, 0xfd, 0x8e, 0x2f, 0x03, 0xff, 0x6a, 0x72, 0x6d, 0x6c, 0x5b, 0x51,
  0x8d, 0x1b, 0xaf, 0x92, 0xbb, 0xdd, 0xbc, 0x7f, 0x11, 0xd9, 0x5c, 0x41, 0x1f, 0x10, 0x5a, 0xd8,
  0x0a, 0xc1, 0x31, 0x88, 0xa5, 0xcd, 0x7b, 0xbd, 0x2d, 0x74, 0xd0, 0x12, 0xb8, 0xe5, 0xb4, 0xb0,
  0x89, 0x69, 0x97, 0x4a, 0x0c, 0x96, 0x77, 0x7e, 0x65, 0xb9, 0xf1, 0x09, 0xc5, 0x6e, 0xc6, 0x84,
  0x18, 0xf0, 0x7d, 0xec, 0x3a, 0xdc, 0x4d, 0x20, 0x79, 0xee, 0x5f, 0x3e, 0xd7, 0xcb, 0x39, 0x48,
]

// ======================== 系统参数 FK ========================

const FK0 = 0xa3b1bac6
const FK1 = 0x56aa3350
const FK2 = 0x677d9197
const FK3 = 0xb27022dc

// ======================== 固定常量 CK（32 个 32 位字） ========================

function generateCK(): number[] {
  const ck = new Array<number>(32)
  for (let i = 0; i < 32; i++) {
    const b0 = ((4 * i) * 7) & 0xff
    const b1 = ((4 * i + 1) * 7) & 0xff
    const b2 = ((4 * i + 2) * 7) & 0xff
    const b3 = ((4 * i + 3) * 7) & 0xff
    ck[i] = (b0 << 24) | (b1 << 16) | (b2 << 8) | b3
  }
  return ck
}

const CK = generateCK()

// ======================== PKCS7 填充 ========================

/**
 * PKCS7 填充，每 16 字节一组，不足时补足，满 16 时额外补 16 字节 0x10
 */
function pkcs7Pad(data: Uint8Array): Uint8Array {
  const padLen = 16 - (data.length % 16)
  const padded = new Uint8Array(data.length + padLen)
  padded.set(data)
  padded.fill(padLen, data.length)
  return padded
}

/**
 * 去除 PKCS7 填充
 */
function pkcs7Unpad(data: Uint8Array): Uint8Array {
  const padLen = data[data.length - 1]
  if (padLen < 1 || padLen > 16) {
    throw new Error('无效的 PKCS7 填充')
  }
  return data.slice(0, data.length - padLen)
}

// ======================== 核心算法 ========================

/**
 * 32 位整数的循环左移
 *
 * @param a 待移位整数
 * @param n 左移位数（0-31）
 * @returns 循环左移结果
 */
function rotl(a: number, n: number): number {
  return (a << n) | (a >>> (32 - n))
}

/**
 * S 盒字节替换：对 32 位字的每个字节查 S 盒
 *
 * @param x 32 位输入
 * @returns S 盒替换后的 32 位结果
 */
function sBoxSub(x: number): number {
  return (S_BOX[(x >>> 24) & 0xff] << 24)
    | (S_BOX[(x >>> 16) & 0xff] << 16)
    | (S_BOX[(x >>> 8) & 0xff] << 8)
    | S_BOX[x & 0xff]
}

/**
 * 非线性变换 τ：4 个 S 盒并行替换
 */
function tau(a: number): number {
  return sBoxSub(a)
}

/**
 * 线性变换 L（加密/解密中使用）
 * <p>L(B) = B ⊕ (B <<< 2) ⊕ (B <<< 10) ⊕ (B <<< 18) ⊕ (B <<< 24)</p>
 */
function lTransform(b: number): number {
  return b ^ rotl(b, 2) ^ rotl(b, 10) ^ rotl(b, 18) ^ rotl(b, 24)
}

/**
 * 线性变换 L'（密钥扩展中使用）
 * <p>L'(B) = B ⊕ (B <<< 13) ⊕ (B <<< 23)</p>
 */
function lPrimeTransform(b: number): number {
  return b ^ rotl(b, 13) ^ rotl(b, 23)
}

/**
 * 合成变换 T = L(τ(a))，用于加解密轮函数
 */
function tTransform(a: number): number {
  return lTransform(tau(a))
}

/**
 * 合成变换 T' = L'(τ(a))，用于密钥扩展
 */
function tPrimeTransform(a: number): number {
  return lPrimeTransform(tau(a))
}

/**
 * 轮函数 F
 * <p>X0 ⊕ T(X1 ⊕ X2 ⊕ X3 ⊕ rk)</p>
 */
function roundFunction(x0: number, x1: number, x2: number, x3: number, rk: number): number {
  return x0 ^ tTransform(x1 ^ x2 ^ x3 ^ rk)
}

/**
 * 密钥扩展：从 128 位密钥生成 32 个 32 位轮密钥
 *
 * @param keyBytes 16 字节密钥
 * @returns 32 个轮密钥
 */
function keyExpansion(keyBytes: Uint8Array): number[] {
  const mk = bytesToWords(keyBytes)
  const k0 = mk[0] ^ FK0
  const k1 = mk[1] ^ FK1
  const k2 = mk[2] ^ FK2
  const k3 = mk[3] ^ FK3

  const rk = new Array<number>(32)
  const k = new Array<number>(36)
  k[0] = k0
  k[1] = k1
  k[2] = k2
  k[3] = k3

  for (let i = 0; i < 32; i++) {
    k[i + 4] = k[i] ^ tPrimeTransform(k[i + 1] ^ k[i + 2] ^ k[i + 3] ^ CK[i])
    rk[i] = k[i + 4]
  }
  return rk
}

/**
 * ECB 模式加密一个 16 字节数据块
 *
 * @param plaintext 16 字节明文块
 * @param rk        32 个轮密钥
 * @returns 16 字节密文块
 */
function encryptBlock(plaintext: Uint8Array, rk: number[]): Uint8Array {
  const x = bytesToWords(plaintext)
  for (let i = 0; i < 32; i++) {
    const x4 = roundFunction(x[0], x[1], x[2], x[3], rk[i])
    x[0] = x[1]
    x[1] = x[2]
    x[2] = x[3]
    x[3] = x4
  }
  // 反序输出 X35, X34, X33, X32
  return wordsToBytes([x[3], x[2], x[1], x[0]])
}

/**
 * ECB 模式解密一个 16 字节数据块（使用反向轮密钥）
 */
function decryptBlock(ciphertext: Uint8Array, rk: number[]): Uint8Array {
  const x = bytesToWords(ciphertext)
  // 解密时轮密钥逆序使用
  for (let i = 0; i < 32; i++) {
    const x4 = roundFunction(x[0], x[1], x[2], x[3], rk[31 - i])
    x[0] = x[1]
    x[1] = x[2]
    x[2] = x[3]
    x[3] = x4
  }
  return wordsToBytes([x[3], x[2], x[1], x[0]])
}

// ======================== 公开 API ========================

/**
 * 生成 16 字节（128 位）随机 SM4 密钥，返回 HEX 字符串
 *
 * @returns 32 字符 HEX 密钥
 */
export function generateKey(): string {
  const key = new Uint8Array(16)
  crypto.getRandomValues(key)
  return bytesToHex(key)
}

/**
 * 生成 16 字节（128 位）随机 IV（初始化向量），返回 HEX 字符串
 *
 * @returns 32 字符 HEX IV
 */
export function generateIv(): string {
  const iv = new Uint8Array(16)
  crypto.getRandomValues(iv)
  return bytesToHex(iv)
}

/**
 * 两个 16 字节块按位异或（用于 CBC 模式）
 */
function xor16(a: Uint8Array, b: Uint8Array): Uint8Array {
  const out = new Uint8Array(16)
  for (let i = 0; i < 16; i++) {
    out[i] = a[i] ^ b[i]
  }
  return out
}

// ======================== ECB 模式 ========================

/**
 * SM4 ECB 模式加密
 *
 * @param plaintext 明文字节数组
 * @param keyHex    HEX 格式密钥（32 字符，16 字节）
 * @returns 密文 HEX 字符串
 */
export function encryptECB(plaintext: Uint8Array, keyHex: string): string {
  const key = hexToBytes(keyHex)
  const rk = keyExpansion(key)
  const padded = pkcs7Pad(plaintext)
  const result = new Uint8Array(padded.length)
  for (let i = 0; i < padded.length; i += 16) {
    const block = padded.slice(i, i + 16)
    const enc = encryptBlock(block, rk)
    result.set(enc, i)
  }
  return bytesToHex(result)
}

/**
 * SM4 ECB 模式加密字符串
 *
 * @param data   明文字符串（UTF-8）
 * @param keyHex HEX 格式密钥
 * @returns 密文 HEX 字符串
 */
export function encryptECBFromString(data: string, keyHex: string): string {
  return encryptECB(new TextEncoder().encode(data), keyHex)
}

/**
 * SM4 ECB 模式解密
 *
 * @param cipherHex 密文 HEX 字符串
 * @param keyHex    HEX 格式密钥
 * @returns 解密后的字节数组（已去除填充）
 */
export function decryptECB(cipherHex: string, keyHex: string): Uint8Array {
  const ciphertext = hexToBytes(cipherHex)
  const key = hexToBytes(keyHex)
  const rk = keyExpansion(key)
  const result = new Uint8Array(ciphertext.length)
  for (let i = 0; i < ciphertext.length; i += 16) {
    const block = ciphertext.slice(i, i + 16)
    const dec = decryptBlock(block, rk)
    result.set(dec, i)
  }
  return pkcs7Unpad(result)
}

/**
 * SM4 ECB 模式解密为 UTF-8 字符串
 *
 * @param cipherHex 密文 HEX 字符串
 * @param keyHex    HEX 格式密钥
 * @returns 解密后的 UTF-8 字符串
 */
export function decryptECBToString(cipherHex: string, keyHex: string): string {
  return new TextDecoder().decode(decryptECB(cipherHex, keyHex))
}

// ======================== CBC 模式 ========================

/**
 * SM4 CBC 模式加密
 *
 * @param plaintext 明文字节数组
 * @param keyHex    HEX 格式密钥
 * @param ivHex     HEX 格式初始化向量（32 字符，16 字节）
 * @returns 密文 HEX 字符串
 */
export function encryptCBC(plaintext: Uint8Array, keyHex: string, ivHex: string): string {
  const key = hexToBytes(keyHex)
  const iv = hexToBytes(ivHex)
  const rk = keyExpansion(key)
  const padded = pkcs7Pad(plaintext)
  const result = new Uint8Array(padded.length)
  let prev = iv
  for (let i = 0; i < padded.length; i += 16) {
    const block = padded.slice(i, i + 16)
    const xored = xor16(block, prev)
    const enc = encryptBlock(xored, rk)
    result.set(enc, i)
    prev = enc
  }
  return bytesToHex(result)
}

/**
 * SM4 CBC 模式加密字符串
 *
 * @param data   明文字符串（UTF-8）
 * @param keyHex HEX 格式密钥
 * @param ivHex  HEX 格式初始化向量
 * @returns 密文 HEX 字符串
 */
export function encryptCBCFromString(data: string, keyHex: string, ivHex: string): string {
  return encryptCBC(new TextEncoder().encode(data), keyHex, ivHex)
}

/**
 * SM4 CBC 模式解密
 *
 * @param cipherHex 密文 HEX 字符串
 * @param keyHex    HEX 格式密钥
 * @param ivHex     HEX 格式初始化向量
 * @returns 解密后的字节数组（已去除填充）
 */
export function decryptCBC(cipherHex: string, keyHex: string, ivHex: string): Uint8Array {
  const ciphertext = hexToBytes(cipherHex)
  const key = hexToBytes(keyHex)
  const iv = hexToBytes(ivHex)
  const rk = keyExpansion(key)
  const result = new Uint8Array(ciphertext.length)
  let prev = iv
  for (let i = 0; i < ciphertext.length; i += 16) {
    const block = ciphertext.slice(i, i + 16)
    const dec = decryptBlock(block, rk)
    const xored = xor16(dec, prev)
    result.set(xored, i)
    prev = block
  }
  return pkcs7Unpad(result)
}

/**
 * SM4 CBC 模式解密为 UTF-8 字符串
 *
 * @param cipherHex 密文 HEX 字符串
 * @param keyHex    HEX 格式密钥
 * @param ivHex     HEX 格式初始化向量
 * @returns 解密后的 UTF-8 字符串
 */
export function decryptCBCToString(cipherHex: string, keyHex: string, ivHex: string): string {
  return new TextDecoder().decode(decryptCBC(cipherHex, keyHex, ivHex))
}

// ======================== HEX / 字节数组工具 ========================

/**
 * HEX 字符串转字节数组
 */
export function hexToBytes(hex: string): Uint8Array {
  const len = hex.length
  const data = new Uint8Array(len / 2)
  for (let i = 0; i < len; i += 2) {
    data[i / 2] = (parseInt(hex.charAt(i), 16) << 4) | parseInt(hex.charAt(i + 1), 16)
  }
  return data
}

/**
 * 字节数组转大写 HEX 字符串
 */
export function bytesToHex(bytes: Uint8Array): string {
  let sb = ''
  for (const b of bytes) {
    sb += (b & 0xff).toString(16).padStart(2, '0')
  }
  return sb.toUpperCase()
}

/**
 * 4 字节 → 1 个 int（大端序）
 */
function bytesToWord(b: Uint8Array, off: number): number {
  return (b[off] & 0xff) << 24
    | (b[off + 1] & 0xff) << 16
    | (b[off + 2] & 0xff) << 8
    | (b[off + 3] & 0xff)
}

/**
 * 字节数组 → int 数组（每 4 字节一组）
 */
function bytesToWords(b: Uint8Array): number[] {
  const words = new Array<number>(b.length / 4)
  for (let i = 0; i < words.length; i++) {
    words[i] = bytesToWord(b, i * 4)
  }
  return words
}

/**
 * int 数组（大端序）→ 字节数组
 */
function wordsToBytes(words: number[]): Uint8Array {
  const b = new Uint8Array(words.length * 4)
  for (let i = 0; i < words.length; i++) {
    b[i * 4] = (words[i] >>> 24) & 0xff
    b[i * 4 + 1] = (words[i] >>> 16) & 0xff
    b[i * 4 + 2] = (words[i] >>> 8) & 0xff
    b[i * 4 + 3] = words[i] & 0xff
  }
  return b
}

// ======================== 命令行入口 ========================

function printUsage() {
  console.log('SM4 国密算法工具 — 密钥生成 / 加解密')
  console.log()
  console.log('用法: bun run scripts/sm4-utils.ts [选项]')
  console.log()
  console.log('选项:')
  console.log('  -m, --mode <ECB|CBC>  加密模式（默认 ECB）')
  console.log('  -k, --key <hex>       SM4 密钥（32 字符 HEX，可选，未指定则自动生成）')
  console.log('  -i, --iv <hex>        初始化向量 IV（CBC 模式使用，32 字符 HEX，未指定则自动生成）')
  console.log('  -e, --encrypt <text>  待加密的明文字符串')
  console.log('  -d, --decrypt <hex>   待解密的密文（HEX 格式，兼容 SM4ENC(...) 格式）')
  console.log('  -h, --help            显示此帮助信息')
  console.log()
  console.log('使用示例:')
  console.log('  bun run scripts/sm4-utils.ts -k 0123456789ABCDEFFEDCBA9876543210 -e HelloWorld')
  console.log('  bun run scripts/sm4-utils.ts -k 0123456789ABCDEFFEDCBA9876543210 -d 3F4A...')
  console.log('  bun run scripts/sm4-utils.ts -e HelloWorld')
  console.log('  bun run scripts/sm4-utils.ts -m CBC -k 0123456789ABCDEFFEDCBA9876543210 -i 0123456789ABCDEFFEDCBA9876543210 -e HelloWorld')
  console.log('  bun run scripts/sm4-utils.ts -m CBC -k 0123456789ABCDEFFEDCBA9876543210 -d 3F4A...')
}

function main() {
  const args = process.argv.slice(2)
  let key: string | null = null
  let encryptText: string | null = null
  let decryptHex: string | null = null
  let iv: string | null = null
  let cbcMode = false
  let showHelp = false

  for (let i = 0; i < args.length; i++) {
    switch (args[i]) {
      case '-h':
      case '--help':
        showHelp = true
        break
      case '-m':
      case '--mode':
        if (i + 1 >= args.length) {
          console.error('错误：-m 缺少模式参数')
          printUsage()
          return
        }
        const mode = args[++i]
        if (mode.toLowerCase() === 'cbc') {
          cbcMode = true
        } else if (mode.toLowerCase() !== 'ecb') {
          console.error(`错误：不支持的加密模式: ${mode}（仅支持 ECB / CBC）`)
          printUsage()
          return
        }
        break
      case '-i':
      case '--iv':
        if (i + 1 >= args.length) {
          console.error('错误：-i 缺少 IV 参数')
          printUsage()
          return
        }
        iv = args[++i]
        break
      case '-k':
      case '--key':
        if (i + 1 >= args.length) {
          console.error('错误：-k 缺少密钥参数')
          printUsage()
          return
        }
        key = args[++i]
        break
      case '-e':
      case '--encrypt':
        if (i + 1 >= args.length) {
          console.error('错误：-e 缺少明文参数')
          printUsage()
          return
        }
        encryptText = args[++i]
        break
      case '-d':
      case '--decrypt':
        if (i + 1 >= args.length) {
          console.error('错误：-d 缺少密文参数')
          printUsage()
          return
        }
        decryptHex = args[++i]
        break
      default:
        // 忽略未知参数
        break
    }
  }

  if (showHelp || (encryptText === null && decryptHex === null)) {
    printUsage()
    return
  }

  if (cbcMode && iv === null) {
    iv = generateIv()
    console.log(`IV（自动生成）：${iv.toUpperCase()}`)
  } else if (cbcMode) {
    console.log(`IV：${iv.toUpperCase()}`)
  }

  if (key === null) {
    key = generateKey()
    console.log(`密钥（自动生成）：${key.toUpperCase()}`)
  } else {
    console.log(`密钥：${key.toUpperCase()}`)
  }

  const modeLabel = cbcMode ? 'CBC' : 'ECB'

  try {
    if (encryptText !== null) {
      const encrypted = cbcMode
        ? encryptCBCFromString(encryptText, key, iv)
        : encryptECBFromString(encryptText, key)
      console.log(`加密模式：${modeLabel}`)
      console.log(`加密明文：${encryptText}`)
      console.log(`加密密文：${encrypted.toUpperCase()}`)
    }
  } catch (e) {
    console.error(`SM4 加密失败：${(e as Error).message}`)
  }

  try {
    if (decryptHex !== null) {
      let plain = decryptHex
      if (plain.startsWith('SM4ENC(') && plain.endsWith(')')) {
        plain = plain.substring(7, plain.length - 1)
      }
      const decrypted = cbcMode
        ? decryptCBCToString(plain, key, iv)
        : decryptECBToString(plain, key)
      console.log(`解密模式：${modeLabel}`)
      console.log(`解密密文：${decryptHex}`)
      console.log(`解密明文：${decrypted}`)
    }
  } catch (e) {
    console.error(`SM4 解密失败：${(e as Error).message}`)
  }
}

if (import.meta.main) {
  main()
}