gmkitx API - v0.10.1
    正在准备搜索索引...

    变量 default

    default: {
        compressPublicKey: (publicKey: BytesLike) => string;
        decompressPublicKey: (publicKey: BytesLike) => string;
        digest: (
            data: string | Uint8Array<ArrayBufferLike>,
            options?: SM3Options,
        ) => string;
        eea3: (
            key: BytesLike,
            count: number,
            bearer: number,
            direction: number,
            length: number,
        ) => string;
        eea3Encrypt: (
            key: BytesLike,
            count: number,
            bearer: number,
            direction: number,
            message: string | Uint8Array<ArrayBufferLike>,
            bitLength?: number,
        ) => string;
        eia3: (
            key: BytesLike,
            count: number,
            bearer: number,
            direction: number,
            message: string | Uint8Array<ArrayBufferLike>,
            bitLength?: number,
        ) => string;
        generateKeyPair: (compressed?: boolean) => KeyPair;
        getPublicKeyFromPrivateKey: (
            privateKey: BytesLike,
            compressed?: boolean,
        ) => string;
        hmac: (
            key: string | Uint8Array<ArrayBufferLike>,
            data: string | Uint8Array<ArrayBufferLike>,
            options?: SM3Options,
        ) => string;
        hmacSha256: (
            key: string | Uint8Array<ArrayBufferLike>,
            data: string | Uint8Array<ArrayBufferLike>,
            options?: SHAOptions,
        ) => string;
        hmacSha384: (
            key: string | Uint8Array<ArrayBufferLike>,
            data: string | Uint8Array<ArrayBufferLike>,
            options?: SHAOptions,
        ) => string;
        hmacSha512: (
            key: string | Uint8Array<ArrayBufferLike>,
            data: string | Uint8Array<ArrayBufferLike>,
            options?: SHAOptions,
        ) => string;
        keyExchange: (params: SM2KeyExchangeParams) => SM2KeyExchangeResult;
        sha: {
            SHA1: typeof SHA1;
            SHA256: typeof SHA256;
            SHA384: typeof SHA384;
            SHA512: typeof SHA512;
            hmacSha256(
                key: string | Uint8Array<ArrayBufferLike>,
                data: string | Uint8Array<ArrayBufferLike>,
                options?: SHAOptions,
            ): string;
            hmacSha384(
                key: string | Uint8Array<ArrayBufferLike>,
                data: string | Uint8Array<ArrayBufferLike>,
                options?: SHAOptions,
            ): string;
            hmacSha512(
                key: string | Uint8Array<ArrayBufferLike>,
                data: string | Uint8Array<ArrayBufferLike>,
                options?: SHAOptions,
            ): string;
            sha1(
                data: string | Uint8Array<ArrayBufferLike>,
                options?: SHAOptions,
            ): string;
            sha256(
                data: string | Uint8Array<ArrayBufferLike>,
                options?: SHAOptions,
            ): string;
            sha384(
                data: string | Uint8Array<ArrayBufferLike>,
                options?: SHAOptions,
            ): string;
            sha512(
                data: string | Uint8Array<ArrayBufferLike>,
                options?: SHAOptions,
            ): string;
        };
        sha1: (
            data: string | Uint8Array<ArrayBufferLike>,
            options?: SHAOptions,
        ) => string;
        sha256: (
            data: string | Uint8Array<ArrayBufferLike>,
            options?: SHAOptions,
        ) => string;
        sha384: (
            data: string | Uint8Array<ArrayBufferLike>,
            options?: SHAOptions,
        ) => string;
        sha512: (
            data: string | Uint8Array<ArrayBufferLike>,
            options?: SHAOptions,
        ) => string;
        sign: (
            privateKey: BytesLike,
            data: string | Uint8Array<ArrayBufferLike>,
            options?: SignOptions,
        ) => string;
        sm2: {
            SM2: typeof SM2;
            compressPublicKey(publicKey: BytesLike): string;
            decompressPublicKey(publicKey: BytesLike): string;
            decrypt(
                privateKey: BytesLike,
                encryptedData: BytesLike,
                options?: SM2DecryptOptions,
            ): string;
            decryptBytes(
                privateKey: BytesLike,
                encryptedData: BytesLike,
                options?: SM2DecryptOptions,
            ): Uint8Array;
            encrypt(
                publicKey: BytesLike,
                data: string | Uint8Array<ArrayBufferLike>,
                options?: SM2EncryptOptions,
            ): string;
            generateKeyPair(compressed?: boolean): KeyPair;
            getPublicKeyFromPrivateKey(
                privateKey: BytesLike,
                compressed?: boolean,
            ): string;
            keyExchange(params: SM2KeyExchangeParams): SM2KeyExchangeResult;
            sign(
                privateKey: BytesLike,
                data: string | Uint8Array<ArrayBufferLike>,
                options?: SignOptions,
            ): string;
            verify(
                publicKey: BytesLike,
                data: string | Uint8Array<ArrayBufferLike>,
                signature: BytesLike,
                options?: VerifyOptions,
            ): boolean;
        };
        sm2CompressPublicKey: (publicKey: BytesLike) => string;
        sm2DecompressPublicKey: (publicKey: BytesLike) => string;
        sm2Decrypt: (
            privateKey: BytesLike,
            encryptedData: BytesLike,
            options?: SM2DecryptOptions,
        ) => string;
        sm2DecryptBytes: (
            privateKey: BytesLike,
            encryptedData: BytesLike,
            options?: SM2DecryptOptions,
        ) => Uint8Array;
        sm2Encrypt: (
            publicKey: BytesLike,
            data: string | Uint8Array<ArrayBufferLike>,
            options?: SM2EncryptOptions,
        ) => string;
        sm2GenerateKeyPair: (compressed?: boolean) => KeyPair;
        sm2GetPublicKeyFromPrivateKey: (
            privateKey: BytesLike,
            compressed?: boolean,
        ) => string;
        sm2KeyExchange: (params: SM2KeyExchangeParams) => SM2KeyExchangeResult;
        sm2Sign: (
            privateKey: BytesLike,
            data: string | Uint8Array<ArrayBufferLike>,
            options?: SignOptions,
        ) => string;
        sm2Verify: (
            publicKey: BytesLike,
            data: string | Uint8Array<ArrayBufferLike>,
            signature: BytesLike,
            options?: VerifyOptions,
        ) => boolean;
        sm3: {
            SM3HashState: any;
            SM3: typeof SM3;
            sm3Digest: (
                data: string | Uint8Array<ArrayBufferLike>,
                options?: SM3Options,
            ) => string;
            digest(
                data: string | Uint8Array<ArrayBufferLike>,
                options?: SM3Options,
            ): string;
            hmac(
                key: string | Uint8Array<ArrayBufferLike>,
                data: string | Uint8Array<ArrayBufferLike>,
                options?: SM3Options,
            ): string;
        };
        sm3Digest: (
            data: string | Uint8Array<ArrayBufferLike>,
            options?: SM3Options,
        ) => string;
        sm3Hmac: (
            key: string | Uint8Array<ArrayBufferLike>,
            data: string | Uint8Array<ArrayBufferLike>,
            options?: SM3Options,
        ) => string;
        sm4: {
            SM4: typeof SM4;
            decrypt(
                key: BytesLike,
                encryptedData: BytesLike | SM4CipherResult,
                options?: SM4DecryptOptions,
            ): string;
            decryptBytes(
                key: BytesLike,
                encryptedData: BytesLike | SM4CipherResult,
                options?: SM4DecryptOptions,
            ): Uint8Array;
            encrypt(
                key: BytesLike,
                data: string | Uint8Array<ArrayBufferLike>,
                options?: SM4Options,
            ): SM4CipherResult;
        };
        sm4Decrypt: (
            key: BytesLike,
            encryptedData: BytesLike | SM4CipherResult,
            options?: SM4DecryptOptions,
        ) => string;
        sm4DecryptBytes: (
            key: BytesLike,
            encryptedData: BytesLike | SM4CipherResult,
            options?: SM4DecryptOptions,
        ) => Uint8Array;
        sm4Encrypt: (
            key: BytesLike,
            data: string | Uint8Array<ArrayBufferLike>,
            options?: SM4Options,
        ) => SM4CipherResult;
        verify: (
            publicKey: BytesLike,
            data: string | Uint8Array<ArrayBufferLike>,
            signature: BytesLike,
            options?: VerifyOptions,
        ) => boolean;
        zuc: {
            ZUCState: any;
            ZUC: typeof ZUC;
            decrypt(
                key: BytesLike,
                iv: BytesLike,
                ciphertext: BytesLike,
                options?: ZUCDecryptOptions,
            ): string;
            decryptBytes(
                key: BytesLike,
                iv: BytesLike,
                ciphertext: BytesLike,
                options?: ZUCDecryptOptions,
            ): Uint8Array;
            eea3(
                key: BytesLike,
                count: number,
                bearer: number,
                direction: number,
                length: number,
            ): string;
            eea3Encrypt(
                key: BytesLike,
                count: number,
                bearer: number,
                direction: number,
                message: string | Uint8Array<ArrayBufferLike>,
                bitLength?: number,
            ): string;
            eia3(
                key: BytesLike,
                count: number,
                bearer: number,
                direction: number,
                message: string | Uint8Array<ArrayBufferLike>,
                bitLength?: number,
            ): string;
            encrypt(
                key: BytesLike,
                iv: BytesLike,
                plaintext: string | Uint8Array<ArrayBufferLike>,
                options?: ZUCOptions,
            ): string;
            generateKeystream(
                key: string | Uint8Array<ArrayBufferLike>,
                iv: string | Uint8Array<ArrayBufferLike>,
                length: number,
            ): Uint32Array;
            getKeystream(key: BytesLike, iv: BytesLike, length: number): string;
            getKeystreamWords(key: BytesLike, iv: BytesLike, length: number): string;
        };
        zucDecrypt: (
            key: BytesLike,
            iv: BytesLike,
            ciphertext: BytesLike,
            options?: ZUCDecryptOptions,
        ) => string;
        zucDecryptBytes: (
            key: BytesLike,
            iv: BytesLike,
            ciphertext: BytesLike,
            options?: ZUCDecryptOptions,
        ) => Uint8Array;
        zucEncrypt: (
            key: BytesLike,
            iv: BytesLike,
            plaintext: string | Uint8Array<ArrayBufferLike>,
            options?: ZUCOptions,
        ) => string;
        zucGenerateKeystream: (
            key: string | Uint8Array<ArrayBufferLike>,
            iv: string | Uint8Array<ArrayBufferLike>,
            length: number,
        ) => Uint32Array;
        zucKeystream: (key: BytesLike, iv: BytesLike, length: number) => string;
        zucKeystreamWords: (
            key: BytesLike,
            iv: BytesLike,
            length: number,
        ) => string;
    }

    UMD 与旧版整体导入使用的聚合对象。

    新的 ESM/CommonJS 代码优先使用具名导出,以便静态分析和 tree-shaking。

    类型声明

    • compressPublicKey: (publicKey: BytesLike) => string

      请改用 sm2CompressPublicKey

    • decompressPublicKey: (publicKey: BytesLike) => string

      请改用 sm2DecompressPublicKey

    • digest: (data: string | Uint8Array<ArrayBufferLike>, options?: SM3Options) => string

      请改用 sm3Digest

    • eea3: (
          key: BytesLike,
          count: number,
          bearer: number,
          direction: number,
          length: number,
      ) => string

      具名导出 eea3

    • eea3Encrypt: (
          key: BytesLike,
          count: number,
          bearer: number,
          direction: number,
          message: string | Uint8Array<ArrayBufferLike>,
          bitLength?: number,
      ) => string

      具名导出 eea3Encrypt

    • eia3: (
          key: BytesLike,
          count: number,
          bearer: number,
          direction: number,
          message: string | Uint8Array<ArrayBufferLike>,
          bitLength?: number,
      ) => string

      具名导出 eia3

    • generateKeyPair: (compressed?: boolean) => KeyPair

      请改用 sm2GenerateKeyPair

    • getPublicKeyFromPrivateKey: (privateKey: BytesLike, compressed?: boolean) => string

      请改用 sm2GetPublicKeyFromPrivateKey

    • hmac: (
          key: string | Uint8Array<ArrayBufferLike>,
          data: string | Uint8Array<ArrayBufferLike>,
          options?: SM3Options,
      ) => string

      请改用 sm3Hmac

    • hmacSha256: (
          key: string | Uint8Array<ArrayBufferLike>,
          data: string | Uint8Array<ArrayBufferLike>,
          options?: SHAOptions,
      ) => string

      具名导出 hmacSha256

    • hmacSha384: (
          key: string | Uint8Array<ArrayBufferLike>,
          data: string | Uint8Array<ArrayBufferLike>,
          options?: SHAOptions,
      ) => string

      具名导出 hmacSha384

    • hmacSha512: (
          key: string | Uint8Array<ArrayBufferLike>,
          data: string | Uint8Array<ArrayBufferLike>,
          options?: SHAOptions,
      ) => string

      具名导出 hmacSha512

    • keyExchange: (params: SM2KeyExchangeParams) => SM2KeyExchangeResult

      请改用 sm2KeyExchange

    • sha: {
          SHA1: typeof SHA1;
          SHA256: typeof SHA256;
          SHA384: typeof SHA384;
          SHA512: typeof SHA512;
          hmacSha256(
              key: string | Uint8Array<ArrayBufferLike>,
              data: string | Uint8Array<ArrayBufferLike>,
              options?: SHAOptions,
          ): string;
          hmacSha384(
              key: string | Uint8Array<ArrayBufferLike>,
              data: string | Uint8Array<ArrayBufferLike>,
              options?: SHAOptions,
          ): string;
          hmacSha512(
              key: string | Uint8Array<ArrayBufferLike>,
              data: string | Uint8Array<ArrayBufferLike>,
              options?: SHAOptions,
          ): string;
          sha1(
              data: string | Uint8Array<ArrayBufferLike>,
              options?: SHAOptions,
          ): string;
          sha256(
              data: string | Uint8Array<ArrayBufferLike>,
              options?: SHAOptions,
          ): string;
          sha384(
              data: string | Uint8Array<ArrayBufferLike>,
              options?: SHAOptions,
          ): string;
          sha512(
              data: string | Uint8Array<ArrayBufferLike>,
              options?: SHAOptions,
          ): string;
      }

      SHA 与 HMAC API 命名空间。

      • SHA1: typeof SHA1

        SHA-1 增量摘要类,仅用于旧协议兼容。

      • SHA256: typeof SHA256

        SHA-256 增量摘要类。

      • SHA384: typeof SHA384

        SHA-384 增量摘要类。

      • SHA512: typeof SHA512

        SHA-512 增量摘要类。

      • hmacSha256: function
        • 计算 HMAC-SHA256

          参数

          • key: string | Uint8Array<ArrayBufferLike>

            密钥(字符串或 Uint8Array)

          • data: string | Uint8Array<ArrayBufferLike>

            要认证的数据(字符串或 Uint8Array)

          • 可选options: SHAOptions

            哈希选项

          返回 string

          HMAC 值(默认十六进制字符串,64 个字符)

          const mac = hmacSha256('secret-key', 'data to authenticate');
          console.log(mac); // 十六进制格式
      • hmacSha384: function
        • 计算 HMAC-SHA384

          参数

          • key: string | Uint8Array<ArrayBufferLike>

            密钥(字符串或 Uint8Array)

          • data: string | Uint8Array<ArrayBufferLike>

            要认证的数据(字符串或 Uint8Array)

          • 可选options: SHAOptions

            哈希选项

          返回 string

          HMAC 值(默认十六进制字符串,96 个字符)

      • hmacSha512: function
        • 计算 HMAC-SHA512

          参数

          • key: string | Uint8Array<ArrayBufferLike>

            密钥(字符串或 Uint8Array)

          • data: string | Uint8Array<ArrayBufferLike>

            要认证的数据(字符串或 Uint8Array)

          • 可选options: SHAOptions

            哈希选项

          返回 string

          HMAC 值(默认十六进制字符串,128 个字符)

      • sha1: function
        • 计算 SHA-1 哈希摘要

          ⚠️ 安全警告: SHA-1 已于 2017 年被 Google 证明存在实际碰撞攻击(SHAttered)。 请勿用于密码签名、数字证书等安全敏感场景。 仅建议用于兼容旧系统或非安全敏感的校验和。

          参数

          • data: string | Uint8Array<ArrayBufferLike>

            输入数据(字符串或 Uint8Array)

          • 可选options: SHAOptions

            哈希选项

          返回 string

          哈希摘要(默认十六进制字符串,40 个字符)

          const hash = sha1('abc');
          console.log(hash); // 十六进制格式

          不推荐用于新项目,请使用 SHA-256 或更高版本

      • sha256: function
        • 计算 SHA-256 哈希摘要

          参数

          • data: string | Uint8Array<ArrayBufferLike>

            输入数据(字符串或 Uint8Array)

          • 可选options: SHAOptions

            哈希选项

          返回 string

          哈希摘要(默认十六进制字符串,64 个字符)

          const hash = sha256('abc');
          console.log(hash); // 十六进制格式

          const hash64 = sha256('abc', { outputFormat: OutputFormat.BASE64 });
          console.log(hash64); // Base64 格式
      • sha384: function
        • 计算 SHA-384 哈希摘要

          参数

          • data: string | Uint8Array<ArrayBufferLike>

            输入数据(字符串或 Uint8Array)

          • 可选options: SHAOptions

            哈希选项

          返回 string

          哈希摘要(默认十六进制字符串,96 个字符)

          const hash = sha384('abc');
          console.log(hash); // 十六进制格式
      • sha512: function
        • 计算 SHA-512 哈希摘要

          参数

          • data: string | Uint8Array<ArrayBufferLike>

            输入数据(字符串或 Uint8Array)

          • 可选options: SHAOptions

            哈希选项

          返回 string

          哈希摘要(默认十六进制字符串,128 个字符)

          const hash = sha512('abc');
          console.log(hash); // 十六进制格式
    • sha1: (data: string | Uint8Array<ArrayBufferLike>, options?: SHAOptions) => string

      具名导出 sha1

    • sha256: (data: string | Uint8Array<ArrayBufferLike>, options?: SHAOptions) => string

      具名导出 sha256

    • sha384: (data: string | Uint8Array<ArrayBufferLike>, options?: SHAOptions) => string

      具名导出 sha384

    • sha512: (data: string | Uint8Array<ArrayBufferLike>, options?: SHAOptions) => string

      具名导出 sha512

    • sign: (
          privateKey: BytesLike,
          data: string | Uint8Array<ArrayBufferLike>,
          options?: SignOptions,
      ) => string

      请改用 sm2Sign

    • sm2: {
          SM2: typeof SM2;
          compressPublicKey(publicKey: BytesLike): string;
          decompressPublicKey(publicKey: BytesLike): string;
          decrypt(
              privateKey: BytesLike,
              encryptedData: BytesLike,
              options?: SM2DecryptOptions,
          ): string;
          decryptBytes(
              privateKey: BytesLike,
              encryptedData: BytesLike,
              options?: SM2DecryptOptions,
          ): Uint8Array;
          encrypt(
              publicKey: BytesLike,
              data: string | Uint8Array<ArrayBufferLike>,
              options?: SM2EncryptOptions,
          ): string;
          generateKeyPair(compressed?: boolean): KeyPair;
          getPublicKeyFromPrivateKey(
              privateKey: BytesLike,
              compressed?: boolean,
          ): string;
          keyExchange(params: SM2KeyExchangeParams): SM2KeyExchangeResult;
          sign(
              privateKey: BytesLike,
              data: string | Uint8Array<ArrayBufferLike>,
              options?: SignOptions,
          ): string;
          verify(
              publicKey: BytesLike,
              data: string | Uint8Array<ArrayBufferLike>,
              signature: BytesLike,
              options?: VerifyOptions,
          ): boolean;
      }

      SM2 函数与对象式 API 命名空间。

      • SM2: typeof SM2

        SM2 对象式 API。实例可持有密钥并执行加解密、签名验签和密钥交换。

      • compressPublicKey: function
        • 压缩公钥(从非压缩格式转换为压缩格式)

          SM2 公钥是椭圆曲线上的点 (x, y),有两种表示格式:

          1. 非压缩格式(65 字节):04 || x || y

            • 前缀 04 表示非压缩格式
            • x 坐标:32 字节
            • y 坐标:32 字节
            • 总长度:1 + 32 + 32 = 65 字节(130 个十六进制字符)
          2. 压缩格式(33 字节):02/03 || x

            • 前缀 02 表示 y 坐标为偶数
            • 前缀 03 表示 y 坐标为奇数
            • x 坐标:32 字节
            • 总长度:1 + 32 = 33 字节(66 个十六进制字符)

          压缩的原理: 由于椭圆曲线方程 y² = x³ + ax + b,给定 x 坐标,可以计算出两个可能的 y 值 (一个为正,一个为负,或者说一个为奇数,一个为偶数)。 因此只需要保存 x 坐标和 y 的奇偶性,就可以恢复完整的点坐标。

          优势:

          • 节省存储空间(从 65 字节减少到 33 字节,节省约 49%)
          • 节省网络传输带宽
          • 适合资源受限的环境(如物联网设备)

          参数

          • publicKey: BytesLike

            非压缩格式的公钥(十六进制字符串,04 + x + y)

          返回 string

          压缩格式的公钥(十六进制字符串,02/03 + x)

          const uncompressed = '04...'; // 130 个字符
          const compressed = compressPublicKey(uncompressed); // 66 个字符
      • decompressPublicKey: function
        • 解压公钥(从压缩格式转换为非压缩格式)

          从压缩格式恢复完整的公钥坐标。

          解压过程:

          1. 读取 x 坐标(32 字节)
          2. 读取前缀字节(02 或 03)确定 y 的奇偶性
          3. 根据椭圆曲线方程 y² = x³ + ax + b 计算 y²
          4. 对 y² 开平方得到两个可能的 y 值
          5. 根据前缀字节选择正确的 y 值(奇数或偶数)
          6. 组合 x 和 y 得到完整的非压缩公钥

          注意:

          • 如果输入已经是非压缩格式(前缀 04),则直接返回
          • 解压过程涉及模平方根计算,需要一定的计算量
          • 使用 @noble/curves 库进行高效的椭圆曲线运算

          参数

          • publicKey: BytesLike

            压缩格式的公钥(十六进制字符串,02/03 + x)或非压缩格式

          返回 string

          非压缩格式的公钥(十六进制字符串,04 + x + y)

          const compressed = '02...'; // 66 个字符
          const uncompressed = decompressPublicKey(compressed); // 130 个字符
      • decrypt: function
        • 使用 SM2 解密数据

          支持自动识别密文格式:

          • 0x30 开头:ASN.1 格式
          • 0x04 开头:C1 为非压缩点格式(04 + x + y),默认 C1C3C2 模式
          • 0x02/0x03 开头:C1 为压缩点格式(02/03 + x),默认 C1C3C2 模式

          注意:

          1. 虽然可以穷举、尝试所有可能的密文格式,但这会影响解密性能。
          2. 在与其他系统集成时,建议明确约定密文格式,做到知己知彼。
          3. 本实现通过首字节自动检测格式(基于首字节只有固定几种可能的假设):
            • 0x30:ASN.1 格式
            • 0x04:C1 为非压缩点格式,具体是 C1C3C2 还是 C1C2C3 取决于解密时的选项参数,默认为 C1C3C2
            • 0x02/0x03:C1 为压缩点格式,具体是 C1C3C2 还是 C1C2C3 取决于解密时的选项参数,默认为 C1C3C2

          参数

          • privateKey: BytesLike

            私钥(十六进制字符串)

          • encryptedData: BytesLike

            加密的数据(十六进制/Base64 字符串或 Uint8Array)

          • 可选options: SM2DecryptOptions

            输入编码和密文排列;省略时自动识别编码并默认使用 C1C3C2

          返回 string

          解密后的数据(UTF-8 字符串)

          私钥、密文编码、椭圆曲线点或 C3 完整性校验无效时抛出错误

      • decryptBytes: function
        • 使用 SM2 私钥解密并返回原始字节;二进制协议不应经过 UTF-8 字符串转换。

          参数

          • privateKey: BytesLike

            32 字节私钥或对应 Hex 字符串

          • encryptedData: BytesLike

            Hex/Base64 密文字符串或原始密文字节

          • 可选options: SM2DecryptOptions

            密文排列与字符串输入编码;省略时自动识别编码和排列

          返回 Uint8Array

          通过 C3 完整性校验的原始明文字节

          私钥、编码、曲线点、密文结构或 C3 校验无效时抛出错误

      • encrypt: function
        • 使用 SM2 加密数据

          参数

          • publicKey: BytesLike

            公钥(十六进制字符串)

          • data: string | Uint8Array<ArrayBufferLike>

            要加密的数据(字符串或 Uint8Array)

          • 可选options: SM2EncryptOptions

            加密选项对象

          返回 string

          加密后的数据(默认十六进制字符串)

          // 基本用法
          const encrypted = encrypt(publicKey, 'data');
          // 使用选项对象
          const encrypted = encrypt(publicKey, 'data', {
          mode: SM2CipherMode.C1C3C2,
          outputFormat: OutputFormat.BASE64
          });
      • generateKeyPair: function
        • 生成 SM2 密钥对

          参数

          • compressed: boolean = false

            是否返回压缩格式的公钥(默认 false,返回非压缩格式)

          返回 KeyPair

          包含公钥和私钥的对象

      • getPublicKeyFromPrivateKey: function
        • 从私钥导出公钥

          参数

          • privateKey: BytesLike

            私钥(十六进制字符串)

          • compressed: boolean = false

            是否返回压缩格式(默认 false,返回非压缩格式)

          返回 string

          公钥(十六进制字符串,压缩格式:02/03 + x,非压缩格式:04 + x + y)

      • keyExchange: function
        • SM2 密钥交换协议

          标准参考:

          • GM/T 0003.3-2012: SM2 椭圆曲线密钥交换协议
          • GM/T 0009-2023: SM2 密码算法使用规范

          这是一个安全的密钥协商协议,允许两方在不安全的通道上协商出共享密钥。

          协议流程:

          1. 发起方 A 生成临时密钥对 (rA, RA),发送 RA 给响应方 B
          2. 响应方 B 生成临时密钥对 (rB, RB),发送 RB 给发起方 A
          3. 双方各自计算共享密钥 K
          4. 可选:双方交换确认哈希值进行相互认证

          安全特性:

          • 前向保密:即使长期私钥泄露,历史会话密钥仍然安全
          • 相互认证:可选的确认哈希值提供身份验证
          • 抗中间人攻击:需要长期密钥对的参与

          参数

          返回 SM2KeyExchangeResult

          密钥交换结果,包含临时公钥、共享密钥和可选的确认哈希值

          // 双方先生成长期密钥对和本次会话的临时密钥对。
          const keyPairA = generateKeyPair();
          const keyPairB = generateKeyPair();
          const tempKeyPairA = generateKeyPair();
          const tempKeyPairB = generateKeyPair();

          const resultA = keyExchange({
          privateKey: keyPairA.privateKey,
          publicKey: keyPairA.publicKey,
          peerPublicKey: keyPairB.publicKey,
          tempPrivateKey: tempKeyPairA.privateKey,
          peerTempPublicKey: tempKeyPairB.publicKey,
          isInitiator: true
          });

          const resultB = keyExchange({
          privateKey: keyPairB.privateKey,
          publicKey: keyPairB.publicKey,
          peerPublicKey: keyPairA.publicKey,
          tempPrivateKey: tempKeyPairB.privateKey,
          peerTempPublicKey: tempKeyPairA.publicKey,
          isInitiator: false
          });

          if (resultA.sharedKey !== resultB.sharedKey) {
          throw new Error('SM2 密钥交换结果不一致');
          }
      • sign: function
        • 使用 SM2 签名数据

          参数

          • privateKey: BytesLike

            私钥(十六进制字符串)

          • data: string | Uint8Array<ArrayBufferLike>

            要签名的数据(字符串或 Uint8Array)

          • 可选options: SignOptions

            签名选项

          返回 string

          签名(默认十六进制字符串;raw 为 r||s,der 为 ASN.1 DER)

      • verify: function
        • 使用 SM2 验证签名

          参数

          • publicKey: BytesLike

            公钥(十六进制字符串)

          • data: string | Uint8Array<ArrayBufferLike>

            原始数据(字符串或 Uint8Array)

          • signature: BytesLike

            签名(十六进制字符串,r || s 格式或 DER 编码)

          • 可选options: VerifyOptions

            验签选项

          返回 boolean

          签名是否有效

    • sm2CompressPublicKey: (publicKey: BytesLike) => string

      具名导出 sm2CompressPublicKey

    • sm2DecompressPublicKey: (publicKey: BytesLike) => string

      具名导出 sm2DecompressPublicKey

    • sm2Decrypt: (
          privateKey: BytesLike,
          encryptedData: BytesLike,
          options?: SM2DecryptOptions,
      ) => string

      具名导出 sm2Decrypt

    • sm2DecryptBytes: (
          privateKey: BytesLike,
          encryptedData: BytesLike,
          options?: SM2DecryptOptions,
      ) => Uint8Array

      具名导出 sm2DecryptBytes

    • sm2Encrypt: (
          publicKey: BytesLike,
          data: string | Uint8Array<ArrayBufferLike>,
          options?: SM2EncryptOptions,
      ) => string

      具名导出 sm2Encrypt

    • sm2GenerateKeyPair: (compressed?: boolean) => KeyPair

      具名导出 sm2GenerateKeyPair

    • sm2GetPublicKeyFromPrivateKey: (privateKey: BytesLike, compressed?: boolean) => string
    • sm2KeyExchange: (params: SM2KeyExchangeParams) => SM2KeyExchangeResult

      具名导出 sm2KeyExchange

    • sm2Sign: (
          privateKey: BytesLike,
          data: string | Uint8Array<ArrayBufferLike>,
          options?: SignOptions,
      ) => string

      具名导出 sm2Sign

    • sm2Verify: (
          publicKey: BytesLike,
          data: string | Uint8Array<ArrayBufferLike>,
          signature: BytesLike,
          options?: VerifyOptions,
      ) => boolean

      具名导出 sm2Verify

    • sm3: {
          SM3HashState: any;
          SM3: typeof SM3;
          sm3Digest: (
              data: string | Uint8Array<ArrayBufferLike>,
              options?: SM3Options,
          ) => string;
          digest(
              data: string | Uint8Array<ArrayBufferLike>,
              options?: SM3Options,
          ): string;
          hmac(
              key: string | Uint8Array<ArrayBufferLike>,
              data: string | Uint8Array<ArrayBufferLike>,
              options?: SM3Options,
          ): string;
      }

      SM3 函数与对象式 API 命名空间。

      • SM3: typeof SM3

        SM3 对象式 API,支持一次性摘要、HMAC 和增量摘要。

      • sm3Digest: (data: string | Uint8Array<ArrayBufferLike>, options?: SM3Options) => string

        兼容命名:与文档示例和旧版本 API 保持一致

        请使用 digest 函数

      • digest: function
        • 计算 SM3 哈希摘要(优化实现,减少内存分配并直接操作缓冲区)

          参数

          • data: string | Uint8Array<ArrayBufferLike>

            输入数据(字符串或 Uint8Array)

          • 可选options: SM3Options

            哈希选项

          返回 string

          哈希摘要(默认为小写十六进制字符串,64 个字符)

          // 十六进制格式(默认)
          const hash = digest('abc');

          // Base64 格式
          const hash64 = digest('abc', { outputFormat: OutputFormat.BASE64 });
      • hmac: function
        • 计算 SM3-HMAC

          参数

          • key: string | Uint8Array<ArrayBufferLike>

            密钥(字符串或 Uint8Array)

          • data: string | Uint8Array<ArrayBufferLike>

            要认证的数据(字符串或 Uint8Array)

          • 可选options: SM3Options

            哈希选项

          返回 string

          HMAC 值(默认为小写十六进制字符串,64 个字符)

          // 十六进制格式(默认)
          const mac = hmac('secret-key', 'data to authenticate');

          // Base64 格式
          const mac64 = hmac('secret-key', 'data to authenticate', { outputFormat: OutputFormat.BASE64 });
    • sm3Digest: (data: string | Uint8Array<ArrayBufferLike>, options?: SM3Options) => string

      具名导出 sm3Digest

    • sm3Hmac: (
          key: string | Uint8Array<ArrayBufferLike>,
          data: string | Uint8Array<ArrayBufferLike>,
          options?: SM3Options,
      ) => string

      具名导出 sm3Hmac

    • sm4: {
          SM4: typeof SM4;
          decrypt(
              key: BytesLike,
              encryptedData: BytesLike | SM4CipherResult,
              options?: SM4DecryptOptions,
          ): string;
          decryptBytes(
              key: BytesLike,
              encryptedData: BytesLike | SM4CipherResult,
              options?: SM4DecryptOptions,
          ): Uint8Array;
          encrypt(
              key: BytesLike,
              data: string | Uint8Array<ArrayBufferLike>,
              options?: SM4Options,
          ): SM4CipherResult;
      }

      SM4 函数与对象式 API 命名空间。

      • SM4: typeof SM4

        SM4 对象式 API,实例保存 key、mode、padding 与可选 IV 配置。

      • decrypt: function
        • 使用 SM4 解密数据 Decrypt data using SM4 block cipher

          支持的模式 (Supported modes):

          • ECB: 电码本模式 (Electronic Codebook)
          • CBC: 分组链接模式 (Cipher Block Chaining) - 需要IV (Requires IV)
          • CTR: 计数器模式 (Counter mode) - 流密码模式,需要IV (Stream mode, requires IV)
          • CFB: 密文反馈模式 (Cipher Feedback) - 流密码模式,需要IV (Stream mode, requires IV)
          • OFB: 输出反馈模式 (Output Feedback) - 流密码模式,需要IV (Stream mode, requires IV)
          • GCM: 伽罗瓦/计数器模式 (Galois/Counter Mode) - 认证加密,需要IV和tag (AEAD mode, requires IV and tag)
          • CCM: 计数器与 CBC-MAC 模式 (Counter with CBC-MAC) - 认证加密,需要 nonce 和 tag (AEAD mode, requires nonce and tag)

          支持的填充模式 (Supported padding modes):

          • PKCS7: PKCS#7 填充 (PKCS#7 padding) - 默认 (Default)
          • NONE: 无填充 (No padding)
          • ZERO: 零填充 (Zero padding)

          参数

          • key: BytesLike

            解密密钥(十六进制字符串,32 个字符 = 16 字节) Decryption key (hex string, 32 chars = 16 bytes)

          • encryptedData: BytesLike | SM4CipherResult

            加密的数据(十六进制字符串或 AEAD 结果对象) Encrypted data (hex string or AEAD result object)

          • 可选options: SM4DecryptOptions

            解密选项(模式、填充、IV、tag用于 GCM/CCM) Decryption options (mode, padding, IV, tag for GCM/CCM)

          返回 string

          解密后的数据(UTF-8 字符串) Decrypted data (UTF-8 string)

          // ECB 模式
          const decrypted = decrypt(key, encrypted, { mode: CipherMode.ECB, padding: PaddingMode.PKCS7 });
          // GCM 模式(校验认证标签)
          const decrypted = decrypt(key, result, { mode: CipherMode.GCM, iv: '000000000000000000000000', aad: 'metadata' });
      • decryptBytes: function
        • 使用 SM4 解密为原始字节;文本入口会额外执行 UTF-8 解码。

          参数

          • key: BytesLike

            固定 16 字节的密钥或 32 个 Hex 字符

          • encryptedData: BytesLike | SM4CipherResult

            字符串、原始密文字节或带 tag 的结构化结果

          • 可选options: SM4DecryptOptions

            mode、padding、IV/nonce、AAD、tag 与输入编码

          返回 Uint8Array

          解密并完成填充/AEAD 校验后的原始字节

          参数长度、编码、padding 或 AEAD 认证无效时抛出错误

      • encrypt: function
        • 使用 SM4 加密数据 Encrypt data using SM4 block cipher

          支持的模式 (Supported modes):

          • ECB: 电码本模式 (Electronic Codebook) - 不推荐用于生产环境 (Not recommended for production)
          • CBC: 分组链接模式 (Cipher Block Chaining) - 需要IV (Requires IV)
          • CTR: 计数器模式 (Counter mode) - 流密码模式,需要IV (Stream mode, requires IV)
          • CFB: 密文反馈模式 (Cipher Feedback) - 流密码模式,需要IV (Stream mode, requires IV)
          • OFB: 输出反馈模式 (Output Feedback) - 流密码模式,需要IV (Stream mode, requires IV)
          • GCM: 伽罗瓦/计数器模式 (Galois/Counter Mode) - 认证加密,需要IV (AEAD mode, requires IV)
          • CCM: 计数器与 CBC-MAC 模式 (Counter with CBC-MAC) - 认证加密,需要 nonce (AEAD mode, requires nonce)

          支持的填充模式 (Supported padding modes):

          • PKCS7: PKCS#7 填充 (PKCS#7 padding) - 默认 (Default)
          • NONE: 无填充 (No padding) - 数据长度必须是16字节的倍数 (Data length must be multiple of 16 bytes)
          • ZERO: 零填充 (Zero padding) - 用零字节填充 (Pad with zero bytes)

          参数

          • key: BytesLike

            加密密钥(十六进制字符串,32 个字符 = 16 字节) Encryption key (hex string, 32 chars = 16 bytes)

          • data: string | Uint8Array<ArrayBufferLike>

            要加密的数据(字符串或 Uint8Array) Data to encrypt (string or Uint8Array)

          • 可选options: SM4Options

            加密选项(模式、填充、IV) Encryption options (mode, padding, IV)

          返回 SM4CipherResult

          小写十六进制字符串形式的加密数据,或GCM模式下返回包含密文和标签的对象 Encrypted data as lowercase hex string, or object with ciphertext and tag for GCM mode

          // ECB 模式
          const encrypted = encrypt(key, 'order=GMKIT-DEMO-0001&amount=88.00', { mode: CipherMode.ECB, padding: PaddingMode.PKCS7 });
          // GCM 模式(包含认证标签)
          const result = encrypt(key, 'order=GMKIT-DEMO-0001&amount=88.00', { mode: CipherMode.GCM, iv: '000000000000000000000000', aad: 'tenant=demo;schema=1' });
          console.log(result.ciphertext, result.tag);
    • sm4Decrypt: (
          key: BytesLike,
          encryptedData: BytesLike | SM4CipherResult,
          options?: SM4DecryptOptions,
      ) => string

      具名导出 sm4Decrypt

    • sm4DecryptBytes: (
          key: BytesLike,
          encryptedData: BytesLike | SM4CipherResult,
          options?: SM4DecryptOptions,
      ) => Uint8Array

      具名导出 sm4DecryptBytes

    • sm4Encrypt: (
          key: BytesLike,
          data: string | Uint8Array<ArrayBufferLike>,
          options?: SM4Options,
      ) => SM4CipherResult

      具名导出 sm4Encrypt

    • verify: (
          publicKey: BytesLike,
          data: string | Uint8Array<ArrayBufferLike>,
          signature: BytesLike,
          options?: VerifyOptions,
      ) => boolean

      请改用 sm2Verify

    • zuc: {
          ZUCState: any;
          ZUC: typeof ZUC;
          decrypt(
              key: BytesLike,
              iv: BytesLike,
              ciphertext: BytesLike,
              options?: ZUCDecryptOptions,
          ): string;
          decryptBytes(
              key: BytesLike,
              iv: BytesLike,
              ciphertext: BytesLike,
              options?: ZUCDecryptOptions,
          ): Uint8Array;
          eea3(
              key: BytesLike,
              count: number,
              bearer: number,
              direction: number,
              length: number,
          ): string;
          eea3Encrypt(
              key: BytesLike,
              count: number,
              bearer: number,
              direction: number,
              message: string | Uint8Array<ArrayBufferLike>,
              bitLength?: number,
          ): string;
          eia3(
              key: BytesLike,
              count: number,
              bearer: number,
              direction: number,
              message: string | Uint8Array<ArrayBufferLike>,
              bitLength?: number,
          ): string;
          encrypt(
              key: BytesLike,
              iv: BytesLike,
              plaintext: string | Uint8Array<ArrayBufferLike>,
              options?: ZUCOptions,
          ): string;
          generateKeystream(
              key: string | Uint8Array<ArrayBufferLike>,
              iv: string | Uint8Array<ArrayBufferLike>,
              length: number,
          ): Uint32Array;
          getKeystream(key: BytesLike, iv: BytesLike, length: number): string;
          getKeystreamWords(key: BytesLike, iv: BytesLike, length: number): string;
      }

      ZUC、EEA3 与 EIA3 API 命名空间。

      • ZUC: typeof ZUC

        ZUC 对象式 API,实例保存 128 位 key 与 IV。

      • decrypt: function
        • 使用 ZUC-128 流密码解密数据

          参数

          • key: BytesLike

            128-bit key (16 bytes or 32 hex chars) / 128 位密钥

          • iv: BytesLike

            128-bit IV (16 bytes or 32 hex chars) / 128 位初始向量

          • ciphertext: BytesLike

            Encrypted data (hex or base64 string, auto-detected) / 加密的数据(十六进制或 base64,自动检测)

          • 可选options: ZUCDecryptOptions

            字符串输入编码;省略时优先识别 Hex,再识别 Base64

          返回 string

          Decrypted data as string / 解密后的数据

          // 自动检测输入格式
          const decrypted = decrypt(key, iv, encrypted);
      • decryptBytes: function
        • 使用 ZUC-128 解密为原始字节;文本 API 无法无损表示任意二进制数据。

          参数

          • key: BytesLike

            16 字节密钥或 32 个 Hex 字符

          • iv: BytesLike

            16 字节 IV 或 32 个 Hex 字符

          • ciphertext: BytesLike

            Hex/Base64 字符串或原始密文字节

          • 可选options: ZUCDecryptOptions

            字符串输入编码;省略时自动识别

          返回 Uint8Array

          与密文等长的原始明文字节

          key、IV、编码或长度无效时抛出错误

      • eea3: function
        • 生成 EEA3 密钥流(用于 LTE 加密) 优化:单次分配 IV 缓冲区

          参数

          • key: BytesLike

            128 位保密密钥

          • count: number

            32 位计数值

          • bearer: number

            5 位承载标识

          • direction: number

            1 位方向标志(0 表示上行,1 表示下行)

          • length: number

            需要生成的密钥流比特长度

          返回 string

          EEA3 密钥流

      • eea3Encrypt: function
        • 按 3GPP EEA3 规范加密消息。旧 eea3 继续返回字对齐密钥流以保持兼容。

          参数

          • key: BytesLike

            16 字节保密密钥

          • count: number

            32 位计数值

          • bearer: number

            0 到 31 的承载标识

          • direction: number

            方向标志,只能为 0 或 1

          • message: string | Uint8Array<ArrayBufferLike>

            待加密消息;字符串按 UTF-8

          • 可选bitLength: number

            参与加密的消息 bit 数;省略时使用全部字节

          返回 string

          小写 Hex 密文;末字节未使用 bit 清零

          参数范围或 bitLength 无效时抛出错误

      • eia3: function
        • 生成 EIA3 完整性标签(用于 LTE 认证)

          参数

          • key: BytesLike

            128 位完整性密钥

          • count: number

            32 位计数值

          • bearer: number

            5 位承载标识

          • direction: number

            1 位方向标志(0 表示上行,1 表示下行)

          • message: string | Uint8Array<ArrayBufferLike>

            待认证的消息

          • 可选bitLength: number

            参与认证的消息 bit 数;省略时使用全部字节

          返回 string

          32 位 MAC-I(十六进制字符串)

      • encrypt: function
        • 使用 ZUC-128 流密码加密数据

          参数

          • key: BytesLike

            128-bit key (16 bytes or 32 hex chars) / 128 位密钥

          • iv: BytesLike

            128-bit IV (16 bytes or 32 hex chars) / 128 位初始向量

          • plaintext: string | Uint8Array<ArrayBufferLike>

            Data to encrypt (string or Uint8Array) / 要加密的数据

          • 可选options: ZUCOptions

            Encryption options / 加密选项

          返回 string

          Encrypted data (default hex string) / 加密后的数据(默认十六进制字符串)

          // 默认 hex 格式(向后兼容)
          const encrypted = encrypt(key, iv, 'data');
          // Base64 格式
          const encrypted = encrypt(key, iv, 'data', { outputFormat: OutputFormat.BASE64 });
      • generateKeystream: function
        • 生成 ZUC-128 密钥流

          参数

          • key: string | Uint8Array<ArrayBufferLike>

            128 位密钥(16 字节或 32 个十六进制字符)

          • iv: string | Uint8Array<ArrayBufferLike>

            128 位初始向量(16 字节或 32 个十六进制字符)

          • length: number

            需要输出的 32 位密钥字数量

          返回 Uint32Array

          32 位密钥字数组

      • getKeystream: function
        • 生成 ZUC-128 密钥流(按字节长度)

          参数

          • key: BytesLike

            16 字节密钥或 32 个 Hex 字符

          • iv: BytesLike

            16 字节 IV 或 32 个 Hex 字符

          • length: number

            需要生成的字节长度

          返回 string

          固定返回小写 Hex,字符数为 length 的两倍

          key、IV 或 length 无效时抛出错误

      • getKeystreamWords: function
        • 生成 ZUC-128 密钥流

          参数

          • key: BytesLike

            128 位密钥(16 字节或 32 个十六进制字符)

          • iv: BytesLike

            128 位初始向量(16 字节或 32 个十六进制字符)

          • length: number

            需要生成的 32 位字数量

          返回 string

          十六进制字符串形式的密钥流

    • zucDecrypt: (
          key: BytesLike,
          iv: BytesLike,
          ciphertext: BytesLike,
          options?: ZUCDecryptOptions,
      ) => string

      具名导出 zucDecrypt

    • zucDecryptBytes: (
          key: BytesLike,
          iv: BytesLike,
          ciphertext: BytesLike,
          options?: ZUCDecryptOptions,
      ) => Uint8Array

      具名导出 zucDecryptBytes

    • zucEncrypt: (
          key: BytesLike,
          iv: BytesLike,
          plaintext: string | Uint8Array<ArrayBufferLike>,
          options?: ZUCOptions,
      ) => string

      具名导出 zucEncrypt

    • zucGenerateKeystream: (
          key: string | Uint8Array<ArrayBufferLike>,
          iv: string | Uint8Array<ArrayBufferLike>,
          length: number,
      ) => Uint32Array

      具名导出 zucGenerateKeystream

    • zucKeystream: (key: BytesLike, iv: BytesLike, length: number) => string

      具名导出 zucKeystream

    • zucKeystreamWords: (key: BytesLike, iv: BytesLike, length: number) => string

      具名导出 zucKeystreamWords