kh-one-ui 2.0.0

package/src/lib/encrypt/sm-crypto/sm2/ec.js

@@ -0,0 +1,318 @@
+/* eslint-disable no-case-declarations, max-len */
+const {BigInteger} = require('jsbn')
+
+/**
+ * thanks for Tom Wu : http://www-cs-students.stanford.edu/~tjw/jsbn/
+ *
+ * Basic Javascript Elliptic Curve implementation
+ * Ported loosely from BouncyCastle's Java EC code
+ * Only Fp curves implemented for now
+ */
+
+const THREE = new BigInteger('3')
+
+/**
+ * 椭圆曲线域元素
+ */
+class ECFieldElementFp {
+  constructor(q, x) {
+    this.x = x
+    this.q = q
+    // TODO if (x.compareTo(q) >= 0) error
+  }
+
+  /**
+   * 判断相等
+   */
+  equals(other) {
+    if (other === this) return true
+    return (this.q.equals(other.q) && this.x.equals(other.x))
+  }
+
+  /**
+   * 返回具体数值
+   */
+  toBigInteger() {
+    return this.x
+  }
+
+  /**
+   * 取反
+   */
+  negate() {
+    return new ECFieldElementFp(this.q, this.x.negate().mod(this.q))
+  }
+
+  /**
+   * 相加
+   */
+  add(b) {
+    return new ECFieldElementFp(this.q, this.x.add(b.toBigInteger()).mod(this.q))
+  }
+
+  /**
+   * 相减
+   */
+  subtract(b) {
+    return new ECFieldElementFp(this.q, this.x.subtract(b.toBigInteger()).mod(this.q))
+  }
+
+  /**
+   * 相乘
+   */
+  multiply(b) {
+    return new ECFieldElementFp(this.q, this.x.multiply(b.toBigInteger()).mod(this.q))
+  }
+
+  /**
+   * 相除
+   */
+  divide(b) {
+    return new ECFieldElementFp(this.q, this.x.multiply(b.toBigInteger().modInverse(this.q)).mod(this.q))
+  }
+
+  /**
+   * 平方
+   */
+  square() {
+    return new ECFieldElementFp(this.q, this.x.square().mod(this.q))
+  }
+}
+
+class ECPointFp {
+  constructor(curve, x, y, z) {
+    this.curve = curve
+    this.x = x
+    this.y = y
+    // 标准射影坐标系：zinv == null 或 z * zinv == 1
+    this.z = z == null ? BigInteger.ONE : z
+    this.zinv = null
+    // TODO: compression flag
+  }
+
+  getX() {
+    if (this.zinv === null) this.zinv = this.z.modInverse(this.curve.q)
+
+    return this.curve.fromBigInteger(this.x.toBigInteger().multiply(this.zinv).mod(this.curve.q))
+  }
+
+  getY() {
+    if (this.zinv === null) this.zinv = this.z.modInverse(this.curve.q)
+
+    return this.curve.fromBigInteger(this.y.toBigInteger().multiply(this.zinv).mod(this.curve.q))
+  }
+
+  /**
+   * 判断相等
+   */
+  equals(other) {
+    if (other === this) return true
+    if (this.isInfinity()) return other.isInfinity()
+    if (other.isInfinity()) return this.isInfinity()
+
+    // u = y2 * z1 - y1 * z2
+    const u = other.y.toBigInteger().multiply(this.z).subtract(this.y.toBigInteger().multiply(other.z)).mod(this.curve.q)
+    if (!u.equals(BigInteger.ZERO)) return false
+
+    // v = x2 * z1 - x1 * z2
+    const v = other.x.toBigInteger().multiply(this.z).subtract(this.x.toBigInteger().multiply(other.z)).mod(this.curve.q)
+    return v.equals(BigInteger.ZERO)
+  }
+
+  /**
+   * 是否是无穷远点
+   */
+  isInfinity() {
+    if ((this.x === null) && (this.y === null)) return true
+    return this.z.equals(BigInteger.ZERO) && !this.y.toBigInteger().equals(BigInteger.ZERO)
+  }
+
+  /**
+   * 取反，x 轴对称点
+   */
+  negate() {
+    return new ECPointFp(this.curve, this.x, this.y.negate(), this.z)
+  }
+
+  /**
+   * 相加
+   *
+   * 标准射影坐标系：
+   *
+   * λ1 = x1 * z2
+   * λ2 = x2 * z1
+   * λ3 = λ1 − λ2
+   * λ4 = y1 * z2
+   * λ5 = y2 * z1
+   * λ6 = λ4 − λ5
+   * λ7 = λ1 + λ2
+   * λ8 = z1 * z2
+   * λ9 = λ3^2
+   * λ10 = λ3 * λ9
+   * λ11 = λ8 * λ6^2 − λ7 * λ9
+   * x3 = λ3 * λ11
+   * y3 = λ6 * (λ9 * λ1 − λ11) − λ4 * λ10
+   * z3 = λ10 * λ8
+   */
+  add(b) {
+    if (this.isInfinity()) return b
+    if (b.isInfinity()) return this
+
+    const x1 = this.x.toBigInteger()
+    const y1 = this.y.toBigInteger()
+    const z1 = this.z
+    const x2 = b.x.toBigInteger()
+    const y2 = b.y.toBigInteger()
+    const z2 = b.z
+    const q = this.curve.q
+
+    const w1 = x1.multiply(z2).mod(q)
+    const w2 = x2.multiply(z1).mod(q)
+    const w3 = w1.subtract(w2)
+    const w4 = y1.multiply(z2).mod(q)
+    const w5 = y2.multiply(z1).mod(q)
+    const w6 = w4.subtract(w5)
+
+    if (BigInteger.ZERO.equals(w3)) {
+      if (BigInteger.ZERO.equals(w6)) {
+        return this.twice() // this == b，计算自加
+      }
+      return this.curve.infinity // this == -b，则返回无穷远点
+    }
+
+    const w7 = w1.add(w2)
+    const w8 = z1.multiply(z2).mod(q)
+    const w9 = w3.square().mod(q)
+    const w10 = w3.multiply(w9).mod(q)
+    const w11 = w8.multiply(w6.square()).subtract(w7.multiply(w9)).mod(q)
+
+    const x3 = w3.multiply(w11).mod(q)
+    const y3 = w6.multiply(w9.multiply(w1).subtract(w11)).subtract(w4.multiply(w10)).mod(q)
+    const z3 = w10.multiply(w8).mod(q)
+
+    return new ECPointFp(this.curve, this.curve.fromBigInteger(x3), this.curve.fromBigInteger(y3), z3)
+  }
+
+  /**
+   * 自加
+   *
+   * 标准射影坐标系：
+   *
+   * λ1 = 3 * x1^2 + a * z1^2
+   * λ2 = 2 * y1 * z1
+   * λ3 = y1^2
+   * λ4 = λ3 * x1 * z1
+   * λ5 = λ2^2
+   * λ6 = λ1^2 − 8 * λ4
+   * x3 = λ2 * λ6
+   * y3 = λ1 * (4 * λ4 − λ6) − 2 * λ5 * λ3
+   * z3 = λ2 * λ5
+   */
+  twice() {
+    if (this.isInfinity()) return this
+    if (!this.y.toBigInteger().signum()) return this.curve.infinity
+
+    const x1 = this.x.toBigInteger()
+    const y1 = this.y.toBigInteger()
+    const z1 = this.z
+    const q = this.curve.q
+    const a = this.curve.a.toBigInteger()
+
+    const w1 = x1.square().multiply(THREE).add(a.multiply(z1.square())).mod(q)
+    const w2 = y1.shiftLeft(1).multiply(z1).mod(q)
+    const w3 = y1.square().mod(q)
+    const w4 = w3.multiply(x1).multiply(z1).mod(q)
+    const w5 = w2.square().mod(q)
+    const w6 = w1.square().subtract(w4.shiftLeft(3)).mod(q)
+
+    const x3 = w2.multiply(w6).mod(q)
+    const y3 = w1.multiply(w4.shiftLeft(2).subtract(w6)).subtract(w5.shiftLeft(1).multiply(w3)).mod(q)
+    const z3 = w2.multiply(w5).mod(q)
+
+    return new ECPointFp(this.curve, this.curve.fromBigInteger(x3), this.curve.fromBigInteger(y3), z3)
+  }
+
+  /**
+   * 倍点计算
+   */
+  multiply(k) {
+    if (this.isInfinity()) return this
+    if (!k.signum()) return this.curve.infinity
+
+    // 使用加减法
+    const k3 = k.multiply(THREE)
+    const neg = this.negate()
+    let Q = this
+
+    for (let i = k3.bitLength() - 2; i > 0; i--) {
+      Q = Q.twice()
+
+      const k3Bit = k3.testBit(i)
+      const kBit = k.testBit(i)
+
+      if (k3Bit !== kBit) {
+        Q = Q.add(k3Bit ? this : neg)
+      }
+    }
+
+    return Q
+  }
+}
+
+/**
+ * 椭圆曲线 y^2 = x^3 + ax + b
+ */
+class ECCurveFp {
+  constructor(q, a, b) {
+    this.q = q
+    this.a = this.fromBigInteger(a)
+    this.b = this.fromBigInteger(b)
+    this.infinity = new ECPointFp(this, null, null) // 无穷远点
+  }
+
+  /**
+   * 判断两个椭圆曲线是否相等
+   */
+  equals(other) {
+    if (other === this) return true
+    return (this.q.equals(other.q) && this.a.equals(other.a) && this.b.equals(other.b))
+  }
+
+  /**
+   * 生成椭圆曲线域元素
+   */
+  fromBigInteger(x) {
+    return new ECFieldElementFp(this.q, x)
+  }
+
+  /**
+   * 解析 16 进制串为椭圆曲线点
+   */
+  decodePointHex(s) {
+    switch (parseInt(s.substr(0, 2), 16)) {
+      // 第一个字节
+      case 0:
+        return this.infinity
+      case 2:
+      case 3:
+        // 不支持的压缩方式
+        return null
+      case 4:
+      case 6:
+      case 7:
+        const len = (s.length - 2) / 2
+        const xHex = s.substr(2, len)
+        const yHex = s.substr(len + 2, len)
+
+        return new ECPointFp(this, this.fromBigInteger(new BigInteger(xHex, 16)), this.fromBigInteger(new BigInteger(yHex, 16)))
+      default:
+        // 不支持
+        return null
+    }
+  }
+}
+
+module.exports = {
+  ECPointFp,
+  ECCurveFp,
+}

