sm-crypto-v2 0.3.12

package/src/index.ts

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

package/src/sm2/asn1.ts

@@ -0,0 +1,158 @@
+/* eslint-disable class-methods-use-this */
+
+import { BigInteger } from 'jsbn'
+
+export function bigintToValue(bigint: BigInteger) {
+  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.substr(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 = new BigInteger(maskString, 16)
+
+    // 对绝对值取反，加1
+    let output = mask.xor(bigint).add(BigInteger.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: BigInteger) {
+    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 ? new BigInteger(l, 16) : new BigInteger(l.substring(2), 16)
+
+  return bigint.intValue()
+}
+
+/**
+ * 获取 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: BigInteger, s: BigInteger) {
+  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)
+
+  return { r, s }
+}

package/src/sm2/ec.ts

@@ -0,0 +1,333 @@
+/* eslint-disable no-case-declarations, max-len */
+
+import { BigInteger } from '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 TWO = new BigInteger('2')
+const THREE = new BigInteger('3')
+
+/**
+ * 椭圆曲线域元素
+ */
+class ECFieldElementFp {
+  constructor(public q: BigInteger, public x: BigInteger) {
+    // TODO if (x.compareTo(q) >= 0) error
+  }
+
+  /**
+   * 判断相等
+   */
+  equals(other: ECFieldElementFp) {
+    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 {
+  zinv: BigInteger | null
+  z: BigInteger
+  constructor(public curve: ECCurveFp, public x: ECFieldElementFp | null, public y: ECFieldElementFp | null, z?: BigInteger) {
+    // 标准射影坐标系：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: ECPointFp) {
+    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: ECPointFp) {
+    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: BigInteger) {
+    if (this.isInfinity()) return this
+    if (!k.signum()) return this.curve.infinity
+
+    // 使用加减法
+    const k3 = k.multiply(THREE)
+    const neg = this.negate()
+    let Q: ECPointFp = 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
+ */
+export class ECCurveFp {
+  infinity: ECPointFp
+  a: ECFieldElementFp
+  b: ECFieldElementFp
+  constructor(public q: BigInteger, a: BigInteger, b: BigInteger) {
+    this.q = q
+    this.a = this.fromBigInteger(a)
+    this.b = this.fromBigInteger(b)
+    this.infinity = new ECPointFp(this, null, null) // 无穷远点
+  }
+
+  /**
+   * 判断两个椭圆曲线是否相等
+   */
+  equals(other: ECCurveFp) {
+    if (other === this) return true
+    return (this.q.equals(other.q) && this.a.equals(other.a) && this.b.equals(other.b))
+  }
+
+  /**
+   * 生成椭圆曲线域元素
+   */
+  fromBigInteger(x: BigInteger) {
+    return new ECFieldElementFp(this.q, x)
+  }
+
+  /**
+   * 解析 16 进制串为椭圆曲线点
+   */
+  decodePointHex(s: string) {
+    switch (parseInt(s.substring(0, 2), 16)) {
+      // 第一个字节
+      case 0:
+        return this.infinity
+      case 2:
+      case 3:
+        // 压缩
+        const x = this.fromBigInteger(new BigInteger(s.substring(2), 16))
+        // 对 p ≡ 3 (mod4)，即存在正整数 u，使得 p = 4u + 3
+        // 计算 y = (√ (x^3 + ax + b) % p)^(u + 1) modp
+        let y = this.fromBigInteger(x.multiply(x.square()).add(
+          x.multiply(this.a)
+        ).add(this.b).toBigInteger()
+          .modPow(
+            this.q.divide(new BigInteger('4')).add(BigInteger.ONE), this.q
+          ))
+        // 算出结果 2 进制最后 1 位不等于第 1 个字节减 2 则取反
+        if (!y.toBigInteger().mod(TWO).equals(new BigInteger(s.substring(0, 2), 16).subtract(TWO))) {
+          y = y.negate()
+        }
+        return new ECPointFp(this, x, y)
+      case 4:
+      case 6:
+      case 7:
+        const len = (s.length - 2) / 2
+        const xHex = s.substring(2, 2 + len)
+        const yHex = s.substring(len + 2, len + 2 + len)
+
+        return new ECPointFp(this, this.fromBigInteger(new BigInteger(xHex, 16)), this.fromBigInteger(new BigInteger(yHex, 16)))
+      default:
+        // 不支持
+        return null
+    }
+  }
+}
+
+export const ec = {
+  ECPointFp,
+  ECCurveFp,
+}