sm-crypto-v2 1.8.0 → 1.9.0

package/src/sm2/kx.ts

@@ -1,83 +0,0 @@
-import { field, sm2Curve } from './ec';
-import { KeyPair, hexToArray, leftPad } from './utils';
-import * as utils from '@noble/curves/abstract/utils';
-import { sm3 } from './sm3';
-import { EmptyArray, getZ } from '.';
-
-
-// 用到的常数
-const wPow2 = utils.hexToNumber('80000000000000000000000000000000')
-const wPow2Sub1 = utils.hexToNumber('7fffffffffffffffffffffffffffffff')
-
-// from sm2 sign part, extracted for code reusable.
-function hkdf(z: Uint8Array, keylen: number) {
-  let msg = new Uint8Array(keylen)
-  let ct = 1
-  let offset = 0
-  let t = EmptyArray
-  const ctShift = new Uint8Array(4)
-  const nextT = () => {
-    // (1) Hai = hash(z || ct)
-    // (2) ct++
-    ctShift[0] = ct >> 24 & 0x00ff
-    ctShift[1] = ct >> 16 & 0x00ff
-    ctShift[2] = ct >> 8 & 0x00ff
-    ctShift[3] = ct & 0x00ff
-    t = sm3(utils.concatBytes(z, ctShift))
-    ct++
-    offset = 0
-  }
-  nextT() // 先生成 Ha1
-
-  for (let i = 0, len = msg.length; i < len; i++) {
-    // t = Ha1 || Ha2 || Ha3 || Ha4
-    if (offset === t.length) nextT()
-
-    // 输出 stream
-    msg[i] = t[offset++] & 0xff
-  }
-  return msg
-}
-
-export function calculateSharedKey(
-  keypairA: KeyPair,
-  ephemeralKeypairA: KeyPair,
-  publicKeyB: string,
-  ephemeralPublicKeyB: string,
-  sharedKeyLength: number,
-  isRecipient = false,
-  idA: string = '1234567812345678',
-  idB: string = '1234567812345678',
-) {
-  const RA = sm2Curve.ProjectivePoint.fromHex(ephemeralKeypairA.publicKey)
-  const RB = sm2Curve.ProjectivePoint.fromHex(ephemeralPublicKeyB)
-  // const PA = sm2Curve.ProjectivePoint.fromHex(keypairA.publicKey) // 用不到
-  const PB = sm2Curve.ProjectivePoint.fromHex(publicKeyB)
-  let ZA = getZ(keypairA.publicKey, idA)
-  let ZB = getZ(publicKeyB, idB)
-  if (isRecipient) {
-    [ZA, ZB] = [ZB, ZA];
-  }
-  const rA = utils.hexToNumber(ephemeralKeypairA.privateKey)
-  const dA = utils.hexToNumber(keypairA.privateKey)
-  // 1.先算 tA
-  const x1 = RA.x
-  // x1_ = 2^w + (x1 & (2^w - 1))
-  const x1_ = wPow2 + (x1 & wPow2Sub1)
-  // tA = (dA + x1b * rA) mod n
-  const tA = field.add(dA, field.mulN(x1_, rA))
-
-  // 2.算 U
-  // x2_ = 2^w + (x2 & (2^w - 1))
-  const x2 = RB.x
-  const x2_ = field.add(wPow2, (x2 & wPow2Sub1))
-  // U = [h * tA](PB + x2_ * RB)
-  const U = RB.multiply(x2_).add(PB).multiply(tA)
-
-  // 3.算 KDF
-  // KA = KDF(xU || yU || ZA || ZB, kLen)
-  const xU = hexToArray(leftPad(utils.numberToHexUnpadded(U.x), 64))
-  const yU = hexToArray(leftPad(utils.numberToHexUnpadded(U.y), 64))
-  const KA = hkdf(utils.concatBytes(xU, yU, ZA, ZB), sharedKeyLength)
-  return KA
-}

package/src/sm2/rng.ts

