sm-crypto-v2 1.7.0 → 1.9.0

package/package.json

@@ -1,17 +1,20 @@
 {
   "name": "sm-crypto-v2",
-  "version": "1.7.0",
+  "version": "1.9.0",
   "description": "sm-crypto-v2",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
+  "miniprogram": "miniprogram_dist",
   "types": "dist/index.d.ts",
   "scripts": {
     "prepublish": "npm run build",
     "lint": "eslint \"src/**/*.js\" --fix",
-    "build": "vitest run && tsup",
+    "prerelease": "vitest run && npm run build && npm run build-mp",
+    "build": "tsup",
+    "build-mp": "tsup --config=tsup.config.miniprogram.ts",
     "watch": "tsup --watch",
     "test": "vitest",
-    "release": "npm run build && standard-version && git push --follow-tags origin master",
+    "release": "npm run prerelease && standard-version && git push --follow-tags origin master",
     "coverage": "vitest run --coverage"
   },
   "repository": {
@@ -44,12 +47,13 @@
     "@vitest/runner": "^0.33.0",
     "@vitest/ui": "^0.31.0",
     "conventional-changelog-cli": "^2.2.2",
+    "esbuild": "^0.19.10",
     "eslint": "^8.15.0",
     "eslint-config-prettier": "^8.3.0",
     "eslint-plugin-prettier": "^4.0.0",
     "prettier": "^2.6.2",
     "standard-version": "^9.5.0",
-    "tsup": "^5.12.7",
+    "tsup": "^8.0.1",
     "typescript": "^4.7.2",
     "vite": "^4.3.9",
     "vitest": "^0.31.0"

package/{tsup.config.ts → tsup.config.miniprogram.ts}

@@ -3,15 +3,20 @@ import { defineConfig } from 'tsup';
 export default defineConfig({
   entry: ['./src/index.ts'],
   clean: true,
-  outDir: 'dist',
+  outDir: 'miniprogram_dist',
   dts: true,
   // we need to keep minify false, since webpack magic comments
   // will be stripped if minify.
   minify: false,
-  format: ['esm', 'cjs'],
-  target: 'esnext',
+  format: ['cjs'],
+  target: 'es5',
+  noExternal: ['@noble/curves'],
   tsconfig: 'tsconfig.json',
   esbuildOptions(options) {
-    options.define.__BUILD_TS__ = Date.now();
+    options.define.__BUILD_TS__ = Date.now().toString();
+    options.define.import = 'require';
+    options.supported = {
+      'dynamic-import': false,
+    }
   }
 });

package/src/index.ts

@@ -1,3 +0,0 @@
-export * as sm2 from './sm2/index'
-export { sm3 } from './sm3/index'
-export * as sm4 from './sm4/index'

package/src/sm2/asn1.ts

@@ -1,161 +0,0 @@
-/* eslint-disable class-methods-use-this */
-
-import * as utils from '@noble/curves/abstract/utils';
-import { ONE } from './bn';
-
-export function bigintToValue(bigint: bigint) {
-  let h = bigint.toString(16)
-  if (h[0] !== '-') {
-    // 正数
-    if (h.length % 2 === 1) h = '0' + h // 补齐到整字节
-    else if (!h.match(/^[0-7]/)) h = '00' + h // 非0开头，则补一个全0字节
-  } else {
-    // 负数
-    h = h.substring(1)
-    let len = h.length
-    if (len % 2 === 1) len += 1 // 补齐到整字节
-    else if (!h.match(/^[0-7]/)) len += 2 // 非0开头，则补一个全0字节
-
-    let maskString = ''
-    for (let i = 0; i < len; i++) maskString += 'f'
-    let mask = utils.hexToNumber(maskString)
-
-    // 对绝对值取反，加1
-    
-    let output = (mask ^ bigint) + ONE
-    h = output.toString(16).replace(/^-/, '')
-  }
-  return h
-}
-
-class ASN1Object {
-  constructor(
-    public tlv: string | null = null,
-    public t = '00',
-    public l = '00',
-    public v = ''
-  ) { }
-
-  /**
-   * 获取 der 编码比特流16进制串
-   */
-  getEncodedHex() {
-    if (!this.tlv) {
-      this.v = this.getValue()
-      this.l = this.getLength()
-      this.tlv = this.t + this.l + this.v
-    }
-    return this.tlv
-  }
-
-  getLength() {
-    const n = this.v.length / 2 // 字节数
-    let nHex = n.toString(16)
-    if (nHex.length % 2 === 1) nHex = '0' + nHex // 补齐到整字节
-
-    if (n < 128) {
-      // 短格式，以 0 开头
-      return nHex
-    } else {
-      // 长格式，以 1 开头
-      const head = 128 + nHex.length / 2 // 1(1位) + 真正的长度占用字节数(7位) + 真正的长度
-      return head.toString(16) + nHex
-    }
-  }
-
-  getValue() {
-    return ''
-  }
-}
-
-class DERInteger extends ASN1Object {
-  constructor(bigint: bigint) {
-    super()
-
-    this.t = '02' // 整型标签说明
-    if (bigint) this.v = bigintToValue(bigint)
-  }
-
-  getValue() {
-    return this.v
-  }
-}
-
-class DERSequence extends ASN1Object {
-  public t = '30'
-  constructor(public asn1Array: ASN1Object[]) {
-    super()
-  }
-
-  getValue() {
-    this.v = this.asn1Array.map(asn1Object => asn1Object.getEncodedHex()).join('')
-    return this.v
-  }
-}
-
-/**
- * 获取 l 占用字节数
- */
-function getLenOfL(str: string, start: number) {
-  if (+str[start + 2] < 8) return 1 // l 以0开头，则表示短格式，只占一个字节
-  return +str.substring(start + 2, start + 4) & 0x7f + 1 // 长格式，取第一个字节后7位作为长度真正占用字节数，再加上本身
-}
-
-/**
- * 获取 l
- */
-function getL(str: string, start: number) {
-  // 获取 l
-  const len = getLenOfL(str, start)
-  const l = str.substring(start + 2, start + 2 + len * 2)
-
-  if (!l) return -1
-  const bigint = +l[0] < 8 ? utils.hexToNumber(l): utils.hexToNumber(l.substring(2))
-
-  return +bigint.toString()
-}
-
-/**
- * 获取 v 的位置
- */
-function getStartOfV(str: string, start: number) {
-  const len = getLenOfL(str, start)
-  return start + (len + 1) * 2
-}
-
-/**
- * ASN.1 der 编码，针对 sm2 签名
- */
-export function encodeDer(r: bigint, s: bigint) {
-  const derR = new DERInteger(r)
-  const derS = new DERInteger(s)
-  const derSeq = new DERSequence([derR, derS])
-
-  return derSeq.getEncodedHex()
-}
-
-/**
- * 解析 ASN.1 der，针对 sm2 验签
- */
-export function decodeDer(input: string) {
-  // 结构：
-  // input = | tSeq | lSeq | vSeq |
-  // vSeq = | tR | lR | vR | tS | lS | vS |
-  const start = getStartOfV(input, 0)
-
-  const vIndexR = getStartOfV(input, start)
-  const lR = getL(input, start)
-  const vR = input.substr(vIndexR, lR * 2)
-
-  const nextStart = vIndexR + vR.length
-  const vIndexS = getStartOfV(input, nextStart)
-  const lS = getL(input, nextStart)
-  const vS = input.substring(vIndexS, vIndexS + lS * 2)
-
-  // const r = new BigInteger(vR, 16)
-  // const s = new BigInteger(vS, 16)
-  const r = utils.hexToNumber(vR)
-  const s = utils.hexToNumber(vS)
-
-  return { r, s }
-}

package/src/sm2/bn.ts

@@ -1,4 +0,0 @@
-export const ZERO = BigInt(0);
-export const ONE = BigInt(1);
-export const TWO = BigInt(2);
-export const THREE = BigInt(3);

package/src/sm2/ec.ts

@@ -1,24 +0,0 @@
-import { weierstrass } from '@noble/curves/abstract/weierstrass';
-import { Field } from '@noble/curves/abstract/modular'; // finite field for mod arithmetics
-import { ONE } from './bn';
-import { randomBytes } from './rng';
-import { sm3 } from './sm3';
-import { hmac } from './hmac';
-import { concatBytes } from '@noble/curves/abstract/utils';
-
-export const sm2Fp = Field(BigInt('115792089210356248756420345214020892766250353991924191454421193933289684991999'))
-export const sm2Curve = weierstrass({
-  // sm2: short weierstrass.
-  a: BigInt('115792089210356248756420345214020892766250353991924191454421193933289684991996'),
-  b: BigInt('18505919022281880113072981827955639221458448578012075254857346196103069175443'),
-  Fp: sm2Fp,
-  h: ONE,
-  n: BigInt('115792089210356248756420345214020892766061623724957744567843809356293439045923'),
-  Gx: BigInt('22963146547237050559479531362550074578802567295341616970375194840604139615431'),
-  Gy: BigInt('85132369209828568825618990617112496413088388631904505083283536607588877201568'),
-  hash: sm3,
-  hmac: (key: Uint8Array, ...msgs: Uint8Array[]) => hmac(sm3, key, concatBytes(...msgs)),
-  randomBytes,
-});
-// 有限域运算
-export const field = Field(BigInt(sm2Curve.CURVE.n))

package/src/sm2/hmac.ts

@@ -1,76 +0,0 @@
-import { Hash, CHash, Input, toBytes } from '../sm3/utils';
-// HMAC (RFC 2104)
-export class HMAC<T extends Hash<T>> extends Hash<HMAC<T>> {
-  oHash: T;
-  iHash: T;
-  blockLen: number;
-  outputLen: number;
-  private finished = false;
-  private destroyed = false;
-
-  constructor(hash: CHash, _key: Input) {
-    super();
-    const key = toBytes(_key);
-    this.iHash = hash.create() as T;
-    if (typeof this.iHash.update !== 'function')
-      throw new Error('Expected instance of class which extends utils.Hash');
-    this.blockLen = this.iHash.blockLen;
-    this.outputLen = this.iHash.outputLen;
-    const blockLen = this.blockLen;
-    const pad = new Uint8Array(blockLen);
-    // blockLen can be bigger than outputLen
-    pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);
-    for (let i = 0; i < pad.length; i++) pad[i] ^= 0x36;
-    this.iHash.update(pad);
-    // By doing update (processing of first block) of outer hash here we can re-use it between multiple calls via clone
-    this.oHash = hash.create() as T;
-    // Undo internal XOR && apply outer XOR
-    for (let i = 0; i < pad.length; i++) pad[i] ^= 0x36 ^ 0x5c;
-    this.oHash.update(pad);
-    pad.fill(0);
-  }
-  update(buf: Input) {
-    this.iHash.update(buf);
-    return this;
-  }
-  digestInto(out: Uint8Array) {
-    this.finished = true;
-    this.iHash.digestInto(out);
-    this.oHash.update(out);
-    this.oHash.digestInto(out);
-    this.destroy();
-  }
-  digest() {
-    const out = new Uint8Array(this.oHash.outputLen);
-    this.digestInto(out);
-    return out;
-  }
-  _cloneInto(to?: HMAC<T>): HMAC<T> {
-    // Create new instance without calling constructor since key already in state and we don't know it.
-    to ||= Object.create(Object.getPrototypeOf(this), {});
-    const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
-    to = to as this;
-    to.finished = finished;
-    to.destroyed = destroyed;
-    to.blockLen = blockLen;
-    to.outputLen = outputLen;
-    to.oHash = oHash._cloneInto(to.oHash);
-    to.iHash = iHash._cloneInto(to.iHash);
-    return to;
-  }
-  destroy() {
-    this.destroyed = true;
-    this.oHash.destroy();
-    this.iHash.destroy();
-  }
-}
-
-/**
- * HMAC: RFC2104 message authentication code.
- * @param hash - function that would be used e.g. sha256
- * @param key - message key
- * @param message - message data
- */
-export const hmac = (hash: CHash, key: Input, message: Input): Uint8Array =>
-  new HMAC<any>(hash, key).update(message).digest();
-hmac.create = (hash: CHash, key: Input) => new HMAC<any>(hash, key);

package/src/sm2/index.ts

@@ -1,291 +0,0 @@
-/* eslint-disable no-use-before-define */
-import { encodeDer, decodeDer } from './asn1'
-import { arrayToHex, arrayToUtf8, generateKeyPairHex, hexToArray, leftPad, utf8ToHex } from './utils'
-import { sm3 } from './sm3'
-import * as utils from '@noble/curves/abstract/utils';
-import { field, sm2Curve } from './ec';
-import { ONE, ZERO } from './bn';
-import { bytesToHex } from '@/sm3/utils';
-import { ProjPointType } from '@noble/curves/abstract/weierstrass';
-
-export * from './utils'
-export { initRNGPool } from './rng'
-export { calculateSharedKey } from './kx'
-
-const C1C2C3 = 0
-// a empty array, just make tsc happy
-export const EmptyArray = new Uint8Array()
-/**
- * 加密
- */
-export function doEncrypt(msg: string | Uint8Array, publicKey: string | ProjPointType<bigint>, cipherMode = 1) {
-
-  const msgArr = typeof msg === 'string' ? hexToArray(utf8ToHex(msg)) : Uint8Array.from(msg)
-  const publicKeyPoint = typeof publicKey === 'string' ? sm2Curve.ProjectivePoint.fromHex(publicKey) :
-    publicKey
-
-  const keypair = generateKeyPairHex()
-  const k = utils.hexToNumber(keypair.privateKey)
-
-  // c1 = k * G
-  let c1 = keypair.publicKey
-  if (c1.length > 128) c1 = c1.substring(c1.length - 128)
-  const p = publicKeyPoint.multiply(k)
-  
-  // (x2, y2) = k * publicKey
-  const x2 = hexToArray(leftPad(utils.numberToHexUnpadded(p.x), 64))
-  const y2 = hexToArray(leftPad(utils.numberToHexUnpadded(p.y), 64))
-
-  // c3 = hash(x2 || msg || y2)
-  const c3 = bytesToHex(sm3(utils.concatBytes(x2, msgArr, y2)));
-
-  xorCipherStream(x2, y2, msgArr)
-  const c2 = bytesToHex(msgArr)
-
-  return cipherMode === C1C2C3 ? c1 + c2 + c3 : c1 + c3 + c2
-}
-
-function xorCipherStream(x2: Uint8Array, y2: Uint8Array, msg: Uint8Array) {
-  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(x2, y2, 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()
-
-    // c2 = msg ^ t
-    msg[i] ^= t[offset++] & 0xff
-  }
-
-}
-
-/**
- * 解密
- */
-export function doDecrypt(encryptData: string, privateKey: string, cipherMode?: number, options?: {
-  output: 'array'
-}): Uint8Array
-export function doDecrypt(encryptData: string, privateKey: string, cipherMode?: number, options?: {
-  output: 'string'
-}): string
-export function doDecrypt(encryptData: string, privateKey: string, cipherMode = 1, {
-  output = 'string',
-} = {}) {
-  const privateKeyInteger = utils.hexToNumber(privateKey)
-
-  let c3 = encryptData.substring(128, 128 + 64)
-  let c2 = encryptData.substring(128 + 64)
-
-  if (cipherMode === C1C2C3) {
-    c3 = encryptData.substring(encryptData.length - 64)
-    c2 = encryptData.substring(128, encryptData.length - 64)
-  }
-
-  const msg = hexToArray(c2)
-  const c1 = sm2Curve.ProjectivePoint.fromHex('04' + encryptData.substring(0, 128))!
-
-  const p = c1.multiply(privateKeyInteger)
-  const x2 = hexToArray(leftPad(utils.numberToHexUnpadded(p.x), 64))
-  const y2 = hexToArray(leftPad(utils.numberToHexUnpadded(p.y), 64))
-
-  xorCipherStream(x2, y2, msg)
-  // c3 = hash(x2 || msg || y2)
-  const checkC3 = arrayToHex(Array.from(sm3(utils.concatBytes(x2, msg, y2))))
-
-  if (checkC3 === c3.toLowerCase()) {
-    return output === 'array' ? msg : arrayToUtf8(msg)
-  } else {
-    return output === 'array' ? [] : ''
-  }
-}
-
-export interface SignaturePoint {
-  k: bigint
-  x1: bigint
-}
-
-/**
- * 签名
- */
-export function doSignature(msg: Uint8Array | string, privateKey: string, options: {
-  pointPool?: SignaturePoint[], der?: boolean, hash?: boolean, publicKey?: string, userId?: string
-} = {}) {
-  let {
-    pointPool, der, hash, publicKey, userId
-  } = options
-  let hashHex = typeof msg === 'string' ? utf8ToHex(msg) : arrayToHex(Array.from(msg))
-
-  if (hash) {
-    // sm3杂凑
-    publicKey = publicKey || getPublicKeyFromPrivateKey(privateKey)
-    hashHex = getHash(hashHex, publicKey, userId)
-  }
-
-  const dA = utils.hexToNumber(privateKey)
-  const e = utils.hexToNumber(hashHex)
-
-  // k
-  let k: bigint | null = null
-  let r: bigint | null = null
-  let s: bigint | null = null
-
-  do {
-    do {
-      let point: SignaturePoint
-      if (pointPool && pointPool.length) {
-        point = pointPool.pop()!
-      } else {
-        point = getPoint()
-      }
-      k = point.k
-
-      // r = (e + x1) mod n
-      r = field.add(e, point.x1)
-    } while (r === ZERO || (r + k) === sm2Curve.CURVE.n)
-
-    // s = ((1 + dA)^-1 * (k - r * dA)) mod n
-    s = field.mul(field.inv(field.addN(dA, ONE)), field.subN(k, field.mulN(r, dA)))
-  } while (s === ZERO)
-  if (der) return encodeDer(r, s) // asn.1 der 编码
-  return leftPad(utils.numberToHexUnpadded(r), 64) + leftPad(utils.numberToHexUnpadded(s), 64)
-}
-
-/**
- * 验签
- */
-export function doVerifySignature(msg: string | Uint8Array, signHex: string, publicKey: string | ProjPointType<bigint>, options: { der?: boolean, hash?: boolean, userId?: string } = {}) {
-  let hashHex: string
-  const {
-    hash,
-    der,
-    userId,
-  } = options
-  const publicKeyHex = typeof publicKey === 'string' ? publicKey : publicKey.toHex(false)
-  if (hash) {
-    // sm3杂凑
-    hashHex = getHash(typeof msg === 'string' ? utf8ToHex(msg) : msg, publicKeyHex, userId)
-  } else {
-    hashHex = typeof msg === 'string' ? utf8ToHex(msg) : arrayToHex(Array.from(msg))
-  }
-
-  let r: bigint;
-  let s: bigint;
-  if (der) {
-    const decodeDerObj = decodeDer(signHex) // asn.1 der 解码
-    r = decodeDerObj.r
-    s = decodeDerObj.s
-  } else {
-    r = utils.hexToNumber(signHex.substring(0, 64))
-    s = utils.hexToNumber(signHex.substring(64))
-  }
-  
-  const PA = typeof publicKey === 'string' ? sm2Curve.ProjectivePoint.fromHex(publicKey) : publicKey
-  const e = utils.hexToNumber(hashHex)
-  
-  // t = (r + s) mod n
-  const t = field.add(r, s)
-
-  if (t === ZERO) return false
-
-  // x1y1 = s * G + t * PA
-  const x1y1 = sm2Curve.ProjectivePoint.BASE.multiply(s).add(PA.multiply(t))
-
-  // R = (e + x1) mod n
-  // const R = e.add(x1y1.getX().toBigInteger()).mod(n)
-  const R = field.add(e, x1y1.x)
-
-  // return r.equals(R)
-  return r === R
-}
-
-export function getZ(publicKey: string, userId = '1234567812345678') {
-  // z = hash(entl || userId || a || b || gx || gy || px || py)
-  userId = utf8ToHex(userId)
-  const a = leftPad(utils.numberToHexUnpadded(sm2Curve.CURVE.a), 64)
-  // const b = leftPad(G.curve.b.toBigInteger().toRadix(16), 64)
-  const b = leftPad(utils.numberToHexUnpadded(sm2Curve.CURVE.b), 64)
-  // const gx = leftPad(G.getX().toBigInteger().toRadix(16), 64)
-  const gx = leftPad(utils.numberToHexUnpadded(sm2Curve.ProjectivePoint.BASE.x), 64)
-  // const gy = leftPad(G.getY().toBigInteger().toRadix(16), 64)
-  const gy = leftPad(utils.numberToHexUnpadded(sm2Curve.ProjectivePoint.BASE.y), 64)
-  let px: string
-  let py: string
-  if (publicKey.length === 128) {
-    px = publicKey.substring(0, 64)
-    py = publicKey.substring(64, 128)
-  } else {
-    // const point = G.curve.decodePointHex(publicKey)!
-    const point = sm2Curve.ProjectivePoint.fromHex(publicKey)!
-    // px = leftPad(point.getX().toBigInteger().toRadix(16), 64)
-    px = leftPad(utils.numberToHexUnpadded(point.x), 64)
-    // py = leftPad(point.getY().toBigInteger().toRadix(16), 64)
-    py = leftPad(utils.numberToHexUnpadded(point.y), 64)
-  }
-  const data = hexToArray(userId + a + b + gx + gy + px + py)
-
-  const entl = userId.length * 4
-
-  const z = sm3(utils.concatBytes(new Uint8Array([entl >> 8 & 0x00ff, entl & 0x00ff]), data))
-
-  return z
-}
-
-/**
- * sm3杂凑算法
- */
-export function getHash(hashHex: string | Uint8Array, publicKey: string, userId = '1234567812345678') {
-  const z = getZ(publicKey, userId)
-  // e = hash(z || msg)
-  return bytesToHex(sm3(utils.concatBytes(z, typeof hashHex === 'string' ? hexToArray(hashHex) : hashHex)))
-}
-
-/**
- * 预计算公钥点，可用于提升加密性能
- * @export
- * @param {string} publicKey 公钥
- * @param windowSize 计算窗口大小，默认为 8
- * @returns {ProjPointType<bigint>} 预计算的点
- */
-export function precomputePublicKey(publicKey: string, windowSize?: number) {
-  const point = sm2Curve.ProjectivePoint.fromHex(publicKey)
-  return sm2Curve.utils.precompute(windowSize, point)
-}
-
-/**
- * 计算公钥
- */
-export function getPublicKeyFromPrivateKey(privateKey: string) {
-  const pubKey = sm2Curve.getPublicKey(privateKey, false)
-  const pubPad = leftPad(utils.bytesToHex(pubKey), 64)
-  return pubPad
-}
-
-/**
- * 获取椭圆曲线点
- */
-export function getPoint() {
-  const keypair = generateKeyPairHex()
-  const PA = sm2Curve.ProjectivePoint.fromHex(keypair.publicKey)
-  const k = utils.hexToNumber(keypair.privateKey)
-
-  return {
-    ...keypair,
-    k,
-    x1: PA!.x,
-  }
-}
-