package/src/lib/encrypt/sm-crypto/sm2/index.js

@@ -0,0 +1,213 @@
+/* eslint-disable no-use-before-define */
+const {BigInteger} = require('jsbn')
+const {encodeDer, decodeDer} = require('./asn1')
+const SM3Digest = require('./sm3')
+const SM2Cipher = require('./sm2')
+const _ = require('./utils')
+
+const {G, curve, n} = _.generateEcparam()
+const C1C2C3 = 0
+
+/**
+ * 加密
+ */
+function doEncrypt(msg, publicKey, cipherMode = 1) {
+  const cipher = new SM2Cipher()
+  msg = _.hexToArray(_.parseUtf8StringToHex(msg))
+
+  if (publicKey.length > 128) {
+    publicKey = publicKey.substr(publicKey.length - 128)
+  }
+  const xHex = publicKey.substr(0, 64)
+  const yHex = publicKey.substr(64)
+  publicKey = cipher.createPoint(xHex, yHex)
+
+  const c1 = cipher.initEncipher(publicKey)
+
+  cipher.encryptBlock(msg)
+  const c2 = _.arrayToHex(msg)
+
+  let c3 = new Array(32)
+  cipher.doFinal(c3)
+  c3 = _.arrayToHex(c3)
+
+  return cipherMode === C1C2C3 ? c1 + c2 + c3 : c1 + c3 + c2
+}
+
+/**
+ * 解密
+ */
+function doDecrypt(encryptData, privateKey, cipherMode = 1) {
+  const cipher = new SM2Cipher()
+
+  privateKey = new BigInteger(privateKey, 16)
+
+  const c1X = encryptData.substr(0, 64)
+  const c1Y = encryptData.substr(0 + c1X.length, 64)
+  const c1Length = c1X.length + c1Y.length
+
+  let c3 = encryptData.substr(c1Length, 64)
+  let c2 = encryptData.substr(c1Length + 64)
+
+  if (cipherMode === C1C2C3) {
+    c3 = encryptData.substr(encryptData.length - 64)
+    c2 = encryptData.substr(c1Length, encryptData.length - c1Length - 64)
+  }
+
+  const data = _.hexToArray(c2)
+
+  const c1 = cipher.createPoint(c1X, c1Y)
+  cipher.initDecipher(privateKey, c1)
+  cipher.decryptBlock(data)
+  const c3_ = new Array(32)
+  cipher.doFinal(c3_)
+
+  const isDecrypt = _.arrayToHex(c3_) === c3
+
+  if (isDecrypt) {
+    const decryptData = _.arrayToUtf8(data)
+    return decryptData
+  } else {
+    return ''
+  }
+}
+
+/**
+ * 签名
+ */
+function doSignature(msg, privateKey, {
+  pointPool, der, hash, publicKey, userId
+} = {}) {
+  let hashHex = typeof msg === 'string' ? _.parseUtf8StringToHex(msg) : _.parseArrayBufferToHex(msg)
+
+  if (hash) {
+    // sm3杂凑
+    publicKey = publicKey || getPublicKeyFromPrivateKey(privateKey)
+    hashHex = doSm3Hash(hashHex, publicKey, userId)
+  }
+
+  const dA = new BigInteger(privateKey, 16)
+  const e = new BigInteger(hashHex, 16)
+
+  // k
+  let k = null
+  let r = null
+  let s = null
+
+  do {
+    do {
+      let point
+      if (pointPool && pointPool.length) {
+        point = pointPool.pop()
+      } else {
+        point = getPoint()
+      }
+      k = point.k
+
+      // r = (e + x1) mod n
+      r = e.add(point.x1).mod(n)
+    } while (r.equals(BigInteger.ZERO) || r.add(k).equals(n))
+
+    // s = ((1 + dA)^-1 * (k - r * dA)) mod n
+    s = dA.add(BigInteger.ONE).modInverse(n).multiply(k.subtract(r.multiply(dA))).mod(n)
+  } while (s.equals(BigInteger.ZERO))
+
+  if (der) {
+    // asn1 der编码
+    return encodeDer(r, s)
+  }
+
+  return _.leftPad(r.toString(16), 64) + _.leftPad(s.toString(16), 64)
+}
+
+/**
+ * 验签
+ */
+function doVerifySignature(msg, signHex, publicKey, {der, hash, userId} = {}) {
+  let hashHex = typeof msg === 'string' ? _.parseUtf8StringToHex(msg) : _.parseArrayBufferToHex(msg)
+
+  if (hash) {
+    // sm3杂凑
+    hashHex = doSm3Hash(hashHex, publicKey, userId)
+  }
+
+  let r; let
+    s
+  if (der) {
+    const decodeDerObj = decodeDer(signHex)
+    r = decodeDerObj.r
+    s = decodeDerObj.s
+  } else {
+    r = new BigInteger(signHex.substring(0, 64), 16)
+    s = new BigInteger(signHex.substring(64), 16)
+  }
+
+  const PA = curve.decodePointHex(publicKey)
+  const e = new BigInteger(hashHex, 16)
+
+  // t = (r + s) mod n
+  const t = r.add(s).mod(n)
+
+  if (t.equals(BigInteger.ZERO)) return false
+
+  // x1y1 = s * G + t * PA
+  const x1y1 = G.multiply(s).add(PA.multiply(t))
+
+  // R = (e + x1) mod n
+  const R = e.add(x1y1.getX().toBigInteger()).mod(n)
+
+  return r.equals(R)
+}
+
+/**
+ * sm3杂凑算法
+ * 计算M值: Hash(za || msg)
+ */
+function doSm3Hash(hashHex, publicKey, userId = '1234567812345678') {
+  const smDigest = new SM3Digest()
+
+  const z = new SM3Digest().getZ(G, publicKey.substr(2, 128), userId)
+  const zValue = _.hexToArray(_.arrayToHex(z).toString())
+
+  const p = hashHex
+  const pValue = _.hexToArray(p)
+
+  const hashData = new Array(smDigest.getDigestSize())
+  smDigest.blockUpdate(zValue, 0, zValue.length)
+  smDigest.blockUpdate(pValue, 0, pValue.length)
+  smDigest.doFinal(hashData, 0)
+
+  return _.arrayToHex(hashData).toString()
+}
+
+/**
+ * 计算公钥
+ */
+function getPublicKeyFromPrivateKey(privateKey) {
+  const PA = G.multiply(new BigInteger(privateKey, 16))
+  const x = _.leftPad(PA.getX().toBigInteger().toString(16), 64)
+  const y = _.leftPad(PA.getY().toBigInteger().toString(16), 64)
+  return '04' + x + y
+}
+
+/**
+ * 获取椭圆曲线点
+ */
+function getPoint() {
+  const keypair = _.generateKeyPairHex()
+  const PA = curve.decodePointHex(keypair.publicKey)
+
+  keypair.k = new BigInteger(keypair.privateKey, 16)
+  keypair.x1 = PA.getX().toBigInteger()
+
+  return keypair
+}
+
+module.exports = {
+  generateKeyPairHex: _.generateKeyPairHex,
+  doEncrypt,
+  doDecrypt,
+  doSignature,
+  doVerifySignature,
+  getPoint,
+}