@@ -1,77 +0,0 @@
-// Secure RNG Generator wrapper
-// 1. Use native sync API if available
-// 2. Use async API and maintain number pool if available
-// 3. Throw error if none of above available
-// Web: globalThis.crypto
-// Node: async import("crypto").webcrypto
-// Mini Program: wx.getRandomValues
-declare module wx {
-  function getRandomValues(options: {
-    length: number;
-    success: (res: { randomValues: ArrayBuffer }) => void;
-  }): void;
-}
-
-const DEFAULT_PRNG_POOL_SIZE = 16384
-let prngPool = new Uint8Array(0)
-let _syncCrypto: typeof import('crypto')['webcrypto']
-export async function initRNGPool() {
-  if ('crypto' in globalThis) {
-    _syncCrypto = globalThis.crypto
-    return // no need to use pooling
-  }
-  if (prngPool.length > DEFAULT_PRNG_POOL_SIZE / 2) return // there is sufficient number
-  // we always populate full pool size
-  // since numbers may be consumed during micro tasks.
-  if ('wx' in globalThis && 'getRandomValues' in globalThis.wx) {
-    prngPool = await new Promise(r => {
-      wx.getRandomValues({
-        length: DEFAULT_PRNG_POOL_SIZE,
-        success(res) {
-          r(new Uint8Array(res.randomValues));
-        }
-      });
-    });
-  } else {
-    // check if node or browser, use webcrypto if available
-    try {
-      // node 19+ and browser
-      if (globalThis.crypto) {
-        _syncCrypto = globalThis.crypto
-      } else {
-        // node below 19
-        const crypto = await import(/* webpackIgnore: true */ 'crypto');
-        _syncCrypto = crypto.webcrypto
-      }
-      const array = new Uint8Array(DEFAULT_PRNG_POOL_SIZE);
-      _syncCrypto.getRandomValues(array);
-      prngPool = array;
-    } catch (error) {
-      throw new Error('no available csprng, abort.');
-    }
-  }
-}
-
-initRNGPool()
-
-function consumePool(length: number): Uint8Array {
-  if (prngPool.length > length) {
-    const prng = prngPool.slice(0, length)
-    prngPool = prngPool.slice(length)
-    initRNGPool()
-    return prng
-  } else {
-    throw new Error('random number pool is not ready or insufficient, prevent getting too long random values or too often.')
-  }
-}
-
-export function randomBytes(length = 0): Uint8Array {
-  const array = new Uint8Array(length);
-  if (_syncCrypto) {
-    return _syncCrypto.getRandomValues(array);
-  } else {
-    // no sync crypto available, use async pool
-    const result = consumePool(length)
-    return result
-  }
-}

package/src/sm2/sm3.ts

@@ -1,241 +0,0 @@
-// import assert from './_assert.js';
-import { Hash, createView, Input, toBytes, wrapConstructor } from '../sm3/utils.js';
-
-const BoolA = (A: number, B: number, C: number) => ((A & B) | (A & C)) | (B & C)
-const BoolB = (A: number, B: number, C: number) => ((A ^ B) ^ C)
-const BoolC = (A: number, B: number, C: number) => (A & B) | ((~A) & C)
-// Polyfill for Safari 14
-function setBigUint64(view: DataView, byteOffset: number, value: bigint, isLE: boolean): void {
-  if (typeof view.setBigUint64 === 'function') return view.setBigUint64(byteOffset, value, isLE);
-  const _32n = BigInt(32);
-  const _u32_max = BigInt(0xffffffff);
-  const wh = Number((value >> _32n) & _u32_max);
-  const wl = Number(value & _u32_max);
-  const h = isLE ? 4 : 0;
-  const l = isLE ? 0 : 4;
-  view.setUint32(byteOffset + h, wh, isLE);
-  view.setUint32(byteOffset + l, wl, isLE);
-}
-
-/**
- * 循环左移
- */
-export function rotl(x: number, n: number) {
-  const s = n & 31
-  return (x << s) | (x >>> (32 - s))
-}
-
-/**
- * 二进制异或运算
- */
-function xor(x: Uint8Array, y: Uint8Array) {
-  const result = new Uint8Array(x.length)
-  for (let i = x.length - 1; i >= 0; i--) result[i] = (x[i] ^ y[i]) & 0xff
-  return result
-}
-
-/**
- * 压缩函数中的置换函数 P0(X) = X xor (X <<< 9) xor (X <<< 17)
- */
-function P0(X: number) {
-  return (X ^ rotl(X, 9)) ^ rotl(X, 17)
-}
-
-/**
- * 消息扩展中的置换函数 P1(X) = X xor (X <<< 15) xor (X <<< 23)
- */
-function P1(X: number) {
-  return (X ^ rotl(X, 15)) ^ rotl(X, 23)
-}
-
-// from noble-hashes (https://github.com/paulmillr/noble-hashes#hmac)
-/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-
-// Base SHA2 class (RFC 6234)
-export abstract class SHA2<T extends SHA2<T>> extends Hash<T> {
-  protected abstract process(buf: DataView, offset: number): void;
-  protected abstract get(): number[];
-  protected abstract set(...args: number[]): void;
-  abstract destroy(): void;
-  protected abstract roundClean(): void;
-  // For partial updates less than block size
-  protected buffer: Uint8Array;
-  protected view: DataView;
-  protected finished = false;
-  protected length = 0;
-  protected pos = 0;
-  protected destroyed = false;
-
-  constructor(
-    readonly blockLen: number,
-    public outputLen: number,
-    readonly padOffset: number,
-    readonly isLE: boolean
-  ) {
-    super();
-    this.buffer = new Uint8Array(blockLen);
-    this.view = createView(this.buffer);
-  }
-  update(data: Input): this {
-    const { view, buffer, blockLen } = this;
-    data = toBytes(data);
-    const len = data.length;
-    for (let pos = 0; pos < len; ) {
-      const take = Math.min(blockLen - this.pos, len - pos);
-      // Fast path: we have at least one block in input, cast it to view and process
-      if (take === blockLen) {
-        const dataView = createView(data);
-        for (; blockLen <= len - pos; pos += blockLen) this.process(dataView, pos);
-        continue;
-      }
-      buffer.set(data.subarray(pos, pos + take), this.pos);
-      this.pos += take;
-      pos += take;
-      if (this.pos === blockLen) {
-        this.process(view, 0);
-        this.pos = 0;
-      }
-    }
-    this.length += data.length;
-    this.roundClean();
-    return this;
-  }
-  digestInto(out: Uint8Array) {
-    this.finished = true;
-    // Padding
-    // We can avoid allocation of buffer for padding completely if it
-    // was previously not allocated here. But it won't change performance.
-    const { buffer, view, blockLen, isLE } = this;
-    let { pos } = this;
-    // append the bit '1' to the message
-    buffer[pos++] = 0b10000000;
-    this.buffer.subarray(pos).fill(0);
-    // we have less than padOffset left in buffer, so we cannot put length in current block, need process it and pad again
-    if (this.padOffset > blockLen - pos) {
-      this.process(view, 0);
-      pos = 0;
-    }
-    // Pad until full block byte with zeros
-    for (let i = pos; i < blockLen; i++) buffer[i] = 0;
-    // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that
-    // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen.
-    // So we just write lowest 64 bits of that value.
-    setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
-    this.process(view, 0);
-    const oview = createView(out);
-    const len = this.outputLen;
-    // NOTE: we do division by 4 later, which should be fused in single op with modulo by JIT
-    if (len % 4) throw new Error('_sha2: outputLen should be aligned to 32bit');
-    const outLen = len / 4;
-    const state = this.get();
-    if (outLen > state.length) throw new Error('_sha2: outputLen bigger than state');
-    for (let i = 0; i < outLen; i++) oview.setUint32(4 * i, state[i], isLE);
-  }
-  digest() {
-    const { buffer, outputLen } = this;
-    this.digestInto(buffer);
-    const res = buffer.slice(0, outputLen);
-    this.destroy();
-    return res;
-  }
-  _cloneInto(to?: T): T {
-    to ||= new (this.constructor as any)() as T;
-    to.set(...this.get());
-    const { blockLen, buffer, length, finished, destroyed, pos } = this;
-    to.length = length;
-    to.pos = pos;
-    to.finished = finished;
-    to.destroyed = destroyed;
-    if (length % blockLen) to.buffer.set(buffer);
-    return to;
-  }
-}
-
-const IV = new Uint32Array([0x7380166f, 0x4914b2b9, 0x172442d7, 0xda8a0600, 0xa96f30bc, 0x163138aa, 0xe38dee4d, 0xb0fb0e4e])
-const SM3_W = new Uint32Array(68)
-const SM3_M = new Uint32Array(64)
-
-const T1 = 0x79cc4519
-const T2 = 0x7a879d8a
-
-class SM3 extends SHA2<SM3> {
-  // 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;
-  D = IV[3] | 0;
-  E = IV[4] | 0;
-  F = IV[5] | 0;
-  G = IV[6] | 0;
-  H = IV[7] | 0;
-
-  constructor() {
-    super(64, 32, 8, false);
-  }
-  protected get(): [number, number, number, number, number, number, number, number] {
-    const { A, B, C, D, E, F, G, H } = this;
-    return [A, B, C, D, E, F, G, H];
-  }
-  // prettier-ignore
-  protected set(
-    A: number, B: number, C: number, D: number, E: number, F: number, G: number, H: number
-  ) {
-    this.A = A | 0;
-    this.B = B | 0;
-    this.C = C | 0;
-    this.D = D | 0;
-    this.E = E | 0;
-    this.F = F | 0;
-    this.G = G | 0;
-    this.H = H | 0;
-  }
-  protected process(view: DataView, offset: number): void {
-    // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array
-    for (let i = 0; i < 16; i++, offset += 4) SM3_W[i] = view.getUint32(offset, false);
-    for (let i = 16; i < 68; i++) {
-      SM3_W[i] = (P1((SM3_W[i- 16] ^ SM3_W[i - 9]) ^ rotl(SM3_W[i - 3], 15)) ^ rotl(SM3_W[i - 13], 7)) ^ SM3_W[i - 6]
-    }
-    for (let i = 0; i < 64; i++) {
-      SM3_M[i] = SM3_W[i] ^ SM3_W[i + 4]
-    }
-    // Compression function main loop, 64 rounds
-    let { A, B, C, D, E, F, G, H } = this;
-    for (let j = 0; j < 64; j++) {
-      let small = j >= 0 && j <= 15
-      let T = small ? T1 : T2
-      let SS1 = rotl(rotl(A, 12) + E + rotl(T, j), 7)
-      let SS2 = SS1 ^ rotl(A, 12)
-
-      let TT1 = ((small ? BoolB(A, B, C) : BoolA(A, B, C)) + D + SS2 + SM3_M[j]) | 0
-      let TT2 = ((small ? BoolB(E, F, G) : BoolC(E, F, G)) + H + SS1 + SM3_W[j]) | 0
-
-      D = C
-      C = rotl(B, 9)
-      B = A
-      A = TT1
-      H = G
-      G = rotl(F, 19)
-      F = E
-      E = P0(TT2)
-    }
-    // Add the compressed chunk to the current hash value
-    A = (A ^ this.A) | 0;
-    B = (B ^ this.B) | 0;
-    C = (C ^ this.C) | 0;
-    D = (D ^ this.D) | 0;
-    E = (E ^ this.E) | 0;
-    F = (F ^ this.F) | 0;
-    G = (G ^ this.G) | 0;
-    H = (H ^ this.H) | 0;
-    this.set(A, B, C, D, E, F, G, H);
-  }
-  protected roundClean() {
-    SM3_W.fill(0);
-  }
-  destroy() {
-    this.set(0, 0, 0, 0, 0, 0, 0, 0);
-    this.buffer.fill(0);
-  }
-}
-export const sm3 = wrapConstructor(() => new SM3());