package/src/lib/encrypt/sm-crypto/sm2/sm2.js

@@ -0,0 +1,93 @@
+/* eslint-disable no-bitwise, no-mixed-operators, class-methods-use-this */
+const {BigInteger} = require('jsbn')
+const SM3Digest = require('./sm3')
+const _ = require('./utils')
+
+class SM2Cipher {
+  constructor() {
+    this.ct = 1
+    this.p2 = null
+    this.sm3keybase = null
+    this.sm3c3 = null
+    this.key = new Array(32)
+    this.keyOff = 0
+  }
+
+  reset() {
+    this.sm3keybase = new SM3Digest()
+    this.sm3c3 = new SM3Digest()
+    const xWords = _.hexToArray(_.leftPad(this.p2.getX().toBigInteger().toRadix(16), 64))
+    const yWords = _.hexToArray(_.leftPad(this.p2.getY().toBigInteger().toRadix(16), 64))
+    this.sm3keybase.blockUpdate(xWords, 0, xWords.length)
+    this.sm3c3.blockUpdate(xWords, 0, xWords.length)
+    this.sm3keybase.blockUpdate(yWords, 0, yWords.length)
+    this.ct = 1
+    this.nextKey()
+  }
+
+  nextKey() {
+    const sm3keycur = new SM3Digest(this.sm3keybase)
+    sm3keycur.update((this.ct >> 24 & 0x00ff))
+    sm3keycur.update((this.ct >> 16 & 0x00ff))
+    sm3keycur.update((this.ct >> 8 & 0x00ff))
+    sm3keycur.update((this.ct & 0x00ff))
+    sm3keycur.doFinal(this.key, 0)
+    this.keyOff = 0
+    this.ct++
+  }
+
+  initEncipher(userKey) {
+    const keypair = _.generateKeyPairHex()
+    const k = new BigInteger(keypair.privateKey, 16)
+    let publicKey = keypair.publicKey
+
+    this.p2 = userKey.multiply(k) // [k](Pb)
+    this.reset()
+
+    if (publicKey.length > 128) {
+      publicKey = publicKey.substr(publicKey.length - 128)
+    }
+
+    return publicKey
+  }
+
+  encryptBlock(data) {
+    this.sm3c3.blockUpdate(data, 0, data.length)
+    for (let i = 0; i < data.length; i++) {
+      if (this.keyOff === this.key.length) {
+        this.nextKey()
+      }
+      data[i] ^= this.key[this.keyOff++] & 0xff
+    }
+  }
+
+  initDecipher(userD, c1) {
+    this.p2 = c1.multiply(userD)
+    this.reset()
+  }
+
+  decryptBlock(data) {
+    for (let i = 0; i < data.length; i++) {
+      if (this.keyOff === this.key.length) {
+        this.nextKey()
+      }
+      data[i] ^= this.key[this.keyOff++] & 0xff
+    }
+    this.sm3c3.blockUpdate(data, 0, data.length)
+  }
+
+  doFinal(c3) {
+    const yWords = _.hexToArray(_.leftPad(this.p2.getY().toBigInteger().toRadix(16), 64))
+    this.sm3c3.blockUpdate(yWords, 0, yWords.length)
+    this.sm3c3.doFinal(c3, 0)
+    this.reset()
+  }
+
+  createPoint(x, y) {
+    const publicKey = '04' + x + y
+    const point = _.getGlobalCurve().decodePointHex(publicKey)
+    return point
+  }
+}
+
+module.exports = SM2Cipher