package/src/sm2/utils.ts

@@ -1,164 +0,0 @@
-/* eslint-disable no-bitwise, no-mixed-operators, no-use-before-define, max-len */
-import * as utils from '@noble/curves/abstract/utils';
-
-import { sm2Curve, sm2Fp } from './ec';
-import { mod } from '@noble/curves/abstract/modular';
-import { ONE, TWO, ZERO } from './bn';
-
-export interface KeyPair {
-  privateKey: string
-  publicKey: string
-}
-
-/**
- * 生成密钥对：publicKey = privateKey * G
- */
-export function generateKeyPairHex(str?: string): KeyPair {
-  const privateKey = str ? utils.numberToBytesBE((mod(BigInt(str), ONE) + ONE), 32) : sm2Curve.utils.randomPrivateKey()
-  // const random = typeof a === 'string' ? new BigInteger(a, b) :
-  //   a ? new BigInteger(a, b!, c!) : new BigInteger(n.bitLength(), rng)
-  // const d = random.mod(n.subtract(BigInteger.ONE)).add(BigInteger.ONE) // 随机数
-  // const privateKey = leftPad(d.toString(16), 64)
-
-  // const P = G!.multiply(d) // P = dG，p 为公钥，d 为私钥
-  // const Px = leftPad(P.getX().toBigInteger().toString(16), 64)
-  // const Py = leftPad(P.getY().toBigInteger().toString(16), 64)
-  // const publicKey = '04' + Px + Py
-  const publicKey = sm2Curve.getPublicKey(privateKey, false);
-  const privPad = leftPad(utils.bytesToHex(privateKey), 64)
-  const pubPad = leftPad(utils.bytesToHex(publicKey), 64)
-  return {privateKey: privPad, publicKey: pubPad}
-}
-
-/**
- * 生成压缩公钥
- */
-export function compressPublicKeyHex(s: string) {
-  if (s.length !== 130) throw new Error('Invalid public key to compress')
-
-  const len = (s.length - 2) / 2
-  const xHex = s.substring(2, 2 + len)
-  const y = utils.hexToNumber(s.substring(len + 2, len + len + 2))
-
-  let prefix = '03'
-  if (mod(y, TWO) === ZERO) prefix = '02'
-  return prefix + xHex
-}
-
-/**
- * utf8串转16进制串
- */
-export function utf8ToHex(input: string) {
-  input = decodeURIComponent(encodeURIComponent(input))
-
-  const length = input.length
-
-  // 转换到字数组
-  const words = new Uint32Array((length >>> 2) + 1)
-  for (let i = 0; i < length; i++) {
-    words[i >>> 2] |= (input.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8)
-  }
-
-  // 转换到16进制
-  const hexChars: string[]= []
-  for (let i = 0; i < length; i++) {
-    const bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff
-    hexChars.push((bite >>> 4).toString(16))
-    hexChars.push((bite & 0x0f).toString(16))
-  }
-
-  return hexChars.join('')
-}
-
-/**
- * 补全16进制字符串
- */
-export function leftPad(input: string, num: number) {
-  if (input.length >= num) return input
-
-  return (new Array(num - input.length + 1)).join('0') + input
-}
-
-/**
- * 转成16进制串
- */
-export function arrayToHex(arr: number[]) {
-  return arr.map(item => {
-    const hex = item.toString(16)
-    return hex.length === 1 ? '0' + hex : hex
-  }).join('')
-}
-
-/**
- * 转成utf8串
- */
-export function arrayToUtf8(arr: Uint8Array) {
-  const str: string[] = []
-  for (let i = 0, len = arr.length; i < len; i++) {
-    if (arr[i] >= 0xf0 && arr[i] <= 0xf7) {
-      // 四字节
-      str.push(String.fromCodePoint(((arr[i] & 0x07) << 18) + ((arr[i + 1] & 0x3f) << 12) + ((arr[i + 2] & 0x3f) << 6) + (arr[i + 3] & 0x3f)))
-      i += 3
-    } else if (arr[i] >= 0xe0 && arr[i] <= 0xef) {
-      // 三字节
-      str.push(String.fromCodePoint(((arr[i] & 0x0f) << 12) + ((arr[i + 1] & 0x3f) << 6) + (arr[i + 2] & 0x3f)))
-      i += 2
-    } else if (arr[i] >= 0xc0 && arr[i] <= 0xdf) {
-      // 双字节
-      str.push(String.fromCodePoint(((arr[i] & 0x1f) << 6) + (arr[i + 1] & 0x3f)))
-      i++
-    } else {
-      // 单字节
-      str.push(String.fromCodePoint(arr[i]))
-    }
-  }
-
-  return str.join('')
-}
-
-/**
- * 转成字节数组
- */
-export function hexToArray(hexStr: string) {
-  let hexStrLength = hexStr.length
-
-  if (hexStrLength % 2 !== 0) {
-    hexStr = leftPad(hexStr, hexStrLength + 1)
-  }
-
-  hexStrLength = hexStr.length
-  const wordLength = hexStrLength / 2
-  const words = new Uint8Array(wordLength)
-
-  for (let i = 0; i < wordLength; i++) {
-    words[i] = (parseInt(hexStr.substring(i * 2, i * 2 + 2), 16))
-  }
-  return words
-}
-
-/**
- * 验证公钥是否为椭圆曲线上的点
- */
-export function verifyPublicKey(publicKey: string) {
-  const point = sm2Curve.ProjectivePoint.fromHex(publicKey)
-  if (!point) return false
-  try {
-    point.assertValidity()
-    return true
-  } catch (error) {
-    return false
-  }
-}
-
-/**
- * 验证公钥是否等价，等价返回true
- */
-export function comparePublicKeyHex(publicKey1: string, publicKey2: string) {
-  const point1 = sm2Curve.ProjectivePoint.fromHex(publicKey1)
-  if (!point1) return false
-
-  const point2 = sm2Curve.ProjectivePoint.fromHex(publicKey2)
-  if (!point2) return false
-
-  return point1.equals(point2)
-}

package/src/sm3/index.ts

@@ -1,72 +0,0 @@
-import { hmac } from '@/sm2/hmac'
-import { sm3 as sm2sm3 } from '../sm2/sm3'
-import { hexToArray } from '../sm2/utils'
-import { bytesToHex } from './utils'
-
-/**
- * 补全16进制字符串
- */
-// function leftPad(input, num) {
-//   if (input.length >= num) return input
-
-//   return (new Array(num - input.length + 1)).join('0') + input
-// }
-
-/**
- * utf8 串转字节数组
- */
-export function utf8ToArray(str: string) {
-  const arr: number[] = []
-
-  for (let i = 0, len = str.length; i < len; i++) {
-    const point = str.codePointAt(i)!
-
-    if (point <= 0x007f) {
-      // 单字节，标量值：00000000 00000000 0zzzzzzz
-      arr.push(point)
-    } else if (point <= 0x07ff) {
-      // 双字节，标量值：00000000 00000yyy yyzzzzzz
-      arr.push(0xc0 | (point >>> 6)) // 110yyyyy（0xc0-0xdf）
-      arr.push(0x80 | (point & 0x3f)) // 10zzzzzz（0x80-0xbf）
-    } else if (point <= 0xD7FF || (point >= 0xE000 && point <= 0xFFFF)) {
-      // 三字节：标量值：00000000 xxxxyyyy yyzzzzzz
-      arr.push(0xe0 | (point >>> 12)) // 1110xxxx（0xe0-0xef）
-      arr.push(0x80 | ((point >>> 6) & 0x3f)) // 10yyyyyy（0x80-0xbf）
-      arr.push(0x80 | (point & 0x3f)) // 10zzzzzz（0x80-0xbf）
-    } else if (point >= 0x010000 && point <= 0x10FFFF) {
-      // 四字节：标量值：000wwwxx xxxxyyyy yyzzzzzz
-      i++
-      arr.push((0xf0 | (point >>> 18) & 0x1c)) // 11110www（0xf0-0xf7）
-      arr.push((0x80 | ((point >>> 12) & 0x3f))) // 10xxxxxx（0x80-0xbf）
-      arr.push((0x80 | ((point >>> 6) & 0x3f))) // 10yyyyyy（0x80-0xbf）
-      arr.push((0x80 | (point & 0x3f))) // 10zzzzzz（0x80-0xbf）
-    } else {
-      // 五、六字节，暂时不支持
-      arr.push(point)
-      throw new Error('input is not supported')
-    }
-  }
-
-  return new Uint8Array(arr)
-}
-
-export function sm3(input: string | Uint8Array, options?: {
-  key: Uint8Array | string
-  mode?: 'hmac' | 'mac'
-}) {
-  input = typeof input === 'string' ? utf8ToArray(input) : input
-
-  if (options) {
-    const mode = options.mode || 'hmac'
-    if (mode !== 'hmac') throw new Error('invalid mode')
-
-    let key = options.key
-    if (!key) throw new Error('invalid key')
-
-    key = typeof key === 'string' ? hexToArray(key) : key
-    return bytesToHex(hmac(sm2sm3, key, input));
-  }
-  return bytesToHex(sm2sm3(input))
-}
-
-export default sm3